@getpaseo/server 0.1.98 → 0.1.99

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

@@ -1,10 +1,7 @@
-import { homedir } from "node:os";
 import { z } from "zod";
 import { checkProviderLaunchAvailable, resolveProviderLaunch } from "../provider-launch-config.js";
-import { ACPAgentClient, DEFAULT_ACP_CAPABILITIES, deriveModelDefinitionsFromACP, deriveModesFromACP, } from "./acp-agent.js";
-import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
-const ACP_DIAGNOSTIC_INITIALIZE_TIMEOUT_MS = 8000;
-const ACP_DIAGNOSTIC_SESSION_TIMEOUT_MS = 8000;
+import { ACPAgentClient, DEFAULT_ACP_CAPABILITIES } from "./acp-agent.js";
+import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, } from "./diagnostic-utils.js";
 export const GenericACPProviderParamsSchema = z
     .object({
     supportsMcpServers: z.boolean().optional(),
@@ -43,17 +40,7 @@ export class GenericACPAgentClient extends ACPAgentClient {
         try {
             const launch = await this.resolveConfiguredLaunch();
             const availability = await checkProviderLaunchAvailable(launch);
-            const available = availability.available;
             const versionProbe = buildVersionProbeCommand(this.command);
-            const probeResult = available
-                ? await this.runDiagnosticACPProbe()
-                : {
-                    status: formatDiagnosticStatus(false),
-                    initialize: "Not checked",
-                    session: "Not checked",
-                    models: "Not checked",
-                    modes: "Not checked",
-                };
             return {
                 diagnostic: formatProviderDiagnostic(providerName, [
                     { label: "Provider ID", value: this.providerId ?? "unknown" },
@@ -70,11 +57,6 @@ export class GenericACPAgentClient extends ACPAgentClient {
                         label: "Version command",
                         value: formatCommand(versionProbe.command, versionProbe.args),
                     },
-                    { label: "ACP initialize", value: probeResult.initialize },
-                    { label: "ACP session/new", value: probeResult.session },
-                    { label: "Models", value: probeResult.models },
-                    { label: "Modes", value: probeResult.modes },
-                    { label: "Status", value: probeResult.status },
                 ]),
             };
         }
@@ -90,50 +72,6 @@ export class GenericACPAgentClient extends ACPAgentClient {
             defaultBinary: this.command[0],
         });
     }
-    async runDiagnosticACPProbe() {
-        let initializeValue = "Not checked";
-        let sessionValue = "Not checked";
-        try {
-            const probe = await this.spawnProcess({
-                NO_BROWSER: "true",
-                NO_OPEN_BROWSER: "1",
-                GEMINI_CLI_NO_BROWSER: "true",
-                CI: "1",
-            }, {
-                initializeTimeoutMs: ACP_DIAGNOSTIC_INITIALIZE_TIMEOUT_MS,
-            });
-            try {
-                initializeValue = formatInitializeResult(probe.initialize);
-                const response = await withTimeout(probe.connection.newSession({
-                    cwd: homedir(),
-                    mcpServers: [],
-                }), ACP_DIAGNOSTIC_SESSION_TIMEOUT_MS, "ACP session/new");
-                sessionValue = response.sessionId ? `ok (${response.sessionId})` : "ok";
-                const transformed = this.transformSessionResponse(response);
-                return {
-                    status: formatDiagnosticStatus(true),
-                    initialize: initializeValue,
-                    session: sessionValue,
-                    ...summarizeSessionState(this.provider, transformed),
-                };
-            }
-            finally {
-                await this.closeProbe(probe);
-            }
-        }
-        catch (error) {
-            return {
-                status: formatDiagnosticStatus(true, {
-                    source: "ACP probe",
-                    cause: error,
-                }),
-                initialize: formatProbeError(initializeValue, error),
-                session: initializeValue === "Not checked" ? "Not checked" : formatProbeError(sessionValue, error),
-                models: "Not checked",
-                modes: "Not checked",
-            };
-        }
-    }
 }
 function buildGenericACPCapabilities(options) {
     const params = parseGenericACPProviderParams(options.providerParams);
@@ -200,48 +138,4 @@ function takePackageSpecPrefix(args) {
     }
     return prefix;
 }
