@astrosheep/keiyaku 2.9.13 → 4.0.1

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

@@ -0,0 +1,337 @@
+import { noteEvent, unknownEvent, } from "../../provider.js";
+export const CODEX_NOTIFICATION_DISPOSITIONS = {
+    "account/login/completed": "drop",
+    "account/rateLimits/updated": "drop",
+    "account/updated": "drop",
+    "app/list/updated": "drop",
+    "command/exec/outputDelta": "drop",
+    configWarning: "note",
+    deprecationNotice: "note",
+    error: "error",
+    "externalAgentConfig/import/completed": "note",
+    "externalAgentConfig/import/progress": "note",
+    "fs/changed": "note",
+    "fuzzyFileSearch/sessionCompleted": "drop",
+    "fuzzyFileSearch/sessionUpdated": "drop",
+    guardianWarning: "note",
+    "hook/completed": "drop",
+    "hook/started": "note",
+    "item/agentMessage/delta": "drop",
+    "item/autoApprovalReview/completed": "note",
+    "item/autoApprovalReview/started": "note",
+    "item/commandExecution/outputDelta": "drop",
+    "item/commandExecution/terminalInteraction": "drop",
+    "item/completed": "item-completed",
+    "item/fileChange/outputDelta": "drop",
+    "item/fileChange/patchUpdated": "drop",
+    "item/mcpToolCall/progress": "drop",
+    "item/plan/delta": "drop",
+    "item/reasoning/summaryPartAdded": "drop",
+    "item/reasoning/summaryTextDelta": "drop",
+    "item/reasoning/textDelta": "drop",
+    "item/started": "item-started",
+    "mcpServer/oauthLogin/completed": "drop",
+    "mcpServer/startupStatus/updated": "drop",
+    "model/rerouted": "note",
+    "model/safetyBuffering/updated": "drop",
+    "model/verification": "drop",
+    "process/exited": "drop",
+    "process/outputDelta": "drop",
+    "rawResponse/completed": "drop",
+    "rawResponseItem/completed": "drop",
+    "remoteControl/status/changed": "drop",
+    "serverRequest/resolved": "drop",
+    "skills/changed": "drop",
+    "thread/archived": "drop",
+    "thread/closed": "drop",
+    "thread/compacted": "drop",
+    "thread/deleted": "drop",
+    "thread/environment/connected": "drop",
+    "thread/environment/disconnected": "drop",
+    "thread/goal/cleared": "note",
+    "thread/goal/updated": "note",
+    "thread/name/updated": "drop",
+    "thread/realtime/closed": "drop",
+    "thread/realtime/error": "note",
+    "thread/realtime/itemAdded": "drop",
+    "thread/realtime/outputAudio/delta": "drop",
+    "thread/realtime/sdp": "drop",
+    "thread/realtime/started": "drop",
+    "thread/realtime/transcript/delta": "drop",
+    "thread/realtime/transcript/done": "drop",
+    "thread/settings/updated": "drop",
+    "thread/started": "drop",
+    "thread/status/changed": "drop",
+    "thread/tokenUsage/updated": "drop",
+    "thread/unarchived": "drop",
+    "turn/completed": "terminal",
+    "turn/diff/updated": "drop",
+    "turn/moderationMetadata": "note",
+    "turn/plan/updated": "plan",
+    "turn/started": "drop",
+    warning: "note",
+    "windows/worldWritableWarning": "note",
+    "windowsSandbox/setupCompleted": "note",
+};
+export const CODEX_ITEM_DISPOSITIONS = {
+    agentMessage: "assistant",
+    collabAgentToolCall: "tool",
+    commandExecution: "tool",
+    contextCompaction: "drop",
+    dynamicToolCall: "tool",
+    enteredReviewMode: "note",
+    exitedReviewMode: "note",
+    fileChange: "tool",
+    hookPrompt: "drop",
+    imageGeneration: "tool",
+    imageView: "tool",
+    mcpToolCall: "tool",
+    plan: "plan",
+    reasoning: "thought",
+    sleep: "note",
+    subAgentActivity: "note",
+    userMessage: "drop",
+    webSearch: "tool",
+};
+export function codexObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+export function codexText(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function turnError(value) {
+    const error = codexObject(value);
+    const message = codexText(error?.message);
+    const details = codexText(error?.additionalDetails);
+    if (message === undefined)
+        return details;
+    return details === undefined || details === message ? message : `${message}: ${details}`;
+}
+function itemNote(item, kind) {
+    switch (kind) {
+        case "enteredReviewMode": return "Entered review mode";
+        case "exitedReviewMode": return "Exited review mode";
+        case "sleep": return "Waiting";
+        case "subAgentActivity": return `Agent activity: ${codexText(item.kind) ?? "updated"}`;
+        default: return kind;
+    }
+}
+function itemToolName(item, kind) {
+    if (kind === "mcpToolCall")
+        return `${codexText(item.server) ?? "unknown"}/${codexText(item.tool) ?? "unknown"}`;
+    if (kind === "dynamicToolCall") {
+        const namespace = codexText(item.namespace);
+        return `${namespace === undefined ? "" : `${namespace}/`}${codexText(item.tool) ?? "unknown"}`;
+    }
+    return codexText(item.tool) ?? kind;
+}
+function fileChangeOp(value) {
+    if (value === "add" || value === "update" || value === "delete")
+        return value;
+    const record = codexObject(value);
+    return record?.type === "add" || record?.type === "update" || record?.type === "delete"
+        ? record.type
+        : undefined;
+}
+function diffstatFromUnifiedPatch(patch) {
+    if (!patch.split("\n").some((line) => /^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/u.test(line)))
+        return undefined;
+    let added = 0;
+    let removed = 0;
+    for (const line of patch.split("\n")) {
+        if (line.startsWith("+") && !line.startsWith("+++"))
+            added += 1;
+        if (line.startsWith("-") && !line.startsWith("---"))
+            removed += 1;
+    }
+    return { added, removed };
+}
+function itemChanges(item) {
+    if (!Array.isArray(item.changes))
+        return [];
+    return item.changes.flatMap((value) => {
+        const change = codexObject(value);
+        const path = codexText(change?.path);
+        const op = fileChangeOp(change?.kind);
+        if (path === undefined || op === undefined)
+            return [];
+        const diffstat = typeof change?.diff === "string" ? diffstatFromUnifiedPatch(change.diff) : undefined;
+        return [{
+                op,
+                path,
+                ...(diffstat === undefined ? {} : { diffstat }),
+            }];
+    });
+}
+function reasoningSummary(item) {
+    if (typeof item.summary === "string")
+        return codexText(item.summary);
+    if (!Array.isArray(item.summary))
+        return undefined;
+    return codexText(item.summary.map((part) => {
+        if (typeof part === "string")
+            return part;
+        const value = codexObject(part);
+        return value?.type === "summary_text" || value?.type === "text" ? codexText(value.text) ?? "" : "";
+    }).join("\n"));
+}
+function itemToolCall(item, kind) {
+    if (kind === "commandExecution") {
+        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 };
+    }
+    if (kind === "webSearch") {
+        return { kind: "search", query: codexText(item.query) ?? "web search" };
+    }
+    if (kind === "fileChange") {
+        const changes = itemChanges(item);
+        return changes.length === 0 ? { kind: "other", display: "fileChange" } : { kind: "fileChange", changes };
+    }
+    return { kind: "other", display: itemToolName(item, kind) };
+}
+function itemToolResult(item) {
+    const error = codexObject(item.error);
+    const status = codexText(item.status);
+    const failed = error !== undefined || status === "failed" || status === "error";
+    const detail = codexText(error?.message) ?? codexText(error?.additionalDetails);
+    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: detail }),
+        ...(exitCode === undefined ? {} : { exitCode }),
+    };
+}
+function emitItem(item, completed, events, state) {
+    const kind = codexText(item.type) ?? "unknown";
+    if (!Object.hasOwn(CODEX_ITEM_DISPOSITIONS, kind)) {
+        events.emit(unknownEvent(kind));
+        return;
+    }
+    const disposition = CODEX_ITEM_DISPOSITIONS[kind];
+    if (disposition === "assistant") {
+        if (!completed)
+            return;
+        const message = typeof item.text === "string" ? item.text : undefined;
+        if (message !== undefined) {
+            state.lastAnswer = message;
+            events.emit({ type: "assistant", text: message });
+        }
+        return;
+    }
+    if (disposition === "plan") {
+        if (completed)
+            events.emit(noteEvent(`Plan updated: ${codexText(item.text) ?? "updated"}`));
+        return;
+    }
+    if (disposition === "thought") {
+        if (!completed)
+            return;
+        const summary = reasoningSummary(item);
+        if (summary !== undefined)
+            events.emit({ type: "thought", text: summary });
+        return;
+    }
+    if (disposition === "note") {
+        if (!completed)
+            events.emit(noteEvent(itemNote(item, kind)));
+        return;
+    }
+    if (disposition !== "tool")
+        return;
+    const id = codexText(item.id);
+    if (id === undefined) {
+        events.emit(unknownEvent(`${kind}/missing-id`));
+        return;
+    }
+    if (!completed) {
+        const observed = { name: itemToolName(item, kind), call: itemToolCall(item, kind) };
+        state.tools.set(id, observed);
+        events.emit({ type: "tool", phase: "started", id, ...observed });
+        return;
+    }
+    const started = state.tools.get(id);
+    const observed = {
+        name: started?.name ?? itemToolName(item, kind),
+        call: itemToolCall(item, kind),
+    };
+    state.tools.delete(id);
+    events.emit({ type: "tool", phase: "completed", id, ...observed, result: itemToolResult(item) });
+}
+function notificationAction(method, params) {
+    const message = codexText(params.message) ?? codexText(params.reason) ?? codexText(params.error);
+    switch (method) {
+        case "configWarning": return `Configuration warning: ${message ?? "unknown warning"}`;
+        case "deprecationNotice": return `Deprecation warning: ${message ?? "deprecated behavior"}`;
+        case "externalAgentConfig/import/completed": return "External agent configuration import completed";
+        case "externalAgentConfig/import/progress": return "External agent configuration import updated";
+        case "fs/changed": return "Filesystem changed";
+        case "guardianWarning": return `Guardian warning: ${message ?? "action warned"}`;
+        case "hook/started": return `Hook ${codexText(params.name) ?? codexText(params.hookName) ?? "unknown"} started`;
+        case "item/autoApprovalReview/completed": return "Action approval review completed";
+        case "item/autoApprovalReview/started": return "Action approval review started";
+        case "model/rerouted": return `Model rerouted${message === undefined ? "" : `: ${message}`}`;
+        case "thread/goal/cleared": return "Goal cleared";
+        case "thread/goal/updated": return "Goal updated";
+        case "thread/realtime/error": return `Realtime warning: ${message ?? "unknown error"}`;
+        case "turn/moderationMetadata": return "Moderation updated";
+        case "warning": return `Warning: ${message ?? "unknown warning"}`;
+        case "windows/worldWritableWarning": return `Filesystem warning: ${message ?? "world-writable path"}`;
+        case "windowsSandbox/setupCompleted": return "Windows sandbox setup completed";
+        default: return method;
+    }
+}
+function observeError(params, state, events) {
+    const detail = turnError(params.error) ?? codexText(params.message) ?? "codex app-server error";
+    state.error = detail;
+    events.emit(noteEvent(params.willRetry === true ? `Retrying after error: ${detail}` : `Error: ${detail}`));
+}
+function terminalResult(params, state) {
+    const turn = codexObject(params.turn);
+    const completedId = codexText(turn?.id);
+    const status = codexText(turn?.status) ?? "unknown";
+    if (completedId === undefined)
+        return { kind: "failed", diagnostic: "codex app-server completed without a turn id" };
+    if (state.turnId !== undefined && completedId !== state.turnId) {
+        return { kind: "failed", diagnostic: "codex app-server completed a different turn" };
+    }
+    return status === "completed"
+        ? { 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) {
+    const method = notification.method;
+    if (!Object.hasOwn(CODEX_NOTIFICATION_DISPOSITIONS, method)) {
+        events.emit(unknownEvent(method));
+        return undefined;
+    }
+    const disposition = CODEX_NOTIFICATION_DISPOSITIONS[method];
+    const params = codexObject(notification.params) ?? {};
+    switch (disposition) {
+        case "drop": return undefined;
+        case "note":
+            events.emit(noteEvent(notificationAction(method, params)));
+            return undefined;
+        case "plan": {
+            const explanation = codexText(params.explanation);
+            const steps = Array.isArray(params.plan) ? params.plan.length : 0;
+            events.emit(noteEvent(`Plan updated: ${explanation ?? `${steps} steps`}`));
+            return undefined;
+        }
+        case "item-started":
+        case "item-completed": {
+            const item = codexObject(params.item);
+            if (item !== undefined)
+                emitItem(item, disposition === "item-completed", events, state);
+            return undefined;
+        }
+        case "error":
+            observeError(params, state, events);
+            return undefined;
+        case "terminal": return terminalResult(params, state);
+    }
+}

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

@@ -0,0 +1,29 @@
+import { type Session, type ProviderAdapter, type ProviderOptions } from "../../provider.js";
+import type { ProviderExecution } from "../../heart/index.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;
+    admitOptions(options: ProviderOptions): import("../../provider.js").ProviderOptionAdmission;
+    fork?(input: Readonly<{
+        session: import("../../coordinate.js").ResumeCoordinate;
+        at: string;
+        cwd: string;
+    }>): Promise<Readonly<{
+        session: import("../../coordinate.js").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: import("../../coordinate.js").ResumeCoordinate;
+        }>;
+    }>): Promise<Session>;
+}>;

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

