@astrosheep/keiyaku 4.0.0 → 4.0.2

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

@@ -28,7 +28,29 @@ 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) {
+    if (options.readonly === true) {
+        return { type: "readOnly", networkAccess: options.network === "enabled" };
+    }
     return {
         type: "workspaceWrite",
         writableRoots: [cwd, ...(requests === undefined ? [] : [requests.dir])],
@@ -46,16 +68,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 +89,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 +110,15 @@ async function forkCodex(execution, input) {
         await server.close();
     }
 }
-async function abortTurn(server, state, completion, finish) {
-    if (!state.settled && state.threadId !== undefined && state.turnId !== undefined) {
-        try {
-            await server.request("turn/interrupt", { threadId: state.threadId, turnId: state.turnId });
-            await completion;
-        }
-        catch (error) {
-            finish({ kind: "failed", diagnostic: diagnostic(error) });
-        }
-    }
-    else if (!state.settled) {
-        finish({ kind: "failed", diagnostic: "codex app-server aborted before turn admission" });
-    }
+async function abortTurn(server, state, settle) {
+    if (!state.settled)
+        settle({ kind: "failed", diagnostic: "codex app-server interrupted" });
     await server.close(true);
 }
 async function startCodex(execution, input) {
+    const signal = input.signal ?? new AbortController().signal;
+    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 +129,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 +159,30 @@ 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);
-    });
+    const abortSetup = () => { void server.close(true); };
+    signal.addEventListener("abort", abortSetup, { once: true });
     try {
+        signal.throwIfAborted();
         await admitTurn(server, input, state, events, execution.config);
     }
     catch (error) {
+        if (signal.aborted) {
+            await server.close(true);
+            throw signal.reason;
+        }
         finish({ kind: "failed", diagnostic: diagnostic(error) });
     }
+    finally {
+        signal.removeEventListener("abort", abortSetup);
+    }
+    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),
+        abort: () => abortTurn(server, state, finish),
+        tell: (tell) => steerTurn(server, state, tell),
     };
 }
 export function createCodexAppServerProvider(input = "codex") {
@@ -150,13 +192,15 @@ export function createCodexAppServerProvider(input = "codex") {
     return {
         confinement: ({ cwd }) => ({ kind: "declared", writableRoots: [cwd] }),
         admitOptions(options) {
-            if (options.access !== undefined && options.access !== "write") {
-                return { kind: "refused", diagnostic: "Codex app-server supports only access: write" };
-            }
-            return { kind: "admitted", options: Object.freeze({ ...options }) };
+            return {
+                kind: "admitted",
+                options: Object.freeze({ ...options }),
+                ...(options.readonly === undefined ? {} : { readonly: { enforcement: "native" } }),
+            };
         },
         fork: (input) => forkCodex(execution, input),
         start: (input) => startCodex(execution, input),
+        resume: (input) => startCodex(execution, input),
     };
 }
 export const codexAppServerProvider = createCodexAppServerProvider();

package/build/src/akuma/providers/grok-build/index.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderAdapter } from "../../provider.js";
+import type { ProviderExecution } from "../../provider-recipe.js";
+import { type AcpDependencies } from "../acp/core.js";
+export declare function createGrokBuildProvider(execution: ProviderExecution, dependencies?: AcpDependencies): ProviderAdapter;

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

