@getpaseo/server 0.9.2 → 0.10.0

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

@@ -0,0 +1,3 @@
+import type { AgentCapabilityFlags } from "../../../agent-sdk-types.js";
+export declare const V2_CAPABILITIES: AgentCapabilityFlags;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/server/server/agent/providers/opencode/v2/capabilities.js

@@ -0,0 +1,13 @@
+export const V2_CAPABILITIES = {
+    supportsStreaming: true,
+    supportsSessionPersistence: true,
+    supportsSessionListing: true,
+    supportsDynamicModes: true,
+    supportsMcpServers: true,
+    supportsReasoningStream: true,
+    supportsToolInvocations: true,
+    supportsRewindBoth: true,
+    supportsRewindConversation: false,
+    supportsRewindFiles: false,
+};
+//# sourceMappingURL=capabilities.js.map

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

@@ -0,0 +1,20 @@
+import type { AgentStreamEvent } from "../../../agent-sdk-types.js";
+import type { V2Api } from "./api.js";
+interface ChildrenOptions {
+    client(): V2Api;
+    id: string;
+    emit(event: AgentStreamEvent): void;
+    reconcilePermissions(id: string): Promise<void>;
+    bindChild?: (id: string) => void;
+}
+export declare class SessionChildren {
+    private readonly options;
+    private readonly children;
+    private readonly childStates;
+    constructor(options: ChildrenOptions);
+    observe(event: import("@opencode/client").OpenCodeEvent): Promise<void>;
+    reconcile(parentID: string): Promise<void>;
+    private reconcileChild;
+}
+export {};
+//# sourceMappingURL=children.d.ts.map

package/dist/server/server/agent/providers/opencode/v2/children.js

@@ -0,0 +1,75 @@
+import { V2Timeline } from "./timeline.js";
+import { messages } from "./history.js";
+export class SessionChildren {
+    constructor(options) {
+        this.options = options;
+        this.children = new Map();
+        this.childStates = new Map();
+    }
+    async observe(event) {
+        if (event.type === "session.created" &&
+            event.data.parentID &&
+            (event.data.parentID === this.options.id || this.children.has(event.data.parentID))) {
+            await this.reconcile(event.data.parentID);
+        }
+        if ("sessionID" in event.data &&
+            typeof event.data.sessionID === "string" &&
+            this.children.has(event.data.sessionID)) {
+            await this.reconcileChild(await this.options.client().session.get({ sessionID: event.data.sessionID }));
+        }
+    }
+    async reconcile(parentID) {
+        let cursor;
+        do {
+            const page = await this.options.client().session.list({
+                ...(cursor ? { cursor } : { parentID }),
+                limit: 100,
+            });
+            for (const child of page.data) {
+                await this.reconcileChild(child);
+                await this.reconcile(child.id);
+            }
+            cursor = page.cursor.next ?? undefined;
+        } while (cursor);
+    }
+    async reconcileChild(info) {
+        await this.options.reconcilePermissions(info.id);
+        let timeline = this.children.get(info.id);
+        if (!timeline) {
+            timeline = new V2Timeline();
+            this.children.set(info.id, timeline);
+            this.options.bindChild?.(info.id);
+        }
+        const active = await this.options.client().session.active();
+        let status = "completed";
+        if (active[info.id])
+            status = "running";
+        else if (info.outcome === "failed")
+            status = "failed";
+        else if (info.outcome === "interrupted")
+            status = "canceled";
+        const presentation = {
+            type: "upsert",
+            id: info.id,
+            parentSubagentId: info.parentID === this.options.id ? null : info.parentID,
+            title: info.title ?? null,
+            status,
+            cwd: info.location.directory,
+            timestamp: new Date(info.time.updated).toISOString(),
+        };
+        const signature = JSON.stringify(presentation);
+        if (this.childStates.get(info.id) !== signature) {
+            this.childStates.set(info.id, signature);
+            this.options.emit({ type: "provider_subagent", provider: "opencode", event: presentation });
+        }
+        for (const event of timeline.messages(await messages(this.options.client(), info.id))) {
+            if (event.type === "timeline")
+                this.options.emit({
+                    type: "provider_subagent",
+                    provider: "opencode",
+                    event: { type: "timeline", id: info.id, item: event.item, timestamp: event.timestamp },
+                });
+        }
+    }
+}
+//# sourceMappingURL=children.js.map

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

