Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

Refresh provider composition catalogs after changes and reconnects (#11520)

[._.]/07a7cf4ceae3
diff --git a/client/src/hooks/useProviderCatalog.js b/client/src/hooks/useProviderCatalog.js
index f898f372a1..dbaaa06c2c 100644
--- a/client/src/hooks/useProviderCatalog.js
+++ b/client/src/hooks/useProviderCatalog.js
@@ -1,5 +1,6 @@
import { useCallback, useEffect, useState } from 'react';
import { createProviderPreset, getProviderCatalog } from '../services/api';
+import socket from '../services/socket.js';
import { harnessLabel } from '../utils/providerHarnesses.js';
import { parseProviderRef } from '../utils/providerRef.js';
@@ -12,6 +13,8 @@ import { parseProviderRef } from '../utils/providerRef.js';
* share ONE `/providers/catalog` fetch rather than firing N of them.
*/
let inFlight = null;
+let generation = 0;
+let listenersInstalled = false;
// Mounted hooks, notified when the shared cache is dropped so they re-read.
// The AI Providers page (#7567) toggles a harness, edits a service or saves a
@@ -24,10 +27,11 @@ const EMPTY_CATALOG = Object.freeze({
});
function fetchCatalog() {
+ const readGeneration = generation;
inFlight ||= getProviderCatalog({ silent: true })
.catch((err) => {
console.warn(`⚠️ Provider catalog fetch failed: ${err?.message || err}`);
- inFlight = null;
+ if (readGeneration === generation) inFlight = null;
return null;
});
return inFlight;
@@ -35,6 +39,7 @@ function fetchCatalog() {
/** Test seam — drop the shared cache so each case starts from "never fetched". */
export function __resetProviderCatalogCache() {
+ generation += 1;
inFlight = null;
}
@@ -44,10 +49,21 @@ export function __resetProviderCatalogCache() {
* enablement toggle, a service create/edit/delete/refresh, a bootstrap save.
*/
export function invalidateProviderCatalog() {
+ generation += 1;
inFlight = null;
for (const notify of subscribers) notify();
}
+// Like the providers API cache, keep one pair of listeners for the lifetime of
+// the shared cache, including between mounts. A reconnect can recover a write
+// missed while disconnected; neither event fetches until a consumer is enabled.
+function listenForProviderChanges() {
+ if (listenersInstalled) return;
+ socket.on('providers:changed', invalidateProviderCatalog);
+ socket.on('connect', invalidateProviderCatalog);
+ listenersInstalled = true;
+}
+
/**
* The composition catalog behind the preset-first `ProviderModelSelector` and
* `ProviderComposePopover` (#7566): one fetch of `GET /api/providers/catalog`
@@ -97,28 +113,31 @@ export function invalidateProviderCatalog() {
* }}
*/
export default function useProviderCatalog(enabled = true) {
- const [state, setState] = useState({ catalog: null, loaded: false });
+ const [state, setState] = useState({ catalog: null, loaded: false, generation });
+
+ // A revision change must retrigger an already-loading picker too. Merely
+ // setting loaded=false leaves its obsolete request as the only active read.
+ useEffect(() => {
+ listenForProviderChanges();
+ const notify = () => setState((current) => ({ ...current, loaded: false, generation }));
+ subscribers.add(notify);
+ return () => { subscribers.delete(notify); };
+ }, []);
useEffect(() => {
if (!enabled || state.loaded) return undefined;
let canceled = false;
+ const readGeneration = generation;
fetchCatalog().then((catalog) => {
- if (!canceled) setState({ catalog, loaded: true });
+ if (!canceled && readGeneration === generation) {
+ setState((current) => ({ ...current, catalog: catalog ?? current.catalog, loaded: true }));
+ }
});
// A cancel (popover closed mid-flight) leaves `loaded` false, so reopening
// re-reads rather than rendering a result that never arrived — free when
// the first fetch already succeeded, since the shared cache still has it.
return () => { canceled = true; };
- }, [enabled, state.loaded]);
-
- // An invalidation flips `loaded` off; the fetch effect above then re-reads.
- // The stale catalog stays rendered until the new one lands — a picker never
- // blanks mid-toggle.
- useEffect(() => {
- const notify = () => setState((current) => ({ ...current, loaded: false }));
- subscribers.add(notify);
- return () => { subscribers.delete(notify); };
- }, []);
+ }, [enabled, state.loaded, state.generation]);
const catalog = state.catalog || EMPTY_CATALOG;
diff --git a/client/src/hooks/useProviderCatalog.test.js b/client/src/hooks/useProviderCatalog.test.js
index 6c24c7a4df..23f2de0cfc 100644
--- a/client/src/hooks/useProviderCatalog.test.js
+++ b/client/src/hooks/useProviderCatalog.test.js
@@ -1,9 +1,27 @@
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { renderHook, waitFor, act } from '@testing-library/react';
-import useProviderCatalog, { __resetProviderCatalogCache } from './useProviderCatalog.js';
+import useProviderCatalog, { __resetProviderCatalogCache, invalidateProviderCatalog } from './useProviderCatalog.js';
const api = vi.hoisted(() => ({ getProviderCatalog: vi.fn(), createProviderPreset: vi.fn() }));
vi.mock('../services/api.js', () => api);
+const socket = vi.hoisted(() => {
+ const listeners = new Map();
+ return {
+ on(event, listener) {
+ listeners.set(event, [...(listeners.get(event) || []), listener]);
+ },
+ emit(event) { for (const listener of listeners.get(event) || []) listener(); },
+ listenerCount(event) { return (listeners.get(event) || []).length; },
+ };
+});
+vi.mock('../services/socket.js', () => ({ default: socket }));
+
+function deferred() {
+ let resolve;
+ let reject;
+ const promise = new Promise((done, fail) => { resolve = done; reject = fail; });
+ return { promise, resolve, reject };
+}
const CATALOG = {
harnesses: [
@@ -19,6 +37,7 @@ const CATALOG = {
effortLevelsByModel: { pi: {}, claude: {} },
presets: [{ id: 'claude-code', name: 'Claude', enabled: true }],
};
+const UPDATED_CATALOG = { ...CATALOG, harnesses: CATALOG.harnesses.map((h) => ({ ...h, enabled: true })) };
beforeEach(() => {
__resetProviderCatalogCache();
@@ -154,24 +173,78 @@ describe('invalidateProviderCatalog', () => {
// picker's compose flow must reflect it without a reload (#7567): one
// invalidation re-reads the catalog in every mounted hook, keeping the
// stale rows rendered until the new ones land.
- it('re-reads the catalog in every mounted hook and keeps the stale rows until it lands', async () => {
- const { invalidateProviderCatalog } = await import('./useProviderCatalog.js');
+ it.each(['local mutation', 'providers:changed', 'connect'])('shares a replacement read after %s, keeping useful old rows while loading', async (event) => {
const { result: a } = renderHook(() => useProviderCatalog());
const { result: b } = renderHook(() => useProviderCatalog());
await waitFor(() => expect(a.current.loading).toBe(false));
await waitFor(() => expect(b.current.loading).toBe(false));
- const next = { ...CATALOG, harnesses: CATALOG.harnesses.map((h) => ({ ...h, enabled: true })) };
- let release;
- api.getProviderCatalog.mockImplementationOnce(() => new Promise((resolve) => { release = () => resolve(next); }));
- act(() => { invalidateProviderCatalog(); });
+ const replacement = deferred();
+ api.getProviderCatalog.mockReturnValueOnce(replacement.promise);
+ act(() => { event === 'local mutation' ? invalidateProviderCatalog() : socket.emit(event); });
// In flight: the old rows are still what renders, not an empty catalog.
expect(a.current.harnesses.find((h) => h.id === 'claude').enabled).toBe(false);
+ expect(a.current.loading).toBe(true);
+ expect(b.current.loading).toBe(true);
expect(api.getProviderCatalog).toHaveBeenCalledTimes(2);
- await act(async () => { release(); });
+ await act(async () => { replacement.resolve(UPDATED_CATALOG); });
await waitFor(() => expect(a.current.harnesses.find((h) => h.id === 'claude').enabled).toBe(true));
await waitFor(() => expect(b.current.harnesses.find((h) => h.id === 'claude').enabled).toBe(true));
// One shared fetch served both hooks, as on the first read.
expect(api.getProviderCatalog).toHaveBeenCalledTimes(2);
});
+
+ it.each(['providers:changed', 'connect'])('invalidates between mounts on %s without fetching for a disabled consumer', async (event) => {
+ const first = renderHook(() => useProviderCatalog());
+ await waitFor(() => expect(first.result.current.loading).toBe(false));
+ first.unmount();
+ api.getProviderCatalog.mockResolvedValue(UPDATED_CATALOG);
+ act(() => { socket.emit(event); });
+ expect(api.getProviderCatalog).toHaveBeenCalledTimes(1);
+
+ const next = renderHook(({ enabled }) => useProviderCatalog(enabled), { initialProps: { enabled: false } });
+ act(() => { socket.emit(event); });
+ expect(api.getProviderCatalog).toHaveBeenCalledTimes(1);
+ expect(next.result.current.loading).toBe(false);
+ next.rerender({ enabled: true });
+ await waitFor(() => expect(next.result.current.harnesses).toEqual(UPDATED_CATALOG.harnesses));
+ expect(api.getProviderCatalog).toHaveBeenCalledTimes(2);
+ next.unmount();
+ // Listener lifetime belongs to the cache, not to any individual mount.
+ expect(socket.listenerCount('providers:changed')).toBe(1);
+ expect(socket.listenerCount('connect')).toBe(1);
+ });
+
+ it.each(['before replacement', 'after replacement', 'failure after replacement'])('ignores an obsolete initial request settling %s', async (order) => {
+ const obsolete = deferred();
+ const replacement = deferred();
+ api.getProviderCatalog.mockReturnValueOnce(obsolete.promise).mockReturnValueOnce(replacement.promise);
+ const first = renderHook(() => useProviderCatalog());
+ const second = renderHook(() => useProviderCatalog());
+ act(() => { socket.emit('providers:changed'); });
+ expect(api.getProviderCatalog).toHaveBeenCalledTimes(2);
+
+ if (order === 'before replacement') {
+ await act(async () => { obsolete.resolve(CATALOG); });
+ expect(first.result.current.loading).toBe(true);
+ expect(first.result.current.harnesses).toEqual([]);
+ expect(second.result.current.loading).toBe(true);
+ }
+ await act(async () => { replacement.resolve(UPDATED_CATALOG); });
+ if (order !== 'before replacement') {
+ await act(async () => {
+ if (order === 'failure after replacement') obsolete.reject(new Error('old request failed'));
+ else obsolete.resolve(CATALOG);
+ });
+ }
+ expect(first.result.current.harnesses).toEqual(UPDATED_CATALOG.harnesses);
+ expect(second.result.current.harnesses).toEqual(UPDATED_CATALOG.harnesses);
+ expect(first.result.current.loading).toBe(false);
+ first.unmount();
+ second.unmount();
+ const later = renderHook(() => useProviderCatalog());
+ await waitFor(() => expect(later.result.current.loading).toBe(false));
+ expect(later.result.current.harnesses).toEqual(UPDATED_CATALOG.harnesses);
+ expect(api.getProviderCatalog).toHaveBeenCalledTimes(2);
+ });
});