@getpaseo/server 0.1.98 → 0.1.99

package/dist/server/server/agent/agent-manager.js

@@ -2580,8 +2580,8 @@ export class AgentManager {
             const client = this.clients.get(normalized.provider);
             if (client) {
                 try {
-                    const models = await client.listModels({ cwd: normalized.cwd, force: false });
-                    const defaultModel = models.find((model) => model.isDefault) ?? models[0];
+                    const catalog = await client.fetchCatalog({ cwd: normalized.cwd, force: false });
+                    const defaultModel = catalog.models.find((model) => model.isDefault) ?? catalog.models[0];
                     if (defaultModel) {
                         normalized.model = defaultModel.id;
                     }

package/dist/server/server/agent/agent-sdk-types.d.ts

@@ -578,21 +578,26 @@ export interface AgentSession {
         }): Promise<void>;
     } | null;
 }
-export interface ListModelsOptions {
+export interface FetchCatalogOptions {
     cwd: string;
     force: boolean;
 }
-export interface ListModesOptions {
-    cwd: string;
-    force: boolean;
+export interface ProviderCatalog {
+    models: AgentModelDefinition[];
+    modes: AgentMode[];
 }
 export interface AgentClient {
     readonly provider: AgentProvider;
     readonly capabilities: AgentCapabilityFlags;
     createSession(config: AgentSessionConfig, launchContext?: AgentLaunchContext, options?: AgentCreateSessionOptions): Promise<AgentSession>;
     resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, launchContext?: AgentLaunchContext): Promise<AgentSession>;
-    listModels(options: ListModelsOptions): Promise<AgentModelDefinition[]>;
-    listModes?(options: ListModesOptions): Promise<AgentMode[]>;
+    /**
+     * Discover models and modes together. Implementations may use one upstream
+     * process, separate upstream calls, static modes, or private helpers; callers
+     * outside the provider do not get separate runtime model/mode probes.
+     * The registry is responsible for merging configured model overrides.
+     */
+    fetchCatalog(options: FetchCatalogOptions): Promise<ProviderCatalog>;
     resolveCreateConfig?(input: ResolveAgentCreateConfigInput): ResolveAgentCreateConfigResult;
     isCreateConfigUnattended?(input: AgentCreateConfigUnattendedInput): boolean;
     listCommands?(config: AgentSessionConfig): Promise<AgentSlashCommand[]>;

package/dist/server/server/agent/provider-registry.d.ts

@@ -1,5 +1,5 @@
 import type { Logger } from "pino";
-import type { AgentClient, AgentCreateConfigUnattendedInput, AgentMode, AgentModelDefinition, AgentProvider, AgentSession, ListModelsOptions, ListModesOptions, ResolveAgentCreateConfigInput, ResolveAgentCreateConfigResult } from "./agent-sdk-types.js";
+import type { AgentClient, AgentCreateConfigUnattendedInput, AgentProvider, AgentSession, FetchCatalogOptions, ProviderCatalog, ResolveAgentCreateConfigInput, ResolveAgentCreateConfigResult } from "./agent-sdk-types.js";
 import type { WorkspaceGitService } from "../workspace-git-service.js";
 import type { ManagedProcessRegistry } from "../managed-processes/managed-processes.js";
 import type { AgentProviderRuntimeSettingsMap, ProviderOverride } from "./provider-launch-config.js";
@@ -17,8 +17,11 @@ export interface ProviderDefinition extends AgentProviderDefinition {
     createClient: (logger: Logger) => AgentClient;
     resolveCreateConfig: (input: ResolveAgentCreateConfigInput) => ResolveAgentCreateConfigResult;
     isCreateConfigUnattended: (input: AgentCreateConfigUnattendedInput) => boolean;
-    fetchModels: (options: ListModelsOptions) => Promise<AgentModelDefinition[]>;
-    fetchModes: (options: ListModesOptions) => Promise<AgentMode[]>;
+    /**
+     * Single catalog discovery call used by ProviderSnapshotManager. Should spawn
+     * at most one provider runtime process and return both models and modes.
+     */
+    fetchCatalog: (options: FetchCatalogOptions, client?: AgentClient) => Promise<ProviderCatalog>;
 }
 export interface BuildProviderRegistryOptions {
     runtimeSettings?: AgentProviderRuntimeSettingsMap;

package/dist/server/server/agent/provider-registry.js

@@ -232,10 +232,15 @@ function wrapClientProvider(provider, inner, profileModels, additionalModels, pr
                 provider: inner.provider,
             }
             : undefined, launchContext)),
-        listModels: async (options) => mergeModels(provider, profileModels, additionalModels, await inner.listModels(options), {
-            profileModelsAreAdditive,
-        }),
-        listModes: inner.listModes?.bind(inner),
+        fetchCatalog: async (options) => {
+            const catalog = await inner.fetchCatalog(options);
+            return {
+                models: mergeModels(provider, profileModels, additionalModels, catalog.models, {
+                    profileModelsAreAdditive,
+                }),
+                modes: catalog.modes,
+            };
+        },
         resolveCreateConfig: inner.resolveCreateConfig?.bind(inner),
         isCreateConfigUnattended: inner.isCreateConfigUnattended?.bind(inner),
         listImportableSessions: listImportableSessions
@@ -275,6 +280,22 @@ function wrapClientProvider(provider, inner, profileModels, additionalModels, pr
 }
 function createRegistryEntry(logger, provider, resolved) {
     const modelClient = resolved.createBaseClient(logger);
+    const hasReplacementModels = resolved.profileModels.length > 0 && !resolved.profileModelsAreAdditive;
+    const replacementModels = hasReplacementModels
+        ? resolved.profileModels.map((model) => mapModel(provider, model))
+        : [];
+    const decorateModes = (modes) => modes.map((mode) => {
+        if (mode.icon && mode.colorTier)
+            return mode;
+        const definitionMode = resolved.definition.modes.find((d) => d.id === mode.id);
+        if (!definitionMode)
+            return mode;
+        return Object.assign({}, mode, {
+            icon: mode.icon ?? definitionMode.icon,
+            colorTier: mode.colorTier ?? definitionMode.colorTier,
+        });
+    });
+    const hasStaticModes = resolved.definition.modes.length > 0;
     return {
         ...resolved.definition,
         enabled: resolved.enabled,
@@ -282,24 +303,29 @@ function createRegistryEntry(logger, provider, resolved) {
         createClient: (providerLogger) => createResolvedProviderClient(providerLogger, provider, resolved),
         resolveCreateConfig: modelClient.resolveCreateConfig ?? resolveDefaultAgentCreateConfig,
         isCreateConfigUnattended: modelClient.isCreateConfigUnattended ?? isDefaultAgentCreateConfigUnattended,
-        fetchModels: async (options) => mergeModels(provider, resolved.profileModels, resolved.additionalModels, await modelClient.listModels(options), {
-            profileModelsAreAdditive: resolved.profileModelsAreAdditive,
-        }),
-        fetchModes: async (options) => {
-            const modes = modelClient.listModes
-                ? await modelClient.listModes(options)
-                : resolved.definition.modes;
-            return modes.map((mode) => {
-                if (mode.icon && mode.colorTier)
-                    return mode;
-                const definitionMode = resolved.definition.modes.find((d) => d.id === mode.id);
-                if (!definitionMode)
-                    return mode;
-                return Object.assign({}, mode, {
-                    icon: mode.icon ?? definitionMode.icon,
-                    colorTier: mode.colorTier ?? definitionMode.colorTier,
-                });
-            });
+        fetchCatalog: async (options, client) => {
+            const catalogClient = client ?? modelClient;
+            if (hasReplacementModels) {
+                // Replacement models skip runtime model discovery, but additionalModels
+                // must still be merged on top. If modes are dynamic, probe for modes via
+                // the single catalog API; otherwise use static/empty modes with no runtime.
+                const models = mergeModelAdditions(provider, replacementModels, resolved.additionalModels);
+                if (hasStaticModes) {
+                    return {
+                        models,
+                        modes: decorateModes(resolved.definition.modes),
+                    };
+                }
+                const catalog = await catalogClient.fetchCatalog(options);
+                return { models, modes: decorateModes(catalog.modes) };
+            }
+            const catalog = await catalogClient.fetchCatalog(options);
+            return {
+                models: mergeModels(provider, resolved.profileModels, resolved.additionalModels, catalog.models, {
+                    profileModelsAreAdditive: resolved.profileModelsAreAdditive,
+                }),
+                modes: decorateModes(catalog.modes),
+            };
         },
     };
 }

package/dist/server/server/agent/provider-snapshot-manager.js

@@ -5,6 +5,7 @@ import { expandTilde } from "../../utils/path.js";
 import { withTimeout } from "../../utils/promise-timeout.js";
 import { buildProviderRegistry, shutdownAgentClients, } from "./provider-registry.js";
 import { applyMutableProviderConfigToOverrides } from "../daemon-config-store.js";
+import { formatProviderDiagnostic } from "./providers/diagnostic-utils.js";
 const DEFAULT_REFRESH_TIMEOUT_MS = 30000;
 const REFRESH_TIMEOUT_ENV_VAR = "PASEO_PROVIDER_REFRESH_TIMEOUT_MS";
 // Provider refresh probes can be slow on cold starts (e.g. Copilot's first
@@ -179,13 +180,19 @@ export class ProviderSnapshotManager {
         });
     }
     async getProviderDiagnostic(provider) {
-        const client = this.providerClients[provider];
-        if (!client) {
-            throw new Error(`Provider ${provider} is not configured`);
-        }
-        const diagnostic = client.getDiagnostic
+        const definition = this.requireProvider(provider);
+        const client = this.ensureClient(provider, definition);
+        // Force-refresh the snapshot so Models/Status come from the single catalog authority.
+        await this.refreshSnapshotForCwd({ cwd: homedir(), providers: [provider] });
+        const entry = await this.getProvider({ cwd: homedir(), provider, wait: true });
+        const modelCount = entry.status === "ready" ? String(entry.models?.length ?? 0) : "—";
+        const status = formatProviderStatus(entry);
+        const baseDiagnostic = client.getDiagnostic
             ? (await client.getDiagnostic()).diagnostic
-            : "No diagnostic available for this provider.";
+            : formatProviderDiagnostic(definition.label ?? provider, [
+                { label: "Diagnostic", value: "No diagnostic available" },
+            ]);
+        const diagnostic = `${baseDiagnostic}\n  Models: ${modelCount}\n  Status: ${status}`;
         return { provider, diagnostic };
     }
     applyMutableProviderConfig(mutableProviders) {
@@ -238,8 +245,7 @@ export class ProviderSnapshotManager {
                 createClient: () => client,
                 resolveCreateConfig: client.resolveCreateConfig?.bind(client) ?? definition.resolveCreateConfig,
                 isCreateConfigUnattended: client.isCreateConfigUnattended?.bind(client) ?? definition.isCreateConfigUnattended,
-                fetchModels: client.listModels.bind(client),
-                fetchModes: client.listModes?.bind(client) ?? definition.fetchModes,
+                fetchCatalog: client.fetchCatalog.bind(client),
             };
         }
         return registry;
@@ -448,16 +454,13 @@ export class ProviderSnapshotManager {
                 setEntry({ ...base, status: "unavailable", enabled: true });
                 return;
             }
-            const [models, modes] = await withTimeout(Promise.all([
-                definition.fetchModels({ cwd, force }),
-                definition.fetchModes({ cwd, force }),
-            ]), this.refreshTimeoutMs, `Timed out refreshing ${definition.label} after ${this.refreshTimeoutMs}ms`);
+            const catalog = await withTimeout(definition.fetchCatalog({ cwd, force }, client), this.refreshTimeoutMs, `Timed out refreshing ${definition.label} after ${this.refreshTimeoutMs}ms`);
             setEntry({
                 ...base,
                 status: "ready",
                 enabled: true,
-                models,
-                modes,
+                models: catalog.models,
+                modes: catalog.modes,
                 fetchedAt: new Date().toISOString(),
             });
         }
