@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/akuma/providers/acp/core.js

@@ -0,0 +1,159 @@
+import * as acp from "@agentclientprotocol/sdk";
+import { Readable, Writable } from "node:stream";
+import { spawnStdioProcess } from "../../../runtime/proc/stdio.js";
+import { abortable } from "../../abort.js";
+import { AgentEventChannel, } from "../../provider.js";
+import { EMPTY_ACP_EVENT_STATE, flushAcpEvents, mapAcpUpdate } from "./events.js";
+function diagnostic(error) {
+    if (!(error instanceof Error))
+        return String(error);
+    if (!(error instanceof acp.RequestError) || error.data === undefined)
+        return error.message;
+    let data;
+    try {
+        data = typeof error.data === "string" ? error.data : JSON.stringify(error.data);
+    }
+    catch {
+        data = String(error.data);
+    }
+    return data.length === 0 ? `${error.message} [${error.code}]` : `${error.message} [${error.code}]: ${data}`;
+}
+function createAcpClient(onUpdate) {
+    return acp.client({ name: "keiyaku" })
+        .onNotification(acp.methods.client.session.update, ({ params }) => onUpdate(params));
+}
+function promptResult(response) {
+    if (response.stopReason === "end_turn" || response.stopReason === "max_tokens"
+        || response.stopReason === "max_turn_requests") {
+        return { kind: "answered", answer: "" };
+    }
+    return { kind: "failed", diagnostic: `ACP prompt ended ${response.stopReason}` };
+}
+async function establishSession(agent, input) {
+    const initialized = await agent.request(acp.methods.agent.initialize, {
+        protocolVersion: acp.PROTOCOL_VERSION,
+        clientInfo: { name: "keiyaku", version: "4" },
+    });
+    if (input.session.kind === "resume" && initialized.agentCapabilities?.loadSession !== true) {
+        throw new Error("ACP agent does not advertise session/load");
+    }
+    if (input.session.kind === "fresh") {
+        return (await agent.request(acp.methods.agent.session.new, { cwd: input.cwd, mcpServers: [] })).sessionId;
+    }
+    const sessionId = input.session.coordinate.sessionId;
+    if (sessionId === undefined)
+        throw new Error("ACP resume coordinate has no session id");
+    await agent.request(acp.methods.agent.session.load, { cwd: input.cwd, mcpServers: [], sessionId });
+    return sessionId;
+}
+function createAcpTurn(connection) {
+    const events = new AgentEventChannel();
+    let state = EMPTY_ACP_EVENT_STATE;
+    let terminal = false;
+    let resolveCompletion;
+    const completion = new Promise((resolve) => { resolveCompletion = resolve; });
+    const update = (next) => {
+        if (terminal)
+            return;
+        const mapped = mapAcpUpdate(next, state);
+        state = mapped.state;
+        for (const event of mapped.events)
+            events.emit(event);
+    };
+    const finish = async (result, cleanup) => {
+        if (terminal)
+            return;
+        terminal = true;
+        let completionResult = result;
+        const failCleanup = (error) => {
+            completionResult = { kind: "failed", diagnostic: `ACP cleanup failed: ${diagnostic(error)}` };
+        };
+        try {
+            await cleanup();
+        }
+        catch (error) {
+            failCleanup(error);
+        }
+        try {
+            connection.close();
+        }
+        catch (error) {
+            failCleanup(error);
+        }
+        const flushed = flushAcpEvents(state);
+        for (const event of flushed.events)
+            events.emit(event);
+        events.end();
+        resolveCompletion(completionResult.kind === "answered"
+            ? { ...completionResult, answer: flushed.state.answer }
+            : completionResult);
+    };
+    return {
+        events,
+        completion,
+        update,
+        finish,
+        open: () => !terminal,
+    };
+}
+function beginAcpPrompt(agent, child, turn, sessionId, input) {
+    void agent.request(acp.methods.agent.session.prompt, {
+        sessionId,
+        prompt: [{ type: "text", text: input.body }, ...input.launchTells.map(({ text }) => ({ type: "text", text }))],
+    }).then((response) => turn.finish(promptResult(response), () => child.endInputAndDrain()), (error) => turn.finish({ kind: "failed", diagnostic: diagnostic(error) }, () => child.endInputAndDrain()));
+    void child.exited.then((exit) => turn.finish({
+        kind: "failed",
+        diagnostic: exit.stderr || `ACP process exited${exit.code === null ? "" : ` with code ${exit.code}`}`,
+    }, () => child.endInputAndDrain()));
+    return {
+        admission: { fence: sessionId },
+        events: turn.events,
+        completion: turn.completion,
+        abort: async () => {
+            let result = { kind: "failed", diagnostic: "ACP turn cancelled" };
+            try {
+                await agent.notify(acp.methods.agent.session.cancel, { sessionId });
+            }
+            catch (error) {
+                result = { kind: "failed", diagnostic: diagnostic(error) };
+            }
+            if (!turn.open())
+                await child.close(true);
+            else
+                await turn.finish(result, () => child.close(true));
+        },
+    };
+}
+export async function startAcpSession(launch, input, dependencies = {}) {
+    const signal = input.signal ?? new AbortController().signal;
+    signal.throwIfAborted();
+    const child = (dependencies.spawnProcess ?? spawnStdioProcess)({
+        argv: launch.argv,
+        cwd: input.cwd,
+        env: { ...globalThis.process.env, ...launch.env },
+    });
+    let sessionId;
+    let turn;
+    const connection = createAcpClient((notification) => {
+        if (notification.sessionId === sessionId)
+            turn.update(notification.update);
+    }).connect(acp.ndJsonStream(Writable.toWeb(child.input), Readable.toWeb(child.output)));
+    turn = createAcpTurn(connection);
+    try {
+        sessionId = await abortable(establishSession(connection.agent, input), signal);
+        turn.events.emit({ type: "session", coordinate: { sessionId } });
+        const session = beginAcpPrompt(connection.agent, child, turn, sessionId, input);
+        return { session, agent: connection.agent, sessionId, open: turn.open };
+    }
+    catch (error) {
+        connection.close(error);
+        try {
+            await child.close(true);
+        }
+        catch (cleanup) {
+            throw new Error(`${diagnostic(error)}; ACP cleanup failed: ${diagnostic(cleanup)}`, { cause: error });
+        }
+        turn.events.end();
+        throw error;
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { SessionUpdate } from "@agentclientprotocol/sdk";
+import { type AgentEvent } from "../../provider.js";
+type OpenBlock = Readonly<{
+    type: "assistant" | "thought";
+    text: string;
+}> | null;
+export type AcpEventState = Readonly<{
+    answer: string;
+    assistantMessageId: string | null;
+    open: OpenBlock;
+    tools: ReadonlyMap<string, string>;
+}>;
+type AcpEventMapping = Readonly<{
+    events: readonly AgentEvent[];
+    state: AcpEventState;
+}>;
+export declare const EMPTY_ACP_EVENT_STATE: AcpEventState;
+export declare function flushAcpEvents(state: AcpEventState, boundary?: readonly AgentEvent[]): AcpEventMapping;
+export declare function mapAcpUpdate(update: SessionUpdate, previous: AcpEventState): AcpEventMapping;
+export {};

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

@@ -0,0 +1,73 @@
+import { noteEvent, unknownEvent } from "../../provider.js";
+export const EMPTY_ACP_EVENT_STATE = Object.freeze({
+    answer: "",
+    assistantMessageId: null,
+    open: null,
+    tools: new Map(),
+});
+export function flushAcpEvents(state, boundary = []) {
+    const events = state.open === null ? boundary : [{ type: state.open.type, text: state.open.text }, ...boundary];
+    return {
+        events,
+        state: state.open === null ? state : { ...state, open: null },
+    };
+}
+function appendBlock(state, type, text, messageId) {
+    const newAssistantMessage = type === "assistant"
+        && messageId !== undefined
+        && state.assistantMessageId !== messageId;
+    const flushed = state.open === null || (state.open.type === type && !newAssistantMessage)
+        ? { events: [], state }
+        : flushAcpEvents(state);
+    return {
+        events: flushed.events,
+        state: {
+            ...flushed.state,
+            answer: type === "assistant"
+                ? `${newAssistantMessage ? "" : flushed.state.answer}${text}`
+                : flushed.state.answer,
+            assistantMessageId: type === "assistant" && messageId !== undefined
+                ? messageId
+                : flushed.state.assistantMessageId,
+            open: { type, text: `${flushed.state.open?.text ?? ""}${text}` },
+        },
+    };
+}
+export function mapAcpUpdate(update, previous) {
+    switch (update.sessionUpdate) {
+        case "agent_message_chunk":
+        case "agent_thought_chunk": {
+            const text = update.content.type === "text" ? update.content.text : undefined;
+            if (text === undefined)
+                return flushAcpEvents(previous, [unknownEvent(`${update.sessionUpdate}/${update.content.type}`)]);
+            return appendBlock(previous, update.sessionUpdate === "agent_message_chunk" ? "assistant" : "thought", text, update.sessionUpdate === "agent_message_chunk" && update.messageId !== null
+                ? update.messageId
+                : undefined);
+        }
+        case "user_message_chunk": return flushAcpEvents(previous);
+        case "tool_call":
+        case "tool_call_update": {
+            const name = update.title ?? (update.sessionUpdate === "tool_call" ? undefined : previous.tools.get(update.toolCallId)) ?? "ACP tool";
+            const observed = { name, call: { kind: "other", display: name } };
+            const tools = new Map(previous.tools);
+            if (update.status === "completed" || update.status === "failed") {
+                tools.delete(update.toolCallId);
+                return flushAcpEvents({ ...previous, tools }, [{ type: "tool", phase: "completed", id: update.toolCallId, ...observed, result: { status: update.status === "completed" ? "ok" : "error" } }]);
+            }
+            const started = tools.has(update.toolCallId);
+            tools.set(update.toolCallId, name);
+            return started
+                ? flushAcpEvents({ ...previous, tools })
+                : flushAcpEvents({ ...previous, tools }, [{ type: "tool", phase: "started", id: update.toolCallId, ...observed }]);
+        }
+        case "plan": return flushAcpEvents(previous, [noteEvent(`Plan updated: ${update.entries.map((entry) => entry.content).join("; ")}`)]);
+        case "available_commands_update": return flushAcpEvents(previous, [noteEvent("ACP commands updated")]);
+        case "current_mode_update": return flushAcpEvents(previous, [noteEvent("ACP mode updated")]);
+        case "config_option_update": return flushAcpEvents(previous, [noteEvent("ACP configuration updated")]);
+        case "session_info_update": return flushAcpEvents(previous, [noteEvent("ACP session metadata updated")]);
+        case "usage_update": return flushAcpEvents(previous);
+        case "plan_update":
+        case "plan_removed": return flushAcpEvents(previous, [unknownEvent(update.sessionUpdate)]);
+        default: return { events: [unknownEvent(String(update.sessionUpdate))], state: previous };
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { ProviderAdapter } from "../../provider.js";
+import type { ProviderExecution } from "../../provider-recipe.js";
+import { type AcpDependencies } from "./core.js";
+export type AcpExecutionConfig = Readonly<{
+    argvBefore: readonly string[];
+    argvAfter: readonly string[];
+    modelArg?: string;
+    effortArg?: string;
+    systemPromptArg?: string;
+}>;
+export declare function decodeAcpConfig(value: unknown): AcpExecutionConfig;
+export declare function createAcpProvider(execution: ProviderExecution, dependencies?: AcpDependencies): ProviderAdapter;

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

@@ -0,0 +1,94 @@
+import { startAcpSession } from "./core.js";
+function argumentName(value, key) {
+    const selected = value[key];
+    if (selected === undefined)
+        return undefined;
+    if (typeof selected !== "string" || selected.trim().length === 0) {
+        throw new TypeError(`ACP provider config ${key} must be a nonblank string`);
+    }
+    return selected;
+}
+export function decodeAcpConfig(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new TypeError("ACP provider config must be an object");
+    }
+    const config = value;
+    const unknown = Object.keys(config)
+        .find((key) => !["argvBefore", "argvAfter", "effortArg", "modelArg", "systemPromptArg"].includes(key));
+    if (unknown !== undefined)
+        throw new TypeError(`ACP provider config has unknown field ${unknown}`);
+    if (!Array.isArray(config.argvBefore)
+        || config.argvBefore.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
+        throw new TypeError("ACP provider config argvBefore must be an array of nonblank strings");
+    }
+    if (!Array.isArray(config.argvAfter)
+        || config.argvAfter.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
+        throw new TypeError("ACP provider config argvAfter must be an array of nonblank strings");
+    }
+    const modelArg = argumentName(config, "modelArg");
+    const effortArg = argumentName(config, "effortArg");
+    const systemPromptArg = argumentName(config, "systemPromptArg");
+    return Object.freeze({
+        argvBefore: Object.freeze([...config.argvBefore]),
+        argvAfter: Object.freeze([...config.argvAfter]),
+        ...(modelArg === undefined ? {} : { modelArg }),
+        ...(effortArg === undefined ? {} : { effortArg }),
+        ...(systemPromptArg === undefined ? {} : { systemPromptArg }),
+    });
+}
+function optionAdmission(options, config) {
+    if (options.network !== undefined) {
+        return { kind: "refused", diagnostic: "ACP provider does not support the network option" };
+    }
+    if (options.model !== undefined && config.modelArg === undefined) {
+        return { kind: "refused", diagnostic: "ACP provider has no model argument mapping" };
+    }
+    if (options.effort !== undefined && config.effortArg === undefined) {
+        return { kind: "refused", diagnostic: "ACP provider has no effort argument mapping" };
+    }
+    if (options.systemPrompt !== undefined && options.systemPrompt.length > 0 && config.systemPromptArg === undefined) {
+        return { kind: "refused", diagnostic: "ACP provider has no systemPrompt argument mapping" };
+    }
+    return {
+        kind: "admitted",
+        options,
+        ...(options.readonly === undefined ? {} : {
+            readonly: {
+                enforcement: "none",
+                diagnostic: "ACP cannot remove task-surface mutation capabilities",
+            },
+        }),
+    };
+}
+function argv(execution, config, options) {
+    if (execution.executable === undefined)
+        throw new Error("ACP provider execution requires executable");
+    const values = [execution.executable, ...config.argvBefore];
+    if (options.model !== undefined)
+        values.push(config.modelArg, options.model);
+    if (options.effort !== undefined)
+        values.push(config.effortArg, options.effort);
+    if (options.systemPrompt !== undefined && config.systemPromptArg !== undefined) {
+        values.push(config.systemPromptArg, options.systemPrompt);
+    }
+    values.push(...config.argvAfter);
+    return values;
+}
+export function createAcpProvider(execution, dependencies = {}) {
+    if (execution.executable === undefined)
+        throw new TypeError("ACP provider execution requires executable");
+    const config = decodeAcpConfig(execution.config);
+    const drive = async (input) => {
+        const launch = {
+            argv: argv(execution, config, input.options),
+            ...(execution.env === undefined ? {} : { env: execution.env }),
+        };
+        return (await startAcpSession(launch, input, dependencies)).session;
+    };
+    return {
+        confinement: () => ({ kind: "unconfined" }),
+        admitOptions: (options) => optionAdmission(options, config),
+        start: async (input) => await drive(input),
+        resume: async (input) => await drive(input),
+    };
+}

package/build/src/akuma/providers/{claude.d.ts → claude/events.d.ts}

@@ -1,5 +1,11 @@
-import type { Options, Query } from "@anthropic-ai/claude-agent-sdk";
-import { type Drive, type ProviderAdapter, type ProviderOptions } from "../provider.js";
+import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+import { AgentEventChannel, type ToolCall } from "../../provider.js";
+export type ClaudeObservationState = {
+    tools: Map<string, Readonly<{
+        name: string;
+        call: ToolCall;
+    }>>;
+};
 export declare const CLAUDE_MESSAGE_DISPOSITIONS: {
     readonly assistant: "assistant";
     readonly auth_status: "auth";
@@ -43,42 +49,4 @@ export declare const CLAUDE_SYSTEM_DISPOSITIONS: {
     readonly thinking_tokens: "drop";
     readonly worker_shutting_down: "note";
 };
-export type ClaudeSdk = Readonly<{
-    query(input: Readonly<{
-        prompt: string;
-        options?: Options;
-    }>): Query;
-    forkSession?(sessionId: string, options: Readonly<{
-        dir: string;
-        upToMessageId: string;
-    }>): Promise<Readonly<{
-        sessionId: string;
-    }>>;
-}>;
-export declare function createClaudeProvider(load: () => Promise<ClaudeSdk>, execution?: Readonly<{
-    executable?: string;
-    env?: Readonly<Record<string, string>>;
-}>): ProviderAdapter;
-export declare const claudeProvider: Readonly<{
-    confinement(input: Readonly<{
-        cwd: string;
-        options: ProviderOptions;
-    }>): import("../index.js").Confinement;
-    admitOptions(options: ProviderOptions): import("../provider.js").ProviderOptionAdmission;
-    fork?(input: Readonly<{
-        session: import("../provider.js").ResumeCoordinate;
-        at: string;
-        cwd: string;
-    }>): Promise<Readonly<{
-        session: import("../provider.js").ResumeCoordinate;
-    }>>;
-    start(input: Readonly<{
-        prompt: string;
-        cwd: string;
-        options: ProviderOptions;
-        session?: import("../provider.js").ResumeCoordinate;
-        requests?: Readonly<{
-            dir: string;
-        }>;
-    }>): Promise<Drive>;
-}>;
+export declare function emitClaudeMessage(message: SDKMessage, events: AgentEventChannel, state: ClaudeObservationState): void;

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

@@ -0,0 +1,238 @@
+import { noteEvent, unknownEvent, } from "../../provider.js";
+export const CLAUDE_MESSAGE_DISPOSITIONS = {
+    assistant: "assistant",
+    auth_status: "auth",
+    conversation_reset: "note",
+    prompt_suggestion: "drop",
+    rate_limit_event: "drop",
+    result: "terminal",
+    stream_event: "drop",
+    system: "system",
+    tool_progress: "drop",
+    tool_use_summary: "drop",
+    user: "tool-results",
+};
+export const CLAUDE_SYSTEM_DISPOSITIONS = {
+    api_retry: "note",
+    background_tasks_changed: "note",
+    commands_changed: "drop",
+    compact_boundary: "drop",
+    control_request_progress: "control-progress",
+    elicitation_complete: "drop",
+    files_persisted: "note",
+    hook_progress: "drop",
+    hook_response: "drop",
+    hook_started: "note",
+    informational: "note",
+    init: "drop",
+    local_command_output: "drop",
+    memory_recall: "drop",
+    mirror_error: "note",
+    model_refusal_fallback: "note",
+    model_refusal_no_fallback: "note",
+    notification: "note",
+    permission_denied: "note",
+    plugin_install: "note",
+    session_state_changed: "drop",
+    status: "note",
+    task_notification: "note",
+    task_progress: "note",
+    task_started: "note",
+    task_updated: "note",
+    thinking_tokens: "drop",
+    worker_shutting_down: "note",
+};
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function nonblank(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function number(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function positiveLine(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;
+}
+function readRange(value) {
+    const offset = positiveLine(value.offset);
+    const limit = positiveLine(value.limit);
+    return {
+        ...(offset === undefined ? {} : { offset }),
+        ...(limit === undefined ? {} : { limit }),
+    };
+}
+function contentSearch(value, query) {
+    const path = nonblank(value.path);
+    const glob = nonblank(value.glob);
+    return {
+        kind: "search",
+        query,
+        scope: "content",
+        ...(path === undefined ? {} : { path }),
+        ...(glob === undefined ? {} : { glob }),
+    };
+}
+const CLAUDE_SYSTEM_NOTES = {
+    api_retry: (message) => {
+        const attempt = number(message.attempt);
+        const maximum = number(message.max_retries);
+        return attempt === undefined || maximum === undefined
+            ? "Retrying request"
+            : `Retrying request ${attempt}/${maximum}`;
+    },
+    background_tasks_changed: (message) => `Background tasks: ${Array.isArray(message.tasks) ? message.tasks.length : 0}`,
+    files_persisted: (message) => {
+        const files = Array.isArray(message.files) ? message.files.length : 0;
+        const failed = Array.isArray(message.failed) ? message.failed.length : 0;
+        return failed === 0 ? `Persisted ${files} files` : `Persisted ${files} files; ${failed} failed`;
+    },
+    hook_started: (message) => `Hook ${nonblank(message.hook_name) ?? "unknown"} started`,
+    informational: (message) => nonblank(message.content) ?? "Informational notice",
+    mirror_error: (message) => `Transcript mirror warning: ${nonblank(message.error) ?? nonblank(message.message) ?? "unknown error"}`,
+    model_refusal_fallback: () => "Model refusal; using fallback",
+    model_refusal_no_fallback: () => "Model refusal; no fallback available",
+    notification: (message) => nonblank(message.message) ?? nonblank(message.content) ?? "Notification",
+    permission_denied: (message) => `Permission refused${nonblank(message.message) === undefined ? "" : `: ${nonblank(message.message)}`}`,
+    plugin_install: (message) => `Plugin install ${nonblank(message.status) ?? "updated"}${nonblank(message.name) === undefined ? "" : `: ${nonblank(message.name)}`}`,
+    status: (message) => `Status: ${nonblank(message.status) ?? "idle"}${nonblank(message.error) === undefined ? "" : ` (${nonblank(message.error)})`}`,
+    task_notification: (message) => `Task ${nonblank(message.task_id) ?? "unknown"} ${nonblank(message.status) ?? "updated"}`,
+    task_progress: (message) => nonblank(message.description) ?? `Task ${nonblank(message.task_id) ?? "unknown"} progressed`,
+    task_started: (message) => nonblank(message.description) ?? `Task ${nonblank(message.task_id) ?? "unknown"} started`,
+    task_updated: (message) => `Task ${nonblank(message.task_id) ?? "unknown"} updated`,
+    worker_shutting_down: (message) => `Worker stopping: ${nonblank(message.reason) ?? "unknown reason"}`,
+};
+function runCall(name, value) {
+    if (name !== "Bash")
+        return undefined;
+    const command = nonblank(value.command);
+    return command === undefined ? { kind: "other", display: name } : { kind: "run", command };
+}
+function readCall(name, path, value) {
+    return name === "Read" && path !== undefined ? { kind: "read", path, ...readRange(value) } : undefined;
+}
+function searchCall(name, value) {
+    if (name === "Grep") {
+        const query = nonblank(value.pattern) ?? nonblank(value.query);
+        return query === undefined ? undefined : contentSearch(value, query);
+    }
+    if (name === "Glob") {
+        const query = nonblank(value.pattern);
+        const globPath = nonblank(value.path);
+        return query === undefined
+            ? undefined
+            : { kind: "search", query, scope: "files", ...(globPath === undefined ? {} : { path: globPath }) };
+    }
+    if (name === "WebSearch") {
+        const query = nonblank(value.query);
+        return query === undefined ? undefined : { kind: "search", query, scope: "web" };
+    }
+    return undefined;
+}
+function fileChangeCall(name, path) {
+    if (path === undefined)
+        return undefined;
+    if (name === "Write")
+        return { kind: "fileChange", changes: [{ op: "add", path }] };
+    if (name === "Edit" || name === "NotebookEdit") {
+        return { kind: "fileChange", changes: [{ op: "update", path }] };
+    }
+    return undefined;
+}
+function toolCall(name, input) {
+    const value = object(input) ?? {};
+    const run = runCall(name, value);
+    if (run !== undefined)
+        return run;
+    const path = nonblank(value.file_path) ?? (name === "Read" ? nonblank(value.path) : undefined);
+    return readCall(name, path, value)
+        ?? searchCall(name, value)
+        ?? fileChangeCall(name, path)
+        ?? { kind: "other", display: name };
+}
+function assistantEvents(message, events, state) {
+    if (message.aborted === true)
+        return;
+    if (message.error !== undefined) {
+        events.emit(noteEvent(`Assistant error: ${message.error}`));
+        return;
+    }
+    const text = message.message.content
+        .filter((block) => block.type === "text")
+        .map((block) => block.text).join("");
+    if (text.length > 0)
+        events.emit({ type: "assistant", text });
+    for (const block of message.message.content) {
+        const value = object(block);
+        if (value?.type === "thinking" && typeof value.thinking === "string" && value.thinking.trim().length > 0) {
+            events.emit({ type: "thought", text: value.thinking });
+            continue;
+        }
+        if (block.type !== "tool_use")
+            continue;
+        const call = toolCall(block.name, block.input);
+        state.tools.set(block.id, { name: block.name, call });
+        events.emit({ type: "tool", phase: "started", id: block.id, name: block.name, call });
+    }
+}
+function toolResultEvents(message, events, state) {
+    const content = object(message.message)?.content;
+    if (!Array.isArray(content))
+        return;
+    for (const block of content) {
+        const value = object(block);
+        if (value?.type !== "tool_result")
+            continue;
+        const id = nonblank(value.tool_use_id);
+        if (id === undefined)
+            continue;
+        const observed = state.tools.get(id);
+        if (observed === undefined)
+            continue;
+        state.tools.delete(id);
+        events.emit({
+            type: "tool", phase: "completed", id, name: observed.name, call: observed.call,
+            result: { status: value.is_error === true ? "error" : "ok" },
+        });
+    }
+}
+function emitSystemMessage(value, events) {
+    const subtype = nonblank(value?.subtype) ?? "unknown";
+    if (!Object.hasOwn(CLAUDE_SYSTEM_DISPOSITIONS, subtype)) {
+        events.emit(unknownEvent(subtype));
+        return;
+    }
+    const systemDisposition = CLAUDE_SYSTEM_DISPOSITIONS[subtype];
+    if (systemDisposition === "drop")
+        return;
+    if (systemDisposition === "control-progress" && value?.status !== "api_retry")
+        return;
+    const note = CLAUDE_SYSTEM_NOTES[subtype];
+    events.emit(noteEvent(note?.(value ?? {}) ?? subtype));
+}
+export function emitClaudeMessage(message, events, state) {
+    const value = object(message) ?? {};
+    const kind = nonblank(value.type) ?? "unknown";
+    if (!Object.hasOwn(CLAUDE_MESSAGE_DISPOSITIONS, kind))
+        return events.emit(unknownEvent(kind));
+    const disposition = CLAUDE_MESSAGE_DISPOSITIONS[kind];
+    if (disposition === "assistant") {
+        assistantEvents(message, events, state);
+    }
+    else if (disposition === "tool-results") {
+        toolResultEvents(message, events, state);
+    }
+    else if (disposition === "auth") {
+        const error = nonblank(value.error);
+        if (error !== undefined)
+            events.emit(noteEvent(`Authentication warning: ${error}`));
+    }
+    else if (disposition === "note") {
+        events.emit(noteEvent("Conversation reset"));
+    }
+    else if (disposition === "system") {
+        emitSystemMessage(value, events);
+    }
+}