feat: add provider availability detection and normalize legacy "default" model IDs

packages/server/src/client/daemon-client.test.ts

@@ -418,6 +418,60 @@ describe("DaemonClient", () => {
     vi.useRealTimers();
   });
 
+  test("lists available providers via RPC", async () => {
+    const logger = createMockLogger();
+    const mock = createMockTransport();
+
+    const client = new DaemonClient({
+      url: "ws://test",
+      logger,
+      reconnect: { enabled: false },
+      transportFactory: () => mock.transport,
+    });
+    clients.push(client);
+
+    const connectPromise = client.connect();
+    mock.triggerOpen();
+    await connectPromise;
+
+    const promise = client.listAvailableProviders();
+    expect(mock.sent).toHaveLength(1);
+
+    const request = JSON.parse(mock.sent[0]) as {
+      type: "session";
+      message: { type: "list_available_providers_request"; requestId: string };
+    };
+    expect(request.message.type).toBe("list_available_providers_request");
+
+    mock.triggerMessage(
+      JSON.stringify({
+        type: "session",
+        message: {
+          type: "list_available_providers_response",
+          payload: {
+            providers: [
+              { provider: "claude", available: true, error: null },
+              { provider: "codex", available: false, error: "Missing binary" },
+            ],
+            error: null,
+            fetchedAt: "2026-02-12T00:00:00.000Z",
+            requestId: request.message.requestId,
+          },
+        },
+      })
+    );
+
+    await expect(promise).resolves.toEqual({
+      providers: [
+        { provider: "claude", available: true, error: null },
+        { provider: "codex", available: false, error: "Missing binary" },
+      ],
+      error: null,
+      fetchedAt: "2026-02-12T00:00:00.000Z",
+      requestId: request.message.requestId,
+    });
+  });
+
   test("parses canonical agent_stream tool_call payloads without crashing", async () => {
     const logger = createMockLogger();
     const mock = createMockTransport();

packages/server/src/client/daemon-client.ts

@@ -30,6 +30,7 @@ import type {
   ListCommandsResponse,
   ExecuteCommandResponse,
   ListProviderModelsResponseMessage,
+  ListAvailableProvidersResponse,
   SpeechModelsListResponse,
   SpeechModelsDownloadResponse,
   ListTerminalsResponse,
@@ -194,6 +195,7 @@ type PaseoWorktreeArchivePayload = PaseoWorktreeArchiveResponse["payload"];
 type FileExplorerPayload = FileExplorerResponse["payload"];
 type FileDownloadTokenPayload = FileDownloadTokenResponse["payload"];
 type ListProviderModelsPayload = ListProviderModelsResponseMessage["payload"];
+type ListAvailableProvidersPayload = ListAvailableProvidersResponse["payload"];
 type SpeechModelsListPayload = SpeechModelsListResponse["payload"];
 type SpeechModelsDownloadPayload = SpeechModelsDownloadResponse["payload"];
 type ListCommandsPayload = ListCommandsResponse["payload"];
@@ -2054,6 +2056,31 @@ export class DaemonClient {
     });
   }
 
+  async listAvailableProviders(options?: {
+    requestId?: string;
+  }): Promise<ListAvailableProvidersPayload> {
+    const resolvedRequestId = this.createRequestId(options?.requestId);
+    const message = SessionInboundMessageSchema.parse({
+      type: "list_available_providers_request",
+      requestId: resolvedRequestId,
+    });
+    return this.sendRequest({
+      requestId: resolvedRequestId,
+      message,
+      timeout: 30000,
+      options: { skipQueue: true },
+      select: (msg) => {
+        if (msg.type !== "list_available_providers_response") {
+          return null;
+        }
+        if (msg.payload.requestId !== resolvedRequestId) {
+          return null;
+        }
+        return msg.payload;
+      },
+    });
+  }
+
   async listSpeechModels(requestId?: string): Promise<SpeechModelsListPayload> {
     const resolvedRequestId = this.createRequestId(requestId);
     const message = SessionInboundMessageSchema.parse({