This commit is contained in:
Oleg Maslov
2026-09-02 10:14:22 +02:00
parent 0c3e2ead3b
commit b20b138fe4
771 changed files with 161561 additions and 9027 deletions

File diff suppressed because it is too large Load Diff

View File

@@ -1,36 +1,35 @@
/**
* PR5 Phase A — the shared "≥1 working model" gate signal (cloud key OR local
* model), composed from the same /api/providers data the Settings Models tab
* reads.
*/
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { renderHook, waitFor, cleanup } from '@testing-library/react';
import { act, cleanup, renderHook, waitFor } from '@testing-library/react';
const mocks = vi.hoisted(() => ({
adapter: {
getProviders: vi.fn(),
getLocalInferenceStatus: vi.fn(),
probeModel: vi.fn(),
probeProvider: vi.fn(),
},
}));
vi.mock('@/lib/adapter', () => ({ adapter: mocks.adapter, default: vi.fn() }));
import { useHasWorkingModel } from './useHasWorkingModel';
const providers = (...withKey: boolean[]) => ({
providers: withKey.map((hasKey, i) => ({ id: `p${i}`, name: `P${i}`, hasKey, badge: null, keyUrl: null, requiresKey: true, models: [] })),
search: [],
activeSearch: 'duckduckgo',
});
const providerRows = (...rows: Array<{ id: string; hasKey: boolean; requiresKey: boolean }>) => ({
providers: rows.map((row) => ({ ...row, name: row.id, badge: null, keyUrl: null, models: [] })),
search: [],
activeSearch: 'duckduckgo',
});
function deferred<T>() {
let resolve!: (value: T) => void;
const promise = new Promise<T>((resolvePromise) => { resolve = resolvePromise; });
return { promise, resolve };
}
beforeEach(() => {
mocks.adapter.getProviders.mockResolvedValue(providers());
mocks.adapter.getProviders.mockResolvedValue(providerRows());
mocks.adapter.getLocalInferenceStatus.mockResolvedValue({ servers: [], ollamaInstalled: false, totalLocalModels: 0 });
mocks.adapter.probeModel.mockResolvedValue({ model: null, configured: false, verified: false });
mocks.adapter.probeProvider.mockResolvedValue({ configured: false, valid: false, verified: false });
});
afterEach(() => { cleanup(); vi.clearAllMocks(); });
@@ -39,39 +38,211 @@ describe('useHasWorkingModel', () => {
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current).toMatchObject({ hasWorkingModel: false, cloudReady: false, localReady: false });
expect(mocks.adapter.probeModel).not.toHaveBeenCalled();
});
it('a keyed cloud provider → cloudReady → working', async () => {
mocks.adapter.getProviders.mockResolvedValue(providers(false, true));
it('a verified default model is ready without provider fallback', async () => {
mocks.adapter.getProviders.mockResolvedValue(providerRows({ id: 'p0', hasKey: true, requiresKey: true }));
mocks.adapter.probeModel.mockResolvedValue({ model: 'p0/model', configured: true, verified: true });
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(result.current.hasWorkingModel).toBe(true));
expect(result.current.cloudReady).toBe(true);
expect(result.current.localReady).toBe(false);
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current).toMatchObject({ hasWorkingModel: true, cloudReady: true });
expect(mocks.adapter.probeProvider).not.toHaveBeenCalled();
});
it('a detected local model (no cloud key) → localReady → working', async () => {
it('a rejected default model blocks a keyed provider', async () => {
mocks.adapter.getProviders.mockResolvedValue(providerRows({ id: 'p0', hasKey: true, requiresKey: true }));
mocks.adapter.probeModel.mockResolvedValue({ model: 'p0/model', configured: true, verified: false, rejected: true });
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current).toMatchObject({ hasWorkingModel: false, cloudReady: false });
expect(mocks.adapter.probeProvider).not.toHaveBeenCalled();
});
it('a transient default result remains usable after probing settles', async () => {
const modelProbe = deferred<{ model: string; configured: boolean; verified: boolean }>();
mocks.adapter.getProviders.mockResolvedValue(providerRows({ id: 'p0', hasKey: true, requiresKey: true }));
mocks.adapter.probeModel.mockReturnValue(modelProbe.promise);
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(mocks.adapter.probeModel).toHaveBeenCalledTimes(1));
expect(result.current).toMatchObject({ loading: true, cloudReady: false, hasWorkingModel: false });
await act(async () => { modelProbe.resolve({ model: 'p0/model', configured: true, verified: false }); });
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current).toMatchObject({ hasWorkingModel: true, cloudReady: true });
});
it('a keyed cloud provider is ready only after its fallback probe verifies it', async () => {
mocks.adapter.getProviders.mockResolvedValue(providerRows({ id: 'p0', hasKey: true, requiresKey: true }));
mocks.adapter.probeProvider.mockResolvedValue({ configured: true, valid: true, verified: true });
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current).toMatchObject({ hasWorkingModel: true, cloudReady: true, localReady: false });
expect(mocks.adapter.probeModel).toHaveBeenCalledTimes(1);
expect(mocks.adapter.probeProvider).toHaveBeenCalledWith('p0');
});
it('a rejected fallback provider is not ready', async () => {
mocks.adapter.getProviders.mockResolvedValue(providerRows({ id: 'p0', hasKey: true, requiresKey: true }));
mocks.adapter.probeProvider.mockResolvedValue({ configured: true, valid: false, verified: true, error: 'rejected' });
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current).toMatchObject({ hasWorkingModel: false, cloudReady: false });
});
it('a valid but unverified fallback provider remains usable after probing settles', async () => {
mocks.adapter.getProviders.mockResolvedValue(providerRows({ id: 'p0', hasKey: true, requiresKey: true }));
mocks.adapter.probeProvider.mockResolvedValue({ configured: true, valid: true, verified: false });
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current).toMatchObject({ hasWorkingModel: true, cloudReady: true });
});
it('all unconfigured probes are not ready', async () => {
mocks.adapter.getProviders.mockResolvedValue(providerRows({ id: 'p0', hasKey: true, requiresKey: true }));
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current).toMatchObject({ hasWorkingModel: false, cloudReady: false });
});
it('a pending cloud probe stays loading and non-ready', async () => {
const modelProbe = deferred<{ model: string; configured: boolean; verified: boolean }>();
mocks.adapter.getProviders.mockResolvedValue(providerRows({ id: 'p0', hasKey: true, requiresKey: true }));
mocks.adapter.probeModel.mockReturnValue(modelProbe.promise);
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(mocks.adapter.probeModel).toHaveBeenCalledTimes(1));
expect(result.current).toMatchObject({ loading: true, cloudReady: false, hasWorkingModel: false });
});
it('a detected local model overrides a rejected cloud default', async () => {
mocks.adapter.getProviders.mockResolvedValue(providerRows({ id: 'p0', hasKey: true, requiresKey: true }));
mocks.adapter.probeModel.mockResolvedValue({ model: 'p0/model', configured: true, verified: false, rejected: true });
mocks.adapter.getLocalInferenceStatus.mockResolvedValue({ servers: [], ollamaInstalled: true, totalLocalModels: 2 });
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(result.current.hasWorkingModel).toBe(true));
expect(result.current.cloudReady).toBe(false);
expect(result.current.localReady).toBe(true);
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current).toMatchObject({ hasWorkingModel: true, cloudReady: false, localReady: true });
expect(mocks.adapter.probeModel).toHaveBeenCalledTimes(1);
});
it('does not count keyless local providers as cloud keys', async () => {
it('an installed local runtime with zero models is not ready', async () => {
mocks.adapter.getLocalInferenceStatus.mockResolvedValue({ servers: [], ollamaInstalled: true, totalLocalModels: 0 });
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current).toMatchObject({ hasWorkingModel: false, localReady: false });
});
it('does not count a keyless local provider as cloud readiness', async () => {
mocks.adapter.getProviders.mockResolvedValue(providerRows({ id: 'ollama', hasKey: true, requiresKey: false }));
mocks.adapter.getLocalInferenceStatus.mockResolvedValue({ servers: [], ollamaInstalled: true, totalLocalModels: 2 });
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(result.current.hasWorkingModel).toBe(true));
expect(result.current.cloudReady).toBe(false);
expect(result.current.localReady).toBe(true);
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current).toMatchObject({ cloudReady: false, localReady: true, hasWorkingModel: true });
expect(mocks.adapter.probeModel).not.toHaveBeenCalled();
});
it('a local-inference probe failure degrades to no-local (cloud can still pass)', async () => {
it('a local-inference probe failure degrades to no local model', async () => {
mocks.adapter.getLocalInferenceStatus.mockRejectedValue(new Error('ollama down'));
mocks.adapter.getProviders.mockResolvedValue(providers(true));
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current).toMatchObject({ localReady: false, hasWorkingModel: false });
});
it('refresh reprobes unchanged provider ids after a key replacement', async () => {
mocks.adapter.getProviders.mockResolvedValue(providerRows({ id: 'p0', hasKey: true, requiresKey: true }));
mocks.adapter.probeModel
.mockResolvedValueOnce({ model: 'p0/model', configured: true, verified: true })
.mockResolvedValueOnce({ model: 'p0/model', configured: true, verified: false, rejected: true });
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(result.current.hasWorkingModel).toBe(true));
act(() => { result.current.refresh(); });
await waitFor(() => expect(mocks.adapter.probeModel).toHaveBeenCalledTimes(2));
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current).toMatchObject({ hasWorkingModel: false, cloudReady: false });
});
it('a late old cloud success cannot overwrite a newer rejection', async () => {
const oldProbe = deferred<{ model: string; configured: boolean; verified: boolean; rejected?: boolean }>();
const newProbe = deferred<{ model: string; configured: boolean; verified: boolean; rejected?: boolean }>();
mocks.adapter.getProviders.mockResolvedValue(providerRows({ id: 'p0', hasKey: true, requiresKey: true }));
mocks.adapter.probeModel.mockReturnValueOnce(oldProbe.promise).mockReturnValueOnce(newProbe.promise);
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(mocks.adapter.probeModel).toHaveBeenCalledTimes(1));
act(() => { result.current.refresh(); });
await waitFor(() => expect(mocks.adapter.probeModel).toHaveBeenCalledTimes(2));
await act(async () => { newProbe.resolve({ model: 'p0/model', configured: true, verified: false, rejected: true }); });
await waitFor(() => expect(result.current.loading).toBe(false));
await act(async () => { oldProbe.resolve({ model: 'p0/model', configured: true, verified: true }); });
expect(result.current).toMatchObject({ hasWorkingModel: false, cloudReady: false });
});
it('a late old local positive result cannot overwrite a newer zero-model refresh', async () => {
const oldLocal = deferred<{ servers: never[]; ollamaInstalled: boolean; totalLocalModels: number }>();
const newLocal = deferred<{ servers: never[]; ollamaInstalled: boolean; totalLocalModels: number }>();
mocks.adapter.getLocalInferenceStatus.mockReturnValueOnce(oldLocal.promise).mockReturnValueOnce(newLocal.promise);
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(mocks.adapter.getLocalInferenceStatus).toHaveBeenCalledTimes(1));
act(() => { result.current.refresh(); });
await waitFor(() => expect(mocks.adapter.getLocalInferenceStatus).toHaveBeenCalledTimes(2));
await act(async () => { newLocal.resolve({ servers: [], ollamaInstalled: true, totalLocalModels: 0 }); });
await waitFor(() => expect(result.current.loading).toBe(false));
await act(async () => { oldLocal.resolve({ servers: [], ollamaInstalled: true, totalLocalModels: 2 }); });
expect(result.current.localReady).toBe(false);
expect(result.current.hasWorkingModel).toBe(true); // cloud key carries it
});
it('reprobes a same-id provider array returned by a window-focus refresh', async () => {
mocks.adapter.getProviders
.mockResolvedValueOnce(providerRows({ id: 'p0', hasKey: true, requiresKey: true }))
.mockResolvedValueOnce(providerRows({ id: 'p0', hasKey: true, requiresKey: true }));
mocks.adapter.probeModel
.mockResolvedValueOnce({ model: 'p0/model', configured: true, verified: true })
.mockResolvedValueOnce({ model: 'p0/model', configured: true, verified: false, rejected: true });
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(result.current.hasWorkingModel).toBe(true));
act(() => { window.dispatchEvent(new Event('focus')); });
await waitFor(() => expect(mocks.adapter.probeModel).toHaveBeenCalledTimes(2));
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current).toMatchObject({ hasWorkingModel: false, cloudReady: false });
});
it('treats unavailable fallback probes as transient usable readiness', async () => {
mocks.adapter.getProviders.mockResolvedValue(providerRows(
{ id: 'p0', hasKey: true, requiresKey: true },
{ id: 'p1', hasKey: true, requiresKey: true },
));
mocks.adapter.probeProvider.mockRejectedValue(new Error('sidecar offline'));
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current).toMatchObject({ hasWorkingModel: true, cloudReady: true });
});
it('uses only refreshed p1 results when an explicit refresh replaces p0', async () => {
const oldP0Probe = deferred<{ configured: boolean; valid: boolean; verified: boolean }>();
mocks.adapter.getProviders
.mockResolvedValueOnce(providerRows({ id: 'p0', hasKey: true, requiresKey: true }))
.mockResolvedValueOnce(providerRows({ id: 'p1', hasKey: true, requiresKey: true }));
mocks.adapter.probeModel.mockResolvedValue({ model: null, configured: false, verified: false });
mocks.adapter.probeProvider.mockImplementation((id: string) => id === 'p0'
? oldP0Probe.promise
: Promise.resolve({ configured: true, valid: false, verified: true }));
const { result } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(mocks.adapter.probeProvider).toHaveBeenCalledWith('p0'));
act(() => { result.current.refresh(); });
await waitFor(() => expect(mocks.adapter.probeProvider).toHaveBeenCalledWith('p1'));
await waitFor(() => expect(result.current).toMatchObject({ loading: false, cloudReady: false }));
await act(async () => { oldP0Probe.resolve({ configured: true, valid: true, verified: true }); });
expect(mocks.adapter.probeProvider.mock.calls.map(([id]) => id)).toEqual(['p0', 'p1']);
expect(result.current).toMatchObject({ hasWorkingModel: false, cloudReady: false });
});
it('does no cloud work when unmounted during a deferred explicit provider refresh', async () => {
const refreshProviders = deferred<ReturnType<typeof providerRows>>();
mocks.adapter.getProviders
.mockResolvedValueOnce(providerRows())
.mockReturnValueOnce(refreshProviders.promise);
const { result, unmount } = renderHook(() => useHasWorkingModel());
await waitFor(() => expect(result.current.loading).toBe(false));
act(() => { result.current.refresh(); });
unmount();
await act(async () => { refreshProviders.resolve(providerRows({ id: 'p0', hasKey: true, requiresKey: true })); });
expect(mocks.adapter.probeModel).not.toHaveBeenCalled();
});
});

