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
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
Refresh provider composition catalogs after changes and reconnects (#11520)
[._.]/07a7cf4ceae3
diff --git a/client/src/hooks/useProviderCatalog.js b/client/src/hooks/useProviderCatalog.jsindex 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.jsindex 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);+ });});