@astrosheep/keiyaku 4.0.0 → 4.0.1

package/build/src/akuma/provider.js

@@ -1,3 +1,4 @@
+import { decodeResumeCoordinate, encodeResumeCoordinate } from "./coordinate.js";
 export const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
 export const AGENT_EVENT_TEXT_LIMIT = 16_384;
 export const AGENT_THOUGHT_TEXT_LIMIT = 4_000;
@@ -14,6 +15,7 @@ function object(value) {
         ? value
         : null;
 }
+export { decodeResumeCoordinate, encodeResumeCoordinate };
 function optionText(options, field, blank) {
     const selected = options[field];
     if (selected === undefined)
@@ -106,27 +108,34 @@ function decodeToolResult(value) {
     };
 }
 function decodeToolEvent(event) {
+    if (event.truncated !== undefined && event.truncated !== true)
+        return null;
     if (typeof event.id !== "string" || typeof event.name !== "string")
         return null;
     const call = decodeToolCall(event.call);
     if (call !== null && event.phase === "started" && event.result === undefined) {
-        return { type: "tool", phase: "started", id: event.id, name: event.name, call };
+        return { type: "tool", phase: "started", id: event.id, name: event.name, call,
+            ...(event.truncated === true ? { truncated: true } : {}) };
     }
     const result = decodeToolResult(event.result);
     if (call !== null && event.phase === "completed" && result !== null) {
-        return { type: "tool", phase: "completed", id: event.id, name: event.name, call, result };
+        return { type: "tool", phase: "completed", id: event.id, name: event.name, call, result,
+            ...(event.truncated === true ? { truncated: true } : {}) };
     }
     return null;
 }
 function decodeTypedEvent(type, event) {
+    if (type !== "session" && event.truncated !== undefined && event.truncated !== true)
+        return null;
+    const truncated = event.truncated === true ? { truncated: true } : {};
     switch (type) {
         case "assistant":
-        case "thought": return typeof event.text === "string" ? { type, text: event.text } : null;
-        case "note": return typeof event.text === "string" ? { type, text: event.text } : null;
-        case "unknown": return typeof event.kind === "string" ? { type, kind: event.kind } : null;
+        case "thought": return typeof event.text === "string" ? { type, text: event.text, ...truncated } : null;
+        case "note": return typeof event.text === "string" ? { type, text: event.text, ...truncated } : null;
+        case "unknown": return typeof event.kind === "string" ? { type, kind: event.kind, ...truncated } : null;
         case "session": {
-            const coordinate = object(event.coordinate);
-            return typeof coordinate?.sessionId === "string" ? { type, coordinate: { sessionId: coordinate.sessionId } } : null;
+            const coordinate = decodeResumeCoordinate(event.coordinate);
+            return coordinate === null ? null : { type, coordinate };
         }
         case "tool": return decodeToolEvent(event);
         default: return type;
@@ -143,50 +152,61 @@ export function decodeAgentEvent(value) {
 }
 function boundedToolCall(call) {
     switch (call.kind) {
-        case "run": return { kind: call.kind, command: boundedEventText(call.command) };
-        case "read": return { kind: call.kind, path: boundedEventText(call.path) };
-        case "search": return { kind: call.kind, query: boundedEventText(call.query) };
+        case "run": return { value: { kind: call.kind, command: boundedEventText(call.command) }, truncated: call.command.length > AGENT_EVENT_TEXT_LIMIT };
+        case "read": return { value: { kind: call.kind, path: boundedEventText(call.path) }, truncated: call.path.length > AGENT_EVENT_TEXT_LIMIT };
+        case "search": return { value: { kind: call.kind, query: boundedEventText(call.query) }, truncated: call.query.length > AGENT_EVENT_TEXT_LIMIT };
         case "fileChange": return {
-            kind: call.kind,
-            changes: call.changes.map((change) => ({
-                ...change,
-                path: boundedEventText(change.path),
-            })),
+            value: {
+                kind: call.kind,
+                changes: call.changes.map((change) => ({ ...change, path: boundedEventText(change.path) })),
+            },
+            truncated: call.changes.some((change) => change.path.length > AGENT_EVENT_TEXT_LIMIT),
         };
-        case "other": return { kind: call.kind, display: boundedEventText(call.display) };
+        case "other": return { value: { kind: call.kind, display: boundedEventText(call.display) }, truncated: call.display.length > AGENT_EVENT_TEXT_LIMIT };
         default: return call;
     }
 }
 function boundedToolResult(result) {
     return {
-        status: result.status,
-        ...(result.message === undefined ? {} : { message: boundedEventText(result.message) }),
-        ...(result.exitCode === undefined ? {} : { exitCode: result.exitCode }),
+        value: {
+            status: result.status,
+            ...(result.message === undefined ? {} : { message: boundedEventText(result.message) }),
+            ...(result.exitCode === undefined ? {} : { exitCode: result.exitCode }),
+        },
+        truncated: result.message !== undefined && result.message.length > AGENT_EVENT_TEXT_LIMIT,
     };
 }
 export function encodeAgentEvent(event) {
+    const marked = (value, changed) => ({
+        ...value,
+        ...(changed || ("truncated" in event && event.truncated === true) ? { truncated: true } : {}),
+    });
     switch (event.type) {
-        case "session": return { type: event.type, coordinate: { sessionId: event.coordinate.sessionId } };
-        case "assistant": return { type: event.type, text: boundedEventText(event.text) };
-        case "thought": return { type: event.type, text: boundedThoughtText(event.text) };
-        case "note": return { type: event.type, text: boundedEventText(event.text) };
-        case "unknown": return { type: event.type, kind: boundedEventText(event.kind) };
-        case "tool": return event.phase === "started"
-            ? {
+        case "session": return { type: event.type, coordinate: encodeResumeCoordinate(event.coordinate) };
+        case "assistant": return marked({ type: event.type, text: boundedEventText(event.text) }, event.text.length > AGENT_EVENT_TEXT_LIMIT);
+        case "thought": return marked({ type: event.type, text: boundedThoughtText(event.text) }, event.text.length > AGENT_THOUGHT_TEXT_LIMIT);
+        case "note": return marked({ type: event.type, text: boundedEventText(event.text) }, event.text.length > AGENT_EVENT_TEXT_LIMIT);
+        case "unknown": return marked({ type: event.type, kind: boundedEventText(event.kind) }, event.kind.length > AGENT_EVENT_TEXT_LIMIT);
+        case "tool": {
+            const call = boundedToolCall(event.call);
+            const name = boundedEventText(event.name);
+            const result = event.phase === "completed" ? boundedToolResult(event.result) : undefined;
+            return marked(event.phase === "started" ? {
                 type: event.type,
                 id: event.id,
                 phase: event.phase,
-                name: boundedEventText(event.name),
-                call: boundedToolCall(event.call),
+                name,
+                call: call.value,
             }
-            : {
-                type: event.type,
-                id: event.id,
-                phase: event.phase,
-                name: boundedEventText(event.name),
-                call: boundedToolCall(event.call),
-                result: boundedToolResult(event.result),
-            };
+                : {
+                    type: event.type,
+                    id: event.id,
+                    phase: event.phase,
+                    name,
+                    call: call.value,
+                    result: result.value,
+                }, name !== event.name || call.truncated || result?.truncated === true);
+        }
         default: return event;
     }
 }
@@ -197,7 +217,7 @@ export function boundedThoughtText(value) {
     return value.slice(0, AGENT_THOUGHT_TEXT_LIMIT);
 }
 export function noteEvent(note) {
-    return { type: "note", text: boundedEventText(note.replace(/\s+/g, " ").trim()) };
+    return { type: "note", text: note.replace(/\s+/g, " ").trim() };
 }
 export function unknownEvent(kind) {
     return { type: "unknown", kind };

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,185 @@
+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;
+}
+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 toolCall(name, input) {
+    const value = object(input) ?? {};
+    const command = nonblank(value.command);
+    if (command !== undefined)
+        return { kind: "run", command };
+    const path = nonblank(value.file_path) ?? nonblank(value.path);
+    if (/^(?:read|view)/iu.test(name) && path !== undefined)
+        return { kind: "read", path };
+    const query = nonblank(value.query) ?? nonblank(value.pattern);
+    if (/search|grep|glob/iu.test(name) && query !== undefined)
+        return { kind: "search", query };
+    if (/write/iu.test(name) && path !== undefined)
+        return { kind: "fileChange", changes: [{ op: "add", path }] };
+    if (/edit|notebook/iu.test(name) && path !== undefined)
+        return { kind: "fileChange", changes: [{ op: "update", path }] };
+    return { 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);
+    }
+}

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

@@ -0,0 +1,46 @@
+import type { Options, Query, SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
+import { type ProviderAdapter, type ProviderOptions, type Session } from "../../provider.js";
+import type { ResumeCoordinate } from "../../provider.js";
+export { CLAUDE_MESSAGE_DISPOSITIONS, CLAUDE_SYSTEM_DISPOSITIONS } from "./events.js";
+type ClaudeExecution = Readonly<{
+    executable?: string;
+    env?: Readonly<Record<string, string>>;
+}>;
+export type ClaudeSdk = Readonly<{
+    query(input: Readonly<{
+        prompt: string | AsyncIterable<SDKUserMessage>;
+        options?: Options;
+    }>): Query;
+    forkSession?(sessionId: string, options: Readonly<{
+        dir: string;
+        upToMessageId: string;
+    }>): Promise<Readonly<{
+        sessionId: string;
+    }>>;
+}>;
+export declare function createClaudeProvider(load: () => Promise<ClaudeSdk>, execution?: ClaudeExecution): 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: 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>;
+}>;