@@ -580,4 +583,13 @@ function toErrorMessage(error) {
     }
     return "Unknown error";
 }
+function formatProviderStatus(entry) {
+    if (entry.status === "ready")
+        return "Ready";
+    if (entry.status === "error")
+        return `Error: ${entry.error ?? "Unknown error"}`;
+    if (entry.status === "unavailable")
+        return "Unavailable";
+    return "Loading";
+}
 //# sourceMappingURL=provider-snapshot-manager.js.map

package/dist/server/server/agent/providers/acp-agent.d.ts

@@ -3,7 +3,7 @@ import type { ProcessTerminator } from "../../../utils/tree-kill.js";
 import type { ReadableStream as NodeReadableStream, WritableStream as NodeWritableStream } from "node:stream/web";
 import { ClientSideConnection, type Client as ACPClient, type CreateTerminalRequest, type InitializeResponse, type KillTerminalRequest, type LoadSessionResponse, type NewSessionResponse, type ReadTextFileRequest, type RequestPermissionRequest, type RequestPermissionResponse, type ResumeSessionResponse, type SessionConfigOption, type SessionMode, type SessionModelState, type SessionNotification, type TerminalOutputRequest, type TerminalOutputResponse, type ToolCallContent, type ToolCallLocation, type ToolCallStatus, type ToolKind, type Usage, type WaitForTerminalExitRequest, type WriteTextFileRequest, type Stream as ACPStream } from "@agentclientprotocol/sdk";
 import type { Logger } from "pino";
