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({

packages/server/src/server/agent/agent-manager.test.ts

@@ -130,6 +130,28 @@ describe("AgentManager", () => {
     expect(snapshot.model).toBeUndefined();
   });
 
+  test("normalizeConfig strips legacy 'default' model id", async () => {
+    const workdir = mkdtempSync(join(tmpdir(), "agent-manager-test-"));
+    const storagePath = join(workdir, "agents");
+    const storage = new AgentStorage(storagePath, logger);
+    const manager = new AgentManager({
+      clients: {
+        codex: new TestAgentClient(),
+      },
+      registry: storage,
+      logger,
+      idFactory: () => "00000000-0000-4000-8000-000000000102",
+    });
+
+    const snapshot = await manager.createAgent({
+      provider: "codex",
+      cwd: workdir,
+      model: "default",
+    });
+
+    expect(snapshot.model).toBeUndefined();
+  });
+
   test("createAgent fails when cwd does not exist", async () => {
     const workdir = mkdtempSync(join(tmpdir(), "agent-manager-test-"));
     const storagePath = join(workdir, "agents");

packages/server/src/server/agent/agent-manager.ts

@@ -29,6 +29,7 @@ import type {
   PersistedAgentDescriptor,
 } from "./agent-sdk-types.js";
 import type { AgentStorage } from "./agent-storage.js";
+import { AGENT_PROVIDER_IDS } from "./provider-manifest.js";
 
 export { AGENT_LIFECYCLE_STATUSES, type AgentLifecycleStatus };
 
@@ -53,6 +54,12 @@ export type AgentAttentionCallback = (params: {
   reason: "finished" | "error" | "permission";
 }) => void;
 
+export type ProviderAvailability = {
+  provider: AgentProvider;
+  available: boolean;
+  error: string | null;
+};
+
 export type AgentManagerOptions = {
   clients?: Partial<Record<AgentProvider, AgentClient>>;
   maxTimelineItems?: number;
@@ -333,6 +340,42 @@ export class AgentManager {
       .slice(0, limit);
   }
 
+  async listProviderAvailability(): Promise<ProviderAvailability[]> {
+    const checks = AGENT_PROVIDER_IDS.map(async (providerId) => {
+      const provider = providerId as AgentProvider;
+      const client = this.clients.get(provider);
+      if (!client) {
+        return {
+          provider,
+          available: false,
+          error: `No client registered for provider '${provider}'`,
+        } satisfies ProviderAvailability;
+      }
+
+      try {
+        const available = await client.isAvailable();
+        return {
+          provider,
+          available,
+          error: null,
+        } satisfies ProviderAvailability;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.warn(
+          { err: error, provider },
+          "Failed to check provider availability"
+        );
+        return {
+          provider,
+          available: false,
+          error: message,
+        } satisfies ProviderAvailability;
+      }
+    });
+
+    return Promise.all(checks);
+  }
+
   getAgent(id: string): ManagedAgent | null {
     const agent = this.agents.get(id);
     return agent ? { ...agent } : null;
@@ -1460,7 +1503,9 @@ export class AgentManager {
 
     if (typeof normalized.model === "string") {
       const trimmed = normalized.model.trim();
-      normalized.model = trimmed.length > 0 ? trimmed : undefined;
+      const normalizedId = trimmed.toLowerCase();
+      normalized.model =
+        trimmed.length > 0 && normalizedId !== "default" ? trimmed : undefined;
     }
 
     return normalized;

packages/server/src/server/session.ts

@@ -1286,6 +1286,10 @@ export class Session {
           await this.handleListProviderModelsRequest(msg);
           break;
 
+        case "list_available_providers_request":
+          await this.handleListAvailableProvidersRequest(msg);
+          break;
+
         case "speech_models_list_request":
           await this.handleSpeechModelsListRequest(msg);
           break;
@@ -2594,6 +2598,38 @@ export class Session {
     }
   }
 
+  private async handleListAvailableProvidersRequest(
+    msg: Extract<SessionInboundMessage, { type: "list_available_providers_request" }>
+  ): Promise<void> {
+    const fetchedAt = new Date().toISOString();
+    try {
+      const providers = await this.agentManager.listProviderAvailability();
+      this.emit({
+        type: "list_available_providers_response",
+        payload: {
+          providers,
+          error: null,
+          fetchedAt,
+          requestId: msg.requestId,
+        },
+      });
+    } catch (error) {
+      this.sessionLogger.error(
+        { err: error },
+        "Failed to list provider availability"
+      );
+      this.emit({
+        type: "list_available_providers_response",
+        payload: {
+          providers: [],
+          error: (error as Error)?.message ?? String(error),
+          fetchedAt,
+          requestId: msg.requestId,
+        },
+      });
+    }
+  }
+
   private async handleSpeechModelsListRequest(
     msg: Extract<SessionInboundMessage, { type: "speech_models_list_request" }>
   ): Promise<void> {

packages/server/src/shared/messages.ts

@@ -564,6 +564,11 @@ export const ListProviderModelsRequestMessageSchema = z.object({
   requestId: z.string(),
 });
 
+export const ListAvailableProvidersRequestMessageSchema = z.object({
+  type: z.literal("list_available_providers_request"),
+  requestId: z.string(),
+});
+
 export const SpeechModelsListRequestSchema = z.object({
   type: z.literal("speech_models_list_request"),
   requestId: z.string(),
@@ -987,6 +992,7 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
   DictationStreamCancelMessageSchema,
   CreateAgentRequestMessageSchema,
   ListProviderModelsRequestMessageSchema,
+  ListAvailableProvidersRequestMessageSchema,
   SpeechModelsListRequestSchema,
   SpeechModelsDownloadRequestSchema,
   ResumeAgentRequestMessageSchema,
@@ -1635,6 +1641,22 @@ export const ListProviderModelsResponseMessageSchema = z.object({
   }),
 });
 
+const ProviderAvailabilitySchema = z.object({
+  provider: AgentProviderSchema,
+  available: z.boolean(),
+  error: z.string().nullable().optional(),
+});
+
+export const ListAvailableProvidersResponseSchema = z.object({
+  type: z.literal("list_available_providers_response"),
+  payload: z.object({
+    providers: z.array(ProviderAvailabilitySchema),
+    error: z.string().nullable().optional(),
+    fetchedAt: z.string(),
+    requestId: z.string(),
+  }),
+});
+
 export const SpeechModelsListResponseSchema = z.object({
   type: z.literal("speech_models_list_response"),
   payload: z.object({
@@ -1817,6 +1839,7 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
   ProjectIconResponseSchema,
   FileDownloadTokenResponseSchema,
   ListProviderModelsResponseMessageSchema,
+  ListAvailableProvidersResponseSchema,
   SpeechModelsListResponseSchema,
   SpeechModelsDownloadResponseSchema,
   ListCommandsResponseSchema,
@@ -1873,6 +1896,9 @@ export type AgentDeletedMessage = z.infer<typeof AgentDeletedMessageSchema>;
 export type ListProviderModelsResponseMessage = z.infer<
   typeof ListProviderModelsResponseMessageSchema
 >;
+export type ListAvailableProvidersResponse = z.infer<
+  typeof ListAvailableProvidersResponseSchema
+>;
 export type SpeechModelsListResponse = z.infer<typeof SpeechModelsListResponseSchema>;
 export type SpeechModelsDownloadResponse = z.infer<typeof SpeechModelsDownloadResponseSchema>;
 export type InitializeAgentResponseMessage = z.infer<typeof InitializeAgentResponseMessageSchema>;
@@ -1897,6 +1923,9 @@ export type CreateAgentRequestMessage = z.infer<typeof CreateAgentRequestMessage
 export type ListProviderModelsRequestMessage = z.infer<
   typeof ListProviderModelsRequestMessageSchema
 >;
+export type ListAvailableProvidersRequestMessage = z.infer<
+  typeof ListAvailableProvidersRequestMessageSchema
+>;
 export type SpeechModelsListRequestMessage = z.infer<typeof SpeechModelsListRequestSchema>;
 export type SpeechModelsDownloadRequestMessage = z.infer<
   typeof SpeechModelsDownloadRequestSchema