@getpaseo/server 0.9.2 → 0.10.0-beta.1

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

@@ -0,0 +1,465 @@
+import { SessionChildren } from "./children.js";
+import { SessionTurns } from "./turns.js";
+import { V2Timeline } from "./timeline.js";
+import { waitForLocationReady, awaitPaseoPlugin } from "./readiness.js";
+import { setTimeout as delay } from "node:timers/promises";
+import { toDiagnosticErrorMessage } from "../../diagnostic-utils.js";
+import { runProviderTurn } from "../../provider-runner.js";
+import { composeSystemPromptParts } from "../../../system-prompt.js";
+import { raceProviderRefreshAbort } from "../../../provider-refresh-deadline.js";
+import { modelRef, modesFromV2 } from "./mapping.js";
+import { V2_CAPABILITIES } from "./capabilities.js";
+import { features } from "./configuration.js";
+import { commands } from "./commands.js";
+import { messages } from "./history.js";
+import { SessionPermissions } from "./permissions.js";
+export class OpenCodeV2Session {
+    constructor(connection, info, config, logger, persist, requiresPaseoPlugin, unbind, bindChild, acquire, moved) {
+        this.connection = connection;
+        this.info = info;
+        this.config = config;
+        this.logger = logger;
+        this.persist = persist;
+        this.requiresPaseoPlugin = requiresPaseoPlugin;
+        this.unbind = unbind;
+        this.acquire = acquire;
+        this.moved = moved;
+        this.provider = "opencode";
+        this.capabilities = V2_CAPABILITIES;
+        this.listeners = new Set();
+        this.timeline = new V2Timeline();
+        this.abort = new AbortController();
+        this.stream = null;
+        this.streamAbort = new AbortController();
+        this.exited = false;
+        this.reconnecting = null;
+        this.sync = Promise.resolve();
+        this.dirty = false;
+        this.refreshTimer = null;
+        this.closed = false;
+        this.history = [];
+        this.modes = [];
+        this.permissions = new SessionPermissions(() => this.client, info.id, config, (event) => this.emit(event));
+        this.children = new SessionChildren({
+            client: () => this.client,
+            id: info.id,
+            emit: (event) => this.emit(event),
+            reconcilePermissions: (id) => this.permissions.reconcile(id),
+            bindChild,
+        });
+        this.turns = new SessionTurns({
+            client: () => this.client,
+            id: info.id,
+            cwd: config.cwd,
+            signal: this.abort.signal,
+            emit: (event) => this.emit(event),
+            reconcile: async () => {
+                await this.reconcile();
+                return { info: this.info, history: this.history };
+            },
+            clearPermissions: async () => {
+                for (const request of this.permissions.list())
+                    await this.permissions.respondToPermission(request.id, { behavior: "deny" });
+            },
+        });
+    }
+    get id() {
+        return this.info.id;
+    }
+    get features() {
+        return features(this.config);
+    }
+    get client() {
+        return this.connection.client;
+    }
+    async initialize(launch) {
+        this.launchEnv = launch?.env;
+        this.watchExit(this.connection);
+        await this.configureConnection();
+        const location = { directory: this.config.cwd };
+        this.modes = modesFromV2((await this.client.agent.list({ location })).data);
+        this.timeline.messages(await messages(this.client, this.id));
+        await this.startStream();
+        await this.children.reconcile(this.id);
+    }
+    watchExit(connection) {
+        void connection.exited.then((error) => {
+            if (this.closed || this.connection !== connection)
+                return undefined;
+            this.exited = true;
+            this.streamAbort.abort(error);
+            this.turns.fail(error);
+            return undefined;
+        });
+    }
+    async configureConnection() {
+        const location = { directory: this.config.cwd };
+        await waitForLocationReady({ client: this.client, location, signal: this.abort.signal });
+        if (this.requiresPaseoPlugin)
+            await awaitPaseoPlugin({ client: this.client, location, signal: this.abort.signal });
+        if (this.launchEnv)
+            await this.client.session.environment({ sessionID: this.id, variables: this.launchEnv });
+        for (const [server, config] of Object.entries(this.config.mcpServers ?? {})) {
+            await this.client.mcp.add({
+                server,
+                location,
+                config: config.type === "stdio"
+                    ? {
+                        type: "local",
+                        command: [config.command, ...(config.args ?? [])],
+                        environment: config.env,
+                        codemode: false,
+                    }
+                    : {
+                        type: "remote",
+                        url: config.url,
+                        headers: config.headers,
+                        oauth: false,
+                        codemode: false,
+                    },
+            });
+            await this.awaitMcp(server);
+        }
+        const system = composeSystemPromptParts(this.config.systemPrompt, this.config.daemonAppendSystemPrompt);
+        if (system)
+            await this.client.session.instructions.entry.put({
+                sessionID: this.id,
+                key: "paseo",
+                value: system,
+            });
+    }
+    async startStream() {
+        let ready;
+        let fail;
+        const first = new Promise((resolve, reject) => {
+            ready = resolve;
+            fail = reject;
+        });
+        this.stream = this.consume(ready, fail);
+        await raceProviderRefreshAbort(AbortSignal.any([this.abort.signal, AbortSignal.timeout(30000)]), first);
+    }
+    async reconnectIfExited() {
+        if (this.closed)
+            throw new Error("OpenCode session is closed");
+        if (!this.exited)
+            return;
+        this.reconnecting ?? (this.reconnecting = this.reconnect().finally(() => {
+            this.reconnecting = null;
+        }));
+        await this.reconnecting;
+    }
+    async reconnect() {
+        if (!this.acquire)
+            throw new Error("OpenCode helper server exited");
+        await this.stream;
+        await this.sync.catch(() => undefined);
+        const next = await this.acquire();
+        if (this.closed) {
+            await next.release();
+            throw new Error("OpenCode session is closed");
+        }
+        const old = this.connection;
+        this.connection = next;
+        this.streamAbort = new AbortController();
+        this.exited = false;
+        this.watchExit(next);
+        try {
+            await this.configureConnection();
+            await this.startStream();
+        }
+        catch (error) {
+            this.connection = old;
+            this.exited = true;
+            this.streamAbort.abort();
+            await next.release();
+            throw error;
+        }
+        this.moved?.(next);
+        await old.release();
+    }
+    subscribe(callback) {
+        this.listeners.add(callback);
+        return () => {
+            this.listeners.delete(callback);
+        };
+    }
+    async awaitMcp(server) {
+        const signal = AbortSignal.any([this.abort.signal, AbortSignal.timeout(30000)]);
+        while (true) {
+            const catalog = await this.client.mcp.list({ location: { directory: this.config.cwd } }, { signal });
+            const entry = catalog.data.find((item) => item.name === server);
+            if (entry?.status.status === "connected")
+                return;
+            if (entry && entry.status.status !== "pending") {
+                const reason = entry.status.status === "failed" ? entry.status.error : entry.status.status;
+                throw new Error(`OpenCode MCP server ${server} failed to connect: ${reason}`);
+            }
+            await delay(50, undefined, { signal });
+        }
+    }
+    emit(event) {
+        for (const listener of this.listeners)
+            listener(event);
+    }
+    emitTimeline(event) {
+        this.emit({ ...event, ...(this.turns.id ? { turnId: this.turns.id } : {}) });
+    }
+    async *streamHistory() {
+        await this.reconnectIfExited();
+        const history = new V2Timeline(false);
+        yield* history.messages(await messages(this.client, this.id));
+    }
+    async getRuntimeInfo() {
+        await this.reconnectIfExited();
+        this.info = await this.client.session.get({ sessionID: this.id });
+        return {
+            provider: "opencode",
+            sessionId: this.id,
+            model: this.info.model ? `${this.info.model.providerID}/${this.info.model.id}` : null,
+            modeId: this.info.agent ?? null,
+            thinkingOptionId: this.info.model?.variant ?? null,
+        };
+    }
+    async getAvailableModes() {
+        return this.modes;
+    }
+    async getCurrentMode() {
+        return this.info.agent ?? null;
+    }
+    async setMode(modeId) {
+        await this.reconnectIfExited();
+        await this.client.session.switchAgent({ sessionID: this.id, agent: modeId });
+        this.info.agent = modeId;
+        this.config.modeId = modeId;
+        this.emit({
+            type: "mode_changed",
+            provider: "opencode",
+            currentModeId: modeId,
+            availableModes: this.modes,
+        });
+    }
+    async setModel(model) {
+        await this.reconnectIfExited();
+        const selected = model
+            ? modelRef(model, this.config.thinkingOptionId)
+            : (await this.client.model.default({ location: { directory: this.config.cwd } })).data;
+        if (!selected)
+            throw new Error("OpenCode has no default model");
+        await this.client.session.switchModel({
+            sessionID: this.id,
+            model: {
+                id: selected.id,
+                providerID: selected.providerID,
+                variant: this.config.thinkingOptionId,
+            },
+        });
+        this.config.model = model ?? undefined;
+        this.emit({
+            type: "model_changed",
+            provider: "opencode",
+            runtimeInfo: await this.getRuntimeInfo(),
+        });
+    }
+    async setThinkingOption(variant) {
+        await this.reconnectIfExited();
+        const model = this.info.model;
+        if (!model)
+            throw new Error("Select an OpenCode model before changing its variant");
+        await this.client.session.switchModel({
+            sessionID: this.id,
+            model: { id: model.id, providerID: model.providerID, ...(variant ? { variant } : {}) },
+        });
+        this.config.thinkingOptionId = variant ?? undefined;
+        this.info = await this.client.session.get({ sessionID: this.id });
+        this.emit({ type: "thinking_option_changed", provider: "opencode", thinkingOptionId: variant });
+    }
+    async setFeature(id, value) {
+        if (id !== "auto_accept" || typeof value !== "boolean")
+            throw new Error("Unknown OpenCode feature");
+        this.config.featureValues = { ...this.config.featureValues, [id]: value };
+        if (value && !this.config.toolPolicy)
+            for (const request of this.permissions.list())
+                if (request.kind !== "question")
+                    await this.respondToPermission(request.id, { behavior: "allow" });
+    }
+    async listCommands() {
+        await this.reconnectIfExited();
+        return commands(this.client, this.config.cwd);
+    }
+    describePersistence() {
+        return {
+            provider: "opencode",
+            sessionId: this.id,
+            nativeHandle: this.id,
+            metadata: { ...this.config },
+        };
+    }
+    run(prompt, options) {
+        return runProviderTurn({
+            prompt,
+            runOptions: options,
+            startTurn: this.startTurn.bind(this),
+            subscribe: this.subscribe.bind(this),
+            getSessionId: () => this.id,
+            reduceFinalText: ({ current, item }) => item.type === "assistant_message" ? current + item.text : current,
+        });
+    }
+    async startTurn(prompt, options) {
+        await this.reconnectIfExited();
+        return this.turns.startTurn(prompt, options);
+    }
+    steerActiveTurn(prompt, options) {
+        return this.turns.steerActiveTurn(prompt, options);
+    }
+    interrupt() {
+        return this.turns.interrupt();
+    }
+    async revertBoth(input) {
+        await this.interrupt();
+        await this.reconnectIfExited();
+        await this.client.session.revert.stage({
+            sessionID: this.id,
+            messageID: input.messageId,
+            files: true,
+        });
+        await this.client.session.revert.commit({ sessionID: this.id });
+    }
+    getPendingPermissions() {
+        return [...this.permissions.list()];
+    }
+    async respondToPermission(requestId, response) {
+        await this.reconnectIfExited();
+        await this.permissions.respondToPermission(requestId, response);
+    }
+    async reconcileSnapshot() {
+        const [info, history] = await Promise.all([
+            this.client.session.get({ sessionID: this.id }),
+            messages(this.client, this.id),
+        ]);
+        this.info = info;
+        this.history = history;
+        for (const event of this.timeline.messages(history))
+            this.emitTimeline(event);
+        await this.permissions.reconcile(this.id);
+    }
+    async reconcile() {
+        this.dirty = true;
+        this.sync = this.sync.catch(() => undefined).then(() => this.drainReconciliation());
+        return this.sync;
+    }
+    async drainReconciliation() {
+        while (this.dirty && !this.closed) {
+            this.dirty = false;
+            await this.reconcileSnapshot();
+        }
+    }
+    async reconcileConnection() {
+        await this.reconcile();
+        await this.children.reconcile(this.id);
+        const active = await this.client.session.active();
+        if (active[this.id])
+            this.turns.observeActiveTurn();
+    }
+    scheduleReconcile() {
+        if (this.refreshTimer || this.closed)
+            return;
+        this.refreshTimer = setTimeout(() => {
+            this.refreshTimer = null;
+            void this.reconcile().catch((error) => this.logger.warn({ error: toDiagnosticErrorMessage(error) }, "OpenCode reconciliation failed"));
+        }, 25);
+    }
+    observeOwnEvent(event) {
+        if (event.type === "form.created" && event.data.form.sessionID === this.id) {
+            this.scheduleReconcile();
+            return;
+        }
+        if (!("sessionID" in event.data) || event.data.sessionID !== this.id)
+            return;
+        if (event.type === "session.text.started" || event.type === "session.reasoning.started") {
+            if (event.type === "session.text.started" && this.turns.hasStructuredOutput)
+                return;
+            this.timeline.startPart({
+                ...event.data,
+                type: event.type === "session.text.started" ? "text" : "reasoning",
+            });
+            return;
+        }
+        if (event.type === "session.text.delta" || event.type === "session.reasoning.delta") {
+            const isText = event.type === "session.text.delta";
+            // A structured-output turn supplies its answer through a tool, so streamed
+            // prose is not part of the result and must not reach the timeline.
+            if (isText && this.turns.hasStructuredOutput)
+                return;
+            const streamed = this.timeline.delta({
+                assistantMessageID: event.data.assistantMessageID,
+                ordinal: event.data.ordinal,
+                delta: event.data.delta,
+                type: isText ? "text" : "reasoning",
+            });
+            if (streamed)
+                this.emitTimeline(streamed);
+            return;
+        }
+        this.permissions.observe(event);
+        if (event.type === "session.execution.failed")
+            this.turns.executionError = event.data.error.message;
+        this.scheduleReconcile();
+        if (event.type !== "session.execution.started" || this.turns.id)
+            return;
+        this.turns.observeActiveTurn();
+    }
+    async consume(ready, fail) {
+        const signal = AbortSignal.any([this.abort.signal, this.streamAbort.signal]);
+        let connected = false;
+        while (!this.closed && !signal.aborted) {
+            try {
+                for await (const event of this.client.event.subscribe({ signal })) {
+                    if (this.closed || signal.aborted)
+                        return;
+                    if (event.type === "server.connected") {
+                        this.timeline.resetStreams();
+                        await this.reconcileConnection();
+                        connected = true;
+                        ready();
+                    }
+                    await this.children.observe(event);
+                    this.observeOwnEvent(event);
+                }
+                if (!connected)
+                    throw new Error("OpenCode event stream ended before connecting");
+            }
+            catch (error) {
+                if (this.closed || signal.aborted)
+                    return;
+                if (!connected) {
+                    fail(error);
+                    return;
+                }
+                this.logger.warn({ error: toDiagnosticErrorMessage(error) }, "OpenCode event stream interrupted; reconciling on reconnect");
+            }
+            await delay(100, undefined, { signal }).catch(() => undefined);
+        }
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.abort.abort();
+        this.streamAbort.abort();
+        if (this.refreshTimer)
+            clearTimeout(this.refreshTimer);
+        await this.stream;
+        await this.reconnecting?.catch(() => undefined);
+        await this.sync.catch(() => undefined);
+        this.unbind?.();
+        try {
+            if (!this.persist)
+                await this.client.session.remove({ sessionID: this.id });
+        }
+        finally {
+            await this.connection.release();
+        }
+        this.listeners.clear();
+    }
+}
+//# sourceMappingURL=session.js.map

