@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/src/akuma/provider.d.ts

@@ -0,0 +1,123 @@
+import type { Confinement, ProviderOptions, ResumeCoordinate } from "./heart/index.js";
+export type { ProviderOptions, ResumeCoordinate } from "./heart/index.js";
+export declare const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
+export declare const AGENT_EVENT_TEXT_LIMIT = 16384;
+export declare const AGENT_THOUGHT_TEXT_LIMIT = 4000;
+export type ToolCall = Readonly<{
+    kind: "run";
+    command: string;
+}> | Readonly<{
+    kind: "read";
+    path: string;
+}> | Readonly<{
+    kind: "search";
+    query: string;
+}> | Readonly<{
+    kind: "fileChange";
+    changes: readonly Readonly<{
+        op: "add" | "update" | "delete";
+        path: string;
+        diffstat?: Readonly<{
+            added: number;
+            removed: number;
+        }>;
+    }>[];
+}> | Readonly<{
+    kind: "other";
+    display: string;
+}>;
+export type ToolResult = Readonly<{
+    status: "ok" | "error";
+    message?: string;
+    exitCode?: number;
+}>;
+export type ToolEvent = Readonly<{
+    type: "tool";
+    id: string;
+    name: string;
+    call: ToolCall;
+}> & (Readonly<{
+    phase: "started";
+    result?: never;
+}> | Readonly<{
+    phase: "completed";
+    result: ToolResult;
+}>);
+export type AgentEvent = Readonly<{
+    type: "session";
+    coordinate: ResumeCoordinate;
+}> | Readonly<{
+    type: "assistant";
+    text: string;
+}> | Readonly<{
+    type: "thought";
+    text: string;
+}> | ToolEvent | Readonly<{
+    type: "note";
+    text: string;
+}> | Readonly<{
+    type: "unknown";
+    kind: string;
+}>;
+export declare function decodeProviderOptions(value: unknown): ProviderOptions;
+export declare function decodeAgentEvent(value: unknown): AgentEvent;
+export declare function encodeAgentEvent(event: AgentEvent): unknown;
+export declare function boundedEventText(value: string): string;
+export declare function boundedThoughtText(value: string): string;
+export declare function noteEvent(note: string): Extract<AgentEvent, {
+    type: "note";
+}>;
+export declare function unknownEvent(kind: string): Extract<AgentEvent, {
+    type: "unknown";
+}>;
+export declare class AgentEventChannel implements AsyncIterable<AgentEvent> {
+    private readonly queued;
+    private readonly waiters;
+    private ended;
+    emit(event: AgentEvent): void;
+    end(): void;
+    [Symbol.asyncIterator](): AsyncIterator<AgentEvent>;
+}
+export type TurnResult = Readonly<{
+    kind: "answered";
+    answer: string;
+    historyId: string;
+}> | Readonly<{
+    kind: "failed";
+    diagnostic: string;
+}>;
+export type Drive = Readonly<{
+    events: AsyncIterable<AgentEvent>;
+    completion: Promise<TurnResult>;
+    abort(): Promise<void>;
+}>;
+export type ProviderOptionAdmission = Readonly<{
+    kind: "admitted";
+    options: ProviderOptions;
+}> | Readonly<{
+    kind: "refused";
+    diagnostic: string;
+}>;
+export type ProviderAdapter = Readonly<{
+    confinement(input: Readonly<{
+        cwd: string;
+        options: ProviderOptions;
+    }>): Confinement;
+    admitOptions(options: ProviderOptions): ProviderOptionAdmission;
+    fork?(input: Readonly<{
+        session: ResumeCoordinate;
+        at: string;
+        cwd: string;
+    }>): Promise<Readonly<{
+        session: ResumeCoordinate;
+    }>>;
+    start(input: Readonly<{
+        prompt: string;
+        cwd: string;
+        options: ProviderOptions;
+        session?: ResumeCoordinate;
+        requests?: Readonly<{
+            dir: string;
+        }>;
+    }>): Promise<Drive>;
+}>;

package/build/src/akuma/provider.js