@@ -0,0 +1,4 @@
+import type { V2Api } from "./api.js";
+import type { AgentSlashCommand } from "../../../agent-sdk-types.js";
+export declare function commands(client: V2Api, directory: string): Promise<AgentSlashCommand[]>;
+//# sourceMappingURL=commands.d.ts.map

package/dist/server/server/agent/providers/opencode/v2/commands.js

@@ -0,0 +1,36 @@
+import { waitForLocationReady } from "./readiness.js";
+export async function commands(client, directory) {
+    const location = { directory };
+    await waitForLocationReady({ client, location });
+    const [configured, skills] = await Promise.all([
+        client.command.list({ location }),
+        client.skill.list({ location }),
+    ]);
+    const result = new Map();
+    for (const name of ["compact", "summarize"])
+        result.set(name, {
+            name,
+            description: "Compact the current session",
+            argumentHint: "",
+            kind: "command",
+        });
+    for (const command of configured.data)
+        result.set(command.name, {
+            name: command.name,
+            description: command.description ?? "",
+            argumentHint: "",
+            kind: "command",
+        });
+    for (const skill of skills.data) {
+        if (result.has(skill.id))
+            continue;
+        result.set(skill.id, {
+            name: skill.id,
+            description: skill.description ?? "",
+            argumentHint: "",
+            kind: "skill",
+        });
+    }
+    return [...result.values()];
+}
+//# sourceMappingURL=commands.js.map

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

@@ -0,0 +1,8 @@
+import type { SessionInfo, PermissionRuleset } from "@opencode/client";
+import type { V2Api } from "./api.js";
+import type { AgentFeature, AgentLaunchContext, AgentSessionConfig } from "../../../agent-sdk-types.js";
+export declare function features(config: AgentSessionConfig): AgentFeature[];
+export declare function permissionRules(config: AgentSessionConfig): PermissionRuleset;
+export declare function applyResumeOverrides(client: V2Api, info: SessionInfo, overrides?: Partial<AgentSessionConfig>): Promise<void>;
+export declare function requiresDedicatedV2Server(config: AgentSessionConfig, launch?: AgentLaunchContext): boolean;
+//# sourceMappingURL=configuration.d.ts.map

package/dist/server/server/agent/providers/opencode/v2/configuration.js

