@getpaseo/server 0.1.100 → 0.1.102-beta.2

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

@@ -1,7 +1,6 @@
 import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
 import { importSessionFromPersistence } from "../provider-session-import.js";
 import { randomUUID } from "node:crypto";
-import * as fsSync from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -18,7 +17,7 @@ import { extractCodexTerminalSessionId, nonEmptyString } from "./tool-call-mappe
 import { buildCodexFeatures, codexModelSupportsFastMode } from "./codex-feature-definitions.js";
 import { CodexAppServerClient, parseCodexThreadForkResponse, parseCodexThreadRollbackResponse, } from "./codex/app-server-transport.js";
 import { revertCodexConversation } from "./codex/rewind.js";
-import { renderProviderImageOutputAsAssistantMarkdown, } from "./provider-image-output.js";
+import { materializeProviderImage, renderProviderImageOutputAsAssistantMarkdown, } from "./provider-image-output.js";
 import { normalizeProviderReplayTimestamp } from "../provider-history-timestamps.js";
 import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, resolveBinaryVersion, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
@@ -38,7 +37,6 @@ function isCodexAlreadyUnarchivedError(error, threadId) {
 const TURN_START_TIMEOUT_MS = 90 * 1000;
 const INTERRUPT_TIMEOUT_MS = 2000;
 const CODEX_PROVIDER = "codex";
-const CODEX_IMAGE_ATTACHMENT_DIR = "paseo-attachments";
 // Codex treats most app-server client names as the model-request originator.
 // This reserved Codex name is non-originating, so requests keep Codex's default
 // CLI identity instead of showing up as Paseo in provider usage logs.
@@ -1220,21 +1218,6 @@ function codexImageOutputFromResult(result) {
         mimeType: firstStringField(resultRecord, ["mimeType", "mime_type"]),
     };
 }
-function writeImageAttachmentSync(mimeType, data) {
-    const attachmentsDir = path.join(os.tmpdir(), CODEX_IMAGE_ATTACHMENT_DIR);
-    fsSync.mkdirSync(attachmentsDir, { recursive: true });
-    const normalized = normalizeImageData(mimeType, data);
-    const extension = getImageExtension(normalized.mimeType);
-    const filename = `${randomUUID()}.${extension}`;
-    const filePath = path.join(attachmentsDir, filename);
-    fsSync.writeFileSync(filePath, Buffer.from(normalized.data, "base64"));
-    return filePath;
-}
-function materializeCodexImageOutput(image) {
-    return {
-        path: writeImageAttachmentSync(image.mimeType ?? "image/png", image.data),
-    };
-}
 function mapCodexThreadImageItem(normalizedType, normalizedItem) {
     if (normalizedType === "imageView") {
         return renderProviderImageOutputAsAssistantMarkdown({
@@ -1248,7 +1231,7 @@ function mapCodexThreadImageItem(normalizedType, normalizedItem) {
         url: result?.url ?? null,
         data: result?.data ?? null,
         mimeType: result?.mimeType ?? null,
-    }, { materialize: materializeCodexImageOutput });
+    }, { materialize: materializeProviderImage });
 }
 export function threadItemToTimeline(item, options) {
     const itemRecord = toObjectRecord(item);
@@ -1357,33 +1340,6 @@ function toSandboxPolicy(type, networkAccess) {
             return { type: "workspaceWrite", networkAccess: networkAccess ?? false };
     }
 }
