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

packages/app/src/components/agent-form/agent-form-dropdowns.tsx

@@ -343,7 +343,8 @@ export function ComboSelect({
   const anchorRef = useRef<View>(null);
 
   const selectedOption = options.find((opt) => opt.id === value);
-  const displayValue = selectedOption?.label ?? (value || "");
+  const displayValue = selectedOption?.label ?? "";
+  const isEmpty = options.length === 0;
 
   const handleOpen = useCallback(() => setIsOpen(true), []);
   const handleOpenChange = useCallback((open: boolean) => setIsOpen(open), []);
@@ -355,7 +356,7 @@ export function ComboSelect({
         value={displayValue}
         placeholder={placeholder}
         onPress={handleOpen}
-        disabled={disabled}
+        disabled={disabled || isEmpty}
         isLoading={isLoading}
         controlRef={anchorRef}
         icon={icon}
@@ -567,8 +568,8 @@ export function AgentConfigRow({
           title="Select provider"
           value={selectedProvider}
           options={providerOptions}
-          placeholder="Select..."
+          placeholder={providerOptions.length > 0 ? "Select..." : "No providers available"}
-          disabled={disabled}
+          disabled={disabled || providerOptions.length === 0}
           onSelect={onSelectProvider}
           icon={<Bot size={16} color={defaultTheme.colors.foregroundMuted} />}
           showLabel={false}

packages/app/src/components/agent-status-bar.tsx

@@ -17,6 +17,14 @@ interface AgentStatusBarProps {
   serverId: string;
 }
 
+function normalizeModelId(modelId: string | null | undefined): string | null {
+  const normalized = typeof modelId === "string" ? modelId.trim() : "";
+  if (!normalized || normalized.toLowerCase() === "default") {
+    return null;
+  }
+  return normalized;
+}
+
 export function AgentStatusBar({ agentId, serverId }: AgentStatusBarProps) {
   const { theme } = useUnistyles();
   const IS_WEB = Platform.OS === "web";
@@ -61,14 +69,16 @@ export function AgentStatusBar({ agentId, serverId }: AgentStatusBarProps) {
     });
   }
 
+  const normalizedRuntimeModelId = normalizeModelId(agent.runtimeInfo?.model);
+  const normalizedConfiguredModelId = normalizeModelId(agent.model);
+  const preferredModelId = normalizedRuntimeModelId ?? normalizedConfiguredModelId;
   const selectedModel = useMemo(() => {
-    if (!models || !agent.model) return null;
+    if (!models || !preferredModelId) return null;
-    return models.find((m) => m.id === agent.model) ?? null;
+    return models.find((m) => m.id === preferredModelId) ?? null;
-  }, [models, agent.model]);
+  }, [models, preferredModelId]);
 
-  const displayModel = selectedModel
+  const activeModelId = selectedModel?.id ?? preferredModelId ?? null;
-    ? selectedModel.label
+  const displayModel = selectedModel ? selectedModel.label : preferredModelId ?? "Auto";
-    : agent.model ?? "default";
 
   const thinkingOptions = selectedModel?.thinkingOptions ?? null;
   const explicitThinkingId =
@@ -156,7 +166,7 @@ export function AgentStatusBar({ agentId, serverId }: AgentStatusBarProps) {
               testID="agent-model-menu"
             >
               {models?.map((model) => {
-                const isActive = model.id === agent.model;
+                const isActive = model.id === activeModelId;
                 return (
                   <DropdownMenuItem
                     key={model.id}
@@ -297,7 +307,7 @@ export function AgentStatusBar({ agentId, serverId }: AgentStatusBarProps) {
                 </DropdownMenuTrigger>
                 <DropdownMenuContent side="top" align="start">
                   {models?.map((model) => {
-                    const isActive = model.id === agent.model;
+                    const isActive = model.id === activeModelId;
                     return (
                       <DropdownMenuItem
                         key={model.id}

packages/app/src/hooks/use-agent-form-state.test.ts

@@ -1,6 +1,13 @@
 import { describe, expect, it } from "vitest";
 import { __private__ } from "./use-agent-form-state";
-import type { AgentModelDefinition } from "@server/server/agent/agent-sdk-types";
+import {
+  AGENT_PROVIDER_DEFINITIONS,
+  type AgentProviderDefinition,
+} from "@server/server/agent/provider-manifest";
+import type {
+  AgentModelDefinition,
+  AgentProvider,
+} from "@server/server/agent/agent-sdk-types";
 
 describe("useAgentFormState", () => {
   describe("__private__.combineInitialValues", () => {
@@ -146,5 +153,127 @@ describe("useAgentFormState", () => {
 
       expect(resolved.thinkingOptionId).toBe("xhigh");
     });
+
+    it("normalizes legacy model id 'default' from initial values to auto", () => {
+      const resolved = __private__.resolveFormState(
+        { model: "default" },
+        { provider: "codex" },
+        codexModels,
+        {
+          serverId: false,
+          provider: false,
+          modeId: false,
+          model: false,
+          thinkingOptionId: false,
+          workingDir: false,
+        },
+        {
+          serverId: null,
+          provider: "codex",
+          modeId: "",
+          model: "",
+          thinkingOptionId: "",
+          workingDir: "",
+        },
+        new Set<string>()
+      );
+
+      expect(resolved.model).toBe("");
+    });
+
+    it("normalizes legacy model id 'default' from provider preferences to auto", () => {
+      const resolved = __private__.resolveFormState(
+        undefined,
+        {
+          provider: "codex",
+          providerPreferences: {
+            codex: {
+              model: "default",
+            },
+          },
+        },
+        codexModels,
+        {
+          serverId: false,
+          provider: false,
+          modeId: false,
+          model: false,
+          thinkingOptionId: false,
+          workingDir: false,
+        },
+        {
+          serverId: null,
+          provider: "codex",
+          modeId: "",
+          model: "",
+          thinkingOptionId: "",
+          workingDir: "",
+        },
+        new Set<string>()
+      );
+
+      expect(resolved.model).toBe("");
+    });
+
+    it("resolves provider only from allowed provider map", () => {
+      const allowedProviderMap = new Map<AgentProvider, AgentProviderDefinition>(
+        AGENT_PROVIDER_DEFINITIONS
+          .filter((definition) => definition.id === "claude")
+          .map((definition) => [definition.id as AgentProvider, definition])
+      );
+      const resolved = __private__.resolveFormState(
+        undefined,
+        { provider: "codex" },
+        null,
+        {
+          serverId: false,
+          provider: false,
+          modeId: false,
+          model: false,
+          thinkingOptionId: false,
+          workingDir: false,
+        },
+        {
+          serverId: null,
+          provider: "codex",
+          modeId: "",
+          model: "",
+          thinkingOptionId: "",
+          workingDir: "",
+        },
+        new Set<string>(),
+        allowedProviderMap
+      );
+
+      expect(resolved.provider).toBe("claude");
+    });
+
+    it("does not force fallback provider when allowed provider map is empty", () => {
+      const resolved = __private__.resolveFormState(
+        undefined,
+        { provider: "codex" },
+        null,
+        {
+          serverId: false,
+          provider: false,
+          modeId: false,
+          model: false,
+          thinkingOptionId: false,
+          workingDir: false,
+        },
+        {
+          serverId: null,
+          provider: "codex",
+          modeId: "",
+          model: "",
+          thinkingOptionId: "",
+          workingDir: "",
+        },
+        new Set<string>(),
+        new Map<AgentProvider, AgentProviderDefinition>()
+      );
+
+      expect(resolved.provider).toBe("codex");
+    });
   });
 });

packages/app/src/hooks/use-agent-form-state.ts

@@ -89,15 +89,25 @@ type UseAgentFormStateResult = {
   persistFormPreferences: () => Promise<void>;
 };
 
-const providerDefinitions = AGENT_PROVIDER_DEFINITIONS;
+const allProviderDefinitions = AGENT_PROVIDER_DEFINITIONS;
-const providerDefinitionMap = new Map<AgentProvider, AgentProviderDefinition>(
+const allProviderDefinitionMap = new Map<AgentProvider, AgentProviderDefinition>(
-  providerDefinitions.map((definition) => [definition.id, definition])
+  allProviderDefinitions.map((definition) => [definition.id, definition])
 );
-const fallbackDefinition = providerDefinitions[0];
+const fallbackDefinition = allProviderDefinitions[0];
 const DEFAULT_PROVIDER: AgentProvider = fallbackDefinition?.id ?? "claude";
 const DEFAULT_MODE_FOR_DEFAULT_PROVIDER =
   fallbackDefinition?.defaultModeId ?? "";
 
+function normalizeSelectedModelId(
+  modelId: string | null | undefined
+): string {
+  const normalized = typeof modelId === "string" ? modelId.trim() : "";
+  if (!normalized || normalized.toLowerCase() === "default") {
+    return "";
+  }
+  return normalized;
+}
+
 function resolveDefaultModel(
   availableModels: AgentModelDefinition[] | null
 ): AgentModelDefinition | null {
@@ -136,25 +146,33 @@ function resolveFormState(
   availableModels: AgentModelDefinition[] | null,
   userModified: UserModifiedFields,
   currentState: FormState,
-  validServerIds: Set<string>
+  validServerIds: Set<string>,
+  allowedProviderMap: Map<AgentProvider, AgentProviderDefinition> = allProviderDefinitionMap
 ): FormState {
   // Start with current state - we only update non-user-modified fields
   const result = { ...currentState };
+  const fallbackProvider = allowedProviderMap.keys().next().value as
+    | AgentProvider
+    | undefined;
 
   // 1. Resolve provider first (other fields depend on it)
   if (!userModified.provider) {
-    if (initialValues?.provider && providerDefinitionMap.has(initialValues.provider)) {
+    if (initialValues?.provider && allowedProviderMap.has(initialValues.provider)) {
       result.provider = initialValues.provider;
     } else if (
       preferences?.provider &&
-      providerDefinitionMap.has(preferences.provider as AgentProvider)
+      allowedProviderMap.has(preferences.provider as AgentProvider)
     ) {
       result.provider = preferences.provider as AgentProvider;
+    } else if (!allowedProviderMap.has(result.provider) && fallbackProvider) {
+      result.provider = fallbackProvider;
     }
     // else keep current (initialized to DEFAULT_PROVIDER)
+  } else if (!allowedProviderMap.has(result.provider) && fallbackProvider) {
+    result.provider = fallbackProvider;
   }
 
-  const providerDef = providerDefinitionMap.get(result.provider);
+  const providerDef = allowedProviderMap.get(result.provider);
   const providerPrefs = preferences?.providerPreferences?.[result.provider];
 
   // 2. Resolve modeId (depends on provider)
@@ -181,25 +199,24 @@ function resolveFormState(
   if (!userModified.model) {
     const isValidModel = (m: string) =>
       availableModels?.some((am) => am.id === m) ?? false;
+    const initialModel = normalizeSelectedModelId(initialValues?.model);
+    const preferredModel = normalizeSelectedModelId(providerPrefs?.model);
 
-    if (
+    if (initialModel) {
-      typeof initialValues?.model === "string" &&
-      initialValues.model.length > 0
-    ) {
       // If models aren't loaded yet, trust the initial value
       // It will be validated once models load
-      if (!availableModels || isValidModel(initialValues.model)) {
+      if (!availableModels || isValidModel(initialModel)) {
-        result.model = initialValues.model;
+        result.model = initialModel;
-      } else if (providerPrefs?.model && isValidModel(providerPrefs.model)) {
+      } else if (preferredModel && isValidModel(preferredModel)) {
-        result.model = providerPrefs.model;
+        result.model = preferredModel;
       } else {
         result.model = "";
       }
-    } else if (typeof providerPrefs?.model === "string" && providerPrefs.model.length > 0) {
+    } else if (preferredModel) {
       // If models haven't loaded yet, optimistically apply the stored preference.
       // We'll validate once models load and clear it if it isn't available.
-      if (!availableModels || isValidModel(providerPrefs.model)) {
+      if (!availableModels || isValidModel(preferredModel)) {
-        result.model = providerPrefs.model;
+        result.model = preferredModel;
       } else {
         result.model = "";
       }
@@ -353,6 +370,45 @@ export function useAgentFormState(
   const client = sessionState?.client ?? null;
   const isConnected = sessionState?.connection?.isConnected ?? false;
 
+  const availableProvidersQuery = useQuery({
+    queryKey: ["availableProviders", formState.serverId],
+    enabled: Boolean(
+      isVisible && isTargetDaemonReady && formState.serverId && client && isConnected
+    ),
+    staleTime: 60 * 1000,
+    queryFn: async () => {
+      if (!client) {
+        throw new Error("Host is not connected");
+      }
+      const payload = await client.listAvailableProviders();
+      if (payload.error) {
+        throw new Error(payload.error);
+      }
+      return payload.providers
+        .filter((entry) => entry.available)
+        .map((entry) => entry.provider);
+    },
+  });
+
+  const providerDefinitions = useMemo(() => {
+    const availableProviders = availableProvidersQuery.data;
+    if (!availableProviders) {
+      return [];
+    }
+    const available = new Set(availableProviders);
+    return allProviderDefinitions.filter((definition) =>
+      available.has(definition.id as AgentProvider)
+    );
+  }, [availableProvidersQuery.data]);
+
+  const providerDefinitionMap = useMemo(
+    () =>
+      new Map<AgentProvider, AgentProviderDefinition>(
+        providerDefinitions.map((definition) => [definition.id as AgentProvider, definition])
+      ),
+    [providerDefinitions]
+  );
+
   const [debouncedCwd, setDebouncedCwd] = useState<string | undefined>(undefined);
   useEffect(() => {
     const trimmed = formState.workingDir.trim();
@@ -363,7 +419,14 @@ export function useAgentFormState(
 
   const providerModelsQuery = useQuery({
     queryKey: ["providerModels", formState.serverId, formState.provider, debouncedCwd],
-    enabled: Boolean(isVisible && isTargetDaemonReady && formState.serverId && client && isConnected),
+    enabled: Boolean(
+      isVisible &&
+        isTargetDaemonReady &&
+        formState.serverId &&
+        client &&
+        isConnected &&
+        providerDefinitionMap.has(formState.provider)
+    ),
     staleTime: 5 * 60 * 1000,
     queryFn: async () => {
       if (!client) {
@@ -403,7 +466,8 @@ export function useAgentFormState(
       availableModels,
       userModified,
       formStateRef.current,
-      validServerIds
+      validServerIds,
+      providerDefinitionMap
     );
 
     // Only update if something changed
@@ -428,6 +492,7 @@ export function useAgentFormState(
     availableModels,
     userModified,
     validServerIds,
+    providerDefinitionMap,
   ]);
 
   // Auto-select the first online host when:
@@ -500,11 +565,11 @@ export function useAgentFormState(
         ...prev,
         provider,
         modeId: providerPrefs?.mode ?? providerDef?.defaultModeId ?? "",
-        model: providerPrefs?.model ?? "",
+        model: normalizeSelectedModelId(providerPrefs?.model),
         thinkingOptionId: providerPrefs?.thinkingOptionId ?? "",
       }));
     },
-    [preferences?.providerPreferences, updatePreferences]
+    [preferences?.providerPreferences, providerDefinitionMap, updatePreferences]
   );
 
   const setModeFromUser = useCallback(
@@ -518,9 +583,10 @@ export function useAgentFormState(
 
   const setModelFromUser = useCallback(
     (modelId: string) => {
-      setFormState((prev) => ({ ...prev, model: modelId }));
+      const normalizedModelId = normalizeSelectedModelId(modelId);
+      setFormState((prev) => ({ ...prev, model: normalizedModelId }));
       setUserModified((prev) => ({ ...prev, model: true }));
-      void updateProviderPreferences(formState.provider, { model: modelId });
+      void updateProviderPreferences(formState.provider, { model: normalizedModelId });
     },
     [formState.provider, updateProviderPreferences]
   );
@@ -639,6 +705,8 @@ export function useAgentFormState(
       setThinkingOptionFromUser,
       setWorkingDir,
       setWorkingDirFromUser,
+      providerDefinitions,
+      providerDefinitionMap,
       agentDefinition,
       modeOptions,
       availableModels,

packages/app/src/screens/agent/draft-agent-screen.tsx

@@ -785,6 +785,13 @@ export function DraftAgentScreen({
         dispatch({ type: "DRAFT_SET_ERROR", message: "No host selected" });
         throw new Error("No host selected");
       }
+      if (providerDefinitions.length === 0) {
+        dispatch({
+          type: "DRAFT_SET_ERROR",
+          message: "No available providers on the selected host",
+        });
+        throw new Error("No available providers on the selected host");
+      }
       if (gitBlockingError) {
         dispatch({ type: "DRAFT_SET_ERROR", message: gitBlockingError });
         throw new Error(gitBlockingError);
@@ -894,6 +901,7 @@ export function DraftAgentScreen({
       isDirectoryNotExists,
       isNonGitDirectory,
       modeOptions,
+      providerDefinitions,
       persistFormPreferences,
       router,
       selectedMode,

packages/app/src/utils/extract-agent-model.test.ts

@@ -19,4 +19,13 @@ describe("extractAgentModel", () => {
 
     expect(extractAgentModel(agent)).toBe("gpt-5.1-codex");
   });
+
+  it("treats legacy 'default' model ids as unset", () => {
+    const agent = {
+      model: "default",
+      runtimeInfo: { model: "default" },
+    } as Partial<Agent> as Agent;
+
+    expect(extractAgentModel(agent)).toBeNull();
+  });
 });

packages/app/src/utils/extract-agent-model.ts

@@ -4,11 +4,17 @@ export function extractAgentModel(agent?: Agent | null): string | null {
   if (!agent) return null;
   const runtimeModel = agent.runtimeInfo?.model;
   const fallbackModel = agent.model;
-  if (typeof runtimeModel === "string" && runtimeModel.trim().length > 0) {
+  if (typeof runtimeModel === "string") {
-    return runtimeModel.trim();
+    const normalized = runtimeModel.trim();
+    if (normalized.length > 0 && normalized.toLowerCase() !== "default") {
+      return normalized;
+    }
   }
-  if (typeof fallbackModel === "string" && fallbackModel.trim().length > 0) {
+  if (typeof fallbackModel === "string") {
-    return fallbackModel.trim();
+    const normalized = fallbackModel.trim();
+    if (normalized.length > 0 && normalized.toLowerCase() !== "default") {
+      return normalized;
+    }
   }
   return null;
 }

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