@@ -0,0 +1,64 @@
+import { OpenCodeProviderOptionsSchema, buildOpenCodePermissionRules } from "../options.js";
+import { modelRef } from "./mapping.js";
+export function features(config) {
+    return [
+        {
+            type: "toggle",
+            id: "auto_accept",
+            label: "Auto-accept",
+            value: config.featureValues?.["auto_accept"] === true,
+        },
+    ];
+}
+export function permissionRules(config) {
+    const rules = buildOpenCodePermissionRules(OpenCodeProviderOptionsSchema.parse(config.providerOptions ?? {}), undefined) ?? [];
+    const grants = (config.toolPolicy?.preapproved ?? []).map((grant) => ({
+        action: `${grant.server.replace(/[^a-zA-Z0-9_-]/g, "_")}_${grant.tool.replace(/[^a-zA-Z0-9_-]/g, "_")}`,
+        resource: "*",
+        effect: "allow",
+    }));
+    return [
+        ...grants,
+        ...rules.map((rule) => ({
+            action: nativePermissionAction(rule.permission),
+            resource: rule.pattern,
+            effect: rule.action,
+        })),
+    ];
+}
+function nativePermissionAction(action) {
+    if (action === "bash")
+        return "shell";
+    if (action === "task")
+        return "subagent";
+    return action;
+}
+export async function applyResumeOverrides(client, info, overrides) {
+    if (overrides?.modeId) {
+        await client.session.switchAgent({
+            sessionID: info.id,
+            agent: overrides.modeId,
+        });
+        info.agent = overrides.modeId;
+    }
+    if (overrides?.model || overrides?.thinkingOptionId !== undefined) {
+        const model = overrides.model
+            ? modelRef(overrides.model, overrides.thinkingOptionId ?? info.model?.variant)
+            : info.model && { ...info.model, variant: overrides.thinkingOptionId };
+        if (!model)
+            throw new Error("Select an OpenCode model before changing its variant");
+        await client.session.switchModel({ sessionID: info.id, model });
+        info.model = model;
+    }
+}
+// Agent identity env is applied per session through `session.environment`, so
+// it must not force a dedicated server. Custom MCP is location-scoped, and any
+// other env key belongs to the process, so both need isolation. Mirrors the v1
+// adapter's `requiresDedicatedOpenCodeServer`.
+const V2_SESSION_ENV_KEYS = new Set(["PASEO_AGENT_ID", "PASEO_AGENT_CWD"]);
+export function requiresDedicatedV2Server(config, launch) {
+    if (Object.keys(config.mcpServers ?? {}).length > 0)
+        return true;
+    return Object.keys(launch?.env ?? {}).some((key) => !V2_SESSION_ENV_KEYS.has(key));
+}
+//# sourceMappingURL=configuration.js.map

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

@@ -0,0 +1,4 @@
+import type { SessionMessageInfo } from "@opencode/client";
+import type { V2Api } from "./api.js";
+export declare function messages(client: V2Api, sessionID: string): Promise<SessionMessageInfo[]>;
+//# sourceMappingURL=history.d.ts.map

package/dist/server/server/agent/providers/opencode/v2/history.js

@@ -0,0 +1,15 @@
+export async function messages(client, sessionID) {
+    const result = [];
+    let cursor;
+    do {
+        const page = await client.message.list({
+            sessionID,
+            ...(cursor ? { cursor } : { order: "asc" }),
+            limit: 100,
+        });
+        result.push(...page.data);
+        cursor = page.cursor.next ?? undefined;
+    } while (cursor);
+    return result;
+}
+//# sourceMappingURL=history.js.map

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

@@ -0,0 +1,7 @@
+import type { AgentInfo, ModelInfo, ModelRef, SessionInfo } from "@opencode/client";
+import type { AgentMode, AgentModelDefinition, AgentUsage } from "../../../agent-sdk-types.js";
+export declare function modelRef(id: string, variant?: string | null): ModelRef;
+export declare function modelsFromV2(models: ModelInfo[]): AgentModelDefinition[];
+export declare function modesFromV2(agents: AgentInfo[]): AgentMode[];
+export declare function usageFromV2(session: SessionInfo): AgentUsage;
+//# sourceMappingURL=mapping.d.ts.map

package/dist/server/server/agent/providers/opencode/v2/mapping.js

