@astrosheep/keiyaku 4.0.0 → 4.0.1

package/build/src/akuma/providers/codex-app-server/index.js

@@ -2,6 +2,14 @@ import { LineRpcProcess } from "../../../runtime/proc/line-rpc.js";
 import { AgentEventChannel, AKUMA_REQUESTS_ENV, } from "../../provider.js";
 import { codexNotificationResult, codexObject, codexText, } from "./events.js";
 export { CODEX_ITEM_DISPOSITIONS, CODEX_NOTIFICATION_DISPOSITIONS } from "./events.js";
+const INTERRUPT_TIMEOUT_MS = 1_000;
+function interrupt(server, threadId, turnId) {
+    const request = server.request("turn/interrupt", { threadId, turnId });
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error("codex app-server interrupt timed out")), INTERRUPT_TIMEOUT_MS);
+        void request.then((value) => { clearTimeout(timer); resolve(value); }, (error) => { clearTimeout(timer); reject(error); });
+    });
+}
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -28,6 +36,25 @@ function turnId(result) {
         throw new Error("codex app-server did not return a turn id");
     return id;
 }
+async function steerTurn(server, state, tell) {
+    if (state.settled)
+        return { kind: "turn-ended" };
+    if (state.threadId === undefined || state.turnId === undefined)
+        throw new Error("codex app-server turn is not admitted");
+    const request = server.request("turn/steer", {
+        threadId: state.threadId,
+        expectedTurnId: state.turnId,
+        input: [{ type: "text", text: tell.text }],
+        clientUserMessageId: tell.id,
+    });
+    const response = codexObject(await request);
+    const accepted = codexText(response?.turnId);
+    if (accepted === undefined)
+        throw new Error("codex app-server steer did not return a turn id");
+    if (accepted !== state.turnId)
+        throw new Error("codex app-server steer acknowledged a different turn");
+    return { kind: "accepted", fence: `${accepted}:${tell.id}` };
+}
 function sandbox(cwd, options, requests) {
     return {
         type: "workspaceWrite",
@@ -46,16 +73,20 @@ async function admitTurn(server, input, state, events, config) {
         ...(input.options.systemPrompt === undefined || input.options.systemPrompt.length === 0
             ? {} : { developerInstructions: input.options.systemPrompt }),
     };
-    state.threadId = input.session === undefined
-        ? threadId(await server.request("thread/start", threadParams))
-        : threadId(await server.request("thread/resume", {
-            threadId: input.session.sessionId,
+    if (input.session.kind === "fresh") {
+        state.threadId = threadId(await server.request("thread/start", threadParams));
+    }
+    else {
+        state.threadId = threadId(await server.request("thread/resume", {
+            threadId: input.session.coordinate.sessionId,
             ...threadParams,
-        }), input.session.sessionId);
+        }), input.session.coordinate.sessionId);
+    }
     events.emit({ type: "session", coordinate: { sessionId: state.threadId } });
     state.turnId = turnId(await server.request("turn/start", {
         threadId: state.threadId,
-        input: [{ type: "text", text: input.prompt }],
+        input: [{ type: "text", text: [input.body, ...input.launchTells.map((tell) => tell.text)]
+                    .filter((part) => part.length > 0).join("\n\n") }],
         ...(input.options.model === undefined ? {} : { model: input.options.model }),
         ...(input.options.effort === undefined ? {} : { effort: input.options.effort }),
         approvalPolicy: "never",
@@ -63,6 +94,8 @@ async function admitTurn(server, input, state, events, config) {
     }));
 }
 async function forkCodex(execution, input) {
+    if (!("sessionId" in input.session))
+        throw new Error("Codex app-server fork requires sessionId");
     const server = new LineRpcProcess({
         argv: [execution.executable ?? "codex", "app-server", "--listen", "stdio://"],
         cwd: input.cwd,
@@ -82,22 +115,28 @@ async function forkCodex(execution, input) {
         await server.close();
     }
 }
-async function abortTurn(server, state, completion, finish) {
-    if (!state.settled && state.threadId !== undefined && state.turnId !== undefined) {
+async function abortTurn(server, state, completion, settle) {
+    if (state.settled) {
+        await completion;
+        return;
+    }
+    if (state.threadId !== undefined && state.turnId !== undefined) {
         try {
-            await server.request("turn/interrupt", { threadId: state.threadId, turnId: state.turnId });
+            await interrupt(server, state.threadId, state.turnId);
             await completion;
         }
         catch (error) {
-            finish({ kind: "failed", diagnostic: diagnostic(error) });
+            settle({ kind: "failed", diagnostic: diagnostic(error) });
         }
     }
-    else if (!state.settled) {
-        finish({ kind: "failed", diagnostic: "codex app-server aborted before turn admission" });
+    else {
+        settle({ kind: "failed", diagnostic: "codex app-server aborted before turn admission" });
     }
-    await server.close(true);
+    await completion;
 }
 async function startCodex(execution, input) {
+    if (input.session.kind === "resume" && !("sessionId" in input.session.coordinate))
+        throw new Error("Codex app-server resume requires sessionId");
     const events = new AgentEventChannel();
     const server = new LineRpcProcess({
         argv: [execution.executable ?? "codex", "app-server", "--listen", "stdio://"],
@@ -108,16 +147,28 @@ async function startCodex(execution, input) {
                 ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
             } }),
     });
-    const state = { answers: [], settled: false, tools: new Map() };
+    const state = { settled: false, tools: new Map() };
     let settle;
     const completion = new Promise((resolve) => { settle = resolve; });
+    let terminal;
     const finish = (result) => {
-        if (state.settled)
+        if (terminal !== undefined)
             return;
+        terminal = result;
         state.settled = true;
-        events.end();
-        void server.close().then(() => settle(result), (error) => settle({ kind: "failed", diagnostic: `codex app-server cleanup failed: ${diagnostic(error)}` }));
+        void server.endInputAndDrain().then(() => {
+            events.end();
+            settle(result);
+        }, () => {
+            events.end();
+            settle(result);
+        });
     };
+    server.onNotification((notification) => {
+        const result = codexNotificationResult(notification, state, events);
+        if (result !== undefined)
+            finish(result);
+    });
     server.onExit(({ code, signal, stderr }) => finish({
         kind: "failed",
         diagnostic: stderr || `codex app-server exited before completion (${code ?? signal ?? "unknown"})`,
@@ -126,21 +177,20 @@ async function startCodex(execution, input) {
         kind: "failed",
         diagnostic: `codex app-server made forbidden interactive request ${request.method}`,
     }));
-    server.onNotification((notification) => {
-        const result = codexNotificationResult(notification, state, events);
-        if (result !== undefined)
-            finish(result);
-    });
     try {
         await admitTurn(server, input, state, events, execution.config);
     }
     catch (error) {
         finish({ kind: "failed", diagnostic: diagnostic(error) });
     }
+    if (state.turnId === undefined)
+        throw new Error("codex app-server did not admit a turn");
     return {
+        admission: { fence: state.turnId },
         events,
         completion,
         abort: () => abortTurn(server, state, completion, finish),
+        tell: (tell) => steerTurn(server, state, tell),
     };
 }
 export function createCodexAppServerProvider(input = "codex") {
@@ -157,6 +207,7 @@ export function createCodexAppServerProvider(input = "codex") {
         },
         fork: (input) => forkCodex(execution, input),
         start: (input) => startCodex(execution, input),
+        resume: (input) => startCodex(execution, input),
     };
 }
 export const codexAppServerProvider = createCodexAppServerProvider();

package/build/src/akuma/providers/index.js

@@ -1,5 +1,7 @@
-import { claudeProvider, createClaudeProvider } from "./claude.js";
+import { claudeProvider, createClaudeProvider } from "./claude/index.js";
 import { createCodexAppServerProvider } from "./codex-app-server/index.js";
+import { createOpencodeProvider } from "./opencode-sdk/index.js";
+import { createPiProvider } from "./pi/index.js";
 const PROVIDERS = {
     claude: claudeProvider,
 };
@@ -24,6 +26,19 @@ function optionalText(value, field) {
     }
     return selected;
 }
+function providerKind(value) {
+    return value === "claude-agent-sdk" || value === "codex-app-server" || value === "opencode-sdk" || value === "pi";
+}
+function providerConfig(value, kind) {
+    const config = value.config === undefined ? undefined : record(value.config);
+    if (config === null)
+        throw new TypeError("provider execution config must be an object");
+    if (kind === "claude-agent-sdk" && config !== undefined)
+        throw new TypeError("provider execution config is unsupported by claude-agent-sdk");
+    if (kind === "opencode-sdk" && config !== undefined)
+        throw new TypeError("provider execution config is unsupported by opencode-sdk");
+    return config;
+}
 export function decodeProviderExecution(input) {
     const value = record(input);
     if (value === null)
@@ -35,16 +50,11 @@ export function decodeProviderExecution(input) {
     if (typeof value.name !== "string" || value.name.trim().length === 0) {
         throw new TypeError("provider execution name must be a nonblank string");
     }
-    if (value.kind !== "claude-agent-sdk" && value.kind !== "codex-app-server") {
+    if (!providerKind(value.kind)) {
         throw new TypeError("provider execution has unknown kind");
     }
     const executable = optionalText(value, "executable");
-    const config = value.config === undefined ? undefined : record(value.config);
-    if (config === null)
-        throw new TypeError("provider execution config must be an object");
-    if (value.kind === "claude-agent-sdk" && config !== undefined) {
-        throw new TypeError("provider execution config is unsupported by claude-agent-sdk");
-    }
+    const config = providerConfig(value, value.kind);
     const env = value.env === undefined ? undefined : record(value.env);
     if (env === null)
         throw new TypeError("provider execution env must be an object");
@@ -67,5 +77,9 @@ export function providerNamed(execution) {
     }
     if (execution.kind === "codex-app-server")
         return createCodexAppServerProvider(execution);
+    if (execution.kind === "opencode-sdk")
+        return createOpencodeProvider(execution);
+    if (execution.kind === "pi")
+        return createPiProvider(execution);
     throw new TypeError(`unknown Akuma provider kind ${execution.kind}`);
 }

package/build/src/akuma/providers/opencode-sdk/events.d.ts

@@ -0,0 +1,48 @@
+import type { AgentEvent, ToolCall } from "../../provider.js";
+type Emitter = {
+    emit(event: AgentEvent): void;
+};
+type ToolState = Readonly<{
+    name: string;
+    call: ToolCall;
+}>;
+type State = {
+    tools: Map<string, ToolState>;
+    answer: string[];
+    seen: Set<string>;
+    failure?: string;
+};
+export declare const OPENCODE_EVENT_DISPOSITIONS: {
+    readonly "session.next.agent.switched": "dropped";
+    readonly "session.next.model.switched": "dropped";
+    readonly "session.next.moved": "dropped";
+    readonly "session.next.prompted": "dropped";
+    readonly "session.next.prompt.admitted": "dropped";
+    readonly "session.next.context.updated": "dropped";
+    readonly "session.next.synthetic": "dropped";
+    readonly "session.next.shell.started": "dropped";
+    readonly "session.next.shell.ended": "dropped";
+    readonly "session.next.step.started": "dropped";
+    readonly "session.next.step.ended": "dropped";
+    readonly "session.next.step.failed": "mapped";
+    readonly "session.next.text.started": "dropped";
+    readonly "session.next.text.ended": "mapped";
+    readonly "session.next.tool.input.started": "dropped";
+    readonly "session.next.tool.input.ended": "dropped";
+    readonly "session.next.tool.called": "mapped";
+    readonly "session.next.tool.progress": "dropped";
+    readonly "session.next.tool.success": "mapped";
+    readonly "session.next.tool.failed": "mapped";
+    readonly "session.next.reasoning.started": "dropped";
+    readonly "session.next.reasoning.ended": "mapped";
+    readonly "session.next.retried": "mapped";
+    readonly "session.next.compaction.started": "dropped";
+    readonly "session.next.compaction.ended": "dropped";
+    readonly "session.next.revert.staged": "dropped";
+    readonly "session.next.revert.cleared": "dropped";
+    readonly "session.next.revert.committed": "dropped";
+};
+export declare function mapEvent(value: unknown, events: Emitter, state: State): void;
+export type EventState = State;
+export declare function createEventState(): State;
+export {};

package/build/src/akuma/providers/opencode-sdk/events.js

@@ -0,0 +1,116 @@
+export const OPENCODE_EVENT_DISPOSITIONS = {
+    "session.next.agent.switched": "dropped",
+    "session.next.model.switched": "dropped",
+    "session.next.moved": "dropped",
+    "session.next.prompted": "dropped",
+    "session.next.prompt.admitted": "dropped",
+    "session.next.context.updated": "dropped",
+    "session.next.synthetic": "dropped",
+    "session.next.shell.started": "dropped",
+    "session.next.shell.ended": "dropped",
+    "session.next.step.started": "dropped",
+    "session.next.step.ended": "dropped",
+    "session.next.step.failed": "mapped",
+    "session.next.text.started": "dropped",
+    "session.next.text.ended": "mapped",
+    "session.next.tool.input.started": "dropped",
+    "session.next.tool.input.ended": "dropped",
+    "session.next.tool.called": "mapped",
+    "session.next.tool.progress": "dropped",
+    "session.next.tool.success": "mapped",
+    "session.next.tool.failed": "mapped",
+    "session.next.reasoning.started": "dropped",
+    "session.next.reasoning.ended": "mapped",
+    "session.next.retried": "mapped",
+    "session.next.compaction.started": "dropped",
+    "session.next.compaction.ended": "dropped",
+    "session.next.revert.staged": "dropped",
+    "session.next.revert.cleared": "dropped",
+    "session.next.revert.committed": "dropped",
+};
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function text(value) { return typeof value === "string" && value.length > 0 ? value : undefined; }
+function diagnostic(value) { const v = object(value); return text(v?.message) ?? text(v?.error) ?? "OpenCode session failed"; }
+function callFor(name, input) {
+    const value = object(input);
+    if (name === "shell")
+        return { kind: "run", command: text(value?.command) ?? "shell" };
+    if (name === "read")
+        return { kind: "read", path: text(value?.path) ?? "file" };
+    if (name === "grep" || name === "search")
+        return { kind: "search", query: text(value?.query) ?? "search" };
+    return { kind: "other", display: name };
+}
+function resultFor(value, failed) {
+    return { status: failed ? "error" : "ok", ...(failed ? { message: diagnostic(value) } : {}) };
+}
+export function mapEvent(value, events, state) {
+    const event = object(value);
+    const eventId = text(event?.id);
+    if (eventId !== undefined && state.seen.has(eventId))
+        return;
+    if (eventId !== undefined)
+        state.seen.add(eventId);
+    const kind = text(event?.type) ?? "unknown";
+    const data = object(event?.data) ?? event ?? {};
+    switch (kind) {
+        case "session.next.text.ended": {
+            const value = text(data.text);
+            if (value !== undefined) {
+                state.answer.push(value);
+                events.emit({ type: "assistant", text: value });
+            }
+            return;
+        }
+        case "session.next.reasoning.ended": {
+            const value = text(data.text);
+            if (value !== undefined)
+                events.emit({ type: "thought", text: value });
+            return;
+        }
+        case "session.next.tool.called": {
+            const id = text(data.callID);
+            if (id === undefined) {
+                events.emit({ type: "unknown", kind: `${kind}/missing-id` });
+                return;
+            }
+            const observed = { name: text(data.tool) ?? "tool", call: callFor(text(data.tool) ?? "tool", data.input) };
+            state.tools.set(id, observed);
+            events.emit({ type: "tool", phase: "started", id, ...observed });
+            return;
+        }
+        case "session.next.tool.success":
+        case "session.next.tool.failed": {
+            const id = text(data.callID);
+            if (id === undefined) {
+                events.emit({ type: "unknown", kind: `${kind}/missing-id` });
+                return;
+            }
+            const started = state.tools.get(id);
+            const failed = kind.endsWith("failed");
+            if (started === undefined) {
+                events.emit({ type: "unknown", kind: `${kind}/orphan` });
+                return;
+            }
+            state.tools.delete(id);
+            events.emit({ type: "tool", phase: "completed", id, ...started, result: resultFor(data.error, failed) });
+            return;
+        }
+        case "session.next.step.failed":
+            state.failure = diagnostic(data.error);
+            events.emit({ type: "note", text: state.failure });
+            return;
+        case "session.next.retried":
+            events.emit({ type: "note", text: "Retrying" });
+            return;
+        default: {
+            const disposition = OPENCODE_EVENT_DISPOSITIONS[kind];
+            if (disposition === "dropped")
+                return;
+            events.emit({ type: "unknown", kind });
+        }
+    }
+}
+export function createEventState() { return { tools: new Map(), answer: [], seen: new Set() }; }

package/build/src/akuma/providers/opencode-sdk/index.d.ts

@@ -0,0 +1,32 @@
+import { type ProviderAdapter, type ProviderOptions, type Session } from "../../provider.js";
+import type { ProviderExecution, ResumeCoordinate } from "../../heart/index.js";
+import { type OpencodeSdkLoader } from "./session.js";
+export type OpencodeProviderTestOptions = Readonly<{
+    loader?: OpencodeSdkLoader;
+}>;
+export declare function createOpencodeProvider(input?: ProviderExecution | OpencodeProviderTestOptions): ProviderAdapter;
+export declare const opencodeProvider: Readonly<{
+    confinement(input: Readonly<{
+        cwd: string;
+        options: ProviderOptions;
+    }>): import("../../heart/facts.js").Confinement;
+    admitOptions(options: ProviderOptions): import("../../provider.js").ProviderOptionAdmission;
+    fork?(input: Readonly<{
+        session: ResumeCoordinate;
+        at: string;
+        cwd: string;
+    }>): Promise<Readonly<{
+        session: ResumeCoordinate;
+    }>>;
+    start(input: import("../../provider.js").DriveInput & Readonly<{
+        session: Readonly<{
+            kind: "fresh";
+        }>;
+    }>): Promise<Session>;
+    resume?(input: import("../../provider.js").DriveInput & Readonly<{
+        session: Readonly<{
+            kind: "resume";
+            coordinate: ResumeCoordinate;
+        }>;
+    }>): Promise<Session>;
+}>;

package/build/src/akuma/providers/opencode-sdk/index.js

@@ -0,0 +1,203 @@
+import { AgentEventChannel } from "../../provider.js";
+import { createEventState, mapEvent } from "./events.js";
+import { coordinate, loadOpencode, OPENCODE_SDK_PROVIDER, parseModel } from "./session.js";
+function diagnostic(error) { return error instanceof Error ? error.message : String(error); }
+function opencodeSessionId(coordinate) {
+    if (!("sessionId" in coordinate) || coordinate.sessionId === undefined) {
+        throw new Error("OpenCode resume requires sessionId");
+    }
+    return coordinate.sessionId;
+}
+function admit(options) {
+    if (options.access !== undefined)
+        throw new Error("OpenCode does not support explicit access");
+    if (options.network !== undefined)
+        throw new Error("OpenCode does not support explicit network");
+    if (options.systemPrompt !== undefined && options.systemPrompt.length > 0) {
+        throw new Error("OpenCode V2 does not expose an enforceable system prompt option");
+    }
+    if (options.effort !== undefined && options.model === undefined) {
+        throw new Error("OpenCode effort requires an explicit model");
+    }
+    if (options.model !== undefined)
+        parseModel(options.model, options.effort);
+}
+function eventValue(value) {
+    const envelope = objectData(value);
+    if (envelope !== undefined && typeof envelope.data === "string")
+        return eventValue(envelope.data);
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return { type: value };
+    }
+}
+async function drive(execution, input, loader) {
+    admit(input.options);
+    const resumeSessionId = input.session.kind === "resume"
+        ? opencodeSessionId(input.session.coordinate)
+        : undefined;
+    const events = new AgentEventChannel();
+    const state = createEventState();
+    const abortController = new AbortController();
+    const runtime = await loadOpencode(execution, input.cwd, abortController.signal, loader);
+    let closed = false;
+    const closeOnce = async () => {
+        if (closed)
+            return;
+        closed = true;
+        await runtime.close();
+    };
+    try {
+        const session = runtime.client.v2.session;
+        const model = input.options.model === undefined ? undefined : parseModel(input.options.model, input.options.effort);
+        const response = input.session.kind === "fresh"
+            ? await session.create({ location: { directory: input.cwd }, ...(model === undefined ? {} : { model }) }, { throwOnError: true })
+            : await session.get({ sessionID: resumeSessionId }, { throwOnError: true });
+        const responseData = objectData(objectData(response)?.data);
+        const info = objectData(responseData?.data) ?? responseData;
+        const sessionId = textData(info?.id) ?? resumeSessionId;
+        if (sessionId === undefined)
+            throw new Error("OpenCode did not return a session id");
+        if (input.session.kind === "resume" && model !== undefined) {
+            await session.switchModel({ sessionID: sessionId, model }, { throwOnError: true });
+        }
+        events.emit({ type: "session", coordinate: coordinate(sessionId) });
+        const streamResult = await session.events({ sessionID: sessionId });
+        const iterator = streamResult.stream[Symbol.asyncIterator]();
+        const promptText = [input.body, ...input.launchTells.map((tell) => tell.text)].filter((part) => part.length > 0).join("\n\n");
+        const promptResponse = await session.prompt({ sessionID: sessionId, prompt: { text: promptText } }, { throwOnError: true });
+        const fence = admittedFence(sessionId, promptResponse);
+        let settled = false;
+        let settle;
+        const completion = new Promise((resolve) => { settle = resolve; });
+        const finish = async (result) => {
+            if (settled)
+                return;
+            settled = true;
+            events.end();
+            try {
+                await closeOnce();
+                settle(result);
+            }
+            catch (error) {
+                settle({ kind: "failed", diagnostic: `OpenCode cleanup failed: ${diagnostic(error)}` });
+            }
+        };
+        void (async () => {
+            try {
+                await consumeSession(session, sessionId, iterator, state, events);
+                const messages = await session.messages({ sessionID: sessionId, order: "desc", limit: 32 }, { throwOnError: true });
+                const final = messages.data.data.find((message) => message.type === "assistant");
+                const answer = final?.type === "assistant" ? final.content.filter((part) => part.type === "text").map((part) => part.text).join("\n\n") : state.answer.join("\n\n");
+                const historyId = final?.type === "assistant" ? textData(final.id) : undefined;
+                if (state.failure !== undefined || final?.type === "assistant" && final.error !== undefined)
+                    await finish({ kind: "failed", diagnostic: state.failure ?? diagnostic(final?.type === "assistant" ? final.error : undefined) });
+                else if (historyId === undefined) {
+                    await finish({ kind: "failed", diagnostic: "OpenCode completed without a native assistant answer/history point" });
+                }
+                else
+                    await finish({ kind: "answered", answer, historyId });
+            }
+            catch (error) {
+                await finish({ kind: "failed", diagnostic: diagnostic(error) });
+            }
+        })();
+        return {
+            admission: { fence },
+            events,
+            completion,
+            abort: async () => {
+                abortController.abort();
+                void session.interrupt({ sessionID: sessionId }, { throwOnError: true }).catch(() => undefined);
+                await finish({ kind: "failed", diagnostic: "OpenCode session interrupted" });
+            },
+        };
+    }
+    catch (error) {
+        try {
+            await closeOnce();
+        }
+        catch (cleanupError) {
+            throw new Error(`OpenCode setup failed: ${diagnostic(error)}; cleanup failed: ${diagnostic(cleanupError)}`);
+        }
+        throw error;
+    }
+}
+function objectData(value) { return value !== null && typeof value === "object" ? value : undefined; }
+function textData(value) { return typeof value === "string" && value.trim().length > 0 ? value : undefined; }
+function admittedFence(sessionId, response) {
+    const outer = objectData(response);
+    const envelope = objectData(outer?.data);
+    const admission = objectData(envelope?.data) ?? envelope;
+    const id = textData(admission?.id);
+    const sequence = typeof admission?.admittedSeq === "number" && Number.isSafeInteger(admission.admittedSeq)
+        ? admission.admittedSeq : undefined;
+    if (id === undefined && sequence === undefined)
+        throw new Error("OpenCode did not return prompt admission evidence");
+    return `${sessionId}:${sequence ?? id}`;
+}
+async function consumeSession(session, sessionId, iterator, state, events) {
+    const stream = (async () => {
+        for (;;) {
+            const next = await iterator.next();
+            if (next.done)
+                return;
+            mapEvent(eventValue(next.value), events, state);
+        }
+    })();
+    stream.catch(() => undefined);
+    await session.wait({ sessionID: sessionId }, { throwOnError: true });
+    await iterator.return?.();
+    await stream;
+    let after;
+    for (;;) {
+        const history = await session.history({ sessionID: sessionId, limit: 200, ...(after === undefined ? {} : { after }) }, { throwOnError: true });
+        for (const event of history.data.data)
+            mapEvent(event, events, state);
+        const latest = history.data.data.at(-1)?.durable?.seq;
+        if (!history.data.hasMore || latest === undefined || latest === after)
+            return;
+        after = latest;
+    }
+}
+export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, kind: "opencode-sdk" }) {
+    const execution = "kind" in input ? input : { name: OPENCODE_SDK_PROVIDER, kind: "opencode-sdk" };
+    const loader = "loader" in input ? input.loader : undefined;
+    return {
+        confinement: ({ cwd }) => ({ kind: "declared", writableRoots: [cwd] }),
+        admitOptions(options) {
+            try {
+                admit(options);
+            }
+            catch (error) {
+                return { kind: "refused", diagnostic: diagnostic(error) };
+            }
+            return { kind: "admitted", options: Object.freeze({ ...options }) };
+        },
+        start: (input) => drive(execution, input, loader),
+        resume: (input) => drive(execution, input, loader),
+        fork: async (input) => {
+            const sessionId = opencodeSessionId(input.session);
+            const runtime = await loadOpencode(execution, input.cwd, new AbortController().signal, loader);
+            try {
+                const fork = runtime.client.session?.fork;
+                if (fork === undefined)
+                    throw new Error("OpenCode fork is unavailable");
+                const result = objectData(await fork({ sessionID: sessionId, messageID: input.at }));
+                const data = objectData(result?.data);
+                const id = textData(data?.id);
+                if (id === undefined || id === sessionId)
+                    throw new Error("OpenCode fork returned an invalid session id");
+                return { session: coordinate(id) };
+            }
+            finally {
+                await runtime.close();
+            }
+        },
+    };
+}
+export const opencodeProvider = createOpencodeProvider();