@@ -0,0 +1,70 @@
+import { startAcpSession } from "../acp/core.js";
+const INTERJECT_METHOD = "x.ai/interject";
+function optionAdmission(options) {
+    if (options.network !== undefined) {
+        return { kind: "refused", diagnostic: "Grok Build does not support the network option" };
+    }
+    if (options.systemPrompt !== undefined && options.systemPrompt.length > 0) {
+        return { kind: "refused", diagnostic: "Grok Build does not support the systemPrompt option" };
+    }
+    return {
+        kind: "admitted",
+        options,
+        ...(options.readonly === undefined ? {} : {
+            readonly: {
+                enforcement: "none",
+                diagnostic: "Grok Build cannot remove task-surface mutation capabilities",
+            },
+        }),
+    };
+}
+function argv(execution, options) {
+    if (execution.executable === undefined)
+        throw new Error("Grok Build provider execution requires executable");
+    const values = [execution.executable, "agent", "--always-approve"];
+    if (options.model !== undefined)
+        values.push("--model", options.model);
+    if (options.effort !== undefined)
+        values.push("--reasoning-effort", options.effort);
+    values.push("stdio");
+    return values;
+}
+function withInterject(live) {
+    return {
+        ...live.session,
+        tell: async (tell) => {
+            if (!live.open())
+                return { kind: "turn-ended" };
+            const response = await live.agent.request(INTERJECT_METHOD, {
+                sessionId: live.sessionId,
+                text: tell.text,
+                interjectionId: tell.id,
+            });
+            if (!live.open())
+                return { kind: "turn-ended" };
+            if (response === null || typeof response !== "object" || response.status !== "queued") {
+                throw new Error("Grok Build interject did not return queued");
+            }
+            return { kind: "accepted", fence: tell.id };
+        },
+    };
+}
+export function createGrokBuildProvider(execution, dependencies = {}) {
+    if (execution.executable === undefined)
+        throw new TypeError("Grok Build provider execution requires executable");
+    if (execution.config !== undefined)
+        throw new TypeError("Grok Build provider does not support execution config");
+    const drive = async (input) => {
+        const launch = {
+            argv: argv(execution, input.options),
+            ...(execution.env === undefined ? {} : { env: execution.env }),
+        };
+        return withInterject(await startAcpSession(launch, input, dependencies));
+    };
+    return {
+        confinement: () => ({ kind: "unconfined" }),
+        admitOptions: optionAdmission,
+        start: async (input) => await drive(input),
+        resume: async (input) => await drive(input),
+    };
+}

package/build/src/akuma/providers/index.d.ts

@@ -1,4 +1,6 @@
 import type { ProviderAdapter } from "../provider.js";
-import type { ProviderExecution } from "../heart/index.js";
-export declare function decodeProviderExecution(input: unknown): ProviderExecution;
-export declare function providerNamed(execution: ProviderExecution): ProviderAdapter;
+import { type ProviderExecution } from "../provider-recipe.js";
+export declare function resolveProviderExecution(input: unknown): Readonly<{
+    execution: ProviderExecution;
+    adapter: ProviderAdapter;
+}>;

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

@@ -1,65 +1,26 @@
-import { claudeProvider, createClaudeProvider } from "./claude.js";
+import { decodeProviderRecipe } from "../provider-recipe.js";
+import { createAcpProvider, decodeAcpConfig } from "./acp/index.js";
+import { claudeProvider, createClaudeProvider } from "./claude/index.js";
 import { createCodexAppServerProvider } from "./codex-app-server/index.js";
+import { createGrokBuildProvider } from "./grok-build/index.js";
+import { createOpencodeProvider } from "./opencode-sdk/index.js";
+import { createPiProvider } from "./pi/index.js";
 const PROVIDERS = {
     claude: claudeProvider,
 };
-function record(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value : null;
-}
-function snapshot(value) {
-    if (Array.isArray(value))
-        return Object.freeze(value.map(snapshot));
-    const object = record(value);
-    if (object === null)
-        return value;
-    return Object.freeze(Object.fromEntries(Object.entries(object).map(([key, item]) => [key, snapshot(item)])));
-}
-function optionalText(value, field) {
-    const selected = value[field];
-    if (selected === undefined)
-        return undefined;
-    if (typeof selected !== "string" || selected.trim().length === 0) {
-        throw new TypeError(`provider execution ${field} must be a nonblank string`);
-    }
-    return selected;
-}
-export function decodeProviderExecution(input) {
-    const value = record(input);
-    if (value === null)
-        throw new TypeError("provider execution must be an object");
-    const allowed = ["config", "env", "executable", "kind", "name"];
-    const unknown = Object.keys(value).find((key) => !allowed.includes(key));
-    if (unknown !== undefined)
-        throw new TypeError(`provider execution has unknown field ${unknown}`);
-    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") {
-        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) {
+function providerConfig(execution) {
+    const { config, kind } = execution;
+    if (kind === "claude-agent-sdk" && config !== undefined)
         throw new TypeError("provider execution config is unsupported by claude-agent-sdk");
-    }
-    const env = value.env === undefined ? undefined : record(value.env);
-    if (env === null)
-        throw new TypeError("provider execution env must be an object");
-    if (env !== undefined && Object.values(env).some((item) => typeof item !== "string")) {
-        throw new TypeError("provider execution env must contain only string values");
-    }
-    return Object.freeze({
-        name: value.name,
-        kind: value.kind,
-        ...(executable === undefined ? {} : { executable }),
-        ...(config === undefined ? {} : { config: snapshot(config) }),
-        ...(env === undefined ? {} : { env: Object.freeze({ ...env }) }),
-    });
+    if (kind === "opencode-sdk" && config !== undefined)
+        throw new TypeError("provider execution config is unsupported by opencode-sdk");
+    if (kind === "acp")
+        return decodeAcpConfig(config);
+    return config;
 }