@@ -0,0 +1,235 @@
+export const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
+export const AGENT_EVENT_TEXT_LIMIT = 16_384;
+export const AGENT_THOUGHT_TEXT_LIMIT = 4_000;
+const AGENT_EVENT_TYPES = {
+    session: true,
+    assistant: true,
+    thought: true,
+    tool: true,
+    note: true,
+    unknown: true,
+};
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function optionText(options, field, blank) {
+    const selected = options[field];
+    if (selected === undefined)
+        return undefined;
+    if (typeof selected !== "string" || (blank === "refuse" && selected.trim().length === 0)) {
+        throw new TypeError(`provider option ${field} must be ${blank === "allow" ? "a string" : "a nonblank string"}`);
+    }
+    return selected;
+}
+function optionEnum(options, field, allowed) {
+    const selected = options[field];
+    if (selected === undefined)
+        return undefined;
+    if (typeof selected !== "string" || !allowed.includes(selected)) {
+        throw new TypeError(`provider option ${field} must be ${allowed.join(", ")}`);
+    }
+    return selected;
+}
+export function decodeProviderOptions(value) {
+    const options = object(value);
+    if (options === null)
+        throw new TypeError("provider options must be an object");
+    const allowed = ["access", "effort", "model", "network", "systemPrompt"];
+    const unknown = Object.keys(options).find((key) => !allowed.includes(key));
+    if (unknown !== undefined)
+        throw new TypeError(`provider options have unknown field ${unknown}`);
+    const model = optionText(options, "model", "refuse");
+    const effort = optionText(options, "effort", "refuse");
+    const access = optionEnum(options, "access", ["read", "write", "auto"]);
+    const network = optionEnum(options, "network", ["disabled", "enabled"]);
+    const systemPrompt = optionText(options, "systemPrompt", "allow");
+    return Object.freeze({
+        ...(model === undefined ? {} : { model }),
+        ...(effort === undefined ? {} : { effort }),
+        ...(access === undefined ? {} : { access }),
+        ...(network === undefined ? {} : { network }),
+        ...(systemPrompt === undefined ? {} : { systemPrompt }),
+    });
+}
+function eventType(value) {
+    return typeof value === "string" && Object.hasOwn(AGENT_EVENT_TYPES, value);
+}
+function decodeToolCall(value) {
+    const call = object(value);
+    if (call?.kind === "run" && typeof call.command === "string")
+        return { kind: "run", command: call.command };
+    if (call?.kind === "read" && typeof call.path === "string")
+        return { kind: "read", path: call.path };
+    if (call?.kind === "search" && typeof call.query === "string")
+        return { kind: "search", query: call.query };
+    if (call?.kind === "fileChange" && Array.isArray(call.changes)) {
+        const changes = call.changes.map((value) => {
+            const change = object(value);
+            if (change === null || (change.op !== "add" && change.op !== "update" && change.op !== "delete")
+                || typeof change.path !== "string")
+                return null;
+            const rawDiffstat = change.diffstat;
+            const op = change.op;
+            if (rawDiffstat === undefined)
+                return { op, path: change.path };
+            const diffstat = object(rawDiffstat);
+            if (diffstat === null || !Number.isSafeInteger(diffstat.added) || !Number.isSafeInteger(diffstat.removed)
+                || diffstat.added < 0 || diffstat.removed < 0)
+                return null;
+            return {
+                op,
+                path: change.path,
+                diffstat: { added: diffstat.added, removed: diffstat.removed },
+            };
+        });
+        if (changes.every((change) => change !== null))
+            return { kind: "fileChange", changes };
+    }
+    if (call?.kind === "other" && typeof call.display === "string")
+        return { kind: "other", display: call.display };
+    return null;
+}
+function decodeToolResult(value) {
+    const result = object(value);
+    if (result === null || (result.status !== "ok" && result.status !== "error"))
+        return null;
+    if (result.message !== undefined && typeof result.message !== "string")
+        return null;
+    if (result.exitCode !== undefined && !Number.isSafeInteger(result.exitCode))
+        return null;
+    return {
+        status: result.status,
+        ...(result.message === undefined ? {} : { message: result.message }),
+        ...(result.exitCode === undefined ? {} : { exitCode: result.exitCode }),
+    };
+}
+function decodeToolEvent(event) {
+    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 };
+    }
+    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 null;
+}
+function decodeTypedEvent(type, event) {
+    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 "session": {
+            const coordinate = object(event.coordinate);
+            return typeof coordinate?.sessionId === "string" ? { type, coordinate: { sessionId: coordinate.sessionId } } : null;
+        }
+        case "tool": return decodeToolEvent(event);
+        default: return type;
+    }
+}
+export function decodeAgentEvent(value) {
+    const event = object(value);
+    if (event === null || !eventType(event.type))
+        throw new Error("Akuma activity has an invalid event shape");
+    const decoded = decodeTypedEvent(event.type, event);
+    if (decoded === null)
+        throw new Error("Akuma activity has an invalid event shape");
+    return decoded;
+}
+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 "fileChange": return {
+            kind: call.kind,
+            changes: call.changes.map((change) => ({
+                ...change,
+                path: boundedEventText(change.path),
+            })),
+        };
+        case "other": return { kind: call.kind, display: boundedEventText(call.display) };
+        default: return call;
+    }
+}
+function boundedToolResult(result) {
+    return {
+        status: result.status,
+        ...(result.message === undefined ? {} : { message: boundedEventText(result.message) }),
+        ...(result.exitCode === undefined ? {} : { exitCode: result.exitCode }),
+    };
+}
+export function encodeAgentEvent(event) {
+    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"
+            ? {
+                type: event.type,
+                id: event.id,
+                phase: event.phase,
+                name: boundedEventText(event.name),
+                call: boundedToolCall(event.call),
+            }
+            : {
+                type: event.type,
+                id: event.id,
+                phase: event.phase,
+                name: boundedEventText(event.name),
+                call: boundedToolCall(event.call),
+                result: boundedToolResult(event.result),
+            };
+        default: return event;
+    }
+}
+export function boundedEventText(value) {
+    return value.slice(0, AGENT_EVENT_TEXT_LIMIT);
+}
+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()) };
+}
+export function unknownEvent(kind) {
+    return { type: "unknown", kind };
+}
+export class AgentEventChannel {
+    queued = [];
+    waiters = [];
+    ended = false;
+    emit(event) {
+        const waiter = this.waiters.shift();
+        if (waiter === undefined)
+            this.queued.push(event);
+        else
+            waiter.resolve({ done: false, value: event });
+    }
+    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 event = this.queued.shift();
+                if (event !== undefined)
+                    return Promise.resolve({ done: false, value: event });
+                if (this.ended)
+                    return Promise.resolve({ done: true, value: undefined });
+                return new Promise((resolve) => this.waiters.push({ resolve }));
+            },
+        };
+    }
+}

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