View File

@@ -1,59 +1,144 @@
import { useCallback, useEffect, useState } from 'react';
import { useCallback, useEffect, useRef, useState } from 'react';
import { adapter } from '@/lib/adapter';
import { useProviders } from './useProviders';
/**
* useHasWorkingModel — the shared "≥1 working model" signal for the PR5 model
* gate (Onboarding step 3's HARD gate AND the Settings→Models banner). A model
* is "working" if either a cloud provider has a key configured OR a local model
* is detected. This is a UX affordance, not a security boundary — the real
* LLM-availability enforcement happens server-side at chat time — so it derives
* from already-fetched data (no live key-probe required to compute readiness).
*
* Composing useProviders keeps a single source of truth (the same /api/providers
* hasKey data the Settings Models tab reads), so the gate and the banner can
* never disagree about what counts as ready.
* Shared model-readiness signal for the onboarding hard gate and Models banner.
* Cloud keys are live-probed; a detected local model is independently sufficient.
*/
export interface WorkingModelState {
/** cloudReady || localReady — the hard-gate predicate. */
hasWorkingModel: boolean;
/** ≥1 cloud provider has a key in the vault. */
cloudReady: boolean;
/** ≥1 local model detected (Ollama/vLLM). */
localReady: boolean;
loading: boolean;
refresh: () => void;
}
export function useHasWorkingModel(): WorkingModelState {
const { activeProviders, loading: providersLoading, refresh: refreshProviders } = useProviders();
const { providers, activeProviders, loading: providersLoading, refresh: refreshProviders } = useProviders();
const [localModelCount, setLocalModelCount] = useState(0);
const [localLoading, setLocalLoading] = useState(true);
const [cloud, setCloud] = useState({ ready: false, loading: true });
const mounted = useRef(true);
const localGeneration = useRef(0);
const cloudGeneration = useRef(0);
const explicitCloudRefresh = useRef<number | null>(null);
const explicitProviders = useRef<unknown>(null);
const activeProviderIds = useRef<string[]>([]);
activeProviderIds.current = activeProviders.map((provider) => provider.id);
const refreshLocal = useCallback(async () => {
setLocalLoading(true);
const generation = ++localGeneration.current;
if (mounted.current) {
setLocalModelCount(0);
setLocalLoading(true);
}
try {
const status = await adapter.getLocalInferenceStatus();
setLocalModelCount(status?.totalLocalModels ?? 0);
if (mounted.current && generation === localGeneration.current) setLocalModelCount(status?.totalLocalModels ?? 0);
} catch {
// Local-inference probe failed (Ollama not installed / unreachable) —
// treat as "no local model"; a cloud key can still make the gate pass.
setLocalModelCount(0);
if (mounted.current && generation === localGeneration.current) setLocalModelCount(0);
} finally {
setLocalLoading(false);
if (mounted.current && generation === localGeneration.current) setLocalLoading(false);
}
}, []);
useEffect(() => { void refreshLocal(); }, [refreshLocal]);
const probeCloud = useCallback(async (providerIds: string[], generation: number) => {
const setCloudForGeneration = (next: { ready: boolean; loading: boolean }) => {
if (mounted.current && generation === cloudGeneration.current) setCloud(next);
};
if (!mounted.current || generation !== cloudGeneration.current) return;
setCloudForGeneration({ ready: false, loading: true });
const cloudReady = activeProviders.length > 0;
if (providerIds.length === 0) {
setCloudForGeneration({ ready: false, loading: false });
return;
}
let defaultProbe: Awaited<ReturnType<typeof adapter.probeModel>> | null = null;
try {
defaultProbe = await adapter.probeModel();
} catch {
// An unavailable default-model probe falls back to the keyed providers.
}
if (!mounted.current || generation !== cloudGeneration.current) return;
if (defaultProbe?.configured) {
if (defaultProbe.verified) {
setCloudForGeneration({ ready: true, loading: false });
return;
}
if (defaultProbe.rejected) {
setCloudForGeneration({ ready: false, loading: false });
return;
}
setCloudForGeneration({ ready: true, loading: false });
return;
}
const outcomes = await Promise.allSettled(providerIds.map((id) => adapter.probeProvider(id)));
if (!mounted.current || generation !== cloudGeneration.current) return;
const probes = outcomes.flatMap((outcome) => outcome.status === 'fulfilled' ? [outcome.value] : []);
const verified = probes.some((probe) => probe.configured && probe.valid !== false && probe.verified);
const rejected = probes.some((probe) => probe.configured && probe.valid === false);
const transient = outcomes.some((outcome) => outcome.status === 'rejected')
|| probes.some((probe) => probe.configured && probe.valid !== false);
setCloudForGeneration({ ready: verified || (!rejected && transient), loading: false });
}, []);
useEffect(() => {
mounted.current = true;
return () => {
mounted.current = false;
cloudGeneration.current += 1;
localGeneration.current += 1;
};
}, []);
useEffect(() => {
if (providersLoading) return;
if (explicitCloudRefresh.current === cloudGeneration.current) {
if (explicitProviders.current === providers) {
explicitCloudRefresh.current = null;
explicitProviders.current = null;
return;
}
explicitCloudRefresh.current = null;
explicitProviders.current = null;
}
const generation = ++cloudGeneration.current;
void probeCloud(activeProviderIds.current, generation);
}, [probeCloud, providers, providersLoading]);
useEffect(() => {
void refreshLocal();
}, [refreshLocal]);
const refresh = useCallback(() => {
const generation = ++cloudGeneration.current;
explicitCloudRefresh.current = generation;
if (mounted.current) setCloud({ ready: false, loading: true });
void refreshLocal();
void (async () => {
const data = await refreshProviders();
if (!mounted.current || generation !== cloudGeneration.current) return;
const ids = data
? data.providers.filter((provider) => provider.hasKey && provider.requiresKey).map((provider) => provider.id)
: activeProviderIds.current;
explicitProviders.current = data?.providers ?? null;
await probeCloud(ids, generation);
if (mounted.current && generation === cloudGeneration.current && !data) explicitCloudRefresh.current = null;
})();
}, [probeCloud, refreshLocal, refreshProviders]);
const cloudReady = cloud.ready;
const localReady = localModelCount > 0;
return {
hasWorkingModel: cloudReady || localReady,
cloudReady,
localReady,
loading: providersLoading || localLoading,
refresh: () => { refreshProviders(); void refreshLocal(); },
loading: providersLoading || cloud.loading || localLoading,
refresh,
};
}