-export function providerNamed(execution) {
+function adapterFor(execution) {
+    if (execution.kind === "acp")
+        return createAcpProvider(execution);
     if (execution.kind === "claude-agent-sdk") {
         return execution.executable === undefined && execution.env === undefined
             ? PROVIDERS.claude
@@ -67,5 +28,23 @@ export function providerNamed(execution) {
     }
     if (execution.kind === "codex-app-server")
         return createCodexAppServerProvider(execution);
+    if (execution.kind === "grok-build")
+        return createGrokBuildProvider(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}`);
 }
+export function resolveProviderExecution(input) {
+    const decoded = decodeProviderRecipe(input);
+    const config = providerConfig(decoded);
+    const execution = Object.freeze({
+        name: decoded.name,
+        kind: decoded.kind,
+        ...(decoded.executable === undefined ? {} : { executable: decoded.executable }),
+        ...(config === undefined ? {} : { config }),
+        ...(decoded.env === undefined ? {} : { env: decoded.env }),
+    });
+    return Object.freeze({ execution, adapter: adapterFor(execution) });
+}

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

@@ -0,0 +1,54 @@
+import { type AgentEvent, type ToolCall } from "../../provider.js";
+type Emitter = {
+    emit(event: AgentEvent): void;
+};
+type ObservedTool = Readonly<{
+    name: string;
+    call: ToolCall;
+}>;
+type State = {
+    sessionId?: string;
+    assistantParts: Set<string>;
+    reasoningParts: Set<string>;
+    tools: Map<string, ObservedTool>;
+    completedTools: Set<string>;
+    failure?: string;
+};
+export declare const OPENCODE_EVENT_DISPOSITIONS: {
+    readonly "server.instance.disposed": "dropped";
+    readonly "installation.updated": "dropped";
+    readonly "installation.update-available": "dropped";
+    readonly "lsp.client.diagnostics": "dropped";
+    readonly "lsp.updated": "dropped";
+    readonly "message.updated": "mapped";
+    readonly "message.removed": "dropped";
+    readonly "message.part.updated": "mapped";
+    readonly "message.part.removed": "dropped";
+    readonly "permission.updated": "dropped";
+    readonly "permission.replied": "dropped";
+    readonly "session.status": "dropped";
+    readonly "session.idle": "dropped";
+    readonly "session.compacted": "dropped";
+    readonly "file.edited": "dropped";
+    readonly "todo.updated": "mapped";
+    readonly "command.executed": "dropped";
+    readonly "session.created": "dropped";
+    readonly "session.updated": "dropped";
+    readonly "session.deleted": "dropped";
+    readonly "session.diff": "dropped";
+    readonly "session.error": "mapped";
+    readonly "file.watcher.updated": "dropped";
+    readonly "vcs.branch.updated": "dropped";
+    readonly "tui.prompt.append": "dropped";
+    readonly "tui.command.execute": "dropped";
+    readonly "tui.toast.show": "dropped";
+    readonly "pty.created": "dropped";
+    readonly "pty.updated": "dropped";
+    readonly "pty.exited": "dropped";
+    readonly "pty.deleted": "dropped";
+    readonly "server.connected": "dropped";
+};
+export declare function mapEvent(value: unknown, events: Emitter, state: State): void;
+export type EventState = State;
+export declare function createEventState(sessionId?: string): State;
+export {};

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

@@ -0,0 +1,235 @@
+import { noteEvent } from "../../provider.js";
+export const OPENCODE_EVENT_DISPOSITIONS = {
+    "server.instance.disposed": "dropped",
+    "installation.updated": "dropped",
+    "installation.update-available": "dropped",
+    "lsp.client.diagnostics": "dropped",
+    "lsp.updated": "dropped",
+    "message.updated": "mapped",
+    "message.removed": "dropped",
+    "message.part.updated": "mapped",
+    "message.part.removed": "dropped",
+    "permission.updated": "dropped",
+    "permission.replied": "dropped",
+    "session.status": "dropped",
+    "session.idle": "dropped",
+    "session.compacted": "dropped",
+    "file.edited": "dropped",
+    "todo.updated": "mapped",
+    "command.executed": "dropped",
+    "session.created": "dropped",
+    "session.updated": "dropped",
+    "session.deleted": "dropped",
+    "session.diff": "dropped",
+    "session.error": "mapped",
+    "file.watcher.updated": "dropped",
+    "vcs.branch.updated": "dropped",
+    "tui.prompt.append": "dropped",
+    "tui.command.execute": "dropped",
+    "tui.toast.show": "dropped",
+    "pty.created": "dropped",
+    "pty.updated": "dropped",
+    "pty.exited": "dropped",
+    "pty.deleted": "dropped",
+    "server.connected": "dropped",
+};
+// OpenCode may emit these server-side metadata events before the generated
+// SDK union catches up. They are all non-narrative and therefore remain drop
+// dispositions; genuinely new execution events still use the unknown arm.
+const RUNTIME_DROPPED_EVENT_KINDS = new Set([
+    "plugin.added",
+    "catalog.updated",
+    "reference.updated",
+    "integration.updated",
+    "server.heartbeat",
+    "message.part.delta",
+]);
+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 data = object(value);
+    const nested = object(data?.data);
+    return text(nested?.message) ?? text(data?.message) ?? "OpenCode session failed";
+}
+function positiveLine(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;
+}
+function runCall(name, value) {
+    return name === "bash" || name === "shell"
+        ? { kind: "run", command: text(value?.command) ?? name }
+        : undefined;
+}
+function readCall(name, value) {
+    if (name !== "read")
+        return undefined;
+    const path = text(value?.filePath) ?? text(value?.path);
+    if (path === undefined)
+        return undefined;
+    const offset = positiveLine(value?.offset);
+    const limit = positiveLine(value?.limit);
+    return {
+        kind: "read",
+        path,
+        ...(offset === undefined ? {} : { offset }),
+        ...(limit === undefined ? {} : { limit }),
+    };
+}
+function searchCall(name, value) {
+    if (name !== "grep" && name !== "glob" && name !== "search")
+        return undefined;
+    const query = text(value?.pattern) ?? text(value?.query);
+    if (query === undefined)
+        return undefined;
+    const path = text(value?.path) ?? text(value?.filePath);
+    const glob = text(value?.glob);
+    const scope = name === "glob" ? "files" : "content";
+    return {
+        kind: "search",
+        query,
+        scope,
+        ...(path === undefined ? {} : { path }),
+        ...(scope === "content" && glob !== undefined ? { glob } : {}),
+    };
+}
+function callFor(name, input) {
+    const value = object(input);
+    const lower = name.toLowerCase();
+    if (lower === "bash" || lower === "shell")
+        return runCall(lower, value);
+    if (lower === "read")
+        return readCall(lower, value);
+    if (lower === "grep" || lower === "glob" || lower === "search")
+        return searchCall(lower, value);
+    return { kind: "other", display: name };
+}
+function belongs(part, state) {
+    return state.sessionId === undefined || part.sessionID === state.sessionId;
+}
+function mapTextPart(part, events, state, thought) {
+    const id = text(part.id);
+    const time = object(part.time);
+    const content = text(part.text);
+    const seen = thought ? state.reasoningParts : state.assistantParts;
+    if (!belongs(part, state) || id === undefined || content === undefined || time?.end === undefined || seen.has(id))
+        return;
+    seen.add(id);
+    if (thought)
+        events.emit({ type: "thought", text: content });
+    else
+        events.emit({ type: "assistant", text: content });
+}
+function resultFor(state, failed) {
+    const exit = object(state.metadata)?.exit;
+    const exitCode = typeof exit === "number" && Number.isInteger(exit) ? exit : undefined;
+    if (failed) {
+        return { status: "error", message: text(state.error) ?? "OpenCode tool failed", ...(exitCode === undefined ? {} : { exitCode }) };
+    }
+    return { status: exitCode !== undefined && exitCode !== 0 ? "error" : "ok", ...(exitCode === undefined ? {} : { exitCode }) };
+}
+function mapToolPart(part, events, state) {
+    if (!belongs(part, state))
+        return;
+    const id = text(part.callID);
+    const name = text(part.tool);
+    const toolState = object(part.state);
+    if (id === undefined || name === undefined || toolState === undefined)
+        return;
+    if ((toolState.status === "pending" || toolState.status === "running")
+        && !state.tools.has(id) && !state.completedTools.has(id)) {
+        const call = callFor(name, toolState.input);
+        if (call === undefined)
+            return;
+        const observed = { name, call };
+        state.tools.set(id, observed);
+        events.emit({ type: "tool", phase: "started", id, ...observed });
+        return;
+    }
+    if ((toolState.status !== "completed" && toolState.status !== "error") || state.completedTools.has(id))
+        return;
+    const started = state.tools.get(id);
+    const call = started?.call ?? callFor(name, toolState.input);
+    if (call === undefined)
+        return;
+    const observed = started ?? { name, call };
+    if (!state.tools.has(id)) {
+        state.tools.set(id, observed);
+        events.emit({ type: "tool", phase: "started", id, ...observed });
+    }
+    state.completedTools.add(id);
+    events.emit({
+        type: "tool",
+        phase: "completed",
+        id,
+        ...observed,
+        result: resultFor(toolState, toolState.status === "error"),
+    });
+}
+function mapPart(part, events, state) {
+    if (part.type === "text")
+        return mapTextPart(part, events, state, false);
+    if (part.type === "reasoning")
+        return mapTextPart(part, events, state, true);
+    if (part.type === "tool")
+        mapToolPart(part, events, state);
+}
+function mapSessionError(properties, events, state) {
+    if (state.sessionId !== undefined && properties.sessionID !== state.sessionId)
+        return;
+    state.failure = diagnostic(properties.error);
+    events.emit(noteEvent(state.failure));
+}
+function mapTodo(properties, events, state) {
+    if (properties.sessionID !== state.sessionId || !Array.isArray(properties.todos))
+        return;
+    const summary = properties.todos.flatMap((value) => {
+        const todo = object(value);
+        const content = text(todo?.content);
+        return content === undefined ? [] : [`${text(todo?.status) ?? "todo"}: ${content}`];
+    }).join("; ");
+    if (summary.length > 0)
+        events.emit(noteEvent(summary));
+}
+function ignoredEvent(type) {
+    return typeof type === "string"
+        && (OPENCODE_EVENT_DISPOSITIONS[type] === "dropped" || RUNTIME_DROPPED_EVENT_KINDS.has(type));
+}
+export function mapEvent(value, events, state) {
+    const event = object(value);
+    if (event === undefined)
+        return;
+    const properties = object(event.properties) ?? {};
+    if (event.type === "message.part.updated") {
+        const part = object(properties.part);
+        if (part !== undefined)
+            mapPart(part, events, state);
+        return;
+    }
+    if (event.type === "message.updated") {
+        const info = object(properties.info);
+        if (info !== undefined && info.sessionID === state.sessionId && info.role === "assistant" && info.error !== undefined) {
+            state.failure = diagnostic(info.error);
+        }
+        return;
+    }
+    if (event.type === "session.error")
+        return mapSessionError(properties, events, state);
+    if (event.type === "todo.updated")
+        return mapTodo(properties, events, state);
+    if (ignoredEvent(event.type))
+        return;
+    events.emit({ type: "unknown", kind: typeof event.type === "string" ? event.type : "unknown" });
+}
+export function createEventState(sessionId) {
+    return {
+        ...(sessionId === undefined ? {} : { sessionId }),
+        assistantParts: new Set(),
+        reasoningParts: new Set(),
+        tools: new Map(),
+        completedTools: new Set(),
+    };
+}