@getpaseo/server 0.9.2 → 0.10.0

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

@@ -1325,6 +1325,7 @@ export declare const OmpRuntimeEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject
     title: z.ZodOptional<z.ZodString>;
     message: z.ZodOptional<z.ZodString>;
     options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optionDetails: z.ZodOptional<z.ZodUnknown>;
     placeholder: z.ZodOptional<z.ZodString>;
     url: z.ZodOptional<z.ZodString>;
     launchUrl: z.ZodOptional<z.ZodString>;

package/dist/server/server/agent/providers/omp/rpc-types.js

@@ -425,6 +425,7 @@ const OmpExtensionUiRequestSchema = z
     title: z.string().optional(),
     message: z.string().optional(),
     options: z.array(z.string()).optional(),
+    optionDetails: z.unknown().optional(),
     placeholder: z.string().optional(),
     url: z.string().optional(),
     launchUrl: z.string().optional(),

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

@@ -19,12 +19,14 @@ export declare class OpenCodeBridge {
     private server;
     private baseUrl;
     private pluginUrl;
+    private v2PluginUrl;
     private manifestCatalog;
     constructor(options: OpenCodeBridgeOptions);
     start(): Promise<void>;
     setManifestCatalog(catalog: PaseoToolCatalog | null): void;
     bindSession(input: BindOpenCodeSessionInput): () => void;
     decorateServerEnv(env: Record<string, string>): Record<string, string>;
+    decorateV2ServerEnv(env: Record<string, string>): Promise<Record<string, string>>;
     close(): Promise<void>;
     private materializePlugin;
     private route;
@@ -33,7 +35,9 @@ export declare class OpenCodeBridge {
     private requireBaseUrl;
     private requirePluginUrl;
 }
+export declare function materializeOpenCodeV2Plugin(paseoHome: string): Promise<string>;
+export declare function decorateOpenCodeV2Env(env: Record<string, string>, pluginUrl: string, options?: Record<string, string>): Record<string, string>;
 type CompileOpenCodeBridgePlugin = (sourcePath: string) => Promise<Uint8Array>;
-export declare function loadOpenCodeBridgePluginArtifact(moduleUrl: string, compileSource?: CompileOpenCodeBridgePlugin): Promise<Uint8Array>;
+export declare function loadOpenCodeBridgePluginArtifact(moduleUrl: string, compileSource?: CompileOpenCodeBridgePlugin, version?: 1 | 2): Promise<Uint8Array>;
 export {};
 //# sourceMappingURL=bridge.d.ts.map

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

@@ -14,6 +14,7 @@ export class OpenCodeBridge {
         this.server = null;
         this.baseUrl = null;
         this.pluginUrl = null;
+        this.v2PluginUrl = null;
         this.manifestCatalog = null;
         this.paseoHome = options.paseoHome;
         this.logger = options.logger.child({ module: "agent", component: "opencode-bridge" });
@@ -75,6 +76,13 @@ export class OpenCodeBridge {
             }),
         };
     }