-function formatInitializeResult(initialize) {
-    const agentInfo = isAgentInfo(initialize.agentInfo)
-        ? `${initialize.agentInfo.name}${initialize.agentInfo.version ? ` ${initialize.agentInfo.version}` : ""}`
-        : "ok";
-    return `ok (protocol ${initialize.protocolVersion}, ${agentInfo})`;
-}
-function isAgentInfo(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        "name" in value &&
-        typeof Reflect.get(value, "name") === "string");
-}
-function summarizeSessionState(provider, response) {
-    const models = deriveModelDefinitionsFromACP(provider, response.models, response.configOptions);
-    const { modes } = deriveModesFromACP([], response.modes, response.configOptions);
-    return {
-        models: `${models.length}`,
-        modes: modes.length > 0 ? modes.map((mode) => mode.label || mode.id).join(", ") : "none reported",
-    };
-}
-function formatProbeError(currentValue, error) {
-    if (currentValue !== "Not checked") {
-        return currentValue;
-    }
-    return `Error - ${toDiagnosticErrorMessage(error)}`;
-}
-async function withTimeout(promise, timeoutMs, label) {
-    let timeout = null;
-    try {
-        return await Promise.race([
-            promise,
-            new Promise((_, reject) => {
-                timeout = setTimeout(() => {
-                    reject(new Error(`${label} timed out after ${timeoutMs}ms`));
-                }, timeoutMs);
-            }),
-        ]);
-    }
-    finally {
-        if (timeout) {
-            clearTimeout(timeout);
-        }
-    }
-}
 //# sourceMappingURL=generic-acp-agent.js.map

package/dist/server/server/agent/providers/mock-load-test-agent.d.ts

@@ -1,5 +1,5 @@
 import type { Logger } from "pino";
-import type { AgentCapabilityFlags, AgentClient, AgentFeature, AgentLaunchContext, AgentMode, AgentModelDefinition, AgentPersistenceHandle, AgentPermissionRequest, AgentPermissionResponse, AgentPermissionResult, AgentPromptInput, AgentProvider, AgentRunOptions, AgentRunResult, AgentRuntimeInfo, AgentSession, AgentSessionConfig, AgentStreamEvent, ImportableProviderSession, ImportProviderSessionContext, ImportProviderSessionInput, ListModesOptions, ListModelsOptions } from "../agent-sdk-types.js";
+import type { AgentCapabilityFlags, AgentClient, AgentFeature, AgentLaunchContext, AgentMode, AgentPersistenceHandle, AgentPermissionRequest, AgentPermissionResponse, AgentPermissionResult, AgentPromptInput, AgentProvider, AgentRunOptions, AgentRunResult, AgentRuntimeInfo, AgentSession, AgentSessionConfig, AgentStreamEvent, FetchCatalogOptions, ImportableProviderSession, ImportProviderSessionContext, ImportProviderSessionInput, ProviderCatalog } from "../agent-sdk-types.js";
 export declare const MOCK_LOAD_TEST_PROVIDER_ID = "mock";
 export declare const MOCK_LOAD_TEST_DEFAULT_MODEL_ID = "five-minute-stream";
 export declare class MockLoadTestAgentClient implements AgentClient {
@@ -9,8 +9,7 @@ export declare class MockLoadTestAgentClient implements AgentClient {
     constructor(logger?: Logger | undefined);
     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(): Promise<ImportableProviderSession[]>;
     importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../agent-sdk-types.js").ImportedProviderSession>;
     isAvailable(): Promise<boolean>;

package/dist/server/server/agent/providers/mock-load-test-agent.js

@@ -379,11 +379,11 @@ export class MockLoadTestAgentClient {
             logger: this.logger,
         });
     }