View File

@@ -2,6 +2,7 @@ import { useState, useCallback, useEffect } from 'react';
import { adapter } from '@/lib/adapter';
import type { Workspace } from '@/lib/types';
import { useRevalidateOnError } from '@/hooks/useRevalidateOnError';
import { toast } from '@/hooks/use-toast';
import {
resolveActiveWorkspaceId,
readPersistedWorkspaceId,
@@ -41,7 +42,7 @@ export const useWorkspaces = () => {
// P1b D3 plus-clause: errored list revalidates on focus/online/connect-settled.
useRevalidateOnError(error !== null, fetchWorkspaces);
const createWorkspace = useCallback(async (data: { name: string; group: string; persona?: string; agentGroupId?: string; shared?: boolean; templateId?: string }) => {
const createWorkspace = useCallback(async (data: { name: string; group: string; persona?: string; agentGroupId?: string; shared?: boolean; templateId?: string; storageType?: Workspace['storageType']; storagePath?: string; storageConfig?: Record<string, unknown> }) => {
try {
const ws = await adapter.createWorkspace(data);
setWorkspaces(prev => [...prev, ws]);
@@ -49,23 +50,15 @@ export const useWorkspaces = () => {
persistWorkspaceId(ws.id);
return ws;
} catch (err) {
console.error('[useWorkspaces] create failed, using local fallback:', err);
const localWs: Workspace = {
id: `local-${Date.now()}`,
name: data.name,
group: data.group,
persona: data.persona,
shared: data.shared,
templateId: data.templateId,
health: 'healthy',
memoryCount: 0,
sessionCount: 0,
lastActive: new Date().toISOString(),
};
setWorkspaces(prev => [...prev, localWs]);
setActiveWorkspaceId(localWs.id);
persistWorkspaceId(localWs.id);
return localWs;
console.error('[useWorkspaces] create failed:', err);
const message = err instanceof Error ? err.message : 'Failed to create workspace';
setError(message);
toast({
title: "Couldn't create workspace",
description: message,
variant: 'destructive',
});
return null;
}
}, []);