feat: reduce probe timeouts and add refreshProviders to server API

Author: Aditya190803

apps/server/src/provider/Layers/ClaudeProvider.ts

@@ -391,7 +391,7 @@ export function adjustModelsForSubscription(
 
 // ── SDK capability probe ────────────────────────────────────────────
 
-const CAPABILITIES_PROBE_TIMEOUT_MS = 8_000;
+const CAPABILITIES_PROBE_TIMEOUT_MS = 2_000;
 const CLAUDE_RATE_LIMIT_PROBE_TIMEOUT_MS = 1_000;
 
 /**

apps/server/src/provider/Layers/CodexProvider.ts

@@ -282,7 +282,7 @@ export const hasCustomModelProvider = readCodexConfigModelProvider().pipe(
   Effect.orElseSucceed(() => false),
 );
 
-const CAPABILITIES_PROBE_TIMEOUT_MS = 8_000;
+const CAPABILITIES_PROBE_TIMEOUT_MS = 2_000;
 
 const probeCodexCapabilities = (input: {
   readonly binaryPath: string;

apps/server/src/provider/codexAppServer.ts

@@ -23,7 +23,7 @@ interface JsonRpcProbeResponse {
   };
 }
 
-const RATE_LIMITS_PROBE_GRACE_MS = 1_500;
+const RATE_LIMITS_PROBE_GRACE_MS = 150;
 
 function readErrorMessage(response: JsonRpcProbeResponse): string | undefined {
   return typeof response.error?.message === "string" ? response.error.message : undefined;

apps/web/src/rpc/serverState.test.ts

@@ -62,6 +62,11 @@ const baseServerConfig: ServerConfig = {
 
 const serverApi = {
   getConfig: vi.fn<() => Promise<ServerConfig>>(),
+  refreshProviders: vi.fn<
+    () => Promise<{
+      providers: ReadonlyArray<ServerProvider>;
+    }>
+  >(),
   subscribeConfig: vi.fn((listener: (event: ServerConfigStreamEvent) => void) =>
     registerListener(configListeners, listener),
   ),
@@ -101,6 +106,7 @@ beforeEach(() => {
   vi.clearAllMocks();
   lifecycleListeners.clear();
   configListeners.clear();
+  serverApi.refreshProviders.mockResolvedValue({ providers: defaultProviders });
   resetServerStateForTests();
 });
 
@@ -123,6 +129,7 @@ describe("serverState", () => {
     expect(serverApi.subscribeConfig).toHaveBeenCalledOnce();
     expect(serverApi.subscribeLifecycle).toHaveBeenCalledOnce();
     expect(serverApi.getConfig).toHaveBeenCalledOnce();
+    expect(serverApi.refreshProviders).toHaveBeenCalledOnce();
     expect(configListener).toHaveBeenCalledWith(
       {
         issues: [],
@@ -168,10 +175,15 @@ describe("serverState", () => {
       expect(getServerConfig()).toEqual(streamedConfig);
     });
 
+    await waitFor(() => {
+      expect(serverApi.refreshProviders).toHaveBeenCalledOnce();
+    });
+
     deferred.resolve(baseServerConfig);
     await new Promise((resolve) => setTimeout(resolve, 0));
 
     expect(getServerConfig()).toEqual(streamedConfig);
+    expect(serverApi.refreshProviders).toHaveBeenCalledOnce();
     stop();
   });
 
@@ -274,24 +286,22 @@ describe("serverState", () => {
     });
 
     expect(providersListener).toHaveBeenLastCalledWith({ providers: nextProviders });
-    expect(configListener).toHaveBeenNthCalledWith(
-      2,
+    expect(configListener.mock.calls).toContainEqual([
       {
         issues: [{ kind: "keybindings.malformed-config", message: "bad json" }],
         providers: defaultProviders,
         settings: DEFAULT_SERVER_SETTINGS,
       },
       "keybindingsUpdated",
-    );
-    expect(configListener).toHaveBeenNthCalledWith(
-      3,
+    ]);
+    expect(configListener.mock.calls).toContainEqual([
       {
         issues: [{ kind: "keybindings.malformed-config", message: "bad json" }],
         providers: nextProviders,
         settings: DEFAULT_SERVER_SETTINGS,
       },
       "providerStatuses",
-    );
+    ]);
     expect(configListener).toHaveBeenLastCalledWith(
       {
         issues: [{ kind: "keybindings.malformed-config", message: "bad json" }],
@@ -308,4 +318,39 @@ describe("serverState", () => {
     unsubscribeConfig();
     stop();
   });
+
+  it("applies eager refreshProviders results without waiting for stream events", async () => {
+    const refreshedProviders: ReadonlyArray<ServerProvider> = [
+      {
+        ...defaultProviders[0]!,
+        checkedAt: "2026-01-03T00:00:00.000Z",
+        usage: {
+          updatedAt: "2026-01-03T00:00:00.000Z",
+          buckets: [
+            {
+              id: "weekly",
+              label: "Weekly usage limit",
+              usedPercent: 12,
+              remainingPercent: 88,
+              resetsAt: "2026-01-08T16:19:00.000Z",
+            },
+          ],
+        },
+      },
+    ];
+    serverApi.getConfig.mockResolvedValueOnce(baseServerConfig);
+    serverApi.refreshProviders.mockResolvedValueOnce({ providers: refreshedProviders });
+
+    const stop = startServerStateSync(serverApi);
+
+    await waitFor(() => {
+      expect(getServerConfig()).toEqual({
+        ...baseServerConfig,
+        providers: refreshedProviders,
+      });
+    });
+
+    expect(serverApi.refreshProviders).toHaveBeenCalledOnce();
+    stop();
+  });
 });

apps/web/src/rpc/serverState.ts

@@ -24,7 +24,7 @@ export interface ServerConfigUpdatedNotification {
 
 type ServerStateClient = Pick<
   WsRpcClient["server"],
-  "getConfig" | "subscribeConfig" | "subscribeLifecycle"
+  "getConfig" | "refreshProviders" | "subscribeConfig" | "subscribeLifecycle"
 >;
 
 function makeStateAtom<A>(label: string, initialValue: A) {
@@ -161,6 +161,24 @@ export function onProvidersUpdated(
 
 export function startServerStateSync(client: ServerStateClient): () => void {
   let disposed = false;
+  let providerRefreshRequested = false;
+
+  const requestProviderRefresh = () => {
+    if (disposed || providerRefreshRequested) {
+      return;
+    }
+    providerRefreshRequested = true;
+    void client
+      .refreshProviders()
+      .then((payload) => {
+        if (disposed) {
+          return;
+        }
+        applyProvidersUpdated(payload);
+      })
+      .catch(() => undefined);
+  };
+
   const cleanups = [
     client.subscribeLifecycle((event) => {
       if (event.type === "welcome") {
@@ -169,6 +187,9 @@ export function startServerStateSync(client: ServerStateClient): () => void {
     }),
     client.subscribeConfig((event) => {
       applyServerConfigEvent(event);
+      if (event.type === "snapshot") {
+        requestProviderRefresh();
+      }
     }),
   ];
 
@@ -180,8 +201,11 @@ export function startServerStateSync(client: ServerStateClient): () => void {
           return;
         }
         setServerConfigSnapshot(config);
+        requestProviderRefresh();
       })
       .catch(() => undefined);
+  } else {
+    requestProviderRefresh();
   }
 
   return () => {