moving
This commit is contained in:
File diff suppressed because it is too large
Load Diff
@@ -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();
|
||||
});
|
||||
});
|
||||
|
||||
@@ -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,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}, []);
|
||||
|
||||
|
||||
Reference in New Issue
Block a user