@@ -0,0 +1,213 @@
+import { LineRpcProcess } from "../../../runtime/proc/line-rpc.js";
+import { AgentEventChannel, AKUMA_REQUESTS_ENV, } from "../../provider.js";
+import { codexNotificationResult, codexObject, codexText, } from "./events.js";
+export { CODEX_ITEM_DISPOSITIONS, CODEX_NOTIFICATION_DISPOSITIONS } from "./events.js";
+const INTERRUPT_TIMEOUT_MS = 1_000;
+function interrupt(server, threadId, turnId) {
+    const request = server.request("turn/interrupt", { threadId, turnId });
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error("codex app-server interrupt timed out")), INTERRUPT_TIMEOUT_MS);
+        void request.then((value) => { clearTimeout(timer); resolve(value); }, (error) => { clearTimeout(timer); reject(error); });
+    });
+}
+function diagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function initialize(server) {
+    await server.request("initialize", {
+        clientInfo: { name: "keiyaku", title: "keiyaku", version: "4" },
+        capabilities: { experimentalApi: false, requestAttestation: false },
+    });
+    server.notify("initialized");
+}
+function threadId(result, fallback) {
+    const value = codexObject(result);
+    const thread = codexObject(value?.thread) ?? value;
+    const id = codexText(thread?.id) ?? fallback;
+    if (id === undefined)
+        throw new Error("codex app-server did not return a thread id");
+    return id;
+}
+function turnId(result) {
+    const value = codexObject(result);
+    const turn = codexObject(value?.turn) ?? value;
+    const id = codexText(turn?.id);
+    if (id === undefined)
+        throw new Error("codex app-server did not return a turn id");
+    return id;
+}
+async function steerTurn(server, state, tell) {
+    if (state.settled)
+        return { kind: "turn-ended" };
+    if (state.threadId === undefined || state.turnId === undefined)
+        throw new Error("codex app-server turn is not admitted");
+    const request = server.request("turn/steer", {
+        threadId: state.threadId,
+        expectedTurnId: state.turnId,
+        input: [{ type: "text", text: tell.text }],
+        clientUserMessageId: tell.id,
+    });
+    const response = codexObject(await request);
+    const accepted = codexText(response?.turnId);
+    if (accepted === undefined)
+        throw new Error("codex app-server steer did not return a turn id");
+    if (accepted !== state.turnId)
+        throw new Error("codex app-server steer acknowledged a different turn");
+    return { kind: "accepted", fence: `${accepted}:${tell.id}` };
+}
+function sandbox(cwd, options, requests) {
+    return {
+        type: "workspaceWrite",
+        writableRoots: [cwd, ...(requests === undefined ? [] : [requests.dir])],
+        networkAccess: options.network === "enabled",
+        excludeTmpdirEnvVar: false,
+        excludeSlashTmp: false,
+    };
+}
+async function admitTurn(server, input, state, events, config) {
+    await initialize(server);
+    const threadParams = {
+        cwd: input.cwd,
+        ...(config === undefined ? {} : { config }),
+        ...(input.options.model === undefined ? {} : { model: input.options.model }),
+        ...(input.options.systemPrompt === undefined || input.options.systemPrompt.length === 0
+            ? {} : { developerInstructions: input.options.systemPrompt }),
+    };
+    if (input.session.kind === "fresh") {
+        state.threadId = threadId(await server.request("thread/start", threadParams));
+    }
+    else {
+        state.threadId = threadId(await server.request("thread/resume", {
+            threadId: input.session.coordinate.sessionId,
+            ...threadParams,
+        }), input.session.coordinate.sessionId);
+    }
+    events.emit({ type: "session", coordinate: { sessionId: state.threadId } });
+    state.turnId = turnId(await server.request("turn/start", {
+        threadId: state.threadId,
+        input: [{ type: "text", text: [input.body, ...input.launchTells.map((tell) => tell.text)]
+                    .filter((part) => part.length > 0).join("\n\n") }],
+        ...(input.options.model === undefined ? {} : { model: input.options.model }),
+        ...(input.options.effort === undefined ? {} : { effort: input.options.effort }),
+        approvalPolicy: "never",
+        sandboxPolicy: sandbox(input.cwd, input.options, input.requests),
+    }));
+}
+async function forkCodex(execution, input) {
+    if (!("sessionId" in input.session))
+        throw new Error("Codex app-server fork requires sessionId");
+    const server = new LineRpcProcess({
+        argv: [execution.executable ?? "codex", "app-server", "--listen", "stdio://"],
+        cwd: input.cwd,
+        ...(execution.env === undefined ? {} : { env: { ...process.env, ...execution.env } }),
+    });
+    try {
+        await initialize(server);
+        const child = threadId(await server.request("thread/fork", {
+            threadId: input.session.sessionId,
+            lastTurnId: input.at,
+        }));
+        if (child === input.session.sessionId)
+            throw new Error("Codex app-server fork reused the source thread id");
+        return { session: { sessionId: child } };
+    }
+    finally {
+        await server.close();
+    }
+}
+async function abortTurn(server, state, completion, settle) {
+    if (state.settled) {
+        await completion;
+        return;
+    }
+    if (state.threadId !== undefined && state.turnId !== undefined) {
+        try {
+            await interrupt(server, state.threadId, state.turnId);
+            await completion;
+        }
+        catch (error) {
+            settle({ kind: "failed", diagnostic: diagnostic(error) });
+        }
+    }
+    else {
+        settle({ kind: "failed", diagnostic: "codex app-server aborted before turn admission" });
+    }
+    await completion;
+}
+async function startCodex(execution, input) {
+    if (input.session.kind === "resume" && !("sessionId" in input.session.coordinate))
+        throw new Error("Codex app-server resume requires sessionId");
+    const events = new AgentEventChannel();
+    const server = new LineRpcProcess({
+        argv: [execution.executable ?? "codex", "app-server", "--listen", "stdio://"],
+        cwd: input.cwd,
+        ...((execution.env === undefined && input.requests === undefined) ? {} : { env: {
+                ...process.env,
+                ...execution.env,
+                ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
+            } }),
+    });
+    const state = { settled: false, tools: new Map() };
+    let settle;
+    const completion = new Promise((resolve) => { settle = resolve; });
+    let terminal;
+    const finish = (result) => {
+        if (terminal !== undefined)
+            return;
+        terminal = result;
+        state.settled = true;
+        void server.endInputAndDrain().then(() => {
+            events.end();
+            settle(result);
+        }, () => {
+            events.end();
+            settle(result);
+        });
+    };
+    server.onNotification((notification) => {
+        const result = codexNotificationResult(notification, state, events);
+        if (result !== undefined)
+            finish(result);
+    });
+    server.onExit(({ code, signal, stderr }) => finish({
+        kind: "failed",
+        diagnostic: stderr || `codex app-server exited before completion (${code ?? signal ?? "unknown"})`,
+    }));
+    server.onServerRequest((request) => finish({
+        kind: "failed",
+        diagnostic: `codex app-server made forbidden interactive request ${request.method}`,
+    }));
+    try {
+        await admitTurn(server, input, state, events, execution.config);
+    }
+    catch (error) {
+        finish({ kind: "failed", diagnostic: diagnostic(error) });
+    }
+    if (state.turnId === undefined)
+        throw new Error("codex app-server did not admit a turn");
+    return {
+        admission: { fence: state.turnId },
+        events,
+        completion,
+        abort: () => abortTurn(server, state, completion, finish),
+        tell: (tell) => steerTurn(server, state, tell),
+    };
+}
+export function createCodexAppServerProvider(input = "codex") {
+    const execution = typeof input === "string"
+        ? { name: "codex-app-server", kind: "codex-app-server", executable: input }
+        : input;
+    return {
+        confinement: ({ cwd }) => ({ kind: "declared", writableRoots: [cwd] }),
+        admitOptions(options) {
+            if (options.access !== undefined && options.access !== "write") {
+                return { kind: "refused", diagnostic: "Codex app-server supports only access: write" };
+            }
+            return { kind: "admitted", options: Object.freeze({ ...options }) };
+        },
+        fork: (input) => forkCodex(execution, input),
+        start: (input) => startCodex(execution, input),
+        resume: (input) => startCodex(execution, input),
+    };
+}
+export const codexAppServerProvider = createCodexAppServerProvider();

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

