@astrosheep/keiyaku 2.9.13 → 4.0.0

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

@@ -0,0 +1,305 @@
+import { AgentEventChannel, boundedEventText, boundedThoughtText, 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 assistantText(message) {
+    if (message.type !== "assistant" || message.aborted === true || message.error !== undefined)
+        return null;
+    const text = message.message.content
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("");
+    return text.length === 0 ? null : text;
+}
+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: boundedEventText(command) };
+    const path = nonblank(value.file_path) ?? nonblank(value.path);
+    if (/^(?:read|view)/iu.test(name) && path !== undefined)
+        return { kind: "read", path: boundedEventText(path) };
+    const query = nonblank(value.query) ?? nonblank(value.pattern);
+    if (/search|grep|glob/iu.test(name) && query !== undefined)
+        return { kind: "search", query: boundedEventText(query) };
+    if (/write/iu.test(name) && path !== undefined) {
+        return { kind: "fileChange", changes: [{ op: "add", path: boundedEventText(path) }] };
+    }
+    if (/edit|notebook/iu.test(name) && path !== undefined) {
+        return { kind: "fileChange", changes: [{ op: "update", path: boundedEventText(path) }] };
+    }
+    return { kind: "other", display: boundedEventText(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 = assistantText(message);
+    if (text !== null)
+        events.emit({ type: "assistant", text: boundedEventText(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: boundedThoughtText(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 systemNote(message, subtype) {
+    const note = CLAUDE_SYSTEM_NOTES[subtype];
+    return note?.(message) ?? subtype;
+}
+function emitClaudeMessage(message, events, state) {
+    const value = object(message);
+    const kind = nonblank(value?.type) ?? "unknown";
+    if (!Object.hasOwn(CLAUDE_MESSAGE_DISPOSITIONS, kind)) {
+        events.emit(unknownEvent(kind));
+        return;
+    }
+    const disposition = CLAUDE_MESSAGE_DISPOSITIONS[kind];
+    if (disposition === "assistant") {
+        assistantEvents(message, events, state);
+        return;
+    }
+    if (disposition === "tool-results") {
+        toolResultEvents(message, events, state);
+        return;
+    }
+    if (disposition === "auth") {
+        const error = nonblank(value?.error);
+        if (error !== undefined)
+            events.emit(noteEvent(`Authentication warning: ${error}`));
+        return;
+    }
+    if (disposition === "note") {
+        events.emit(noteEvent("Conversation reset"));
+        return;
+    }
+    if (disposition !== "system")
+        return;
+    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;
+    events.emit(noteEvent(systemNote(value ?? {}, subtype)));
+}
+function admitClaudeOptions(options) {
+    if (options.network !== undefined) {
+        return { kind: "refused", diagnostic: "Claude provider does not support the Archetype network option" };
+    }
+    return { kind: "admitted", options: Object.freeze({ ...options }) };
+}
+function permissionMode(access) {
+    if (access === "read")
+        return "plan";
+    if (access === "write")
+        return "acceptEdits";
+    return "bypassPermissions";
+}
+async function forkClaude(load, execution, input) {
+    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(input.session.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 === input.session.sessionId)
+        throw new Error("Claude fork reused the source session id");
+    return { session: { sessionId: forked.sessionId } };
+}
+export function createClaudeProvider(load, execution = {}) {
+    return {
+        confinement: () => ({ kind: "unconfined" }),
+        admitOptions: admitClaudeOptions,
+        fork: (input) => forkClaude(load, execution, input),
+        async start(input) {
+            const sdk = await load();
+            const events = new AgentEventChannel();
+            const abortController = new AbortController();
+            const providerOptions = input.options;
+            const access = permissionMode(providerOptions.access);
+            const options = {
+                cwd: input.cwd,
+                abortController,
+                ...(execution.executable === undefined ? {} : { pathToClaudeCodeExecutable: execution.executable }),
+                ...(execution.env === undefined ? {} : { env: { ...process.env, ...execution.env } }),
+                permissionMode: access,
+                ...(access === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
+                settingSources: ["user", "project", "local"],
+                ...(providerOptions.model === undefined ? {} : { model: providerOptions.model }),
+                ...(providerOptions.effort === undefined ? {} : { effort: providerOptions.effort }),
+                ...(providerOptions.systemPrompt === undefined || providerOptions.systemPrompt.length === 0 ? {} : {
+                    systemPrompt: { type: "preset", preset: "claude_code", append: providerOptions.systemPrompt },
+                }),
+                ...(input.session === undefined ? {} : { resume: input.session.sessionId }),
+            };
+            const query = sdk.query({ prompt: input.prompt, options });
+            const observation = { tools: new Map() };
+            let admitted = false;
+            let settle;
+            const completion = new Promise((resolve) => { settle = resolve; });
+            void (async () => {
+                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 } });
+                        }
+                        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")
+                            terminal = message.subtype === "success"
+                                ? historyId === undefined
+                                    ? { kind: "failed", diagnostic: "Claude query succeeded without an assistant history id" }
+                                    : { kind: "answered", answer: message.result, historyId }
+                                : { kind: "failed", diagnostic: message.errors.join("; ") || message.subtype };
+                    }
+                    settle(terminal ?? { kind: "failed", diagnostic: "Claude query ended without a result" });
+                }
+                catch (error) {
+                    settle({ kind: "failed", diagnostic: error instanceof Error ? error.message : String(error) });
+                }
+                finally {
+                    events.end();
+                }
+            })();
+            return {
+                events,
+                completion,
+                async abort() {
+                    abortController.abort();
+                    query.close();
+                    await completion;
+                },
+            };
+        },
+    };
+}
+export const claudeProvider = createClaudeProvider(async () => await import("@anthropic-ai/claude-agent-sdk"));

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

@@ -0,0 +1,110 @@
+import type { LineRpcNotification } from "../../../runtime/proc/line-rpc.js";
+import { AgentEventChannel, type ToolCall, type TurnResult } from "../../provider.js";
+export type CodexTurnState = {
+    threadId?: string;
+    turnId?: string;
+    answers: string[];
+    error?: string;
+    settled: boolean;
+    tools: Map<string, Readonly<{
+        name: string;
+        call: ToolCall;
+    }>>;
+};
+export declare const CODEX_NOTIFICATION_DISPOSITIONS: {
+    readonly "account/login/completed": "drop";
+    readonly "account/rateLimits/updated": "drop";
+    readonly "account/updated": "drop";
+    readonly "app/list/updated": "drop";
+    readonly "command/exec/outputDelta": "drop";
+    readonly configWarning: "note";
+    readonly deprecationNotice: "note";
+    readonly error: "error";
+    readonly "externalAgentConfig/import/completed": "note";
+    readonly "externalAgentConfig/import/progress": "note";
+    readonly "fs/changed": "note";
+    readonly "fuzzyFileSearch/sessionCompleted": "drop";
+    readonly "fuzzyFileSearch/sessionUpdated": "drop";
+    readonly guardianWarning: "note";
+    readonly "hook/completed": "drop";
+    readonly "hook/started": "note";
+    readonly "item/agentMessage/delta": "drop";
+    readonly "item/autoApprovalReview/completed": "note";
+    readonly "item/autoApprovalReview/started": "note";
+    readonly "item/commandExecution/outputDelta": "drop";
+    readonly "item/commandExecution/terminalInteraction": "drop";
+    readonly "item/completed": "item-completed";
+    readonly "item/fileChange/outputDelta": "drop";
+    readonly "item/fileChange/patchUpdated": "drop";
+    readonly "item/mcpToolCall/progress": "drop";
+    readonly "item/plan/delta": "drop";
+    readonly "item/reasoning/summaryPartAdded": "drop";
+    readonly "item/reasoning/summaryTextDelta": "drop";
+    readonly "item/reasoning/textDelta": "drop";
+    readonly "item/started": "item-started";
+    readonly "mcpServer/oauthLogin/completed": "drop";
+    readonly "mcpServer/startupStatus/updated": "drop";
+    readonly "model/rerouted": "note";
+    readonly "model/safetyBuffering/updated": "drop";
+    readonly "model/verification": "drop";
+    readonly "process/exited": "drop";
+    readonly "process/outputDelta": "drop";
+    readonly "rawResponse/completed": "drop";
+    readonly "rawResponseItem/completed": "drop";
+    readonly "remoteControl/status/changed": "drop";
+    readonly "serverRequest/resolved": "drop";
+    readonly "skills/changed": "drop";
+    readonly "thread/archived": "drop";
+    readonly "thread/closed": "drop";
+    readonly "thread/compacted": "drop";
+    readonly "thread/deleted": "drop";
+    readonly "thread/environment/connected": "drop";
+    readonly "thread/environment/disconnected": "drop";
+    readonly "thread/goal/cleared": "note";
+    readonly "thread/goal/updated": "note";
+    readonly "thread/name/updated": "drop";
+    readonly "thread/realtime/closed": "drop";
+    readonly "thread/realtime/error": "note";
+    readonly "thread/realtime/itemAdded": "drop";
+    readonly "thread/realtime/outputAudio/delta": "drop";
+    readonly "thread/realtime/sdp": "drop";
+    readonly "thread/realtime/started": "drop";
+    readonly "thread/realtime/transcript/delta": "drop";
+    readonly "thread/realtime/transcript/done": "drop";
+    readonly "thread/settings/updated": "drop";
+    readonly "thread/started": "drop";
+    readonly "thread/status/changed": "drop";
+    readonly "thread/tokenUsage/updated": "drop";
+    readonly "thread/unarchived": "drop";
+    readonly "turn/completed": "terminal";
+    readonly "turn/diff/updated": "drop";
+    readonly "turn/moderationMetadata": "note";
+    readonly "turn/plan/updated": "plan";
+    readonly "turn/started": "drop";
+    readonly warning: "note";
+    readonly "windows/worldWritableWarning": "note";
+    readonly "windowsSandbox/setupCompleted": "note";
+};
+export declare const CODEX_ITEM_DISPOSITIONS: {
+    readonly agentMessage: "assistant";
+    readonly collabAgentToolCall: "tool";
+    readonly commandExecution: "tool";
+    readonly contextCompaction: "drop";
+    readonly dynamicToolCall: "tool";
+    readonly enteredReviewMode: "note";
+    readonly exitedReviewMode: "note";
+    readonly fileChange: "tool";
+    readonly hookPrompt: "drop";
+    readonly imageGeneration: "tool";
+    readonly imageView: "tool";
+    readonly mcpToolCall: "tool";
+    readonly plan: "plan";
+    readonly reasoning: "thought";
+    readonly sleep: "note";
+    readonly subAgentActivity: "note";
+    readonly userMessage: "drop";
+    readonly webSearch: "tool";
+};
+export declare function codexObject(value: unknown): Readonly<Record<string, unknown>> | undefined;
+export declare function codexText(value: unknown): string | undefined;
+export declare function codexNotificationResult(notification: LineRpcNotification, state: CodexTurnState, events: AgentEventChannel): TurnResult | undefined;