-    async listModels(_options) {
-        return MODELS;
-    }
-    async listModes(_options) {
-        return getAgentProviderDefinition(MOCK_LOAD_TEST_PROVIDER_ID).modes;
+    async fetchCatalog(_options) {
+        return {
+            models: MODELS,
+            modes: getAgentProviderDefinition(MOCK_LOAD_TEST_PROVIDER_ID).modes,
+        };
     }
     async listImportableSessions() {
         return [];

package/dist/server/server/agent/providers/mock-slow-provider.d.ts

@@ -1,11 +1,10 @@
-import type { AgentCapabilityFlags, AgentClient, AgentLaunchContext, AgentMode, AgentModelDefinition, AgentPersistenceHandle, AgentProvider, AgentSession, AgentSessionConfig, ListModelsOptions, ListModesOptions } from "../agent-sdk-types.js";
+import type { AgentCapabilityFlags, AgentClient, AgentLaunchContext, AgentPersistenceHandle, AgentProvider, AgentSession, AgentSessionConfig, FetchCatalogOptions, ProviderCatalog } from "../agent-sdk-types.js";
 export declare const MOCK_SLOW_PROVIDER_ID = "mock-slow";
 export declare class MockSlowProviderClient implements AgentClient {
     readonly provider: AgentProvider;
     readonly capabilities: AgentCapabilityFlags;
     isAvailable(): Promise<boolean>;
-    listModels(_options: ListModelsOptions): Promise<AgentModelDefinition[]>;
-    listModes(_options: ListModesOptions): Promise<AgentMode[]>;
+    fetchCatalog(_options: FetchCatalogOptions): Promise<ProviderCatalog>;
     getDiagnostic(): Promise<{
         diagnostic: string;
     }>;

package/dist/server/server/agent/providers/mock-slow-provider.js

@@ -21,15 +21,12 @@ export class MockSlowProviderClient {
     async isAvailable() {
         return process.env.PASEO_ENABLE_MOCK_SLOW === "true";
     }
-    listModels(_options) {
-        return neverResolves();
-    }
-    listModes(_options) {
+    async fetchCatalog(_options) {
         return neverResolves();
     }
     async getDiagnostic() {
         return {
-            diagnostic: "Mock slow provider: dev-only. listModels() never resolves so the snapshot manager will time out.",
+            diagnostic: "Mock slow provider: dev-only. fetchCatalog() never resolves so the snapshot manager will time out.",
         };
     }
     createSession(_config, _launchContext) {

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

@@ -1,6 +1,6 @@
 import { type AssistantMessage as OpenCodeAssistantMessage, type Event as OpenCodeEvent, type FilePartInput as OpenCodeFilePartInput, type Message as OpenCodeMessage, type OpencodeClient, type Part as OpenCodePart, type TextPartInput as OpenCodeTextPartInput } from "@opencode-ai/sdk/v2/client";
 import type { Logger } from "pino";
-import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, 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 AgentTimelineItem, type AgentUsage, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ResolveAgentCreateConfigInput, type ResolveAgentCreateConfigResult, type ListModelsOptions, type ListModesOptions, type ToolCallTimelineItem } from "../agent-sdk-types.js";
+import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, 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 AgentTimelineItem, type AgentUsage, type FetchCatalogOptions, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ResolveAgentCreateConfigInput, type ResolveAgentCreateConfigResult, type ProviderCatalog, type ToolCallTimelineItem } from "../agent-sdk-types.js";
 import { isDefaultAgentCreateConfigUnattended } from "../create-agent-mode.js";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
 import { type OpenCodeRuntime } from "./opencode/runtime.js";
@@ -118,8 +118,7 @@ export declare class OpenCodeAgentClient implements AgentClient {
     constructor(logger: Logger, runtimeSettings?: ProviderRuntimeSettings, deps?: OpenCodeAgentClientDeps);
     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[]>;
+    fetchCatalog(options: FetchCatalogOptions): Promise<ProviderCatalog>;
     listCommands(config: AgentSessionConfig): Promise<AgentSlashCommand[]>;
     listFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
     listImportableSessions(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
@@ -129,6 +128,8 @@ export declare class OpenCodeAgentClient implements AgentClient {
     getDiagnostic(): Promise<{
         diagnostic: string;
     }>;
+    private fetchModelsFromClient;
+    private fetchModesFromClient;
     private assertConfig;
     private populateModelContextWindowCache;
 }

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

@@ -1,4 +1,3 @@
-import { homedir } from "node:os";
 import { createPathEquivalenceMatcher } from "../../../utils/path.js";
 import pLimit from "p-limit";
 import { z } from "zod";
@@ -11,7 +10,7 @@ import { execCommand } from "../../../utils/spawn.js";
 import { buildToolCallDisplayModel } from "@getpaseo/protocol/tool-call-display";
 import { mapOpencodeToolCall } from "./opencode/tool-call-mapper.js";
 import { OpenCodeServerManager } from "./opencode/server-manager.js";
-import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 import { composeSystemPromptParts } from "../system-prompt.js";
@@ -940,70 +939,17 @@ export class OpenCodeAgentClient {
             throw error;
         }
     }
-    async listModels(options) {
-        const acquisition = await this.runtime.acquireServer({ force: options.force });
-        const { url } = acquisition.server;
-        const client = this.runtime.createClient({
-            baseUrl: url,
-            directory: options.cwd,
-        });
-        try {
-            // Background model discovery can be legitimately slow while OpenCode refreshes
-            // provider state, so allow longer than turn execution paths.
-            const response = await openCodeMetadataLimit(() => withTimeout(client.provider.list({ directory: options.cwd }), OPENCODE_PROVIDER_LIST_TIMEOUT_MS, `OpenCode provider.list timed out after ${OPENCODE_PROVIDER_LIST_TIMEOUT_MS / 1000}s - server may not be authenticated or connected to any providers`));
-            if (response.error) {
-                throw new Error(`Failed to fetch OpenCode providers: ${JSON.stringify(response.error)}`);
-            }
-            const providers = response.data;
-            if (!providers) {
-                return [];
-            }
-            const connectedProviderIds = new Set(providers.connected);
-            // Providers with source "api" are managed by the OpenCode console/subscription (e.g. Pi
-            // coding agent). They do not appear in `connected` (which only lists env/config providers)
-            // but are fully usable — OpenCode authenticates them internally via the console session.
-            const isAccessible = (provider) => connectedProviderIds.has(provider.id) || provider.source === "api";
-            // Fail fast if no providers are accessible at all
-            if (!providers.all.some(isAccessible)) {
-                throw new Error("OpenCode has no connected providers. Please authenticate with at least one provider " +
-                    "(e.g., openai, anthropic), set appropriate environment variables (e.g., OPENAI_API_KEY), " +
-                    "or log in to OpenCode Go via the console.");
-            }
-            const models = [];
-            this.modelContextWindows.clear();
-            for (const provider of providers.all) {
-                if (!isAccessible(provider)) {
-                    continue;
-                }
-                for (const [modelId, model] of Object.entries(provider.models)) {
-                    const definition = buildOpenCodeModelDefinition(provider, modelId, model);
-                    const contextWindowMaxTokens = extractOpenCodeModelContextWindow(model);
-                    if (contextWindowMaxTokens !== undefined) {
-                        this.modelContextWindows.set(buildOpenCodeModelLookupKey(provider.id, modelId), contextWindowMaxTokens);
-                    }
-                    models.push(definition);
-                }
-            }
-            return models;
-        }
-        finally {
-            acquisition.release();
-        }
-    }
-    async listModes(options) {
+    async fetchCatalog(options) {
         const acquisition = await this.runtime.acquireServer({ force: options.force });
         const { url } = acquisition.server;
         const directory = options.cwd;
         const client = this.runtime.createClient({ baseUrl: url, directory });
         try {
-            const response = await openCodeMetadataLimit(() => withTimeout(client.app.agents({ directory }), 10000, "OpenCode app.agents timed out after 10s"));
-            if (response.error || !response.data) {
-                return DEFAULT_MODES;
-            }
-            const discovered = response.data
-                .filter(isSelectableOpenCodeAgent)
-                .map(mapOpenCodeAgentToMode);
-            return mergeOpenCodeModes(discovered);
+            const [models, modes] = await Promise.all([
+                this.fetchModelsFromClient(client, directory),
+                this.fetchModesFromClient(client, directory),
+            ]);
+            return { models, modes };
         }
         finally {
             acquisition.release();
@@ -1094,17 +1040,6 @@ export class OpenCodeAgentClient {
                 defaultBinary: "opencode",
             });
             const availability = await checkProviderLaunchAvailable(launch);
-            const available = availability.available;
-            let serverStatus = "Not running";
-            let modelsValue = "Not checked";
-            let status = formatDiagnosticStatus(available);
-            try {
-                const { url } = await this.runtime.ensureServerRunning();
-                serverStatus = `Running (${url})`;
-            }
-            catch (error) {
-                serverStatus = `Unavailable (${toDiagnosticErrorMessage(error)})`;
-            }
             let authValue = "Not checked";
             const authCommand = availability.available
                 ? (availability.resolvedPath ?? launch.command)
@@ -1122,40 +1057,13 @@ export class OpenCodeAgentClient {
                     authValue = `Error - ${toDiagnosticErrorMessage(error)}`;
                 }
             }
-            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("OpenCode", [
                     ...(await buildCommandResolutionDiagnosticRows(launch, {
                         knownBinaryNames: ["opencode"],
                     })),
                     ...(await buildBinaryDiagnosticRows(launch, availability)),
-                    { label: "Server", value: serverStatus },
                     { label: "Auth", value: authValue },
-                    { label: "Models", value: modelsValue },
-                    { label: "Status", value: status },
                 ]),
             };
         }
@@ -1165,6 +1073,47 @@ export class OpenCodeAgentClient {
             };
         }
     }
+    async fetchModelsFromClient(client, directory) {
+        const response = await openCodeMetadataLimit(() => withTimeout(client.provider.list({ directory }), OPENCODE_PROVIDER_LIST_TIMEOUT_MS, `OpenCode provider.list timed out after ${OPENCODE_PROVIDER_LIST_TIMEOUT_MS / 1000}s - server may not be authenticated or connected to any providers`));
+        if (response.error) {
+            throw new Error(`Failed to fetch OpenCode providers: ${JSON.stringify(response.error)}`);
+        }
+        const providers = response.data;
+        if (!providers) {
+            return [];
+        }
+        const connectedProviderIds = new Set(providers.connected);
+        const isAccessible = (provider) => connectedProviderIds.has(provider.id) || provider.source === "api";
+        if (!providers.all.some(isAccessible)) {
+            throw new Error("OpenCode has no connected providers. Please authenticate with at least one provider " +
+                "(e.g., openai, anthropic), set appropriate environment variables (e.g., OPENAI_API_KEY), " +
+                "or log in to OpenCode Go via the console.");
+        }
+        const models = [];
+        this.modelContextWindows.clear();
+        for (const provider of providers.all) {
+            if (!isAccessible(provider)) {
+                continue;
+            }
+            for (const [modelId, model] of Object.entries(provider.models)) {
+                const definition = buildOpenCodeModelDefinition(provider, modelId, model);
+                const contextWindowMaxTokens = extractOpenCodeModelContextWindow(model);
+                if (contextWindowMaxTokens !== undefined) {
+                    this.modelContextWindows.set(buildOpenCodeModelLookupKey(provider.id, modelId), contextWindowMaxTokens);
+                }
+                models.push(definition);
+            }
+        }
+        return models;
+    }
+    async fetchModesFromClient(client, directory) {
+        const response = await openCodeMetadataLimit(() => withTimeout(client.app.agents({ directory }), 10000, "OpenCode app.agents timed out after 10s"));
+        if (response.error || !response.data) {
+            return DEFAULT_MODES;
+        }
+        const discovered = response.data.filter(isSelectableOpenCodeAgent).map(mapOpenCodeAgentToMode);
+        return mergeOpenCodeModes(discovered);
+    }
     assertConfig(config) {
         if (config.provider !== "opencode") {
             throw new Error(`OpenCodeAgentClient received config for provider '${config.provider}'`);

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

@@ -1,6 +1,6 @@
 import type { Logger } from "pino";
 import { z } from "zod";
-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 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 FetchCatalogOptions, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ProviderCatalog } from "../../agent-sdk-types.js";
 import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
 import type { PiRuntime, PiRuntimeSession } from "./runtime.js";
 import type { PiSessionState } from "./rpc-types.js";
@@ -112,8 +112,7 @@ export declare class PiRpcAgentClient implements AgentClient {
     constructor(options: PiRpcAgentClientOptions);
     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>;

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

@@ -3,13 +3,12 @@ import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 import { z } from "zod";
-import { withTimeout } from "../../../../utils/promise-timeout.js";
 import { importSessionFromPersistence } from "../../provider-session-import.js";
 import { runProviderTurn } from "../provider-runner.js";
 import { checkProviderLaunchAvailable, resolveProviderLaunch, } from "../../provider-launch-config.js";
 import { renderPromptAttachmentAsText } from "../../prompt-attachments.js";
 import { composeSystemPromptParts } from "../../system-prompt.js";
-import { buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, toDiagnosticErrorMessage, } from "../diagnostic-utils.js";
+import { buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, formatProviderDiagnostic, formatProviderDiagnosticError, toDiagnosticErrorMessage, } from "../diagnostic-utils.js";
 import { getUserMessageText, streamPiHistory, } from "./history-mapper.js";
 import { PiCliRuntime } from "./cli-runtime.js";
 import { revertPiConversation } from "./rewind.js";
@@ -18,6 +17,7 @@ import { mapToolDetail, parseToolArgs, parseToolResult, resolveToolCallName, } f
 const PI_PROVIDER = "pi";
 const DEFAULT_PI_THINKING_LEVEL = "medium";
 const PI_BINARY_COMMAND = process.env.PI_COMMAND ?? process.env.PI_ACP_PI_COMMAND ?? "pi";
+const PI_CATALOG_REQUEST_TIMEOUT_MS = 120000;
 const PASEO_PI_TREE_EXTENSION_COMMAND = "paseo_tree";
 const PASEO_PI_CAPTURE_EXTENSION_COMMAND = "paseo_capture_entries";
 const PASEO_PI_ENTRY_CAPTURE_MARKER = "PASEO_ENTRY_CAPTURE";
@@ -1538,18 +1538,16 @@ export class PiRpcAgentClient {
             throw error;
         }
     }
-    async listModels(options) {
+    async fetchCatalog(options) {
         const runtimeSession = await this.runtime.startSession({ cwd: options.cwd });
         try {
-            return transformPiModels((await runtimeSession.getAvailableModels()).map(mapPiModel));
+            const models = transformPiModels((await runtimeSession.getAvailableModels(PI_CATALOG_REQUEST_TIMEOUT_MS)).map(mapPiModel));
+            return { models, modes: [] };
         }
         finally {
             await runtimeSession.close();
         }
     }
-    async listModes(_options) {
-        return [];
-    }
     async listImportableSessions(options) {
         return await listPiImportableSessions({
             ...options,
@@ -1569,28 +1567,9 @@ export class PiRpcAgentClient {
     }
     async isAvailable() {
         try {
-            return await withTimeout((async () => {
-                const launch = await this.resolvePiLaunch();
-                const availability = await checkProviderLaunchAvailable(launch);
-                if (!availability.available) {
-                    return false;
-                }
-                const runtimeSession = await this.runtime
-                    .startSession({ cwd: homedir() })
-                    .catch(() => null);
-                if (!runtimeSession) {
-                    return false;
-                }
-                try {
-                    return (await runtimeSession.getAvailableModels()).length > 0;
-                }
-                catch {
-                    return false;
-                }
-                finally {
-                    await runtimeSession.close().catch(() => undefined);
-                }
-            })(), 2000, "Pi availability check timed out");
+            const launch = await this.resolvePiLaunch();
+            const availability = await checkProviderLaunchAvailable(launch);
+            return availability.available;
         }
         catch {
             return false;
@@ -1600,61 +1579,17 @@ export class PiRpcAgentClient {
         try {
             const launch = await this.resolvePiLaunch();
             const availability = await checkProviderLaunchAvailable(launch);
-            const available = availability.available;
             const authConfigPath = join(homedir(), ".pi", "agent", "auth.json");
-            let modelsValue = "Not checked";
-            let configuredProvidersValue = "none";
-            let mcpToolsValue = "Not checked";
-            let status = formatDiagnosticStatus(available);
-            if (availability.available) {
-                const runtimeSession = await this.runtime
-                    .startSession({ cwd: homedir() })
-                    .catch((error) => {
-                    status = formatDiagnosticStatus(false, {
-                        source: "startup",
-                        cause: error,
-                    });
-                    return null;
-                });
-                if (runtimeSession) {
-                    try {
-                        const models = await runtimeSession.getAvailableModels();
-                        modelsValue = String(models.length);
-                        const configuredProviders = Array.from(new Set(models.map((model) => model.provider))).sort();
-                        configuredProvidersValue =
-                            configuredProviders.length > 0 ? configuredProviders.join(", ") : "none";
-                        const commands = await runtimeSession.getCommands();
-                        mcpToolsValue = commands.some(isPiMcpAdapterCommand)
-                            ? "yes (pi-mcp-adapter loaded)"
-                            : "no (install pi-mcp-adapter)";
-                    }
-                    catch (error) {
-                        modelsValue = `Error - ${toDiagnosticErrorMessage(error)}`;
-                        mcpToolsValue = `Error - ${toDiagnosticErrorMessage(error)}`;
-                        status = formatDiagnosticStatus(available, {
-                            source: "model fetch",
-                            cause: error,
-                        });
-                    }
-                    finally {
-                        await runtimeSession.close().catch(() => undefined);
-                    }
-                }
-            }
             return {
                 diagnostic: formatProviderDiagnostic("Pi", [
                     ...(await buildCommandResolutionDiagnosticRows(launch, {
                         knownBinaryNames: [launch.command],
                     })),
                     ...(await buildBinaryDiagnosticRows(launch, availability)),
-                    { label: "Configured providers", value: configuredProvidersValue },
                     {
                         label: "Auth config (~/.pi/agent/auth.json)",
                         value: existsSync(authConfigPath) ? "found" : "not found",
                     },
-                    { label: "Models", value: modelsValue },
-                    { label: "Paseo MCP tools", value: mcpToolsValue },
-                    { label: "Status", value: status },
                 ]),
             };
         }

package/dist/server/server/agent/providers/pi/cli-runtime.js

@@ -95,8 +95,8 @@ class PiCliRuntimeSession {
         const data = (await this.request({ type: "get_messages" }));
         return data.messages ?? [];
     }
-    async getAvailableModels() {
-        const data = (await this.request({ type: "get_available_models" }));
+    async getAvailableModels(timeoutMs) {
+        const data = (await this.request({ type: "get_available_models" }, timeoutMs));
         return data.models ?? [];
     }
     async setModel(provider, modelId) {

package/dist/server/server/agent/providers/pi/runtime.d.ts

@@ -33,7 +33,7 @@ export interface PiRuntimeSession {
     abort(): Promise<void>;
     getState(): Promise<PiSessionState>;
     getMessages(): Promise<PiAgentMessage[]>;
-    getAvailableModels(): Promise<PiModel[]>;
+    getAvailableModels(timeoutMs?: number): Promise<PiModel[]>;
     setModel(provider: string, modelId: string): Promise<PiModel>;
     setThinkingLevel(level: string): Promise<void>;
     getSessionStats(): Promise<PiSessionStats>;

package/dist/server/server/agent/providers/pi/test-utils/fake-pi.d.ts

@@ -61,7 +61,7 @@ export declare class FakePiSession implements PiRuntimeSession {
     abort(): Promise<void>;
     getState(): Promise<PiSessionState>;
     getMessages(): Promise<PiAgentMessage[]>;
-    getAvailableModels(): Promise<PiModel[]>;
+    getAvailableModels(_timeoutMs?: number): Promise<PiModel[]>;
     setModel(provider: string, modelId: string): Promise<PiModel>;
     setThinkingLevel(level: string): Promise<void>;
     getSessionStats(): Promise<PiSessionStats>;

package/dist/server/server/agent/providers/pi/test-utils/fake-pi.js

@@ -100,7 +100,7 @@ export class FakePiSession {
     async getMessages() {
         return this.messages;
     }
-    async getAvailableModels() {
+    async getAvailableModels(_timeoutMs) {
         return this.models;
     }
     async setModel(provider, modelId) {