@getpaseo/server 0.1.97 → 0.1.99

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

@@ -1,5 +1,8 @@
 import type { ChildProcess } from "node:child_process";
 import type { Logger } from "pino";
+import { type SpawnProcessOptions } from "../../../../utils/spawn.js";
+import { type ProcessTerminator } from "../../../../utils/tree-kill.js";
+import type { ManagedProcessRegistry } from "../../../managed-processes/managed-processes.js";
 import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
 export interface OpenCodeServerAcquisition {
     server: {
@@ -24,6 +27,22 @@ export interface OpenCodeServerGeneration {
     url: string;
     refCount: number;
     retired: boolean;
+    managedProcessId?: string;
+}
+export type OpenCodePortAllocator = () => Promise<number>;
+export type OpenCodeCommandPrefixResolver = () => Promise<{
+    command: string;
+    args: string[];
+}>;
+export type OpenCodeServerProcessSpawner = (command: string, args: string[], options: SpawnProcessOptions) => ChildProcess;
+export interface OpenCodeServerManagerOptions {
+    logger: Logger;
+    runtimeSettings?: ProviderRuntimeSettings;
+    managedProcesses?: ManagedProcessRegistry;
+    terminateProcess?: ProcessTerminator;
+    portAllocator?: OpenCodePortAllocator;
+    resolveCommandPrefix?: OpenCodeCommandPrefixResolver;
+    spawnServerProcess?: OpenCodeServerProcessSpawner;
 }
 export declare class OpenCodeServerManager implements OpenCodeServerManagerLike {
     private static instance;
@@ -35,8 +54,13 @@ export declare class OpenCodeServerManager implements OpenCodeServerManagerLike
     private readonly logger;
     private readonly runtimeSettings?;
     private readonly runtimeSettingsKey;
-    private constructor();
-    static getInstance(logger: Logger, runtimeSettings?: ProviderRuntimeSettings): OpenCodeServerManager;
+    private readonly managedProcesses?;
+    private readonly terminateProcess;
+    private readonly portAllocator;
+    private readonly resolveCommandPrefix;
+    private readonly spawnServerProcess;
+    constructor(options: OpenCodeServerManagerOptions);
+    static getInstance(logger: Logger, runtimeSettings?: ProviderRuntimeSettings, options?: Omit<OpenCodeServerManagerOptions, "logger" | "runtimeSettings">): OpenCodeServerManager;
     private static registerExitHandler;
     ensureRunning(): Promise<{
         port: number;
@@ -55,5 +79,8 @@ export declare class OpenCodeServerManager implements OpenCodeServerManagerLike
     shutdown(): Promise<void>;
     private cleanupRetiredServers;
     private killServer;
+    private recordManagedServerProcess;
+    private removeManagedProcessRecordWhenResolved;
+    private removeManagedProcessId;
 }
 //# sourceMappingURL=server-manager.d.ts.map

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

@@ -1,4 +1,5 @@
 import net from "node:net";
+import os from "node:os";
 import { findExecutable } from "../../../../executable-resolution/executable-resolution.js";
 import { spawnProcess } from "../../../../utils/spawn.js";
 import { terminateWithTreeKill } from "../../../../utils/tree-kill.js";
@@ -6,19 +7,30 @@ import { createProviderEnvSpec, resolveProviderCommandPrefix, } from "../../prov
 const OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS = 5000;
 const OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS = 1000;
 export class OpenCodeServerManager {
-    constructor(logger, runtimeSettings) {
+    constructor(options) {
         this.currentServer = null;
         this.retiredServers = new Set();
         this.startPromise = null;
         this.forcedRefreshPromise = null;
-        this.logger = logger;
-        this.runtimeSettings = runtimeSettings;
-        this.runtimeSettingsKey = JSON.stringify(runtimeSettings ?? {});
+        this.logger = options.logger;
+        this.runtimeSettings = options.runtimeSettings;
+        this.runtimeSettingsKey = JSON.stringify(this.runtimeSettings ?? {});
+        this.managedProcesses = options.managedProcesses;
+        this.terminateProcess = options.terminateProcess ?? terminateWithTreeKill;
+        this.portAllocator = options.portAllocator ?? findAvailablePort;
+        this.resolveCommandPrefix =
+            options.resolveCommandPrefix ??
+                (() => resolveProviderCommandPrefix(this.runtimeSettings?.command, resolveOpenCodeBinary));
+        this.spawnServerProcess = options.spawnServerProcess ?? spawnProcess;
     }
-    static getInstance(logger, runtimeSettings) {
+    static getInstance(logger, runtimeSettings, options = {}) {
         const nextSettingsKey = JSON.stringify(runtimeSettings ?? {});
         if (!OpenCodeServerManager.instance) {
-            OpenCodeServerManager.instance = new OpenCodeServerManager(logger, runtimeSettings);
+            OpenCodeServerManager.instance = new OpenCodeServerManager({
+                logger,
+                runtimeSettings,
+                ...options,
+            });
             OpenCodeServerManager.registerExitHandler();
         }
         else if (OpenCodeServerManager.instance.runtimeSettingsKey !== nextSettingsKey) {
@@ -128,11 +140,14 @@ export class OpenCodeServerManager {
         return server;
     }
     async startServer(launchEnv) {
-        const port = await findAvailablePort();
+        const port = await this.portAllocator();
         const url = `http://127.0.0.1:${port}`;
-        const launchPrefix = await resolveProviderCommandPrefix(this.runtimeSettings?.command, resolveOpenCodeBinary);
+        const launchPrefix = await this.resolveCommandPrefix();
+        const serverArgs = [...launchPrefix.args, "serve", "--port", String(port)];
+        const serverCwd = os.homedir();
         return new Promise((resolve, reject) => {
-            const serverProcess = spawnProcess(launchPrefix.command, [...launchPrefix.args, "serve", "--port", String(port)], {
+            const serverProcess = this.spawnServerProcess(launchPrefix.command, serverArgs, {
+                cwd: serverCwd,
                 detached: process.platform !== "win32",
                 stdio: ["ignore", "pipe", "pipe"],
                 ...createProviderEnvSpec({
@@ -140,6 +155,12 @@ export class OpenCodeServerManager {
                     overlays: [launchEnv],
                 }),
             });
+            const managedProcessRecord = this.recordManagedServerProcess({
+                process: serverProcess,
+                command: launchPrefix.command,
+                args: serverArgs,
+                port,
+            });
             let started = false;
             let stderrBuffer = "";
             let stdoutBuffer = "";
@@ -174,13 +195,17 @@ export class OpenCodeServerManager {
                 if (output.includes("listening on") && !started) {
                     started = true;
                     clearTimeout(timeout);
-                    resolve({
-                        process: serverProcess,
-                        port,
-                        url,
-                        refCount: 0,
-                        retired: false,
-                    });
+                    void (async () => {
+                        const record = await managedProcessRecord;
+                        resolve({
+                            process: serverProcess,
+                            port,
+                            url,
+                            refCount: 0,
+                            retired: false,
+                            ...(record ? { managedProcessId: record.id } : {}),
+                        });
+                    })();
                 }
             });
             serverProcess.stderr?.on("data", (data) => {
@@ -190,10 +215,12 @@ export class OpenCodeServerManager {
             });
             serverProcess.on("error", (error) => {
                 clearTimeout(timeout);
+                this.removeManagedProcessRecordWhenResolved(managedProcessRecord);
                 const headline = error instanceof Error ? error.message : String(error);
                 reject(new Error(buildStartupErrorMessage(headline)));
             });
             serverProcess.on("exit", (code) => {
+                this.removeManagedProcessRecordWhenResolved(managedProcessRecord);
                 if (!started) {
                     clearTimeout(timeout);
                     reject(new Error(buildStartupErrorMessage(`OpenCode server exited with code ${code}`)));
@@ -231,7 +258,7 @@ export class OpenCodeServerManager {
             (server.process.signalCode !== null && server.process.signalCode !== undefined)) {
             return;
         }
-        const result = await terminateWithTreeKill(server.process, {
+        const result = await this.terminateProcess(server.process, {
             gracefulTimeoutMs: OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS,
             forceTimeoutMs: OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS,
             onForceSignal: () => {
@@ -241,6 +268,45 @@ export class OpenCodeServerManager {
         if (result === "kill-timeout") {
             this.logger.warn({ timeoutMs: OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS }, "OpenCode server did not report exit after SIGKILL");
         }
+        if (server.managedProcessId) {
+            await this.removeManagedProcessId(server.managedProcessId);
+            server.managedProcessId = undefined;
+        }
+    }
+    async recordManagedServerProcess(options) {
+        const pid = options.process.pid;
+        if (!this.managedProcesses || typeof pid !== "number" || pid <= 0) {
+            return null;
+        }
+        try {
+            return await this.managedProcesses.record({
+                owner: { provider: "opencode", kind: "helper-server" },
+                pid,
+                command: options.command,
+                args: options.args,
+                metadata: { port: options.port },
+            });
+        }
+        catch (error) {
+            this.logger.warn({ err: error, pid, port: options.port }, "Failed to record OpenCode helper process");
+            return null;
+        }
+    }
+    removeManagedProcessRecordWhenResolved(record) {
+        void record.then((resolved) => {
+            if (resolved) {
+                return this.removeManagedProcessId(resolved.id);
+            }
+            return undefined;
+        });
+    }
+    async removeManagedProcessId(id) {
+        try {
+            await this.managedProcesses?.remove(id);
+        }
+        catch (error) {
+            this.logger.warn({ err: error, id }, "Failed to remove OpenCode helper process record");
+        }
     }
 }
 OpenCodeServerManager.instance = null;

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

@@ -1,9 +1,10 @@
 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";
+import type { ManagedProcessRegistry } from "../../managed-processes/managed-processes.js";
 declare function resolveOpenCodeCreateConfig(input: ResolveAgentCreateConfigInput): ResolveAgentCreateConfigResult;
 declare function isOpenCodeCreateConfigUnattended(input: Parameters<typeof isDefaultAgentCreateConfigUnattended>[0]): boolean;
 type OpenCodeAgentConfig = AgentSessionConfig & {
@@ -103,6 +104,7 @@ export declare const __openCodeInternals: {
 };
 interface OpenCodeAgentClientDeps {
     runtime?: OpenCodeRuntime;
+    managedProcesses?: ManagedProcessRegistry;
 }
 export declare class OpenCodeAgentClient implements AgentClient {
     readonly provider: "opencode";
@@ -116,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[]>;
@@ -127,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, 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";
@@ -398,14 +397,14 @@ function mapOpenCodeAgentToMode(agent) {
     };
 }
 function mergeOpenCodeModes(discoveredModes) {
-    const modesById = new Map(DEFAULT_MODES.map((mode) => [mode.id, mode]));
-    for (const mode of discoveredModes) {
-        if (mode.id === OPENCODE_LEGACY_FULL_ACCESS_MODE_ID) {
-            continue;
-        }
-        modesById.set(mode.id, mode);
+    const filtered = discoveredModes.filter((mode) => mode.id !== OPENCODE_LEGACY_FULL_ACCESS_MODE_ID);
+    // When discovery returns results, trust them exactly — don't inject hardcoded
+    // defaults that the user may have intentionally disabled in their OpenCode config.
+    // Fall back to DEFAULT_MODES only when discovery produced nothing.
+    if (filtered.length > 0) {
+        return sortOpenCodeModes(filtered);
     }
-    return sortOpenCodeModes(Array.from(modesById.values()));
+    return sortOpenCodeModes([...DEFAULT_MODES]);
 }
 function sortOpenCodeModes(modes) {
     const order = new Map(DEFAULT_MODES.map((mode, index) => [mode.id, index]));
@@ -880,7 +879,9 @@ export class OpenCodeAgentClient {
         this.runtimeSettings = runtimeSettings;
         this.runtime =
             deps.runtime ??
-                new ProductionOpenCodeRuntime(OpenCodeServerManager.getInstance(this.logger, runtimeSettings));
+                new ProductionOpenCodeRuntime(OpenCodeServerManager.getInstance(this.logger, runtimeSettings, {
+                    managedProcesses: deps.managedProcesses,
+                }));
     }
     async createSession(config, launchContext, options) {
         const openCodeConfig = this.assertConfig(config);
@@ -938,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();
@@ -1092,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)
@@ -1120,37 +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 },
                 ]),
             };
         }
@@ -1160,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

@@ -8,7 +8,7 @@ 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, 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";
@@ -17,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";
@@ -1537,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,
@@ -1567,81 +1566,30 @@ export class PiRpcAgentClient {
         });
     }
     async isAvailable() {
-        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;
+            const launch = await this.resolvePiLaunch();
+            const availability = await checkProviderLaunchAvailable(launch);
+            return availability.available;
         }
         catch {
             return false;
         }
-        finally {
-            await runtimeSession.close().catch(() => undefined);
-        }
     }
     async getDiagnostic() {
         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>;