-function getImageExtension(mimeType) {
-    switch (mimeType) {
-        case "image/jpeg":
-            return "jpg";
-        case "image/png":
-            return "png";
-        case "image/webp":
-            return "webp";
-        case "image/gif":
-            return "gif";
-        case "image/bmp":
-            return "bmp";
-        case "image/tiff":
-            return "tiff";
-        default:
-            return "bin";
-    }
-}
-function normalizeImageData(mimeType, data) {
-    if (data.startsWith("data:")) {
-        const match = data.match(/^data:([^;]+);base64,(.*)$/);
-        if (match) {
-            return { mimeType: match[1], data: match[2] };
-        }
-    }
-    return { mimeType, data };
-}
 const ThreadStartedNotificationSchema = z
     .object({
     thread: z.object({ id: z.string() }).passthrough(),
@@ -2008,16 +1964,6 @@ const CodexNotificationSchema = z.union([
         .object({ method: z.string(), params: z.unknown() })
         .transform(({ method, params }) => ({ kind: "unknown_method", method, params })),
 ]);
-async function writeImageAttachment(mimeType, data) {
-    const attachmentsDir = path.join(os.tmpdir(), CODEX_IMAGE_ATTACHMENT_DIR);
-    await fs.mkdir(attachmentsDir, { recursive: true });
-    const normalized = normalizeImageData(mimeType, data);
-    const extension = getImageExtension(normalized.mimeType);
-    const filename = `${randomUUID()}.${extension}`;
-    const filePath = path.join(attachmentsDir, filename);
-    await fs.writeFile(filePath, Buffer.from(normalized.data, "base64"));
-    return filePath;
-}
 async function readCodexConfiguredDefaults(client, logger) {
     let savedConfigDefaults = {};
     try {
@@ -2071,7 +2017,10 @@ export async function codexAppServerTurnInputFromPrompt(prompt, logger) {
         }
         if (block.type === "image") {
             try {
-                const filePath = await writeImageAttachment(block.mimeType, block.data);
+                const filePath = materializeProviderImage({
+                    data: block.data,
+                    mimeType: block.mimeType,
+                }).path;
                 output.push({ type: "localImage", path: filePath });
             }
             catch (error) {

package/dist/server/server/agent/providers/diagnostic-utils.d.ts

@@ -10,6 +10,7 @@ export declare function formatDiagnosticStatus(available: boolean, error?: {
     source: string;
     cause: unknown;
 }): string;
+export declare function truncateForDiagnostic(value: string): string;
 export declare function toDiagnosticErrorMessage(error: unknown): string;
 export declare function resolveBinaryVersion(binaryPath: string): Promise<string>;
 export interface BinaryDiagnosticVersionCommand {

package/dist/server/server/agent/providers/diagnostic-utils.js

@@ -24,7 +24,7 @@ export function formatDiagnosticStatus(available, error) {
     return formatAvailabilityStatus(available);
 }
 const DIAGNOSTIC_OUTPUT_CAP = 4096;
-function truncateForDiagnostic(value) {
+export function truncateForDiagnostic(value) {
     const trimmed = value.trim();
     if (trimmed.length <= DIAGNOSTIC_OUTPUT_CAP) {
         return trimmed;

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

@@ -13,11 +13,13 @@ interface GenericACPAgentClientOptions {
     providerParams?: unknown;
     waitForInitialCommands?: boolean;
     initialCommandsWaitTimeoutMs?: number;
+    diagnosticPhaseTimeoutMs?: number;
 }
 export declare class GenericACPAgentClient extends ACPAgentClient {
     private readonly command;
     private readonly providerId?;
     private readonly label?;
+    private readonly diagnosticPhaseTimeoutMs?;
     constructor(options: GenericACPAgentClientOptions);
     protected resolveLaunchCommand(): Promise<{
         command: string;
@@ -28,6 +30,7 @@ export declare class GenericACPAgentClient extends ACPAgentClient {
         diagnostic: string;
     }>;
     private resolveConfiguredLaunch;
+    private getACPProbeRowsForDiagnostic;
 }
 export interface CommandInvocation {
     command: string;

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { checkProviderLaunchAvailable, resolveProviderLaunch } from "../provider-launch-config.js";
 import { ACPAgentClient, DEFAULT_ACP_CAPABILITIES } from "./acp-agent.js";
-import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, } from "./diagnostic-utils.js";
+import { buildBinaryDiagnosticRows, formatProviderDiagnostic, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 export const GenericACPProviderParamsSchema = z
     .object({
     supportsMcpServers: z.boolean().optional(),
@@ -23,6 +23,7 @@ export class GenericACPAgentClient extends ACPAgentClient {
         this.command = options.command;
         this.providerId = options.providerId;
         this.label = options.label;
+        this.diagnosticPhaseTimeoutMs = options.diagnosticPhaseTimeoutMs;
     }
     async resolveLaunchCommand() {
         return {
@@ -37,34 +38,36 @@ export class GenericACPAgentClient extends ACPAgentClient {
     }
     async getDiagnostic() {
         const providerName = formatProviderName(this.label, this.providerId);
+        const entries = [
+            { label: "Provider ID", value: this.providerId ?? "unknown" },
+            { label: "Configured command", value: this.command.join(" ") },
+        ];
+        const versionProbe = buildVersionProbeCommand(this.command);
         try {
             const launch = await this.resolveConfiguredLaunch();
             const availability = await checkProviderLaunchAvailable(launch);
-            const versionProbe = buildVersionProbeCommand(this.command);
-            return {
-                diagnostic: formatProviderDiagnostic(providerName, [
-                    { label: "Provider ID", value: this.providerId ?? "unknown" },
-                    { label: "Configured command", value: this.command.join(" ") },
-                    ...(await buildBinaryDiagnosticRows(launch, availability, {
-                        binaryLabel: "Launcher binary",
-                        versionCommand: {
-                            command: versionProbe.command,
-                            args: versionProbe.args,
-                            env: this.runtimeSettings?.env,
-                        },
-                    })),
-                    {
-                        label: "Version command",
-                        value: formatCommand(versionProbe.command, versionProbe.args),
-                    },
-                ]),
-            };
+            entries.push(...(await buildBinaryDiagnosticRows(launch, availability, {
+                binaryLabel: "Launcher binary",
+                versionCommand: {
+                    command: versionProbe.command,
+                    args: versionProbe.args,
+                    env: this.runtimeSettings?.env,
+                },
+            })));
         }
         catch (error) {
-            return {
-                diagnostic: formatProviderDiagnosticError(providerName, error),
-            };
+            entries.push({
+                label: "Launcher binary",
+                value: `error: ${toDiagnosticErrorMessage(error)}`,
+            });
         }
+        entries.push({
+            label: "Version command",
+            value: formatCommand(versionProbe.command, versionProbe.args),
+        }, ...(await this.getACPProbeRowsForDiagnostic()));
+        return {
+            diagnostic: formatProviderDiagnostic(providerName, entries),
+        };
     }
     async resolveConfiguredLaunch() {
         return resolveProviderLaunch({
@@ -72,6 +75,21 @@ export class GenericACPAgentClient extends ACPAgentClient {
             defaultBinary: this.command[0],
         });
     }
+    async getACPProbeRowsForDiagnostic() {
+        try {
+            return await this.buildACPProbeDiagnosticRows({
+                phaseTimeoutMs: this.diagnosticPhaseTimeoutMs,
+            });
+        }
+        catch (error) {
+            return [
+                {
+                    label: "ACP probe",
+                    value: `error: ${toDiagnosticErrorMessage(error)}`,
+                },
+            ];
+        }
+    }
 }
 function buildGenericACPCapabilities(options) {
     const params = parseGenericACPProviderParams(options.providerParams);

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

@@ -167,7 +167,7 @@ function parseAgentStreamStressPrompt(prompt) {
 }
 function parseStructuredBranchNamePrompt(prompt) {
     const text = promptToText(prompt);
-    const hasBranchNamePrompt = text.includes("Generate a git branch name for a coding agent") &&
+    const hasBranchNamePrompt = text.includes("Generate a title and a git branch name for a coding agent") &&
         (text.includes("Return JSON only with fields 'title' and 'branch'.") ||
             text.includes('"title"') ||
             text.includes('"branch"'));
@@ -177,7 +177,9 @@ function parseStructuredBranchNamePrompt(prompt) {
             text.includes('"branch"'))) {
         return null;
     }
-    const seed = text.split("User context:\n").at(-1)?.trim() ?? "";
+    const seed = text.match(/<user-prompt>\n([\s\S]*?)\n<\/user-prompt>/)?.[1]?.trim() ??
+        text.match(/<attachments>\n([\s\S]*?)\n<\/attachments>/)?.[1]?.trim() ??
+        "";
     const firstLine = seed
         .split("\n")
         .find((line) => line.trim().length > 0)
@@ -437,12 +439,14 @@ export class MockLoadTestAgentSession {
         }
         const profile = resolveModelProfile(this.modelId);
         const turnId = randomUUID();
+        const assistantMessageId = randomUUID();
         let resolve;
         const completed = new Promise((promiseResolve) => {
             resolve = promiseResolve;
         });
         const turn = {
             turnId,
+            assistantMessageId,
             prompt,
             startedAt: Date.now(),
             cycle: 0,
@@ -653,6 +657,7 @@ export class MockLoadTestAgentSession {
         this.emitTimeline(turn.turnId, {
             type: "assistant_message",
             text: finalText,
+            messageId: turn.assistantMessageId,
         });
         this.activeTurn = null;
         this.emit({
@@ -667,6 +672,7 @@ export class MockLoadTestAgentSession {
                 {
                     type: "assistant_message",
                     text: finalText,
+                    messageId: turn.assistantMessageId,
                 },
             ],
             canceled: false,
@@ -766,6 +772,7 @@ export class MockLoadTestAgentSession {
                 ? {
                     type: "assistant_message",
                     text: `stress-update-${index}`,
+                    messageId: turn.assistantMessageId,
                 }
                 : {
                     type: "todo",
@@ -832,6 +839,7 @@ export class MockLoadTestAgentSession {
             this.emitTimeline(turn.turnId, {
                 type: "assistant_message",
                 text: `data:image/png;base64,${payload}`,
+                messageId: turn.assistantMessageId,
             });
         }
         this.activeTurn = null;
@@ -890,6 +898,7 @@ export class MockLoadTestAgentSession {
                 this.emitTimeline(turn.turnId, {
                     type: "assistant_message",
                     text: event.text,
+                    messageId: turn.assistantMessageId,
                 });
                 return;
             }
@@ -931,6 +940,7 @@ export class MockLoadTestAgentSession {
         this.emitTimeline(turn.turnId, {
             type: "assistant_message",
             text: "\n\n_(end of synthetic stream)_\n",
+            messageId: turn.assistantMessageId,
         });
         this.finishTurnWithText(turn, "Synthetic load test complete");
     }

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

@@ -0,0 +1,2 @@
+export declare function resolveOpenCodeHomeDir(env?: NodeJS.ProcessEnv): string;
+//# sourceMappingURL=paths.d.ts.map

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

@@ -0,0 +1,7 @@
+import path from "node:path";
+import { resolvePaseoHome } from "../../../paseo-home.js";
+const OPENCODE_HOME_DIRNAME = "opencode-home";
+export function resolveOpenCodeHomeDir(env = process.env) {
+    return path.join(resolvePaseoHome(env), OPENCODE_HOME_DIRNAME);
+}
+//# sourceMappingURL=paths.js.map

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

@@ -46,6 +46,7 @@ export interface OpenCodeServerManagerOptions {
     terminateProcess?: ProcessTerminator;
     portAllocator?: OpenCodePortAllocator;
     resolveCommandPrefix?: OpenCodeCommandPrefixResolver;
+    resolveHomeDir?: () => string;
     spawnServerProcess?: OpenCodeServerProcessSpawner;
 }
 export declare class OpenCodeServerManager implements OpenCodeServerManagerLike {
@@ -62,6 +63,7 @@ export declare class OpenCodeServerManager implements OpenCodeServerManagerLike
     private readonly terminateProcess;
     private readonly portAllocator;
     private readonly resolveCommandPrefix;
+    private readonly resolveHomeDir;
     private readonly spawnServerProcess;
     constructor(options: OpenCodeServerManagerOptions);
     static getInstance(logger: Logger, runtimeSettings?: ProviderRuntimeSettings, options?: Omit<OpenCodeServerManagerOptions, "logger" | "runtimeSettings">): OpenCodeServerManager;

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

@@ -1,9 +1,12 @@
+import { mkdirSync } from "node:fs";
+import { stat } from "node:fs/promises";
 import net from "node:net";
-import os from "node:os";
+import path from "node:path";
 import { findExecutable } from "../../../../executable-resolution/executable-resolution.js";
 import { spawnProcess } from "../../../../utils/spawn.js";
 import { terminateWithTreeKill } from "../../../../utils/tree-kill.js";
 import { createProviderEnvSpec, resolveProviderCommandPrefix, } from "../../provider-launch-config.js";
+import { resolveOpenCodeHomeDir } from "./paths.js";
 const OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS = 5000;
 const OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS = 1000;
 export class OpenCodeServerManager {
@@ -21,6 +24,7 @@ export class OpenCodeServerManager {
         this.resolveCommandPrefix =
             options.resolveCommandPrefix ??
                 (() => resolveProviderCommandPrefix(this.runtimeSettings?.command, resolveOpenCodeBinary));
+        this.resolveHomeDir = options.resolveHomeDir ?? resolveOpenCodeHomeDir;
         this.spawnServerProcess = options.spawnServerProcess ?? spawnProcess;
     }
     static getInstance(logger, runtimeSettings, options = {}) {
@@ -164,7 +168,11 @@ export class OpenCodeServerManager {
         const url = `http://127.0.0.1:${port}`;
         const launchPrefix = await this.resolveCommandPrefix();
         const serverArgs = [...launchPrefix.args, "serve", "--port", String(port)];
-        const serverCwd = os.homedir();
+        // Use a neutral OpenCode home as the server cwd. Launching from the user's
+        // home directory causes OpenCode to treat it as the default workspace and
+        // index the entire home tree.
+        const serverCwd = this.resolveHomeDir();
+        mkdirSync(serverCwd, { recursive: true });
         const serverProcess = this.spawnServerProcess(launchPrefix.command, serverArgs, {
             cwd: serverCwd,
             detached: process.platform !== "win32",
@@ -371,10 +379,31 @@ OpenCodeServerManager.instance = null;
 OpenCodeServerManager.exitHandlerRegistered = false;
 async function resolveOpenCodeBinary() {
     const found = await findExecutable("opencode");
-    if (found) {
-        return found;
+    if (!found) {
+        throw new Error("OpenCode binary not found. Install OpenCode (https://github.com/opencode-ai/opencode) and ensure it is available in your shell PATH.");
+    }
+    if (process.platform === "win32" && path.extname(found).toLowerCase() === ".cmd") {
+        // Global npm: <prefix>/opencode.cmd → <prefix>/node_modules/opencode-ai/bin/opencode.exe
+        const globalCandidate = path.join(path.dirname(found), "node_modules", "opencode-ai", "bin", "opencode.exe");
+        if (await pathExists(globalCandidate))
+            return globalCandidate;
+        // Local/pnpm: <project>/node_modules/.bin/opencode.cmd → <project>/node_modules/opencode-ai/bin/opencode.exe
+        const localCandidate = path.join(path.dirname(found), "..", "opencode-ai", "bin", "opencode.exe");
+        if (await pathExists(localCandidate))
+            return localCandidate;
+        console.warn("[opencode-server] Found opencode.cmd but could not resolve the real opencode.exe. " +
+            "The process may not be properly terminated on exit. Path: %s", found);
+    }
+    return found;
+}
+async function pathExists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
     }
-    throw new Error("OpenCode binary not found. Install OpenCode (https://github.com/opencode-ai/opencode) and ensure it is available in your shell PATH.");
 }
 function findAvailablePort() {
     return new Promise((resolve, reject) => {

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

@@ -4,6 +4,7 @@ import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOpt
 import { isDefaultAgentCreateConfigUnattended } from "../create-agent-mode.js";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
 import { type OpenCodeServerManagerLike } from "./opencode/server-manager.js";
+import { resolveOpenCodeHomeDir } from "./opencode/paths.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;
@@ -100,11 +101,13 @@ export declare const __openCodeInternals: {
     resolveOpenCodeSelectedModelContextWindow: typeof resolveOpenCodeSelectedModelContextWindow;
     isSelectableOpenCodeAgent: typeof isSelectableOpenCodeAgent;
     mapOpenCodeAgentToMode: typeof mapOpenCodeAgentToMode;
+    resolveOpenCodeHomeDir: typeof resolveOpenCodeHomeDir;
     readonly OpenCodeAgentSession: typeof OpenCodeAgentSession;
 };
 interface OpenCodeAgentClientDeps {
     serverManager?: OpenCodeServerManagerLike;
     createClient?: OpenCodeClientFactory;
+    resolveHomeDir?: () => string;
     managedProcesses?: ManagedProcessRegistry;
 }
 type OpenCodeClientFactory = (options: {
@@ -118,6 +121,7 @@ export declare class OpenCodeAgentClient implements AgentClient {
     readonly isCreateConfigUnattended: typeof isOpenCodeCreateConfigUnattended;
     private readonly serverManager;
     private readonly createOpenCodeClient;
+    private readonly resolveHomeDir;
     private readonly logger;
     private readonly runtimeSettings?;
     private readonly modelContextWindows;

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

@@ -1,4 +1,5 @@
 import { createOpencodeClient, } from "@opencode-ai/sdk/v2/client";
+import fs from "node:fs/promises";
 import { createPathEquivalenceMatcher } from "../../../utils/path.js";
 import pLimit from "p-limit";
 import { z } from "zod";
@@ -11,6 +12,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 { resolveOpenCodeHomeDir } from "./opencode/paths.js";
 import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
@@ -847,6 +849,7 @@ export const __openCodeInternals = {
     resolveOpenCodeSelectedModelContextWindow,
     isSelectableOpenCodeAgent,
     mapOpenCodeAgentToMode,
+    resolveOpenCodeHomeDir,
     get OpenCodeAgentSession() {
         return OpenCodeAgentSession;
     },
@@ -867,8 +870,10 @@ export class OpenCodeAgentClient {
             deps.serverManager ??
                 OpenCodeServerManager.getInstance(this.logger, runtimeSettings, {
                     managedProcesses: deps.managedProcesses,
+                    resolveHomeDir: deps.resolveHomeDir,
                 });
         this.createOpenCodeClient = deps.createClient ?? createSdkOpenCodeClient;
+        this.resolveHomeDir = deps.resolveHomeDir ?? resolveOpenCodeHomeDir;
     }
     async createSession(config, launchContext, options) {
         const openCodeConfig = this.assertConfig(config);
@@ -930,9 +935,16 @@ export class OpenCodeAgentClient {
             ? await this.serverManager.acquireNew()
             : await this.serverManager.acquireCurrent();
         const { url } = acquisition.server;
-        const directory = options.cwd;
-        const client = this.createOpenCodeClient({ baseUrl: url, directory });
+        const isGlobalCatalog = options.scope === "global";
         try {
+            // OpenCode treats the catalog directory as a workspace. The global catalog
+            // is not a project, so use the neutral OpenCode home instead of user home.
+            const directory = isGlobalCatalog ? this.resolveHomeDir() : options.cwd;
+            if (isGlobalCatalog) {
+                await fs.mkdir(directory, { recursive: true });
+                this.logger.debug({ directory }, "opencode catalog refresh: using opencode-home for global provider catalog");
+            }
+            const client = this.createOpenCodeClient({ baseUrl: url, directory });
             const [models, modes] = await Promise.all([
                 this.fetchModelsFromClient(client, directory),
                 this.fetchModesFromClient(client, directory),

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

@@ -1,11 +1,12 @@
 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 FetchCatalogOptions, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ProviderCatalog } from "../../agent-sdk-types.js";
+import { type AgentCapabilityFlags, type AgentClient, 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 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 { PiCommandsRpcType, PiSessionState } from "./rpc-types.js";
 export declare const PiProviderParamsSchema: z.ZodObject<{
     sessionDir: z.ZodOptional<z.ZodString>;
+    extensionTimeoutMs: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>;
 interface PiRpcAgentClientOptions {
     logger: Logger;
@@ -23,6 +24,7 @@ interface PiRpcAgentSessionOptions {
     initialState: PiSessionState;
     capabilities: AgentCapabilityFlags;
     cleanup?: () => void;
+    extensionTimeoutMs?: number;
 }
 export declare function transformPiModels(models: AgentModelDefinition[]): AgentModelDefinition[];
 export declare class PiRpcAgentSession implements AgentSession {
@@ -50,6 +52,7 @@ export declare class PiRpcAgentSession implements AgentSession {
     private readonly runtimeSession;
     private readonly config;
     private readonly cleanup?;
+    private readonly extensionTimeoutMs;
     get id(): string | null;
     run(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<AgentRunResult>;
     startTurn(prompt: AgentPromptInput, _options?: AgentRunOptions): Promise<StartTurnResult>;
@@ -114,6 +117,7 @@ export declare class PiRpcAgentClient implements AgentClient {
     createSession(config: AgentSessionConfig, launchContext?: AgentLaunchContext): Promise<AgentSession>;
     resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, _launchContext?: AgentLaunchContext): Promise<AgentSession>;
     fetchCatalog(options: FetchCatalogOptions): Promise<ProviderCatalog>;
+    listFeatures(_config: AgentSessionConfig): Promise<AgentFeature[]>;
     listImportableSessions(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
     importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../../agent-sdk-types.js").ImportedProviderSession>;
     isAvailable(): Promise<boolean>;

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

@@ -22,7 +22,7 @@ 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";
 const PASEO_PI_COMMAND_RESULT_MARKER = "PASEO_COMMAND_RESULT";
-const PASEO_PI_EXTENSION_RESULT_TIMEOUT_MS = 10000;
+const DEFAULT_PI_EXTENSION_RESULT_TIMEOUT_MS = 30000;
 const QUESTION_RESPONSE_HEADER = "Response";
 const QUESTION_COMMENT_HEADER = "Comment";
 const PI_ASK_USER_FREEFORM_SENTINEL = "✏️ Type custom response...";
@@ -30,6 +30,7 @@ const COMBINED_ASK_USER_METADATA = "ask_user_select_optional_comment";
 export const PiProviderParamsSchema = z
     .object({
     sessionDir: z.string().min(1).optional(),
+    extensionTimeoutMs: z.number().int().positive().default(DEFAULT_PI_EXTENSION_RESULT_TIMEOUT_MS),
 })
     .strict();
 const PI_HANDLED_BUILTIN_SLASH_COMMANDS = [
@@ -715,6 +716,7 @@ export class PiRpcAgentSession {
             normalizePiThinkingOption(options.config.thinkingOptionId) ??
                 this.state.thinkingLevel ??
                 null;
+        this.extensionTimeoutMs = options.extensionTimeoutMs ?? DEFAULT_PI_EXTENSION_RESULT_TIMEOUT_MS;
         this.runtimeSession.onEvent((event) => {
             this.handleRuntimeEvent(event);
         });
@@ -1065,7 +1067,7 @@ export class PiRpcAgentSession {
             const timer = setTimeout(() => {
                 this.pendingExtensionResults.delete(requestId);
                 reject(new Error(`Pi extension result timed out for request ${requestId}`));
-            }, PASEO_PI_EXTENSION_RESULT_TIMEOUT_MS);
+            }, this.extensionTimeoutMs);
             this.pendingExtensionResults.set(requestId, { resolve, reject, timer });
         });
     }
@@ -1489,6 +1491,7 @@ export class PiRpcAgentClient {
                 initialState: await runtimeSession.getState(),
                 capabilities: withPiMcpCapability(mcpConfig !== null),
                 cleanup: combineCleanup([mcpConfig?.cleanup, paseoExtension.cleanup]),
+                extensionTimeoutMs: this.providerParams.extensionTimeoutMs,
             });
         }
         catch (error) {
@@ -1531,6 +1534,7 @@ export class PiRpcAgentClient {
                 initialState: await runtimeSession.getState(),
                 capabilities: withPiMcpCapability(mcpConfig !== null),
                 cleanup: combineCleanup([mcpConfig?.cleanup, paseoExtension.cleanup]),
+                extensionTimeoutMs: this.providerParams.extensionTimeoutMs,
             });
         }
         catch (error) {
@@ -1541,7 +1545,9 @@ export class PiRpcAgentClient {
         }
     }
     async fetchCatalog(options) {
-        const runtimeSession = await this.runtime.startSession({ cwd: options.cwd });
+        const runtimeSession = await this.runtime.startSession({
+            cwd: options.scope === "global" ? homedir() : options.cwd,
+        });
         try {
             const models = transformPiModels((await runtimeSession.getAvailableModels(PI_CATALOG_REQUEST_TIMEOUT_MS)).map(mapPiModel));
             return { models, modes: [] };
@@ -1550,6 +1556,9 @@ export class PiRpcAgentClient {
             await runtimeSession.close();
         }
     }
+    async listFeatures(_config) {
+        return [];
+    }
     async listImportableSessions(options) {
         return await listPiImportableSessions({
             ...options,

package/dist/server/server/agent/providers/provider-image-output.d.ts

@@ -9,6 +9,11 @@ export interface ProviderImageOutput {
 export interface MaterializedProviderImage {
     path: string;
 }
+export declare function materializeProviderImage(image: {
+    data: string;
+    mimeType: string | null;
+}): MaterializedProviderImage;
+export declare function isProviderImageMarkdown(text: string): boolean;
 interface RenderProviderImageOutputOptions {
     materialize?: (image: {
         data: string;