@@ -0,0 +1,42 @@
+export function modelRef(id, variant) {
+    const slash = id.indexOf("/");
+    if (slash < 1 || slash === id.length - 1)
+        throw new Error("OpenCode model must be provider/model");
+    return {
+        providerID: id.slice(0, slash),
+        id: id.slice(slash + 1),
+        ...(variant ? { variant } : {}),
+    };
+}
+export function modelsFromV2(models) {
+    return models
+        .filter((model) => model.enabled)
+        .map((model) => ({
+        provider: "opencode",
+        id: `${model.providerID}/${model.id}`,
+        label: model.name,
+        contextWindowMaxTokens: model.limit.context,
+        metadata: {
+            providerId: model.providerID,
+            modelId: model.id,
+            supportsAttachments: model.capabilities.input.includes("image"),
+            supportsToolCall: model.capabilities.tools,
+            contextWindowMaxTokens: model.limit.context,
+        },
+        thinkingOptions: model.variants.map((variant) => ({ id: variant.id, label: variant.id })),
+    }));
+}
+export function modesFromV2(agents) {
+    return agents
+        .filter((agent) => !agent.hidden && agent.mode !== "subagent")
+        .map((agent) => ({ id: agent.id, label: agent.name, description: agent.description }));
+}
+export function usageFromV2(session) {
+    return {
+        inputTokens: session.tokens.input,
+        outputTokens: session.tokens.output,
+        cachedInputTokens: session.tokens.cache.read,
+        totalCostUsd: session.cost,
+    };
+}
+//# sourceMappingURL=mapping.js.map

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

@@ -0,0 +1,18 @@
+import type { V2Api } from "./api.js";
+import type { AgentPermissionRequest, AgentPermissionResponse, AgentSessionConfig, AgentStreamEvent } from "../../../agent-sdk-types.js";
+export declare class SessionPermissions {
+    private readonly getClient;
+    private readonly id;
+    private readonly config;
+    private readonly emit;
+    private readonly pending;
+    private readonly permissionOwners;
+    private readonly forms;
+    constructor(getClient: () => V2Api, id: string, config: AgentSessionConfig, emit: (event: AgentStreamEvent) => void);
+    observe(event: import("@opencode/client").OpenCodeEvent): void;
+    list(): AgentPermissionRequest[];
+    respondToPermission(requestId: string, response: AgentPermissionResponse): Promise<void>;
+    reconcile(sessionID: string): Promise<void>;
+    resolvePending(requestId: string, resolution: AgentPermissionResponse): void;
+}
+//# sourceMappingURL=permissions.d.ts.map

package/dist/server/server/agent/providers/opencode/v2/permissions.js