package/dist/server/server/agent/providers/opencode/v2/structured-output.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import type { SessionMessageInfo } from "@opencode/client";
+export declare const STRUCTURED_OUTPUT_TOOL = "paseo_structured_output";
+export declare function structuredOutput(input: unknown): {
+    schema: boolean | Record<string, z.core.util.JSONType>;
+    assert(history: SessionMessageInfo[]): void;
+};
+//# sourceMappingURL=structured-output.d.ts.map

package/dist/server/server/agent/providers/opencode/v2/structured-output.js

@@ -0,0 +1,32 @@
+import { Ajv } from "ajv";
+import { z } from "zod";
+export const STRUCTURED_OUTPUT_TOOL = "paseo_structured_output";
+const schemas = new Ajv({ strict: false, allErrors: true });
+export function structuredOutput(input) {
+    const schema = z.union([z.boolean(), z.record(z.string(), z.json())]).parse(input);
+    const validate = schemas.compile(schema);
+    return {
+        schema,
+        assert(history) {
+            const start = history.findLastIndex((message) => message.type === "user");
+            for (const message of history.slice(start + 1)) {
+                if (message.type !== "assistant")
+                    continue;
+                for (const part of message.content) {
+                    if (part.type !== "tool" ||
+                        part.name !== STRUCTURED_OUTPUT_TOOL ||
+                        part.state.status !== "completed")
+                        continue;
+                    const result = part.state.metadata?.paseoStructuredOutput;
+                    if (result === undefined)
+                        continue;
+                    if (!validate(result))
+                        throw new Error(`Invalid OpenCode structured output: ${schemas.errorsText(validate.errors)}`);
+                    return;
+                }
+            }
+            throw new Error("OpenCode finished without submitting the required structured output");
+        },
+    };
+}
+//# sourceMappingURL=structured-output.js.map

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