@@ -0,0 +1,4 @@
+import type { ProviderAdapter } from "../provider.js";
+import type { ProviderExecution } from "../heart/index.js";
+export declare function decodeProviderExecution(input: unknown): ProviderExecution;
+export declare function providerNamed(execution: ProviderExecution): ProviderAdapter;

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

@@ -0,0 +1,85 @@
+import { claudeProvider, createClaudeProvider } from "./claude/index.js";
+import { createCodexAppServerProvider } from "./codex-app-server/index.js";
+import { createOpencodeProvider } from "./opencode-sdk/index.js";
+import { createPiProvider } from "./pi/index.js";
+const PROVIDERS = {
+    claude: claudeProvider,
+};
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value : null;
+}
+function snapshot(value) {
+    if (Array.isArray(value))
+        return Object.freeze(value.map(snapshot));
+    const object = record(value);
+    if (object === null)
+        return value;
+    return Object.freeze(Object.fromEntries(Object.entries(object).map(([key, item]) => [key, snapshot(item)])));
+}
+function optionalText(value, field) {
+    const selected = value[field];
+    if (selected === undefined)
+        return undefined;
+    if (typeof selected !== "string" || selected.trim().length === 0) {
+        throw new TypeError(`provider execution ${field} must be a nonblank string`);
+    }
+    return selected;
+}
+function providerKind(value) {
+    return value === "claude-agent-sdk" || value === "codex-app-server" || value === "opencode-sdk" || value === "pi";
+}
+function providerConfig(value, kind) {
+    const config = value.config === undefined ? undefined : record(value.config);
+    if (config === null)
+        throw new TypeError("provider execution config must be an object");
+    if (kind === "claude-agent-sdk" && config !== undefined)
+        throw new TypeError("provider execution config is unsupported by claude-agent-sdk");
+    if (kind === "opencode-sdk" && config !== undefined)
+        throw new TypeError("provider execution config is unsupported by opencode-sdk");
+    return config;
+}
+export function decodeProviderExecution(input) {
+    const value = record(input);
+    if (value === null)
+        throw new TypeError("provider execution must be an object");
+    const allowed = ["config", "env", "executable", "kind", "name"];
+    const unknown = Object.keys(value).find((key) => !allowed.includes(key));
+    if (unknown !== undefined)
+        throw new TypeError(`provider execution has unknown field ${unknown}`);
+    if (typeof value.name !== "string" || value.name.trim().length === 0) {
+        throw new TypeError("provider execution name must be a nonblank string");
+    }
+    if (!providerKind(value.kind)) {
+        throw new TypeError("provider execution has unknown kind");
+    }
+    const executable = optionalText(value, "executable");
+    const config = providerConfig(value, value.kind);
+    const env = value.env === undefined ? undefined : record(value.env);
+    if (env === null)
+        throw new TypeError("provider execution env must be an object");
+    if (env !== undefined && Object.values(env).some((item) => typeof item !== "string")) {
+        throw new TypeError("provider execution env must contain only string values");
+    }
+    return Object.freeze({
+        name: value.name,
+        kind: value.kind,
+        ...(executable === undefined ? {} : { executable }),
+        ...(config === undefined ? {} : { config: snapshot(config) }),
+        ...(env === undefined ? {} : { env: Object.freeze({ ...env }) }),
+    });
+}
+export function providerNamed(execution) {
+    if (execution.kind === "claude-agent-sdk") {
+        return execution.executable === undefined && execution.env === undefined
+            ? PROVIDERS.claude
+            : createClaudeProvider(async () => await import("@anthropic-ai/claude-agent-sdk"), execution);
+    }
+    if (execution.kind === "codex-app-server")
+        return createCodexAppServerProvider(execution);
+    if (execution.kind === "opencode-sdk")
+        return createOpencodeProvider(execution);
+    if (execution.kind === "pi")
+        return createPiProvider(execution);
+    throw new TypeError(`unknown Akuma provider kind ${execution.kind}`);
+}