@@ -0,0 +1,157 @@
+export class SessionPermissions {
+    constructor(getClient, id, config, emit) {
+        this.getClient = getClient;
+        this.id = id;
+        this.config = config;
+        this.emit = emit;
+        this.pending = new Map();
+        this.permissionOwners = new Map();
+        this.forms = new Map();
+    }
+    observe(event) {
+        if (event.type === "permission.replied") {
+            this.resolvePending(event.data.requestID, {
+                behavior: event.data.reply === "reject" ? "deny" : "allow",
+            });
+        }
+        if (event.type === "form.replied" || event.type === "form.cancelled") {
+            this.resolvePending(event.data.id, {
+                behavior: event.type === "form.cancelled" ? "deny" : "allow",
+            });
+        }
+    }
+    list() {
+        return [...this.pending.values()];
+    }
+    async respondToPermission(requestId, response) {
+        const form = this.forms.get(requestId);
+        if (form) {
+            if (response.behavior === "deny")
+                await this.getClient().session.form.cancel({ sessionID: form.sessionID, formID: form.id });
+            else {
+                const raw = response.updatedInput?.answers;
+                const answer = {};
+                if (!raw || typeof raw !== "object" || Array.isArray(raw))
+                    throw new Error("OpenCode question response requires answers");
+                for (const field of form.fields) {
+                    const value = Reflect.get(raw, field.key) ?? Reflect.get(raw, field.title ?? field.key);
+                    const normalized = formAnswer(field, value);
+                    if (normalized !== undefined)
+                        answer[field.key] = normalized;
+                }
+                await this.getClient().session.form.reply({
+                    sessionID: form.sessionID,
+                    formID: form.id,
+                    answer,
+                });
+            }
+            this.forms.delete(requestId);
+        }
+        else {
+            await this.getClient().permission.reply({
+                sessionID: this.permissionOwners.get(requestId) ?? this.id,
+                requestID: requestId,
+                decision: permissionReply(response),
+            });
+        }
+        this.resolvePending(requestId, response);
+    }
+    async reconcile(sessionID) {
+        const [permissions, forms] = await Promise.all([
+            this.getClient().permission.list({ sessionID }),
+            this.getClient().session.form.list({ sessionID }),
+        ]);
+        for (const request of permissions) {
+            if (this.pending.has(request.id))
+                continue;
+            const pending = {
+                id: request.id,
+                provider: "opencode",
+                kind: "tool",
+                name: request.action,
+                description: request.message ?? request.resources.join("\n"),
+                actions: [
+                    { id: "once", label: "Allow once", behavior: "allow" },
+                    { id: "always", label: "Always allow", behavior: "allow" },
+                    { id: "reject", label: "Deny", behavior: "deny" },
+                ],
+            };
+            this.pending.set(request.id, pending);
+            this.permissionOwners.set(request.id, sessionID);
+            if (!this.config.toolPolicy && this.config.featureValues?.["auto_accept"] === true)
+                await this.respondToPermission(request.id, { behavior: "allow" });
+            else
+                this.emit({ type: "permission_requested", provider: "opencode", request: pending });
+        }
+        for (const form of forms) {
+            if (this.pending.has(form.id))
+                continue;
+            const pending = {
+                id: form.id,
+                provider: "opencode",
+                name: "question",
+                kind: "question",
+                title: form.title,
+                input: {
+                    questions: form.fields.map((field) => ({
+                        header: field.key,
+                        question: field.title ?? field.key,
+                        options: "options" in field ? field.options : undefined,
+                        multiple: field.type === "multiselect",
+                    })),
+                },
+            };
+            this.forms.set(form.id, form);
+            this.pending.set(form.id, pending);
+            this.emit({ type: "permission_requested", provider: "opencode", request: pending });
+        }
+    }
+    resolvePending(requestId, resolution) {
+        if (!this.pending.delete(requestId))
+            return;
+        this.forms.delete(requestId);
+        this.permissionOwners.delete(requestId);
+        this.emit({ type: "permission_resolved", provider: "opencode", requestId, resolution });
+    }
+}
+function permissionReply(response) {
+    if (response.behavior === "deny")
+        return "reject";
+    return response.selectedActionId === "always" ? "always" : "once";
+}
+function formAnswer(field, value) {
+    if (value === undefined)
+        return undefined;
+    if (field.type === "external")
+        return undefined;
+    const labelValue = (label) => {
+        const options = "options" in field ? field.options : undefined;
+        return (options?.find((option) => option.value === label)?.value ??
+            options?.find((option) => option.label === label)?.value ??
+            label);
+    };
+    if (field.type === "multiselect") {
+        if (Array.isArray(value) && value.every((item) => typeof item === "string"))
+            return value.map(labelValue);
+    }
+    else if (field.type === "string" && typeof value === "string") {
+        return labelValue(value);
+    }
+    else if (field.type === "boolean") {
+        if (typeof value === "boolean")
+            return value;
+        if (value === "true")
+            return true;
+        if (value === "false")
+            return false;
+    }
+    else if (field.type === "number" || field.type === "integer") {
+        const numeric = typeof value === "string" && value.trim() ? Number(value) : value;
+        if (typeof numeric === "number" &&
+            Number.isFinite(numeric) &&
+            (field.type !== "integer" || Number.isInteger(numeric)))
+            return numeric;
+    }
+    throw new Error(`Invalid answer for OpenCode question ${field.key}`);
+}
+//# sourceMappingURL=permissions.js.map

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

