@getpaseo/server 0.1.97 → 0.1.99

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

@@ -32,7 +32,9 @@ const PROVIDER_CLIENT_FACTORIES = {
         command: getCursorACPCommand(runtimeSettings),
         env: runtimeSettings?.env,
     }),
-    opencode: (logger, runtimeSettings) => new OpenCodeAgentClient(logger, runtimeSettings),
+    opencode: (logger, runtimeSettings, options) => new OpenCodeAgentClient(logger, runtimeSettings, {
+        managedProcesses: options?.managedProcesses,
+    }),
     pi: (logger, runtimeSettings, options) => new PiRpcAgentClient({
         logger,
         runtimeSettings,
@@ -230,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
@@ -273,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,
@@ -280,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),
+            };
         },
     };
 }
@@ -329,13 +357,14 @@ function buildResolvedBuiltinProviders(providerOverrides, runtimeSettings, optio
             providerParams: override?.params,
             createBaseClient: (logger) => factory(logger, mergedRuntimeSettings, {
                 workspaceGitService: options.workspaceGitService,
+                managedProcesses: options.managedProcesses,
                 providerParams: override?.params,
             }),
         });
     }
     return resolvedProviders;
 }
-function addDerivedProviders(resolvedProviders, providerOverrides) {
+function addDerivedProviders(resolvedProviders, providerOverrides, options) {
     for (const [providerId, override] of Object.entries(providerOverrides)) {
         if (resolvedProviders.has(providerId) || BUILTIN_PROVIDER_IDS.includes(providerId)) {
             continue;
@@ -403,6 +432,7 @@ function addDerivedProviders(resolvedProviders, providerOverrides) {
             derivedFromProviderId: baseProviderId,
             providerParams,
             createBaseClient: (logger) => baseFactory(logger, mergedRuntimeSettings, {
+                managedProcesses: options.managedProcesses,
                 providerParams,
                 customProvider: {
                     id: providerId,
@@ -418,8 +448,11 @@ export function buildProviderRegistry(logger, options) {
     const providerOverrides = options?.providerOverrides ?? {};
     const resolvedProviders = buildResolvedBuiltinProviders(providerOverrides, runtimeSettings, {
         workspaceGitService: options?.workspaceGitService,
+        managedProcesses: options?.managedProcesses,
     }, options?.isDev === true);
-    addDerivedProviders(resolvedProviders, providerOverrides);
+    addDerivedProviders(resolvedProviders, providerOverrides, {
+        managedProcesses: options?.managedProcesses,
+    });
     return Object.fromEntries([...resolvedProviders.entries()].map(([provider, resolved]) => [
         provider,
         createRegistryEntry(logger, provider, resolved),

package/dist/server/server/agent/provider-snapshot-manager.d.ts

@@ -2,6 +2,7 @@ import type { Logger } from "pino";
 import type { AgentClient, AgentMode, AgentModelDefinition, AgentProvider, ProviderSnapshotEntry } from "./agent-sdk-types.js";
 import type { ManagedAgent } from "./agent-manager.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";
 import type { MutableDaemonConfig } from "../daemon-config-store.js";
 type ProviderSnapshotChangeListener = (entries: ProviderSnapshotEntry[], cwd: string) => void;
@@ -10,6 +11,7 @@ export interface ProviderSnapshotManagerOptions {
     runtimeSettings?: AgentProviderRuntimeSettingsMap;
     providerOverrides?: Record<string, ProviderOverride>;
     workspaceGitService?: Pick<WorkspaceGitService, "resolveRepoRoot">;
+    managedProcesses?: ManagedProcessRegistry;
     isDev?: boolean;
     extraClients?: Partial<Record<AgentProvider, AgentClient>>;
     refreshTimeoutMs?: number;
@@ -64,6 +66,7 @@ export declare class ProviderSnapshotManager {
     private readonly refreshTimeoutMs;
     private readonly logger;
     private readonly workspaceGitService?;
+    private readonly managedProcesses?;
     private readonly isDev;
     private readonly extraClients;
     private runtimeSettings;

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
@@ -32,6 +33,7 @@ export class ProviderSnapshotManager {
         this.destroyed = false;
         this.logger = options.logger;
         this.workspaceGitService = options.workspaceGitService;
+        this.managedProcesses = options.managedProcesses;
         this.isDev = options.isDev === true;
         this.extraClients = options.extraClients ?? {};
         this.runtimeSettings = options.runtimeSettings;
@@ -178,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) {
@@ -225,6 +233,7 @@ export class ProviderSnapshotManager {
             runtimeSettings: this.runtimeSettings,
             providerOverrides: this.providerOverrides,
             workspaceGitService: this.workspaceGitService,
+            managedProcesses: this.managedProcesses,
             isDev: this.isDev,
         });
         for (const [provider, client] of Object.entries(this.extraClients)) {
@@ -236,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;
@@ -446,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(),
             });
         }
@@ -549,8 +554,15 @@ export function resolveSnapshotCwd(cwd) {
     if (!trimmed) {
         return homedir();
     }
-    const expanded = trimmed === "~" || trimmed.startsWith("~/") ? `${homedir()}${trimmed.slice(1)}` : trimmed;
-    return resolve(expanded);
+    let expanded = trimmed === "~" || trimmed.startsWith("~/") ? `${homedir()}${trimmed.slice(1)}` : trimmed;
+    if (process.platform === "win32" && /^[A-Za-z]:$/.test(expanded)) {
+        expanded = `${expanded}\\`;
+    }
+    let resolved = resolve(expanded);
+    if (process.platform === "win32" && /^[A-Za-z]:$/.test(resolved)) {
+        resolved = `${resolved}\\`;
+    }
+    return resolved;
 }
 function entriesToArray(entries) {
     return Array.from(entries.values(), cloneEntry);
@@ -571,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>;