@astrosheep/keiyaku 4.0.0 → 4.0.2

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

@@ -0,0 +1,47 @@
+import type { Options, Query, SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
+import { type ProviderAdapter, type Session } from "../../provider.js";
+import type { ProviderOptions } from "../../provider-recipe.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>;
+}>;

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

@@ -0,0 +1,279 @@
+import { randomUUID } from "node:crypto";
+import { abortable } from "../../abort.js";
+import { AgentEventChannel, } from "../../provider.js";
+import { emitClaudeMessage, } from "./events.js";
+import { claudeUserMessage, createClaudeInput, isClaudeTurnEnded } from "./input.js";
+export { CLAUDE_MESSAGE_DISPOSITIONS, CLAUDE_SYSTEM_DISPOSITIONS } from "./events.js";
+class ReceiptChannel {
+    queued = [];
+    waiters = [];
+    ended = false;
+    emit(receipt) {
+        if (this.ended)
+            throw new Error("Claude receipt stream already ended");
+        const waiter = this.waiters.shift();
+        if (waiter === undefined)
+            this.queued.push(receipt);
+        else
+            waiter.resolve({ done: false, value: receipt });
+    }
+    end() {
+        if (this.ended)
+            return;
+        this.ended = true;
+        for (const waiter of this.waiters.splice(0))
+            waiter.resolve({ done: true, value: undefined });
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                const receipt = this.queued.shift();
+                if (receipt !== undefined)
+                    return Promise.resolve({ done: false, value: receipt });
+                if (this.ended)
+                    return Promise.resolve({ done: true, value: undefined });
+                return new Promise((resolve) => this.waiters.push({ resolve }));
+            },
+        };
+    }
+}
+function admitClaudeOptions(options) {
+    if (options.network !== undefined) {
+        return { kind: "refused", diagnostic: "Claude provider does not support the network option" };
+    }
+    return {
+        kind: "admitted",
+        options: Object.freeze({ ...options }),
+        ...(options.readonly === undefined ? {} : { readonly: { enforcement: "native" } }),
+    };
+}
+function permissionMode(readonly) {
+    return readonly === true ? "plan" : "bypassPermissions";
+}
+function claudeSessionId(coordinate) {
+    if (!("sessionId" in coordinate) || coordinate.sessionId === undefined) {
+        throw new Error("Claude resume requires sessionId");
+    }
+    return coordinate.sessionId;
+}
+function claudeQueryOptions(input, execution, abortController) {
+    const mode = permissionMode(input.options.readonly);
+    return {
+        cwd: input.cwd,
+        abortController,
+        ...(execution.executable === undefined ? {} : { pathToClaudeCodeExecutable: execution.executable }),
+        ...(execution.env === undefined ? {} : { env: { ...process.env, ...execution.env } }),
+        permissionMode: mode,
+        ...(mode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
+        settingSources: ["user", "project", "local"],
+        ...(input.options.model === undefined ? {} : { model: input.options.model }),
+        ...(input.options.effort === undefined ? {} : { effort: input.options.effort }),
+        ...(input.options.systemPrompt === undefined || input.options.systemPrompt.length === 0 ? {} : {
+            systemPrompt: { type: "preset", preset: "claude_code", append: input.options.systemPrompt },
+        }),
+        ...(input.session.kind === "fresh" ? {} : { resume: claudeSessionId(input.session.coordinate) }),
+    };
+}
+async function forkClaude(load, execution, input) {
+    const sessionId = claudeSessionId(input.session);
+    if (execution.env !== undefined)
+        throw new Error("Claude fork cannot apply the frozen provider environment");
+    const sdk = await load();
+    if (sdk.forkSession === undefined)
+        throw new Error("Claude SDK does not expose forkSession");
+    const forked = await sdk.forkSession(sessionId, { dir: input.cwd, upToMessageId: input.at });
+    if (forked.sessionId.trim().length === 0)
+        throw new Error("Claude fork returned an empty child session id");
+    if (forked.sessionId === sessionId)
+        throw new Error("Claude fork reused the source session id");
+    return { session: { sessionId: forked.sessionId } };
+}
+function launchText(input) {
+    return [input.body, ...input.launchTells.map((tell) => tell.text)]
+        .filter((part) => part.length > 0).join("\n\n");
+}
+function successfulResult(message, historyId) {
+    return {
+        kind: "answered",
+        answer: message.subtype === "success" ? message.result : "",
+        ...(historyId === undefined ? {} : { historyId }),
+    };
+}
+function finishClaudeInput(input, terminal) {
+    if (terminal?.kind === "answered")
+        input.end();
+    else
+        input.close();
+}
+function observeClaudeQuery(context) {
+    const { query, input, events, receipts, accepted, state } = context;
+    const observation = { tools: new Map() };
+    let admit;
+    let rejectAdmission;
+    const admission = new Promise((resolve, reject) => { admit = resolve; rejectAdmission = reject; });
+    let settle;
+    const completion = new Promise((resolve) => { settle = resolve; });
+    let checkpoint = 0, ended = false;
+    const settleReceipts = () => {
+        if (ended && state.openSubmissions === 0 && accepted.every((tell) => tell.visible))
+            receipts.end();
+    };
+    const flushReceipts = () => {
+        for (let index = 0; index < accepted.length;) {
+            const tell = accepted[index];
+            if (!tell.visible || tell.afterCheckpoint >= checkpoint) {
+                index += 1;
+                continue;
+            }
+            accepted.splice(index, 1);
+            receipts.emit({ evidence: "exact", tellId: tell.id, kind: "consumed" });
+        }
+        closeWhenIdle();
+        settleReceipts();
+    };
+    const closeWhenIdle = () => {
+        if (state.openSubmissions === 0 && accepted.length === 0 && input.pending === 0)
+            input.close();
+    };
+    void (async () => {
+        let admitted = false;
+        let terminal = null;
+        let historyId;
+        try {
+            for await (const message of query) {
+                if (!admitted && "session_id" in message && typeof message.session_id === "string") {
+                    admitted = true;
+                    events.emit({ type: "session", coordinate: { sessionId: message.session_id } });
+                    admit();
+                }
+                emitClaudeMessage(message, events, observation);
+                if (message.type === "assistant" && message.parent_tool_use_id === null
+                    && typeof message.uuid === "string" && message.uuid.length > 0)
+                    historyId = message.uuid;
+                if (message.type !== "result")
+                    continue;
+                if (message.subtype === "success") {
+                    terminal = successfulResult(message, historyId);
+                    checkpoint += 1;
+                    flushReceipts();
+                    queueMicrotask(closeWhenIdle);
+                }
+                else {
+                    terminal = { kind: "failed", diagnostic: message.errors.join("; ") || message.subtype };
+                    input.close();
+                }
+            }
+            ended = true;
+            const result = terminal ?? { kind: "failed", diagnostic: "Claude query ended without a result" };
+            if (!admitted)
+                rejectAdmission(new Error(result.kind === "failed" ? result.diagnostic : "Claude query ended before session admission"));
+            settle(result);
+        }
+        catch (error) {
+            ended = true;
+            input.fail(error);
+            const failure = error instanceof Error ? error : new Error(String(error));
+            if (!admitted)
+                rejectAdmission(failure);
+            settle({ kind: "failed", diagnostic: failure.message });
+        }
+        finally {
+            finishClaudeInput(input, terminal);
+            events.end();
+            settleReceipts();
+        }
+    })();
+    return {
+        admission,
+        completion,
+        get ended() { return ended; },
+        get checkpoint() { return checkpoint; },
+        flushReceipts,
+        settleReceipts,
+    };
+}
+async function driveClaude(load, execution, drive) {
+    if (drive.session.kind === "resume")
+        claudeSessionId(drive.session.coordinate);
+    const signal = drive.signal ?? new AbortController().signal;
+    signal.throwIfAborted();
+    const sdk = await abortable(load(), signal);
+    signal.throwIfAborted();
+    const events = new AgentEventChannel();
+    const receipts = new ReceiptChannel();
+    const input = createClaudeInput();
+    const abortController = new AbortController();
+    const run = randomUUID();
+    const accepted = [];
+    let submission = 0;
+    let openSubmissions = 0;
+    const launchAcknowledged = input.push(claudeUserMessage(launchText(drive)));
+    const query = sdk.query({
+        prompt: input.iterable,
+        options: claudeQueryOptions(drive, execution, abortController),
+    });
+    const shutDown = (error) => {
+        abortController.abort(error);
+        input.fail(error);
+        query.close();
+    };
+    const abortSetup = () => shutDown(signal.reason);
+    signal.addEventListener("abort", abortSetup, { once: true });
+    const observed = observeClaudeQuery({
+        query, input, events, receipts, accepted,
+        state: { get openSubmissions() { return openSubmissions; } },
+    });
+    try {
+        await Promise.all([launchAcknowledged, observed.admission]);
+    }
+    finally {
+        signal.removeEventListener("abort", abortSetup);
+    }
+    return {
+        admission: { fence: `claude:${run}:0` },
+        events,
+        receipts,
+        completion: observed.completion,
+        tell(tell) {
+            if (observed.ended || input.closed)
+                return Promise.resolve({ kind: "turn-ended" });
+            openSubmissions += 1;
+            const ordinal = ++submission;
+            return new Promise((resolve, reject) => {
+                const pending = { id: tell.id, afterCheckpoint: 0, visible: false };
+                void input.push(claudeUserMessage(tell.text), () => {
+                    pending.afterCheckpoint = observed.checkpoint;
+                    accepted.push(pending);
+                }).then(() => {
+                    openSubmissions -= 1;
+                    resolve({ kind: "accepted", fence: `claude:${run}:${ordinal}` });
+                    queueMicrotask(() => {
+                        pending.visible = true;
+                        observed.flushReceipts();
+                        observed.settleReceipts();
+                    });
+                }, (error) => {
+                    openSubmissions -= 1;
+                    if (isClaudeTurnEnded(error))
+                        resolve({ kind: "turn-ended" });
+                    else
+                        reject(error);
+                    observed.settleReceipts();
+                });
+            });
+        },
+        async abort() {
+            shutDown(new Error("Claude query aborted"));
+        },
+    };
+}
+export function createClaudeProvider(load, execution = {}) {
+    return {
+        confinement: () => ({ kind: "unconfined" }),
+        admitOptions: admitClaudeOptions,
+        fork: (input) => forkClaude(load, execution, input),
+        start: (input) => driveClaude(load, execution, input),
+        resume: (input) => driveClaude(load, execution, input),
+    };
+}
+export const claudeProvider = createClaudeProvider(async () => await import("@anthropic-ai/claude-agent-sdk"));

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

@@ -0,0 +1,13 @@
+import type { SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
+export declare function isClaudeTurnEnded(error: unknown): boolean;
+export type ClaudeInput = Readonly<{
+    iterable: AsyncIterable<SDKUserMessage>;
+    get closed(): boolean;
+    get pending(): number;
+    push(message: SDKUserMessage, onPulled?: () => void): Promise<void>;
+    end(): void;
+    close(): void;
+    fail(error: unknown): void;
+}>;
+export declare function claudeUserMessage(text: string): SDKUserMessage;
+export declare function createClaudeInput(): ClaudeInput;

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

@@ -0,0 +1,109 @@
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((accept, refuse) => {
+        resolve = accept;
+        reject = refuse;
+    });
+    return { promise, resolve, reject };
+}
+function ended() {
+    return new Error("Claude input ended before the SDK acknowledged the message");
+}
+const turnEnded = Symbol("claude-turn-ended");
+class ClaudeTurnEndedError extends Error {
+    [turnEnded] = true;
+}
+function turnEndedError() {
+    return new ClaudeTurnEndedError("Claude query ended before the SDK acknowledged the message");
+}
+export function isClaudeTurnEnded(error) {
+    return typeof error === "object" && error !== null && error[turnEnded] === true;
+}
+export function claudeUserMessage(text) {
+    return {
+        type: "user",
+        message: { role: "user", content: text },
+        parent_tool_use_id: null,
+    };
+}
+export function createClaudeInput() {
+    const queue = [];
+    const waiters = [];
+    let previous;
+    let failure;
+    let closed = false;
+    const acknowledgePrevious = () => {
+        previous?.onPulled?.();
+        previous?.pulled.resolve();
+        previous = undefined;
+    };
+    const take = (entry) => {
+        previous = entry;
+        return { done: false, value: entry.message };
+    };
+    const rejectUnresolved = (error) => {
+        previous?.pulled.reject(error);
+        previous = undefined;
+        for (const entry of queue.splice(0))
+            entry.pulled.reject(error);
+    };
+    return {
+        get closed() { return closed; },
+        get pending() { return queue.length + (previous === undefined ? 0 : 1); },
+        push(message, onPulled) {
+            if (closed)
+                return Promise.reject(failure ?? ended());
+            const entry = { message, pulled: deferred(), ...(onPulled === undefined ? {} : { onPulled }) };
+            const waiter = waiters.shift();
+            if (waiter === undefined)
+                queue.push(entry);
+            else
+                waiter.resolve(take(entry));
+            return entry.pulled.promise;
+        },
+        end() {
+            if (closed)
+                return;
+            closed = true;
+            rejectUnresolved(turnEndedError());
+            for (const waiter of waiters.splice(0))
+                waiter.resolve({ done: true, value: undefined });
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            const error = ended();
+            rejectUnresolved(error);
+            for (const waiter of waiters.splice(0))
+                waiter.resolve({ done: true, value: undefined });
+        },
+        fail(error) {
+            if (closed)
+                return;
+            closed = true;
+            failure = error;
+            rejectUnresolved(error);
+            for (const waiter of waiters.splice(0))
+                waiter.reject(error);
+        },
+        iterable: {
+            [Symbol.asyncIterator]() {
+                return {
+                    next() {
+                        acknowledgePrevious();
+                        const entry = queue.shift();
+                        if (entry !== undefined)
+                            return Promise.resolve(take(entry));
+                        if (failure !== undefined)
+                            return Promise.reject(failure);
+                        if (closed)
+                            return Promise.resolve({ done: true, value: undefined });
+                        return new Promise((resolve, reject) => waiters.push({ resolve, reject }));
+                    },
+                };
+            },
+        },
+    };
+}

package/build/src/akuma/providers/codex-app-server/events.d.ts

@@ -3,7 +3,7 @@ import { AgentEventChannel, type ToolCall, type TurnResult } from "../../provide
 export type CodexTurnState = {
     threadId?: string;
     turnId?: string;
-    answers: string[];
+    lastAnswer?: string;
     error?: string;
     settled: boolean;
     tools: Map<string, Readonly<{

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

@@ -1,4 +1,4 @@
-import { boundedEventText, boundedThoughtText, noteEvent, unknownEvent, } from "../../provider.js";
+import { noteEvent, unknownEvent, } from "../../provider.js";
 export const CODEX_NOTIFICATION_DISPOSITIONS = {
     "account/login/completed": "drop",
     "account/rateLimits/updated": "drop",
@@ -160,7 +160,7 @@ function itemChanges(item) {
         const diffstat = typeof change?.diff === "string" ? diffstatFromUnifiedPatch(change.diff) : undefined;
         return [{
                 op,
-                path: boundedEventText(path),
+                path,
                 ...(diffstat === undefined ? {} : { diffstat }),
             }];
     });
@@ -179,20 +179,23 @@ function reasoningSummary(item) {
 }
 function itemToolCall(item, kind) {
     if (kind === "commandExecution") {
-        return { kind: "run", command: boundedEventText(codexText(item.command) ?? "command") };
+        return { kind: "run", command: codexText(item.command) ?? "command" };
     }
     if (kind === "imageView") {
         const path = codexText(item.path);
-        return path === undefined ? { kind: "other", display: "image view" } : { kind: "read", path: boundedEventText(path) };
+        return path === undefined ? { kind: "other", display: "image view" } : { kind: "read", path };
     }
     if (kind === "webSearch") {
-        return { kind: "search", query: boundedEventText(codexText(item.query) ?? "web search") };
+        const query = codexText(item.query);
+        return query === undefined
+            ? { kind: "other", display: "web search" }
+            : { kind: "search", query, scope: "web" };
     }
     if (kind === "fileChange") {
         const changes = itemChanges(item);
         return changes.length === 0 ? { kind: "other", display: "fileChange" } : { kind: "fileChange", changes };
     }
-    return { kind: "other", display: boundedEventText(itemToolName(item, kind)) };
+    return { kind: "other", display: itemToolName(item, kind) };
 }
 function itemToolResult(item) {
     const error = codexObject(item.error);
@@ -202,7 +205,7 @@ function itemToolResult(item) {
     const exitCode = typeof item.exitCode === "number" && Number.isSafeInteger(item.exitCode) ? item.exitCode : undefined;
     return {
         status: failed || (exitCode !== undefined && exitCode !== 0) ? "error" : "ok",
-        ...(detail === undefined ? {} : { message: boundedEventText(detail) }),
+        ...(detail === undefined ? {} : { message: detail }),
         ...(exitCode === undefined ? {} : { exitCode }),
     };
 }
@@ -216,10 +219,10 @@ function emitItem(item, completed, events, state) {
     if (disposition === "assistant") {
         if (!completed)
             return;
-        const message = codexText(item.text);
+        const message = typeof item.text === "string" ? item.text : undefined;
         if (message !== undefined) {
-            state.answers.push(message);
-            events.emit({ type: "assistant", text: boundedEventText(message) });
+            state.lastAnswer = message;
+            events.emit({ type: "assistant", text: message });
         }
         return;
     }
@@ -233,7 +236,7 @@ function emitItem(item, completed, events, state) {
             return;
         const summary = reasoningSummary(item);
         if (summary !== undefined)
-            events.emit({ type: "thought", text: boundedThoughtText(summary) });
+            events.emit({ type: "thought", text: summary });
         return;
     }
     if (disposition === "note") {
@@ -300,7 +303,7 @@ function terminalResult(params, state) {
         return { kind: "failed", diagnostic: "codex app-server completed a different turn" };
     }
     return status === "completed"
-        ? { kind: "answered", answer: state.answers.join("\n\n"), historyId: completedId }
+        ? { kind: "answered", answer: state.lastAnswer ?? "", historyId: completedId }
         : { kind: "failed", diagnostic: turnError(turn?.error) ?? state.error ?? `codex app-server turn ended ${status}` };
 }
 export function codexNotificationResult(notification, state, events) {

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

@@ -1,27 +1,29 @@
-import { type Drive, type ProviderAdapter, type ProviderOptions } from "../../provider.js";
-import type { ProviderExecution } from "../../heart/index.js";
+import { type Session, type ProviderAdapter } from "../../provider.js";
+import type { ProviderExecution, ProviderOptions } from "../../provider-recipe.js";
 export { CODEX_ITEM_DISPOSITIONS, CODEX_NOTIFICATION_DISPOSITIONS } from "./events.js";
 export declare function createCodexAppServerProvider(input?: string | ProviderExecution): ProviderAdapter;
 export declare const codexAppServerProvider: Readonly<{
     confinement(input: Readonly<{
         cwd: string;
         options: ProviderOptions;
-    }>): import("../../heart/facts.js").Confinement;
+    }>): import("../../index.js").Confinement;
     admitOptions(options: ProviderOptions): import("../../provider.js").ProviderOptionAdmission;
     fork?(input: Readonly<{
-        session: import("../../provider.js").ResumeCoordinate;
+        session: import("../../coordinate.js").ResumeCoordinate;
         at: string;
         cwd: string;
     }>): Promise<Readonly<{
-        session: import("../../provider.js").ResumeCoordinate;
+        session: import("../../coordinate.js").ResumeCoordinate;
     }>>;
-    start(input: Readonly<{
-        prompt: string;
-        cwd: string;
-        options: ProviderOptions;
-        session?: import("../../provider.js").ResumeCoordinate;
-        requests?: Readonly<{
-            dir: string;
+    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: import("../../coordinate.js").ResumeCoordinate;
         }>;
-    }>): Promise<Drive>;
+    }>): Promise<Session>;
 }>;