@@ -0,0 +1,84 @@
+import type { Options, Query } from "@anthropic-ai/claude-agent-sdk";
+import { type Drive, type ProviderAdapter, type ProviderOptions } from "../provider.js";
+export declare const CLAUDE_MESSAGE_DISPOSITIONS: {
+    readonly assistant: "assistant";
+    readonly auth_status: "auth";
+    readonly conversation_reset: "note";
+    readonly prompt_suggestion: "drop";
+    readonly rate_limit_event: "drop";
+    readonly result: "terminal";
+    readonly stream_event: "drop";
+    readonly system: "system";
+    readonly tool_progress: "drop";
+    readonly tool_use_summary: "drop";
+    readonly user: "tool-results";
+};
+export declare const CLAUDE_SYSTEM_DISPOSITIONS: {
+    readonly api_retry: "note";
+    readonly background_tasks_changed: "note";
+    readonly commands_changed: "drop";
+    readonly compact_boundary: "drop";
+    readonly control_request_progress: "control-progress";
+    readonly elicitation_complete: "drop";
+    readonly files_persisted: "note";
+    readonly hook_progress: "drop";
+    readonly hook_response: "drop";
+    readonly hook_started: "note";
+    readonly informational: "note";
+    readonly init: "drop";
+    readonly local_command_output: "drop";
+    readonly memory_recall: "drop";
+    readonly mirror_error: "note";
+    readonly model_refusal_fallback: "note";
+    readonly model_refusal_no_fallback: "note";
+    readonly notification: "note";
+    readonly permission_denied: "note";
+    readonly plugin_install: "note";
+    readonly session_state_changed: "drop";
+    readonly status: "note";
+    readonly task_notification: "note";
+    readonly task_progress: "note";
+    readonly task_started: "note";
+    readonly task_updated: "note";
+    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>;
+}>;