+    async decorateV2ServerEnv(env) {
+        this.v2PluginUrl ?? (this.v2PluginUrl = await this.materializePlugin(2));
+        return decorateOpenCodeV2Env(env, this.v2PluginUrl, {
+            baseUrl: this.requireBaseUrl(),
+            token: this.token,
+        });
+    }
     async close() {
         const server = this.server;
         this.server = null;
@@ -83,7 +91,9 @@ export class OpenCodeBridge {
         if (server)
             await closeServer(server);
     }
-    async materializePlugin() {
+    async materializePlugin(version = 1) {
+        if (version === 2)
+            return materializeOpenCodeV2Plugin(this.paseoHome);
         const artifact = await loadOpenCodeBridgePluginArtifact(import.meta.url);
         const digest = createHash("sha256").update(artifact).digest("hex");
         const destination = path.join(this.paseoHome, "runtime", "opencode", `paseo-${digest}.mjs`);
@@ -108,7 +118,12 @@ export class OpenCodeBridge {
                     sendJson(response, 404, { error: "OpenCode session is not bound to a Paseo agent" });
                     return;
                 }
-                sendJson(response, 200, { env: binding.env });
+                sendJson(response, 200, {
+                    env: binding.env,
+                    ...(url.searchParams.has("tools")
+                        ? { tools: [...(binding.tools?.tools.keys() ?? [])] }
+                        : {}),
+                });
                 return;
             }
             const toolMatch = url.pathname.match(new RegExp(`^${INTERNAL_PREFIX}/sessions/([^/]+)/tools/([^/]+)$`));
@@ -177,8 +192,43 @@ export class OpenCodeBridge {
         return this.pluginUrl;
     }
 }
-export async function loadOpenCodeBridgePluginArtifact(moduleUrl, compileSource = compileOpenCodeBridgePlugin) {
-    const bundleUrl = new URL("./bridge-plugin.bundle.mjs", moduleUrl);
+export async function materializeOpenCodeV2Plugin(paseoHome) {
+    const artifact = await loadOpenCodeBridgePluginArtifact(import.meta.url, undefined, 2);
+    const digest = createHash("sha256").update(artifact).digest("hex");
+    // V2 ignores configured file paths; it loads a package directory's server entry point.
+    const directory = path.join(paseoHome, "runtime", "opencode", `paseo-v2-${digest}`);
+    await writeFileAtomic(path.join(directory, "server.js"), artifact);
+    await writeFileAtomic(path.join(directory, "package.json"), JSON.stringify({
+        name: "paseo-opencode-bridge",
+        private: true,
+        type: "module",
+        exports: { "./server": "./server.js" },
+    }));
+    return pathToFileURL(directory).href;
+}
+export function decorateOpenCodeV2Env(env, pluginUrl, options = {}) {
+    const config = parseOpenCodeConfig(env.OPENCODE_CONFIG_CONTENT);
+    const plugins = config.plugins;
+    if (plugins !== undefined && !Array.isArray(plugins))
+        throw new Error("OpenCode v2 plugins must be an array");
+    return {
+        ...env,
+        OPENCODE_CONFIG_CONTENT: JSON.stringify({
+            ...config,
+            plugins: [
+                ...(plugins ?? []).filter((plugin) => plugin !== pluginUrl &&
+                    !(typeof plugin === "object" &&
+                        plugin !== null &&
+                        "package" in plugin &&
+                        plugin.package === pluginUrl)),
+                { package: pluginUrl, options },
+            ],
+        }),
+    };
+}
+export async function loadOpenCodeBridgePluginArtifact(moduleUrl, compileSource = compileOpenCodeBridgePlugin, version = 1) {
+    const directory = version === 2 ? "./v2/" : "./";
+    const bundleUrl = new URL(`${directory}bridge-plugin.bundle.mjs`, moduleUrl);
     try {
         return await readFile(bundleUrl);
     }
@@ -187,7 +237,7 @@ export async function loadOpenCodeBridgePluginArtifact(moduleUrl, compileSource
             throw new Error("Bundled OpenCode bridge plugin artifact is missing", { cause: error });
         }
     }
-    return compileSource(fileURLToPath(new URL("./bridge-plugin.mjs", moduleUrl)));
+    return compileSource(fileURLToPath(new URL(`${directory}bridge-plugin.mjs`, moduleUrl)));
 }
 async function compileOpenCodeBridgePlugin(sourcePath) {
     const source = await readFile(sourcePath, "utf8");
@@ -201,6 +251,7 @@ async function compileOpenCodeBridgePlugin(sourcePath) {
         bundle: true,
         format: "esm",
         platform: "neutral",
+        mainFields: ["module", "main"],
         target: "es2022",
         write: false,
     });

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

@@ -0,0 +1,8 @@
+export declare class OpenCodeHttpError extends Error {
+    readonly operation: string;
+    readonly status: number | undefined;
+    readonly html: boolean;
+    readonly name = "OpenCodeHttpError";
+    constructor(operation: string, status: number | undefined, html: boolean);
+}
+//# sourceMappingURL=http-error.d.ts.map

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

@@ -0,0 +1,13 @@
+export class OpenCodeHttpError extends Error {
+    constructor(operation, status, html) {
+        const statusLabel = status === undefined ? "" : ` (HTTP ${status})`;
+        super(html
+            ? `OpenCode ${operation} returned HTML instead of JSON; incompatible OpenCode API${statusLabel}`
+            : `OpenCode ${operation} failed${statusLabel}`);
+        this.operation = operation;
+        this.status = status;
+        this.html = html;
+        this.name = "OpenCodeHttpError";
+    }
+}
+//# sourceMappingURL=http-error.js.map

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

@@ -0,0 +1,38 @@
+import type { Logger } from "pino";
+import type { AgentClient, AgentSessionConfig, AgentLaunchContext, AgentCreateSessionOptions, AgentPersistenceHandle, FetchCatalogOptions, ProviderRefreshContext, ListImportableSessionsOptions, ImportProviderSessionInput, ImportProviderSessionContext } from "../../agent-sdk-types.js";
+import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
+import { OpenCodeAgentClient } from "../opencode-agent.js";
+export declare function openCodeMajorVersion(output: string): 1 | 2;
+export type OpenCodeRuntimeClientOptions = NonNullable<ConstructorParameters<typeof OpenCodeAgentClient>[2]>;
+export declare class OpenCodeRuntimeClient implements AgentClient {
+    private readonly logger;
+    private readonly settings?;
+    private readonly options;
+    readonly provider = "opencode";
+    readonly capabilities: import("../../agent-sdk-types.js").AgentCapabilityFlags;
+    readonly resolveCreateConfig: (input: import("../../agent-sdk-types.js").ResolveAgentCreateConfigInput) => import("../../agent-sdk-types.js").ResolveAgentCreateConfigResult;
+    readonly isCreateConfigUnattended: (input: Parameters<typeof import("../../create-agent-mode.js").isDefaultAgentCreateConfigUnattended>[0]) => boolean;
+    private selected;
+    private legacySelected;
+    private readonly legacy;
+    constructor(logger: Logger, settings?: ProviderRuntimeSettings | undefined, options?: OpenCodeRuntimeClientOptions);
+    private client;
+    isAvailable(): Promise<boolean>;
+    getDiagnostic(): Promise<{
+        diagnostic: string;
+    }>;
+    createSession(config: AgentSessionConfig, launch?: AgentLaunchContext, options?: AgentCreateSessionOptions): Promise<import("../../agent-sdk-types.js").AgentSession>;
+    resumeSession(handle: AgentPersistenceHandle, config?: Partial<AgentSessionConfig>, launch?: AgentLaunchContext): Promise<import("../../agent-sdk-types.js").AgentSession>;
+    fetchCatalog(options: FetchCatalogOptions, context?: ProviderRefreshContext): Promise<{
+        models: import("../../agent-sdk-types.js").AgentModelDefinition[];
+        modes: import("../../agent-sdk-types.js").AgentMode[];
+    }>;
+    listCommands(config: AgentSessionConfig): Promise<import("../../agent-sdk-types.js").AgentSlashCommand[]>;
+    listFeatures(config: AgentSessionConfig): Promise<import("../../agent-sdk-types.js").AgentFeature[]>;
+    listImportableSessions(options?: ListImportableSessionsOptions): Promise<import("../../agent-sdk-types.js").ImportableProviderSession[]>;
+    importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../../agent-sdk-types.js").ImportedProviderSession>;
+    archiveNativeSession(handle: AgentPersistenceHandle): Promise<void>;
+    unarchiveNativeSession(handle: AgentPersistenceHandle): Promise<void>;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=runtime-client.d.ts.map

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

@@ -0,0 +1,131 @@
+import { createProviderEnvSpec, resolveProviderLaunch, } from "../../provider-launch-config.js";
+import { execCommand } from "../../../../utils/spawn.js";
+import { OpenCodeAgentClient } from "../opencode-agent.js";
+import { withOpenCodeRuntimeNotice } from "./runtime-notice.js";
+// Keep the minimum aligned with the SDK and binary exercised by CI.
+const MINIMUM_V2 = [0, 10];
+const VERSION_PATTERN = /^(?:opencode\s+)?v?(\d+)\.(\d+)\.(\d+)(?:[-+][\w.-]+)?$/i;
+export function openCodeMajorVersion(output) {
+    const version = output.trim().match(VERSION_PATTERN);
+    if (!version)
+        return 1;
+    if (version[1] === "1")
+        return 1;
+    if (version[1] === "2") {
+        const [minimumMinor, minimumPatch] = MINIMUM_V2;
+        const minor = Number(version[2]);
+        const patch = Number(version[3]);
+        if (minor < minimumMinor || (minor === minimumMinor && patch < minimumPatch))
+            throw new Error(`OpenCode ${version[1]}.${version[2]}.${version[3]} is too old for this Paseo integration. Update OpenCode to 2.${minimumMinor}.${minimumPatch} or newer, then refresh the provider in Paseo.`);
+        return 2;
+    }
+    throw new Error(`Unsupported OpenCode major version ${version[1]}; supported versions are 1 and 2`);
+}
+// Selection belongs to the configured client, which provider reload replaces.
+export class OpenCodeRuntimeClient {
+    constructor(logger, settings, options = {}) {
+        this.logger = logger;
+        this.settings = settings;
+        this.options = options;
+        this.provider = "opencode";
+        this.selected = null;
+        this.legacySelected = false;
+        this.legacy = new OpenCodeAgentClient(logger, settings, options);
+        this.capabilities = this.legacy.capabilities;
+        this.resolveCreateConfig = this.legacy.resolveCreateConfig;
+        this.isCreateConfigUnattended = this.legacy.isCreateConfigUnattended;
+    }
+    client() {
+        this.selected ?? (this.selected = (async () => {
+            let output;
+            try {
+                const launch = await resolveProviderLaunch({
+                    commandConfig: this.settings?.command,
+                    defaultBinary: "opencode",
+                });
+                const result = await execCommand(launch.command, [...launch.args, "--version"], {
+                    ...createProviderEnvSpec({ runtimeSettings: this.settings }),
+                    timeout: 5000,
+                });
+                output = result.stdout;
+            }
+            catch {
+                // Version discovery is additive: legacy wrappers need not support --version.
+                this.selected = null;
+                this.legacySelected = true;
+                return this.legacy;
+            }
+            if (!VERSION_PATTERN.test(output.trim()))
+                this.selected = null;
+            if (openCodeMajorVersion(output) === 1) {
+                this.legacySelected = true;
+                return this.legacy;
+            }
+            const { OpenCodeV2AgentClient } = await import("./v2/agent.js");
+            return new OpenCodeV2AgentClient({
+                logger: this.logger,
+                settings: this.settings,
+                managedProcesses: this.options.managedProcesses,
+                bridge: this.options.bridge,
+            });
+        })().catch((error) => {
+            // A failed probe must not poison refresh after the user updates the binary.
+            this.selected = null;
+            throw error;
+        }));
+        return this.selected;
+    }
+    async isAvailable() {
+        return this.legacy.isAvailable();
+    }
+    async getDiagnostic() {
+        return this.legacy.getDiagnostic();
+    }
+    async createSession(config, launch, options) {
+        const client = await this.client();
+        const session = await client.createSession(config, launch, options);
+        return client === this.legacy ? session : withOpenCodeRuntimeNotice(session, 2);
+    }
+    async resumeSession(handle, config, launch) {
+        const client = await this.client();
+        const session = await client.resumeSession(handle, config, launch);
+        return client === this.legacy ? session : withOpenCodeRuntimeNotice(session, 2, handle);
+    }
+    async fetchCatalog(options, context) {
+        return (await this.client()).fetchCatalog(options, context);
+    }
+    async listCommands(config) {
+        return (await this.client()).listCommands(config);
+    }
+    async listFeatures(config) {
+        return (await this.client()).listFeatures(config);
+    }
+    async listImportableSessions(options) {
+        return (await this.client()).listImportableSessions(options);
+    }
+    async importSession(input, context) {
+        const client = await this.client();
+        const imported = await client.importSession(input, context);
+        return client === this.legacy
+            ? imported
+            : { ...imported, session: withOpenCodeRuntimeNotice(imported.session, 2) };
+    }
+    async archiveNativeSession(handle) {
+        const client = await this.client();
+        if (client instanceof OpenCodeAgentClient)
+            await client.archiveNativeSession(handle);
+    }
+    async unarchiveNativeSession(handle) {
+        const client = await this.client();
+        if (client instanceof OpenCodeAgentClient)
+            await client.unarchiveNativeSession(handle);
+    }
+    async shutdown() {
+        const selected = await this.selected?.catch(() => null);
+        if (this.legacySelected)
+            await this.legacy.shutdown();
+        if (selected && selected !== this.legacy)
+            await selected.shutdown();
+    }
+}
+//# sourceMappingURL=runtime-client.js.map

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

@@ -0,0 +1,3 @@
+import type { AgentPersistenceHandle, AgentSession } from "../../agent-sdk-types.js";
+export declare function withOpenCodeRuntimeNotice(session: AgentSession, major: 1 | 2, previous?: AgentPersistenceHandle): AgentSession;
+//# sourceMappingURL=runtime-notice.d.ts.map

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

@@ -0,0 +1,47 @@
+import { z } from "zod";
+const Notices = z.array(z.object({ major: z.union([z.literal(1), z.literal(2)]), timestamp: z.string().datetime() }));
+// These rows belong to Paseo, not OpenCode's conversation. Keep their original
+// timestamps in the persistence handle so history rebuilds preserve placement.
+export function withOpenCodeRuntimeNotice(session, major, previous) {
+    const notices = Notices.parse(previous?.metadata?.openCodeRuntimeNotices ?? []);
+    const added = notices.at(-1)?.major !== major;
+    if (added)
+        notices.push({ major, timestamp: new Date().toISOString() });
+    const entries = notices.map(({ major: recordedMajor, timestamp }) => ({
+        timestamp,
+        item: {
+            type: "notification",
+            level: "info",
+            message: `This chat uses OpenCode v${recordedMajor}.`,
+        },
+    }));
+    const describePersistence = session.describePersistence.bind(session);
+    const streamHistory = session.streamHistory.bind(session);
+    return Object.assign(session, {
+        initialTimeline: added ? entries.slice(-1) : [],
+        describePersistence() {
+            const handle = describePersistence();
+            return (handle && { ...handle, metadata: { ...handle.metadata, openCodeRuntimeNotices: notices } });
+        },
+        async *streamHistory() {
+            const pending = [...entries];
+            const event = (entry) => ({
+                type: "timeline",
+                provider: "opencode",
+                ...entry,
+            });
+            for await (const row of streamHistory()) {
+                while (row.type === "timeline" &&
+                    row.timestamp &&
+                    pending[0]?.timestamp &&
+                    pending[0].timestamp <= row.timestamp) {
+                    yield event(pending.shift());
+                }
+                yield row;
+            }
+            for (const entry of pending)
+                yield event(entry);
+        },
+    });
+}
+//# sourceMappingURL=runtime-notice.js.map

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

@@ -1,6 +1,7 @@
 import { mkdirSync } from "node:fs";
 import { stat } from "node:fs/promises";
 import net from "node:net";
+import { createRequire } from "node:module";
 import path from "node:path";
 import { findExecutable } from "../../../../executable-resolution/executable-resolution.js";
 import { spawnProcess } from "../../../../utils/spawn.js";
@@ -471,14 +472,24 @@ async function resolveOpenCodeBinary() {
         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;
+        const packageDirectories = [
+            path.join(path.dirname(found), "node_modules", "opencode-ai"),
+            path.join(path.dirname(found), "..", "opencode-ai"),
+        ];
+        for (const packageDirectory of packageDirectories) {
+            const bundledBinary = path.join(packageDirectory, "bin", "opencode.exe");
+            if (await pathExists(bundledBinary))
+                return bundledBinary;
+            // Newer npm releases keep the executable in a platform dependency.
+            // Resolve from the CLI package so nested installs and pnpm both work.
+            try {
+                const require = createRequire(path.join(packageDirectory, "package.json"));
+                return require.resolve(`opencode-windows-${process.arch}/bin/opencode.exe`);
+            }
+            catch {
+                // Try the other npm layout before retaining the original command.
+            }
+        }
         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);
     }

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

@@ -0,0 +1,36 @@
+import type { Logger } from "pino";
+import type { AgentCapabilityFlags, AgentClient, AgentCreateSessionOptions, AgentFeature, AgentLaunchContext, AgentPersistenceHandle, AgentSession, AgentSessionConfig, FetchCatalogOptions, ImportableProviderSession, ImportProviderSessionInput, ImportProviderSessionContext, ListImportableSessionsOptions, ProviderRefreshContext } from "../../../agent-sdk-types.js";
+import { type ProviderRuntimeSettings } from "../../../provider-launch-config.js";
+import type { ManagedProcessRegistry } from "../../../../managed-processes/managed-processes.js";
+import type { OpenCodeBridge } from "../bridge.js";
+import { V2Runtime } from "./runtime.js";
+interface V2AgentOptions {
+    logger: Logger;
+    settings?: ProviderRuntimeSettings;
+    managedProcesses?: ManagedProcessRegistry;
+    bridge?: OpenCodeBridge;
+    runtime?: Pick<V2Runtime, "acquire" | "shutdown">;
+}
+export declare class OpenCodeV2AgentClient implements AgentClient {
+    private readonly options;
+    readonly provider = "opencode";
+    readonly capabilities: AgentCapabilityFlags;
+    private readonly runtime;
+    private readonly connections;
+    constructor(options: V2AgentOptions);
+    isAvailable(): Promise<boolean>;
+    shutdown(): Promise<void>;
+    fetchCatalog(options: FetchCatalogOptions, context?: ProviderRefreshContext): Promise<{
+        models: import("../../../agent-sdk-types.js").AgentModelDefinition[];
+        modes: import("../../../agent-sdk-types.js").AgentMode[];
+    }>;
+    createSession(config: AgentSessionConfig, launch?: AgentLaunchContext, options?: AgentCreateSessionOptions): Promise<AgentSession>;
+    resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, launch?: AgentLaunchContext): Promise<AgentSession>;
+    private attach;
+    listFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
+    listCommands(config: AgentSessionConfig): Promise<import("../../../agent-sdk-types.js").AgentSlashCommand[]>;
+    listImportableSessions(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
+    importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../../../agent-sdk-types.js").ImportedProviderSession>;
+}
+export {};
+//# sourceMappingURL=agent.d.ts.map