@getpaseo/server 0.1.98 → 0.1.100

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

@@ -1,4 +1,4 @@
-import { homedir } from "node:os";
+import { createOpencodeClient, } from "@opencode-ai/sdk/v2/client";
 import { createPathEquivalenceMatcher } from "../../../utils/path.js";
 import pLimit from "p-limit";
 import { z } from "zod";
@@ -10,12 +10,11 @@ import { withTimeout } from "../../../utils/promise-timeout.js";
 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 { OpenCodeServerManager, } from "./opencode/server-manager.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";
-import { createSdkOpenCodeClient, } from "./opencode/runtime.js";
 import { normalizeProviderReplayTimestamp } from "../provider-history-timestamps.js";
 import { revertOpenCodeConversationAndFiles } from "./opencode/rewind.js";
 const OPENCODE_CAPABILITIES = {
@@ -852,22 +851,8 @@ export const __openCodeInternals = {
         return OpenCodeAgentSession;
     },
 };
-class ProductionOpenCodeRuntime {
-    constructor(serverManager) {
-        this.serverManager = serverManager;
-    }
-    async acquireServer(options) {
-        return this.serverManager.acquire(options);
-    }
-    async ensureServerRunning() {
-        return this.serverManager.ensureRunning();
-    }
-    createClient(options) {
-        return createSdkOpenCodeClient(options);
-    }
-    async shutdown() {
-        await this.serverManager.shutdown();
-    }
+function createSdkOpenCodeClient(options) {
+    return createOpencodeClient(options);
 }
 export class OpenCodeAgentClient {
     constructor(logger, runtimeSettings, deps = {}) {
@@ -878,20 +863,20 @@ export class OpenCodeAgentClient {
         this.modelContextWindows = new Map();
         this.logger = logger.child({ module: "agent", provider: "opencode" });
         this.runtimeSettings = runtimeSettings;
-        this.runtime =
-            deps.runtime ??
-                new ProductionOpenCodeRuntime(OpenCodeServerManager.getInstance(this.logger, runtimeSettings, {
+        this.serverManager =
+            deps.serverManager ??
+                OpenCodeServerManager.getInstance(this.logger, runtimeSettings, {
                     managedProcesses: deps.managedProcesses,
-                }));
+                });
+        this.createOpenCodeClient = deps.createClient ?? createSdkOpenCodeClient;
     }
     async createSession(config, launchContext, options) {
         const openCodeConfig = this.assertConfig(config);
-        const acquisition = await this.runtime.acquireServer({
-            force: false,
-            env: launchContext?.env,
-        });
+        const acquisition = launchContext?.env
+            ? await this.serverManager.acquireDedicated(launchContext.env)
+            : await this.serverManager.acquireCurrent();
         const { url } = acquisition.server;
-        const client = this.runtime.createClient({
+        const client = this.createOpenCodeClient({
             baseUrl: url,
             directory: openCodeConfig.cwd,
         });
@@ -925,9 +910,9 @@ export class OpenCodeAgentClient {
             cwd,
         };
         const openCodeConfig = this.assertConfig(config);
-        const acquisition = await this.runtime.acquireServer({ force: false });
+        const acquisition = await this.serverManager.acquireCurrent();
         const { url } = acquisition.server;
-        const client = this.runtime.createClient({
+        const client = this.createOpenCodeClient({
             baseUrl: url,
             directory: openCodeConfig.cwd,
         });
@@ -940,70 +925,19 @@ 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) {
-        const acquisition = await this.runtime.acquireServer({ force: options.force });
+    async fetchCatalog(options) {
+        const acquisition = options.force
+            ? await this.serverManager.acquireNew()
+            : await this.serverManager.acquireCurrent();
         const { url } = acquisition.server;
         const directory = options.cwd;
-        const client = this.runtime.createClient({ baseUrl: url, directory });
+        const client = this.createOpenCodeClient({ 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();
@@ -1011,9 +945,9 @@ export class OpenCodeAgentClient {
     }
     async listCommands(config) {
         const openCodeConfig = this.assertConfig(config);
-        const acquisition = await this.runtime.acquireServer({ force: false });
+        const acquisition = await this.serverManager.acquireCurrent();
         const { url } = acquisition.server;
-        const client = this.runtime.createClient({
+        const client = this.createOpenCodeClient({
             baseUrl: url,
             directory: openCodeConfig.cwd,
         });
@@ -1028,9 +962,9 @@ export class OpenCodeAgentClient {
         return [buildOpenCodeAutoAcceptFeature(this.assertConfig(config))];
     }
     async listImportableSessions(options) {
-        const acquisition = await this.runtime.acquireServer({ force: false });
+        const acquisition = await this.serverManager.acquireCurrent();
         const { url } = acquisition.server;
-        const client = this.runtime.createClient({
+        const client = this.createOpenCodeClient({
             baseUrl: url,
             directory: options?.cwd ?? "",
         });
@@ -1042,9 +976,9 @@ export class OpenCodeAgentClient {
         }
     }
     async importSession(input, context) {
-        const acquisition = await this.runtime.acquireServer({ force: false });
+        const acquisition = await this.serverManager.acquireCurrent();
         const { url } = acquisition.server;
-        const client = this.runtime.createClient({
+        const client = this.createOpenCodeClient({
             baseUrl: url,
             directory: input.cwd,
         });
@@ -1085,7 +1019,7 @@ export class OpenCodeAgentClient {
         return availability.available;
     }
     async shutdown() {
-        await this.runtime.shutdown();
+        await this.serverManager.shutdown();
     }
     async getDiagnostic() {
         try {
@@ -1094,17 +1028,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 +1045,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 +1061,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,9 +1,9 @@
 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";
+import type { PiCommandsRpcType, PiSessionState } from "./rpc-types.js";
 export declare const PiProviderParamsSchema: z.ZodObject<{
     sessionDir: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
@@ -11,6 +11,7 @@ interface PiRpcAgentClientOptions {
     logger: Logger;
     runtimeSettings?: ProviderRuntimeSettings;
     providerParams?: unknown;
+    commandsRpcType?: PiCommandsRpcType;
     runtime?: PiRuntime;
 }
 interface StartTurnResult {
@@ -112,8 +113,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";
@@ -685,8 +685,8 @@ function mapPiModel(model) {
         defaultThinkingOptionId: model.reasoning ? DEFAULT_PI_THINKING_LEVEL : undefined,
     };
 }
-function createRuntime(logger, runtimeSettings) {
-    return new PiCliRuntime({ logger, runtimeSettings });
+function createRuntime(logger, runtimeSettings, commandsRpcType) {
+    return new PiCliRuntime({ logger, runtimeSettings, commandsRpcType });
 }
 export class PiRpcAgentSession {
     constructor(options) {
@@ -1458,7 +1458,9 @@ export class PiRpcAgentClient {
         this.logger = options.logger;
         this.runtimeSettings = options.runtimeSettings;
         this.providerParams = PiProviderParamsSchema.parse(options.providerParams ?? {});
-        this.runtime = options.runtime ?? createRuntime(options.logger, options.runtimeSettings);
+        this.runtime =
+            options.runtime ??
+                createRuntime(options.logger, options.runtimeSettings, options.commandsRpcType);
     }
     async createSession(config, launchContext) {
         const mcpConfig = await this.prepareMcpConfig(config.cwd, config.mcpServers);
@@ -1538,18 +1540,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 +1569,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 +1581,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.d.ts

@@ -2,15 +2,18 @@ import { type ChildProcessWithoutNullStreams } from "node:child_process";
 import type { Logger } from "pino";
 import type { ProviderRuntimeSettings } from "../../provider-launch-config.js";
 import { type PiRuntime, type PiRuntimeLaunch, type PiRuntimeSession, type PiStartSessionInput } from "./runtime.js";
+import type { PiCommandsRpcType } from "./rpc-types.js";
 export interface PiCliRuntimeOptions {
     logger: Logger;
     runtimeSettings?: ProviderRuntimeSettings;
     command?: [string, ...string[]];
+    commandsRpcType?: PiCommandsRpcType;
     spawnProcess?: (launch: PiRuntimeLaunch) => ChildProcessWithoutNullStreams;
 }
 export declare class PiCliRuntime implements PiRuntime {
     private readonly options;
     private readonly command;
+    private readonly commandsRpcType;
     private readonly spawnProcess;
     constructor(options: PiCliRuntimeOptions);
     startSession(input: PiStartSessionInput): Promise<PiRuntimeSession>;

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

@@ -5,6 +5,7 @@ const DEFAULT_PI_COMMAND = [
     process.env.PI_COMMAND ?? process.env.PI_ACP_PI_COMMAND ?? "pi",
 ];
 const DEFAULT_TIMEOUT_MS = 30000;
+const DEFAULT_COMMANDS_RPC_TYPE = "get_commands";
 const STDERR_BUFFER_LIMIT = 8192;
 const GRACEFUL_SHUTDOWN_TIMEOUT_MS = 2000;
 const FORCE_SHUTDOWN_TIMEOUT_MS = 1000;
@@ -17,6 +18,7 @@ export class PiCliRuntime {
     constructor(options) {
         this.options = options;
         this.command = options.command ?? DEFAULT_PI_COMMAND;
+        this.commandsRpcType = options.commandsRpcType ?? DEFAULT_COMMANDS_RPC_TYPE;
         this.spawnProcess =
             options.spawnProcess ??
                 ((launch) => {
@@ -36,13 +38,14 @@ export class PiCliRuntime {
             runtimeSettings: this.options.runtimeSettings,
             session: input,
         });
-        return new PiCliRuntimeSession(launch, this.spawnProcess(launch), this.options.logger);
+        return new PiCliRuntimeSession(launch, this.spawnProcess(launch), this.options.logger, this.commandsRpcType);
     }
 }
 class PiCliRuntimeSession {
-    constructor(_launch, child, logger) {
+    constructor(_launch, child, logger, commandsRpcType) {
         this.child = child;
         this.logger = logger;
+        this.commandsRpcType = commandsRpcType;
         this.pending = new Map();
         this.subscribers = new Set();
         this.stderrBuffer = "";
@@ -95,8 +98,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) {
@@ -109,7 +112,7 @@ class PiCliRuntimeSession {
         return (await this.request({ type: "get_session_stats" }));
     }
     async getCommands() {
-        const data = (await this.request({ type: "get_commands" }));
+        const data = (await this.request({ type: this.commandsRpcType }));
         return data.commands ?? [];
     }
     respondToExtensionUiRequest(id, response) {

package/dist/server/server/agent/providers/pi/rpc-types.d.ts

@@ -94,6 +94,7 @@ export interface PiRpcSlashCommand {
     source: "extension" | "prompt" | "skill";
     sourceInfo?: Record<string, unknown>;
 }
+export type PiCommandsRpcType = "get_commands" | "get_available_commands";
 export type PiRpcCommand = {
     id?: string;
     type: "prompt";
@@ -133,7 +134,7 @@ export type PiRpcCommand = {
     type: "get_session_stats";
 } | {
     id?: string;
-    type: "get_commands";
+    type: PiCommandsRpcType;
 };
 export interface PiRpcResponse {
     id?: string;

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) {