-import { type AgentCapabilityFlags, type AgentClient, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPersistenceHandle, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentUsage, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ListModesOptions, type ListModelsOptions } from "../agent-sdk-types.js";
+import { type AgentCapabilityFlags, type AgentClient, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPersistenceHandle, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentUsage, type FetchCatalogOptions, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ProviderCatalog } from "../agent-sdk-types.js";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
 export declare function summarizeACPRequestError(error: unknown): {
     message: string;
@@ -155,8 +155,7 @@ export declare class ACPAgentClient implements AgentClient {
     constructor(options: ACPAgentClientOptions);
     createSession(config: AgentSessionConfig, launchContext?: AgentLaunchContext): Promise<AgentSession>;
     resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, launchContext?: AgentLaunchContext): Promise<AgentSession>;
-    listModels(options: ListModelsOptions): Promise<AgentModelDefinition[]>;
-    listModes(options: ListModesOptions): Promise<AgentMode[]>;
+    fetchCatalog(options: FetchCatalogOptions): Promise<ProviderCatalog>;
     listImportableSessions(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
     importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../agent-sdk-types.js").ImportedProviderSession>;
     isAvailable(): Promise<boolean>;
@@ -194,6 +193,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     private readonly pendingPermissions;
     private readonly messageAssemblies;
     private readonly submittedUserMessageIds;
+    private activeSubmittedUserMessage;
     private readonly toolCalls;
     private readonly terminalEntries;
     private readonly persistedHistory;
@@ -282,6 +282,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     private translateSessionUpdate;
     private handleToolCallUpdate;
     private createMessageTimelineItem;
+    private messageAssemblyKey;
     private handleCurrentModeUpdate;
     private handleConfigOptionUpdate;
     private handleSessionInfoUpdate;
@@ -292,6 +293,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     private emitSubmittedUserMessage;
     private runtimeInfo;
     private finishTurn;
+    private isSubmittedUserMessageEcho;
     private emitBootstrapThreadEvent;
     private synthesizeCanceledToolCalls;
     private collectDiagnostic;

package/dist/server/server/agent/providers/acp-agent.js

@@ -344,7 +344,7 @@ export class ACPAgentClient {
         await session.initializeResumedSession();
         return session;
     }
-    async listModels(options) {
+    async fetchCatalog(options) {
         const { cwd } = options;
         const probe = await this.spawnProcess(PROBE_ENV);
         try {
@@ -354,23 +354,11 @@ export class ACPAgentClient {
             }));
             const transformed = this.transformSessionResponse(response);
             const models = deriveModelDefinitionsFromACP(this.provider, transformed.models, transformed.configOptions);
-            return this.modelTransformer ? this.modelTransformer(models) : models;
-        }
-        finally {
-            await this.closeProbe(probe);
-        }
-    }
-    async listModes(options) {
-        const { cwd } = options;
-        const probe = await this.spawnProcess(PROBE_ENV);
-        try {
-            const response = await this.runACPRequest(() => probe.connection.newSession({
-                cwd,
-                mcpServers: [],
-            }));
-            const transformed = this.transformSessionResponse(response);
             const modeInfo = deriveModesFromACP(this.defaultModes, transformed.modes, transformed.configOptions);
-            return modeInfo.modes;
+            return {
+                models: this.modelTransformer ? this.modelTransformer(models) : models,
+                modes: modeInfo.modes,
+            };
         }
         finally {
             await this.closeProbe(probe);
@@ -561,6 +549,7 @@ export class ACPAgentSession {
         this.pendingPermissions = new Map();
         this.messageAssemblies = new Map();
         this.submittedUserMessageIds = new Set();
+        this.activeSubmittedUserMessage = null;
         this.toolCalls = new Map();
         this.terminalEntries = new Map();
         this.persistedHistory = [];
@@ -690,6 +679,7 @@ export class ACPAgentSession {
         const turnId = randomUUID();
         const messageId = options?.messageId ?? randomUUID();
         this.activeForegroundTurnId = turnId;
+        this.activeSubmittedUserMessage = null;
         this.emitBootstrapThreadEvent();
         this.pushEvent({ type: "turn_started", provider: this.provider, turnId });
         this.emitSubmittedUserMessage(prompt, messageId, turnId);
@@ -1413,7 +1403,10 @@ export class ACPAgentSession {
                 if (!item) {
                     return [];
                 }
-                if (update.messageId && this.submittedUserMessageIds.has(update.messageId)) {
+                if (item.type !== "user_message") {
+                    return [this.wrapTimeline(item)];
+                }
+                if (this.isSubmittedUserMessageEcho(item)) {
                     return [];
                 }
                 return [this.wrapTimeline(item)];
@@ -1476,7 +1469,7 @@ export class ACPAgentSession {
         if (!chunkText) {
             return null;
         }
-        const key = `${type}:${update.messageId ?? "default"}`;
+        const key = this.messageAssemblyKey(type, update.messageId);
         const state = this.messageAssemblies.get(key) ?? { text: "" };
         state.text += chunkText;
         this.messageAssemblies.set(key, state);
@@ -1488,6 +1481,10 @@ export class ACPAgentSession {
         }
         return { type: "reasoning", text: chunkText };
     }
+    messageAssemblyKey(type, messageId) {
+        const fallbackId = type === "user_message" ? (this.activeForegroundTurnId ?? "default") : "default";
+        return `${type}:${messageId ?? fallbackId}`;
+    }
     handleCurrentModeUpdate(update) {
         this.currentMode = this.transformModeId(update.currentModeId);
     }
@@ -1589,6 +1586,7 @@ export class ACPAgentSession {
             return;
         }
         this.submittedUserMessageIds.add(messageId);
+        this.activeSubmittedUserMessage = { messageId, text, turnId };
         this.pushEvent({
             type: "timeline",
             provider: this.provider,
@@ -1611,8 +1609,23 @@ export class ACPAgentSession {
     }
     finishTurn(event) {
         this.activeForegroundTurnId = null;
+        if (this.activeSubmittedUserMessage?.turnId === event.turnId) {
+            this.activeSubmittedUserMessage = null;
+        }
         this.pushEvent(event);
     }
+    isSubmittedUserMessageEcho(item) {
+        const active = this.activeSubmittedUserMessage;
+        if (!active || active.turnId !== this.activeForegroundTurnId) {
+            return false;
+        }
+        if (item.messageId) {
+            if (this.submittedUserMessageIds.has(item.messageId)) {
+                return true;
+            }
+        }
+        return active.text.startsWith(item.text);
+    }
     emitBootstrapThreadEvent() {
         if (!this.bootstrapThreadEventPending || !this.sessionId) {
             return;

package/dist/server/server/agent/providers/claude/agent.d.ts

@@ -1,7 +1,7 @@
 import { type AgentDefinition, type McpServerConfig as ClaudeSdkMcpServerConfig, type SDKMessage } from "@anthropic-ai/claude-agent-sdk";
 import type { Logger } from "pino";
 import { type ClaudeQueryFactory } from "./query.js";
-import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, type AgentLaunchContext, type AgentMetadata, type AgentModelDefinition, type AgentPersistenceHandle, type AgentSession, type AgentSessionConfig, type AgentTimelineItem, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ListModelsOptions, type McpServerConfig } from "../../agent-sdk-types.js";
+import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, type AgentLaunchContext, type AgentMetadata, type AgentPersistenceHandle, type AgentSession, type AgentSessionConfig, type AgentTimelineItem, type FetchCatalogOptions, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type McpServerConfig, type ProviderCatalog } from "../../agent-sdk-types.js";
 import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
 export declare function normalizeClaudeAskUserQuestionRequestInput(toolName: string, input: AgentMetadata): AgentMetadata;
 export declare function normalizeClaudeAskUserQuestionUpdatedInput(updatedInput: AgentMetadata | undefined, fallbackInput: AgentMetadata | undefined): AgentMetadata;
@@ -39,7 +39,7 @@ export declare class ClaudeAgentClient implements AgentClient {
     constructor(options: ClaudeAgentClientOptions);
     createSession(config: AgentSessionConfig, launchContext?: AgentLaunchContext, options?: AgentCreateSessionOptions): Promise<AgentSession>;
     resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, launchContext?: AgentLaunchContext): Promise<AgentSession>;
-    listModels(_options: ListModelsOptions): Promise<AgentModelDefinition[]>;
+    fetchCatalog(_options: FetchCatalogOptions): Promise<ProviderCatalog>;
     listFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
     listImportableSessions(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
     importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../../agent-sdk-types.js").ImportedProviderSession>;

package/dist/server/server/agent/providers/claude/agent.js

@@ -9,7 +9,7 @@ import { getClaudeModelsWithSettings, normalizeClaudeRuntimeModelId } from "./mo
 import { parsePartialJsonObject } from "./partial-json.js";
 import { ClaudeSidechainTracker } from "./sidechain-tracker.js";
 import { buildClaudeFeatures, claudeModelSupportsFastMode } from "./feature-definitions.js";
-import { buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, toDiagnosticErrorMessage, } from "../diagnostic-utils.js";
+import { buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, formatProviderDiagnostic, formatProviderDiagnosticError, } from "../diagnostic-utils.js";
 import { appendOrReplaceGrowingAssistantMessage, runProviderTurn } from "../provider-runner.js";
 import { renderPromptAttachmentAsText } from "../../prompt-attachments.js";
 import { claudeQuery } from "./query.js";
@@ -1032,9 +1032,10 @@ export class ClaudeAgentClient {
             resolveBinary: this.resolveBinary,
         });
     }
-    async listModels(_options) {
+    async fetchCatalog(_options) {
         // Claude exposes a global catalog here; cwd/force are intentionally irrelevant.
-        return await getClaudeModelsWithSettings(this.logger, this.configDir);
+        const models = await getClaudeModelsWithSettings(this.logger, this.configDir);
+        return { models, modes: DEFAULT_MODES };
     }
     async listFeatures(config) {
         const claudeConfig = this.assertConfig(config);
@@ -1079,28 +1080,9 @@ export class ClaudeAgentClient {
                 defaultBinary: "claude",
             });
             const availability = await checkProviderLaunchAvailable(launch);
-            const available = availability.available;
-            const auth = available
+            const auth = availability.available
                 ? await resolveClaudeAuth(launch, availability, this.runtimeSettings)
                 : null;
-            let modelsValue = "Not checked";
-            let status = formatDiagnosticStatus(available);
-            if (available) {
-                try {
-                    const models = await this.listModels({
-                        cwd: os.homedir(),
-                        force: false,
-                    });
-                    modelsValue = String(models.length);
-                }
-                catch (error) {
-                    modelsValue = `Error - ${toDiagnosticErrorMessage(error)}`;
-                    status = formatDiagnosticStatus(available, {
-                        source: "model fetch",
-                        cause: error,
-                    });
-                }
-            }
             return {
                 diagnostic: formatProviderDiagnostic("Claude Code", [
                     ...(await buildCommandResolutionDiagnosticRows(launch, {
@@ -1108,8 +1090,6 @@ export class ClaudeAgentClient {
                     })),
                     ...(await buildBinaryDiagnosticRows(launch, availability)),
                     ...(auth ? [{ label: "Auth", value: auth }] : []),
-                    { label: "Models", value: modelsValue },
-                    { label: "Status", value: status },
                 ]),
             };
         }

package/dist/server/server/agent/providers/codex-app-server-agent.d.ts

@@ -1,4 +1,4 @@
-import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPersistenceHandle, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPermissionResult, type AgentProviderNotice, type AgentPromptContentBlock, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentTimelineItem, type ToolCallTimelineItem, type AgentUsage, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ListModelsOptions } from "../agent-sdk-types.js";
+import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, type AgentLaunchContext, type AgentMode, type AgentPersistenceHandle, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPermissionResult, type AgentProviderNotice, type AgentPromptContentBlock, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentTimelineItem, type ToolCallTimelineItem, type AgentUsage, type FetchCatalogOptions, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ProviderCatalog } from "../agent-sdk-types.js";
 import type { Logger } from "pino";
 import type { ChildProcessWithoutNullStreams } from "node:child_process";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
@@ -295,7 +295,8 @@ export declare class CodexAppServerAgentClient implements AgentClient {
     }, overrides?: Partial<AgentSessionConfig>, launchContext?: AgentLaunchContext): Promise<AgentSession>;
     listImportableSessions(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
     importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../agent-sdk-types.js").ImportedProviderSession>;
-    listModels(_options: ListModelsOptions): Promise<AgentModelDefinition[]>;
+    fetchCatalog(_options: FetchCatalogOptions): Promise<ProviderCatalog>;
+    private fetchModelsFromAppServer;
     archiveNativeSession(handle: AgentPersistenceHandle): Promise<void>;
     unarchiveNativeSession(handle: AgentPersistenceHandle): Promise<void>;
     isAvailable(): Promise<boolean>;

package/dist/server/server/agent/providers/codex-app-server-agent.js

@@ -1,6 +1,5 @@
 import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
 import { importSessionFromPersistence } from "../provider-session-import.js";
-import { homedir } from "node:os";
 import { randomUUID } from "node:crypto";
 import * as fsSync from "node:fs";
 import fs from "node:fs/promises";
@@ -21,7 +20,7 @@ import { CodexAppServerClient, parseCodexThreadForkResponse, parseCodexThreadRol
 import { revertCodexConversation } from "./codex/rewind.js";
 import { renderProviderImageOutputAsAssistantMarkdown, } from "./provider-image-output.js";
 import { normalizeProviderReplayTimestamp } from "../provider-history-timestamps.js";
-import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, resolveBinaryVersion, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
 import { SETTING_APPLIES_NEXT_TURN_NOTICE } from "../provider-notices.js";
 function assertChildWithPipes(child) {
@@ -4376,7 +4375,11 @@ export class CodexAppServerAgentClient {
             resumeSession: this.resumeSession.bind(this),
         });
     }
-    async listModels(_options) {
+    async fetchCatalog(_options) {
+        const models = await this.fetchModelsFromAppServer();
+        return { models, modes: CODEX_MODES };
+    }
+    async fetchModelsFromAppServer() {
         // Codex model/list is global to the app server in this flow; cwd/force are intentionally ignored.
         const child = await this.spawnAppServer();
         const client = new CodexAppServerClient(child, this.logger);
@@ -4454,34 +4457,12 @@ export class CodexAppServerAgentClient {
         try {
             const launch = await resolveCodexLaunch(this.runtimeSettings);
             const availability = await checkCodexLaunchAvailable(launch);
-            const available = availability.available;
             const entries = [
                 ...(await buildCommandResolutionDiagnosticRows(launch, {
                     knownBinaryNames: ["codex"],
                 })),
                 ...(await buildBinaryDiagnosticRows(launch, availability)),
             ];
-            let status = formatDiagnosticStatus(available);
-            if (!available) {
-                entries.push({ label: "Models", value: "Not checked" });
-            }
-            else {
-                try {
-                    const models = await this.listModels({ cwd: homedir(), force: false });
-                    entries.push({ label: "Models", value: String(models.length) });
-                }
-                catch (error) {
-                    entries.push({
-                        label: "Models",
-                        value: `Error - ${toDiagnosticErrorMessage(error)}`,
-                    });
-                    status = formatDiagnosticStatus(available, {
-                        source: "model fetch",
-                        cause: error,
-                    });
-                }
-            }
-            entries.push({ label: "Status", value: status });
             return {
                 diagnostic: formatProviderDiagnostic("Codex", entries),
             };

package/dist/server/server/agent/providers/copilot-acp-agent.js

@@ -1,7 +1,6 @@
-import { homedir } from "node:os";
 import { checkProviderLaunchAvailable, resolveProviderLaunch, } from "../provider-launch-config.js";
 import { ACPAgentClient, } from "./acp-agent.js";
-import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, } from "./diagnostic-utils.js";
 const COPILOT_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
@@ -64,41 +63,12 @@ export class CopilotACPAgentClient extends ACPAgentClient {
                 defaultBinary: "copilot",
             });
             const availability = await checkProviderLaunchAvailable(launch);
-            const available = availability.available;
-            let modelsValue = "Not checked";
-            let status = formatDiagnosticStatus(available);
-            if (available) {
-                try {
-                    const models = await this.listModels({ cwd: homedir(), force: false });
-                    modelsValue = String(models.length);
-                }
-                catch (error) {
-                    modelsValue = `Error - ${toDiagnosticErrorMessage(error)}`;
-                    status = formatDiagnosticStatus(available, {
-                        source: "model fetch",
-                        cause: error,
-                    });
-                }
-                if (!modelsValue.startsWith("Error -")) {
-                    try {
-                        await this.listModes({ cwd: homedir(), force: false });
-                    }
-                    catch (error) {
-                        status = formatDiagnosticStatus(available, {
-                            source: "mode fetch",
-                            cause: error,
-                        });
-                    }
-                }
-            }
             return {
                 diagnostic: formatProviderDiagnostic("Copilot", [
                     ...(await buildCommandResolutionDiagnosticRows(launch, {
                         knownBinaryNames: ["copilot"],
                     })),
                     ...(await buildBinaryDiagnosticRows(launch, availability)),
-                    { label: "Models", value: modelsValue },
-                    { label: "Status", value: status },
                 ]),
             };
         }

package/dist/server/server/agent/providers/generic-acp-agent.d.ts

@@ -28,7 +28,6 @@ export declare class GenericACPAgentClient extends ACPAgentClient {
         diagnostic: string;
     }>;
     private resolveConfiguredLaunch;
-    private runDiagnosticACPProbe;
 }
 export interface CommandInvocation {
     command: string;