@@ -0,0 +1,28 @@
+import type { SessionMessageInfo } from "@opencode/client";
+import type { AgentStreamEvent } from "../../../agent-sdk-types.js";
+export declare class V2Timeline {
+    private readonly includeClientMessageId;
+    private readonly content;
+    private readonly streams;
+    resetStreams(): void;
+    startPart(part: TextPartIdentity): void;
+    constructor(includeClientMessageId?: boolean);
+    delta(event: TextPartDelta): AgentStreamEvent | null;
+    messages(messages: SessionMessageInfo[]): AgentStreamEvent[];
+    private userMessage;
+    private assistantMessage;
+    private structuredOutputPart;
+    private textPart;
+    private toolPart;
+    private compactionMessage;
+}
+interface TextPartIdentity {
+    assistantMessageID: string;
+    type: "text" | "reasoning";
+    ordinal: number;
+}
+interface TextPartDelta extends TextPartIdentity {
+    delta: string;
+}
+export {};
+//# sourceMappingURL=timeline.d.ts.map

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

@@ -0,0 +1,154 @@
+import { mapOpencodeToolCall } from "../tool-call-mapper.js";
+import { STRUCTURED_OUTPUT_TOOL } from "./structured-output.js";
+function textPartKey(messageID, part, ordinal) {
+    return `${messageID}:${part}:${ordinal}`;
+}
+// Text and reasoning each number parts from zero, independent of snapshot position.
+export class V2Timeline {
+    resetStreams() {
+        this.streams.clear();
+    }
+    startPart(part) {
+        this.streams.set(textPartKey(part.assistantMessageID, part.type, part.ordinal), "");
+    }
+    constructor(includeClientMessageId = true) {
+        this.includeClientMessageId = includeClientMessageId;
+        this.content = new Map();
+        this.streams = new Map();
+    }
+    delta(event) {
+        const key = textPartKey(event.assistantMessageID, event.type, event.ordinal);
+        const streamed = this.streams.get(key);
+        // Deltas are ephemeral and have no offset. After reconnect, only stream
+        // parts whose start we observed; snapshots recover any interrupted part.
+        if (streamed === undefined || event.delta.length === 0)
+            return null;
+        const text = streamed + event.delta;
+        this.streams.set(key, text);
+        const emitted = this.content.get(key) ?? "";
+        if (text.length <= emitted.length)
+            return null;
+        if (!text.startsWith(emitted))
+            throw new Error("OpenCode changed previously emitted message content");
+        this.content.set(key, text);
+        const suffix = text.slice(emitted.length);
+        const item = event.type === "text"
+            ? { type: "assistant_message", text: suffix, messageId: event.assistantMessageID }
+            : { type: "reasoning", text: suffix };
+        return { type: "timeline", provider: "opencode", item, timestamp: new Date().toISOString() };
+    }
+    messages(messages) {
+        const events = [];
+        const state = { structured: false, accepted: false };
+        for (const message of messages) {
+            const timestamp = new Date(message.time.created).toISOString();
+            const push = (item) => events.push({ type: "timeline", provider: "opencode", item, timestamp });
+            if (message.type === "user")
+                this.userMessage(message, state, push);
+            else if (message.type === "assistant")
+                this.assistantMessage(message, state, push);
+            else if (message.type === "compaction")
+                this.compactionMessage(message, push);
+        }
+        return events;
+    }
+    userMessage(message, state, push) {
+        state.structured = message.metadata?.paseoOutputSchema !== undefined;
+        state.accepted = false;
+        if (this.content.has(message.id))
+            return;
+        this.content.set(message.id, message.text);
+        const clientMessageId = message.metadata?.paseoClientMessageId;
+        push({
+            type: "user_message",
+            text: message.text,
+            messageId: message.id,
+            ...(this.includeClientMessageId && typeof clientMessageId === "string"
+                ? { clientMessageId }
+                : {}),
+        });
+    }
+    assistantMessage(message, state, push) {
+        // Snapshot parts are indexed by position in `message.content`, but deltas
+        // number text and reasoning separately. Track a per-type ordinal so both
+        // paths address the same cursor entry.
+        let textOrdinal = 0;
+        let reasoningOrdinal = 0;
+        message.content.forEach((part, partIndex) => {
+            if (part.type === "tool" && part.name === STRUCTURED_OUTPUT_TOOL) {
+                this.structuredOutputPart(message.id, partIndex, part, state, push);
+            }
+            else if (part.type === "text" || part.type === "reasoning") {
+                const ordinal = part.type === "text" ? textOrdinal++ : reasoningOrdinal++;
+                this.textPart(message.id, part, ordinal, state, push);
+            }
+            else {
+                this.toolPart(message.id, partIndex, part, push);
+            }
+        });
+    }
+    structuredOutputPart(messageID, partIndex, part, state, push) {
+        if (!state.structured || state.accepted || part.state.status !== "completed")
+            return;
+        const value = part.state.metadata?.paseoStructuredOutput;
+        if (value === undefined)
+            return;
+        state.accepted = true;
+        const key = `${messageID}:${partIndex}`;
+        const text = JSON.stringify(value);
+        if (this.content.get(key) === text)
+            return;
+        this.content.set(key, text);
+        push({ type: "assistant_message", text, messageId: messageID });
+    }
+    textPart(messageID, part, ordinal, state, push) {
+        if (state.structured && part.type === "text")
+            return;
+        const key = textPartKey(messageID, part.type, ordinal);
+        const previous = this.content.get(key) ?? "";
+        // Upstream snapshots may briefly lag the volatile delta stream.
+        if (part.text.length <= previous.length)
+            return;
+        if (!part.text.startsWith(previous))
+            throw new Error("OpenCode changed previously emitted message content");
+        this.content.set(key, part.text);
+        const suffix = part.text.slice(previous.length);
+        if (part.type === "text")
+            push({ type: "assistant_message", text: suffix, messageId: messageID });
+        else
+            push({ type: "reasoning", text: suffix });
+    }
+    toolPart(messageID, partIndex, part, push) {
+        const key = `${messageID}:${partIndex}`;
+        const serialized = JSON.stringify(part);
+        if (serialized === this.content.get(key))
+            return;
+        this.content.set(key, serialized);
+        const item = toolFromV2(part);
+        if (item)
+            push(item);
+    }
+    compactionMessage(message, push) {
+        const status = message.status === "running" ? "loading" : "completed";
+        if (this.content.get(message.id) === status)
+            return;
+        this.content.set(message.id, status);
+        push({ type: "compaction", status });
+    }
+}
+function toolFromV2(tool) {
+    const state = tool.state;
+    const output = "content" in state
+        ? state.content?.map((part) => (part.type === "text" ? part.text : part.uri)).join("\n")
+        : undefined;
+    return mapOpencodeToolCall({
+        toolName: tool.name,
+        callId: tool.id,
+        input: state.input,
+        status: state.status === "error" ? "failed" : state.status,
+        output,
+        error: state.status === "error" ? state.error : undefined,
+        metadata: "metadata" in state ? state.metadata : undefined,
+    });
+}
+//# sourceMappingURL=timeline.js.map