@@ -0,0 +1,18 @@
+import type { V2Api } from "./api.js";
+interface ReadinessInput {
+    client: Pick<V2Api, "plugin">;
+    location: {
+        directory: string;
+    };
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export declare class OpenCodeLocationReadyTimeoutError extends Error {
+    readonly directory: string;
+    readonly waitedMs: number;
+    constructor(directory: string, waitedMs: number);
+}
+export declare function waitForLocationReady(input: ReadinessInput): Promise<void>;
+export declare function awaitPaseoPlugin(input: ReadinessInput): Promise<void>;
+export {};
+//# sourceMappingURL=readiness.d.ts.map

package/dist/server/server/agent/providers/opencode/v2/readiness.js

@@ -0,0 +1,51 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { raceProviderRefreshAbort } from "../../../provider-refresh-deadline.js";
+export class OpenCodeLocationReadyTimeoutError extends Error {
+    constructor(directory, waitedMs) {
+        super(`OpenCode location ${directory} did not activate within ${waitedMs}ms`);
+        this.directory = directory;
+        this.waitedMs = waitedMs;
+        this.name = "OpenCodeLocationReadyTimeoutError";
+    }
+}
+export function waitForLocationReady(input) {
+    return waitForPlugins({ ...input, requireBridge: false });
+}
+export function awaitPaseoPlugin(input) {
+    return waitForPlugins({ ...input, requireBridge: true });
+}
+async function waitForPlugins(input) {
+    const { client, location, signal, requireBridge, timeoutMs = 30000 } = input;
+    signal?.throwIfAborted();
+    const deadline = AbortSignal.timeout(timeoutMs);
+    const lifetime = signal ? AbortSignal.any([signal, deadline]) : deadline;
+    try {
+        while (true) {
+            const requestTimeout = AbortSignal.timeout(5000);
+            const requestSignal = AbortSignal.any([lifetime, requestTimeout]);
+            try {
+                const plugins = await raceProviderRefreshAbort(requestSignal, client.plugin.list({ location }, { signal: requestSignal }));
+                if (!requireBridge && plugins.data.length > 0)
+                    return;
+                const bridge = plugins.data.find((plugin) => plugin.id === "paseo");
+                if (requireBridge && bridge?.state.status === "active")
+                    return;
+                if (requireBridge && bridge?.state.status === "failed")
+                    throw new Error(`OpenCode Paseo tool bridge plugin failed: ${bridge.state.error}`);
+            }
+            catch (error) {
+                lifetime.throwIfAborted();
+                if (!requestTimeout.aborted)
+                    throw error;
+            }
+            await delay(50, undefined, { signal: lifetime });
+        }
+    }
+    catch (error) {
+        signal?.throwIfAborted();
+        if (deadline.aborted)
+            throw new OpenCodeLocationReadyTimeoutError(location.directory, timeoutMs);
+        throw error;
+    }
+}
+//# sourceMappingURL=readiness.js.map

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

@@ -0,0 +1,36 @@
+import type { V2Api } from "./api.js";
+import type { Logger } from "pino";
+import { type ProviderRuntimeSettings } from "../../../provider-launch-config.js";
+import type { ManagedProcessRegistry } from "../../../../managed-processes/managed-processes.js";
+export interface V2Connection {
+    client: V2Api;
+    release(): Promise<void>;
+    retain(): V2Connection;
+    readonly exited: Promise<Error>;
+}
+export interface V2RuntimeOptions {
+    logger: Logger;
+    settings?: ProviderRuntimeSettings;
+    managedProcesses?: ManagedProcessRegistry;
+    decorateEnv?: (env: Record<string, string>) => Promise<Record<string, string>>;
+}
+export interface V2RuntimeAcquireOptions {
+    fresh?: boolean;
+    dedicated?: boolean;
+    env?: Record<string, string>;
+    signal?: AbortSignal;
+}
+export declare class V2Runtime {
+    private readonly options;
+    private current;
+    private generations;
+    private starts;
+    private closed;
+    constructor(options: V2RuntimeOptions);
+    acquire(input?: V2RuntimeAcquireOptions): Promise<V2Connection>;
+    private lease;
+    shutdown(): Promise<void>;
+    private startTracked;
+    private start;
+}
+//# sourceMappingURL=runtime.d.ts.map