@astrosheep/keiyaku 2.9.13 → 4.0.1

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();

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

@@ -0,0 +1,41 @@
+import { type OpencodeClient } from "@opencode-ai/sdk/v2";
+import { type ProviderExecution, type ResumeCoordinate } from "../../heart/index.js";
+export type OpencodeSdkSession = Pick<OpencodeClient["v2"]["session"], "create" | "get" | "prompt" | "events" | "history" | "messages" | "interrupt" | "switchModel" | "wait">;
+export type OpencodeSdkLoader = (cwd: string) => Promise<Readonly<{
+    client: {
+        v2: {
+            session: OpencodeSdkSession;
+            model?: Pick<OpencodeClient["v2"]["model"], "list">;
+        };
+        session?: {
+            fork(params: {
+                sessionID: string;
+                messageID: string;
+            }): Promise<unknown>;
+        };
+    };
+    close?: () => Promise<void> | void;
+}>>;
+export declare const OPENCODE_SDK_PROVIDER: "opencode-sdk";
+export declare function parseModel(model: string, effort?: string): Readonly<{
+    providerID: string;
+    id: string;
+    variant?: string;
+}>;
+export type OpencodeRuntime = Readonly<{
+    client: {
+        v2: {
+            session: OpencodeSdkSession;
+            model?: Pick<OpencodeClient["v2"]["model"], "list">;
+        };
+        session?: {
+            fork(params: {
+                sessionID: string;
+                messageID: string;
+            }): Promise<unknown>;
+        };
+    };
+    close: () => Promise<void>;
+}>;
+export declare function loadOpencode(execution: ProviderExecution, cwd: string, signal: AbortSignal, loader?: OpencodeSdkLoader): Promise<OpencodeRuntime>;
+export declare function coordinate(sessionId: string): ResumeCoordinate;

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

@@ -0,0 +1,62 @@
+import net from "node:net";
+import { spawnDetachedProcess, putDownProcessTree } from "../../../runtime/proc/run.js";
+import { createOpencodeClient } from "@opencode-ai/sdk/v2";
+export const OPENCODE_SDK_PROVIDER = "opencode-sdk";
+export function parseModel(model, effort) {
+    const slash = model.indexOf("/");
+    if (slash <= 0 || slash === model.length - 1)
+        throw new Error("OpenCode model must be <provider>/<model>");
+    return { providerID: model.slice(0, slash), id: model.slice(slash + 1), ...(effort === undefined ? {} : { variant: effort }) };
+}
+async function waitReady(client, cwd, signal) {
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        if (signal.aborted)
+            throw new Error("OpenCode startup aborted");
+        try {
+            await client.v2.model.list({ location: { directory: cwd } }, { throwOnError: true });
+            return;
+        }
+        catch {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    throw new Error("OpenCode server did not become ready within 10000ms");
+}
+async function availablePort() {
+    return await new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            if (address === null || typeof address === "string") {
+                server.close();
+                reject(new Error("OpenCode port unavailable"));
+                return;
+            }
+            server.close((error) => error === undefined ? resolve(address.port) : reject(error));
+        });
+    });
+}
+export async function loadOpencode(execution, cwd, signal, loader) {
+    if (loader) {
+        const loaded = await loader(cwd);
+        return { client: loaded.client, close: async () => { await loaded.close?.(); } };
+    }
+    const port = await availablePort();
+    const collar = await spawnDetachedProcess({
+        argv: [execution.executable ?? "opencode", "serve", "--hostname", "127.0.0.1", "--port", String(port)],
+        cwd,
+        env: { ...process.env, ...(execution.env ?? {}) },
+        log: `${cwd}/.opencode.log`,
+    });
+    const client = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}`, directory: cwd });
+    try {
+        await waitReady(client, cwd, signal);
+    }
+    catch (error) {
+        await putDownProcessTree(collar);
+        throw error;
+    }
+    return { client, close: async () => { await putDownProcessTree(collar); } };
+}
+export function coordinate(sessionId) { return { sessionId }; }

package/build/src/akuma/providers/pi/events.d.ts

@@ -0,0 +1,33 @@
+import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
+import { type AgentEvent, type ToolCall } from "../../provider.js";
+export declare const PI_EVENT_DISPOSITIONS: {
+    readonly agent_end: "drop";
+    readonly agent_settled: "drop";
+    readonly agent_start: "drop";
+    readonly auto_retry_end: "drop";
+    readonly auto_retry_start: "note";
+    readonly compaction_end: "note";
+    readonly compaction_start: "drop";
+    readonly entry_appended: "drop";
+    readonly message_end: "message";
+    readonly message_start: "drop";
+    readonly message_update: "drop";
+    readonly queue_update: "drop";
+    readonly session_info_changed: "drop";
+    readonly thinking_level_changed: "drop";
+    readonly tool_execution_end: "tool-end";
+    readonly tool_execution_start: "tool-start";
+    readonly tool_execution_update: "drop";
+    readonly turn_end: "drop";
+    readonly turn_start: "drop";
+};
+export type PiEventState = {
+    answer: string;
+    assistantSeen: boolean;
+    tools: Map<string, Readonly<{
+        name: string;
+        call: ToolCall;
+    }>>;
+};
+export declare function translatePiEvent(event: AgentSessionEvent, state: PiEventState): readonly AgentEvent[];
+export declare function piTerminalFailure(messages: readonly unknown[]): string | null;

package/build/src/akuma/providers/pi/events.js

@@ -0,0 +1,128 @@
+import { noteEvent, unknownEvent } from "../../provider.js";
+export const PI_EVENT_DISPOSITIONS = {
+    agent_end: "drop",
+    agent_settled: "drop",
+    agent_start: "drop",
+    auto_retry_end: "drop",
+    auto_retry_start: "note",
+    compaction_end: "note",
+    compaction_start: "drop",
+    entry_appended: "drop",
+    message_end: "message",
+    message_start: "drop",
+    message_update: "drop",
+    queue_update: "drop",
+    session_info_changed: "drop",
+    thinking_level_changed: "drop",
+    tool_execution_end: "tool-end",
+    tool_execution_start: "tool-start",
+    tool_execution_update: "drop",
+    turn_end: "drop",
+    turn_start: "drop",
+};
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value : null;
+}
+function textContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.map((block) => {
+        const value = record(block);
+        return value?.type === "text" && typeof value.text === "string" ? value.text : "";
+    }).join("");
+}
+function hasTextContent(content) {
+    if (typeof content === "string")
+        return true;
+    return Array.isArray(content) && content.some((block) => {
+        const value = record(block);
+        return value?.type === "text" && typeof value.text === "string";
+    });
+}
+function toolCall(name, args) {
+    const value = record(args) ?? {};
+    if (name === "bash" && typeof value.command === "string")
+        return { kind: "run", command: value.command };
+    if (name === "read" && typeof value.path === "string")
+        return { kind: "read", path: value.path };
+    if ((name === "grep" || name === "find") && typeof (value.pattern ?? value.query) === "string") {
+        return { kind: "search", query: (value.pattern ?? value.query) };
+    }
+    if ((name === "edit" || name === "write") && typeof value.path === "string") {
+        return { kind: "fileChange", changes: [{ op: name === "write" ? "add" : "update", path: value.path }] };
+    }
+    return { kind: "other", display: name };
+}
+function translateNote(event) {
+    if (event.type === "auto_retry_start")
+        return [noteEvent(`Retrying request ${event.attempt}/${event.maxAttempts}: ${event.errorMessage}`)];
+    return event.errorMessage === undefined ? [] : [noteEvent(event.errorMessage)];
+}
+function translateToolStart(event, state) {
+    const call = toolCall(event.toolName, event.args);
+    state.tools.set(event.toolCallId, { name: event.toolName, call });
+    return [{ type: "tool", phase: "started", id: event.toolCallId, name: event.toolName, call }];
+}
+function translateToolEnd(event, state) {
+    const started = state.tools.get(event.toolCallId);
+    state.tools.delete(event.toolCallId);
+    const name = started?.name ?? event.toolName;
+    return [{
+            type: "tool", phase: "completed", id: event.toolCallId, name,
+            call: started?.call ?? { kind: "other", display: name },
+            result: { status: event.isError ? "error" : "ok" },
+        }];
+}
+function translateMessage(event, state) {
+    const message = record(event.message);
+    if (message?.role !== "assistant")
+        return [];
+    state.assistantSeen = true;
+    const translated = [];
+    if (Array.isArray(message.content)) {
+        for (const block of message.content) {
+            const value = record(block);
+            if (value?.type === "thinking" &&
+                value.redacted !== true &&
+                typeof value.thinking === "string" &&
+                value.thinking.trim().length > 0) {
+                translated.push({ type: "thought", text: value.thinking });
+            }
+        }
+    }
+    const text = textContent(message.content);
+    state.answer = text;
+    if (hasTextContent(message.content)) {
+        translated.push({ type: "assistant", text });
+    }
+    return translated;
+}
+export function translatePiEvent(event, state) {
+    const disposition = PI_EVENT_DISPOSITIONS[event.type];
+    if (disposition === "drop")
+        return [];
+    if (disposition === "note")
+        return translateNote(event);
+    if (disposition === "tool-start")
+        return translateToolStart(event, state);
+    if (disposition === "tool-end")
+        return translateToolEnd(event, state);
+    if (disposition === "message")
+        return translateMessage(event, state);
+    return [unknownEvent(event.type)];
+}
+export function piTerminalFailure(messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = record(messages[index]);
+        if (message?.role !== "assistant")
+            continue;
+        if (message.stopReason !== "error")
+            return null;
+        return typeof message.errorMessage === "string" && message.errorMessage.trim().length > 0
+            ? message.errorMessage : "Pi provider ended with an error";
+    }
+    return null;
+}