@astrosheep/keiyaku 2.9.3 → 2.9.5

package/build/agents/launch-snapshot/resolve.js

@@ -1,6 +1,4 @@
-import * as path from "node:path";
-import { nativePolicyOwnership } from "../../config/provider-policy-ownership.js";
-import { buildCodexAppServerWorkspaceWriteSandboxPolicy, configOwnsApprovalPolicy, configOwnsSandboxPolicy, } from "../providers/codex-app-server/adapter.js";
+import { getProviderRegistration } from "../providers/registry.js";
 import { assertEffortAllowed, assertEffortRequiresModel, parseResolvedAkumaLaunchSnapshot, } from "./model.js";
 export function resolveAkumaLaunchSnapshot(selected, input) {
     const model = input.model ?? selected.profile.model;
@@ -28,45 +26,21 @@ export function resolveAkumaLaunchSnapshot(selected, input) {
         policy,
     };
     const instance = selected.profile.providerInstance;
-    const common = { name: selected.profile.provider, source: selected.profile.providerSource, kind: instance.kind };
-    let provider;
-    switch (instance.kind) {
-        case "codex-sdk": {
-            const threadOptions = { ...(instance.threadOptions ?? {}) };
-            const ownership = nativePolicyOwnership(selected.profile.provider, instance);
-            if (ownership.access.length === 0) {
-                threadOptions.sandboxMode = selected.profile.access === "read" ? "read-only" : selected.profile.access === "auto" ? "danger-full-access" : "workspace-write";
-            }
-            if (ownership.network.length === 0)
-                threadOptions.networkAccessEnabled = selected.profile.network === "enabled";
-            if (ownership.webSearch.length === 0)
-                threadOptions.webSearchMode = selected.profile.webSearch ?? "disabled";
-            if (model !== undefined)
-                threadOptions.model = model;
-            if (effort !== undefined)
-                threadOptions.modelReasoningEffort = effort;
-            threadOptions.workingDirectory = input.executionCwd;
-            threadOptions.skipGitRepoCheck = true;
-            provider = { ...common, ...(instance.executable !== undefined ? { executable: instance.executable } : {}), ...(instance.profile !== undefined ? { profile: instance.profile } : {}), ...(instance.config !== undefined ? { config: instance.config } : {}), threadOptions };
-            break;
-        }
-        case "codex-app-server": {
-            const roots = [path.resolve(input.executionCwd), ...(instance.writableRoots ?? []).map((root) => path.resolve(input.projectRoot, root))];
-            const writableRoots = [...new Set(roots)];
-            provider = { ...common, ...(instance.executable !== undefined ? { executable: instance.executable } : {}), ...(instance.profile !== undefined ? { profile: instance.profile } : {}), ...(instance.config !== undefined ? { config: instance.config } : {}), ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { effort } : {}), ...(!configOwnsSandboxPolicy(instance.config) ? { sandboxPolicy: buildCodexAppServerWorkspaceWriteSandboxPolicy({ writableRoots, networkAccess: selected.profile.network === "enabled" }) } : {}), ...(!configOwnsApprovalPolicy(instance.config) ? { approvalPolicy: "never" } : {}), ...(instance.env !== undefined ? { env: instance.env } : {}) };
-            break;
-        }
-        case "claude-agent-sdk": {
-            const permissionMode = selected.profile.access === "read" ? "plan" : selected.profile.access === "write" ? "acceptEdits" : selected.profile.access === "auto" ? "bypassPermissions" : "default";
-            provider = { ...common, ...(instance.executable !== undefined ? { executable: instance.executable } : {}), ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { effort } : {}), ...(instance.settingSources !== undefined ? { settingSources: instance.settingSources } : {}), permissionMode, ...(permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}), ...(selected.profile.webSearch === "disabled" ? { disallowedTools: ["WebSearch"] } : {}), ...(instance.env !== undefined ? { env: instance.env } : {}) };
-            break;
-        }
-        case "opencode-sdk":
-            provider = { ...common, ...(instance.executable !== undefined ? { executable: instance.executable } : {}), ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { effort } : {}), ...(instance.env !== undefined ? { env: instance.env } : {}) };
-            break;
-        case "pi":
-            provider = { ...common, ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { thinkingLevel: effort } : {}), ...(instance.env !== undefined ? { env: instance.env } : {}) };
-            break;
-    }
+    const common = {
+        name: selected.profile.provider,
+        source: selected.profile.providerSource,
+    };
+    const registration = getProviderRegistration(instance.kind);
+    const provider = registration.resolveLaunchProvider({
+        common,
+        instance,
+        model,
+        effort,
+        executionCwd: input.executionCwd,
+        projectRoot: input.projectRoot,
+        access: selected.profile.access,
+        network: selected.profile.network,
+        webSearch: selected.profile.webSearch,
+    });
     return parseResolvedAkumaLaunchSnapshot({ version: 1, akuma, provider });
 }

package/build/agents/opencode-sdk.js

@@ -7,6 +7,7 @@ const DEFAULT_HOSTNAME = "127.0.0.1";
 const DEFAULT_STARTUP_TIMEOUT_MS = 10_000;
 const SERVER_READY_POLL_INTERVAL_MS = 100;
 const SERVER_SHUTDOWN_FORCE_KILL_MS = 1000;
+const SERVER_SHUTDOWN_HARD_TIMEOUT_MS = 2000;
 const OPENCODE_SERVE_SUBCOMMAND = "serve";
 const OPENCODE_HOSTNAME_FLAG = "--hostname";
 const OPENCODE_PORT_FLAG = "--port";
@@ -33,7 +34,10 @@ async function waitForServerReady(client, directory, timeoutMs, signal) {
         if (signal?.aborted)
             throw createAbortError("OpenCode server startup aborted");
         try {
-            await client.config.get({ directory }, { throwOnError: true });
+            // Legacy config endpoints become available before the runtime model
+            // catalog. Prompting in that window is admitted, then fails asynchronously
+            // with ModelUnavailableError and no terminal event.
+            await client.v2.model.list({ location: { directory } }, { throwOnError: true });
             return;
         }
         catch {
@@ -67,13 +71,23 @@ export async function createOpencodeServer(options = {}) {
             return;
         if (mode === "force") {
             forceStop ??= new Promise((resolve, reject) => {
-                child.once("close", resolve);
+                let timer;
+                const finish = (error) => {
+                    if (timer)
+                        clearTimeout(timer);
+                    error === undefined ? resolve() : reject(error);
+                };
+                child.once("close", () => finish());
+                timer = setTimeout(() => {
+                    finish(new Error("OpenCode server forced process exit was not observed"));
+                }, SERVER_SHUTDOWN_HARD_TIMEOUT_MS);
+                timer.unref?.();
                 try {
                     if (!child.kill("SIGKILL") && !exited)
-                        reject(new Error("OpenCode server force kill failed"));
+                        finish(new Error("OpenCode server force kill failed"));
                 }
                 catch (error) {
-                    reject(error);
+                    finish(error);
                 }
             });
             await forceStop;
@@ -83,24 +97,43 @@ export async function createOpencodeServer(options = {}) {
             await forceStop;
             return;
         }
-        gracefulStop ??= new Promise((resolve) => {
+        gracefulStop ??= new Promise((resolve, reject) => {
             let settled = false;
             let forceKill;
-            const finish = () => {
+            let hardTimeout;
+            const finish = (error) => {
                 if (settled)
                     return;
                 settled = true;
                 if (forceKill)
                     clearTimeout(forceKill);
-                resolve();
+                if (hardTimeout)
+                    clearTimeout(hardTimeout);
+                error === undefined ? resolve() : reject(error);
             };
-            child.once("close", finish);
-            child.kill("SIGTERM");
+            child.once("close", () => finish());
+            try {
+                child.kill("SIGTERM");
+            }
+            catch (error) {
+                finish(error);
+                return;
+            }
             forceKill = setTimeout(() => {
-                if (!exited)
-                    child.kill("SIGKILL");
+                if (!exited) {
+                    try {
+                        child.kill("SIGKILL");
+                    }
+                    catch (error) {
+                        finish(error);
+                    }
+                }
             }, SERVER_SHUTDOWN_FORCE_KILL_MS);
-            forceKill.unref();
+            forceKill.unref?.();
+            hardTimeout = setTimeout(() => {
+                finish(new Error("OpenCode server process exit was not observed"));
+            }, SERVER_SHUTDOWN_HARD_TIMEOUT_MS);
+            hardTimeout.unref?.();
         });
         await gracefulStop;
     };

package/build/agents/providers/claude-agent-sdk/adapter.js

@@ -1,33 +1,20 @@
-import { z } from "zod";
 import { appendDebugLog } from "../../../telemetry/debug-log.js";
 import { SUBAGENT_SESSION_VERSION } from "../../session.js";
 import { createProjectionDriver } from "../../harness/execution-handle.js";
+import { createProviderFailure } from "../../harness/provider-adapter.js";
 import { buildSubagentEnv, createAbortError, emitProviderEvidence, linkAbortSignal, sha256Utf8 } from "../../harness/runtime.js";
-import { SubagentFailure } from "../../types.js";
 import { claudeIngressDisposition, emitClaudeThoughts, emitClaudeToolResults, emitClaudeToolStarts, emitClaudeUsage, extractAssistantMessage, extractAssistantMessageId, extractAssistantMessageModel, extractOverloadFallbackWarning, extractResultText, extractResumeToken, isClaudeApiRetryEvent, isClaudeModelRefusalFallbackEvent, isClaudeModelRefusalNoFallbackEvent, mapClaudeApiRetryWarning, } from "./events.js";
 import { CLAUDE_AGENT_SDK_PROVIDER, createPushableUserMessageStream, toClaudeUserMessage, } from "./session.js";
 function toClaudeSdkEffort(effort) {
     return effort; // opacity boundary
 }
-export const claudeSessionSchema = z.object({ sessionId: z.string().trim().min(1) });
-let claudeAgentSdkLoader;
+export { claudeSessionSchema } from "./session-schema.js";
 async function loadClaudeAgentSdk(loader) {
     if (loader) {
         return loader();
     }
-    if (claudeAgentSdkLoader) {
-        return claudeAgentSdkLoader();
-    }
     return (await import("@anthropic-ai/claude-agent-sdk"));
 }
-/** @deprecated Use ClaudeProviderOptions.loader instead. Kept for pipeline-based tests pending loader channel. */
-export function setClaudeAgentSdkLoaderForTests(loader) {
-    claudeAgentSdkLoader = loader;
-}
-/** @deprecated Use ClaudeProviderOptions.loader instead. */
-export function resetClaudeAgentSdkLoaderForTests() {
-    claudeAgentSdkLoader = undefined;
-}
 export async function startClaudeAgentSdk(prompt, cwd, options) {
     const sessionId = options.sessionId?.trim();
     let liveQuery;
@@ -314,7 +301,7 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                                 const failCode = unavailable ? "SUBAGENT_PROVIDER_UNAVAILABLE" : "SUBAGENT_EXEC_ERROR";
                                 builder.emit({ type: "fail", message, code: failCode });
                                 inputStream?.end();
-                                throw new SubagentFailure(failCode, message);
+                                throw createProviderFailure(message, { code: failCode });
                             }
                             default:
                                 break;
@@ -327,7 +314,7 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                 if (!resumedSessionId) {
                     const message = `${CLAUDE_AGENT_SDK_PROVIDER} exec could not determine session id`;
                     builder.emit({ type: "fail", message });
-                    throw new Error(message);
+                    throw createProviderFailure(message);
                 }
                 const session = {
                     provider: "claude-agent-sdk",
@@ -366,3 +353,5 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
         },
     });
 }
+// Compiler-level binding to the named ProviderAdapter function contract.
+startClaudeAgentSdk;

package/build/agents/providers/claude-agent-sdk/registration.js

@@ -0,0 +1,214 @@
+import { z } from "zod";
+import { claudeSettingSourceSchema, executableSchema, providerCommonFields, providerEnvSchema, } from "../../../config/settings/provider-instance-fields.js";
+import { FlowError } from "../../../flow-error.js";
+import { exactKeys, optionalString, optionalStringRecord, requiredEnum, snapshotError, } from "../../launch-snapshot/parse-helpers.js";
+import { SUBAGENT_SESSION_VERSION, subagentSessionEnvelopeSchema, } from "../../session.js";
+import { CLAUDE_AGENT_SDK_PROVIDER } from "./session.js";
+import { claudeSessionSchema } from "./session-schema.js";
+const startClaudeAgentSdk = async (prompt, cwd, options) => {
+    const { startClaudeAgentSdk: start } = await import("./adapter.js");
+    return start(prompt, cwd, options);
+};
+const CLAUDE_SETTING_SOURCES = new Set(["project", "user", "local"]);
+const ACCESS_VALUES = ["read", "write", "auto"];
+function admitResumeShape(schema, session, resumePath) {
+    const envelopeResult = subagentSessionEnvelopeSchema.safeParse(session);
+    if (!envelopeResult.success) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session envelope.`);
+    }
+    if (session.provider !== CLAUDE_AGENT_SDK_PROVIDER) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' was created with provider '${session.provider}', but the selected subagent resolves to '${CLAUDE_AGENT_SDK_PROVIDER}'. Cross-provider resume is not supported.`);
+    }
+    if (session.version !== SUBAGENT_SESSION_VERSION) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' uses unsupported session version '${session.version}' for provider '${session.provider}'.`);
+    }
+    const shapeResult = schema.safeParse(session.handle);
+    if (!shapeResult.success) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session handle for provider '${session.provider}'.`);
+    }
+    return shapeResult.data;
+}
+export const claudeAgentSdkRegistration = {
+    name: CLAUDE_AGENT_SDK_PROVIDER,
+    start: startClaudeAgentSdk,
+    sessionSchema: claudeSessionSchema,
+    effortField: "effort",
+    instanceSchema: z
+        .object({
+        kind: z.literal(CLAUDE_AGENT_SDK_PROVIDER),
+        ...providerCommonFields,
+        executable: executableSchema.optional(),
+        settingSources: z.array(claudeSettingSourceSchema).optional(),
+        env: providerEnvSchema,
+    })
+        .strict(),
+    builtinInstance: {
+        name: CLAUDE_AGENT_SDK_PROVIDER,
+        source: "builtin",
+        instance: {
+            kind: CLAUDE_AGENT_SDK_PROVIDER,
+            executable: "claude",
+            settingSources: ["project"],
+        },
+    },
+    builtinAkumaProfiles: [
+        { name: "akuma-claude", description: "Default Claude Agent SDK Akuma." },
+    ],
+    portablePolicy: {
+        access: new Set(ACCESS_VALUES),
+        network: new Set(),
+        webSearch: new Set(["disabled"]),
+    },
+    maxCaptureChars: (config) => config.claude.execMaxCaptureChars,
+    buildCallTerms: ({ snapshot, baseTerms, body }) => {
+        const provider = snapshot.provider;
+        return {
+            ...baseTerms,
+            provider: CLAUDE_AGENT_SDK_PROVIDER,
+            ...(provider.model !== undefined ? { model: provider.model } : {}),
+            ...(provider.effort !== undefined ? { effort: provider.effort } : {}),
+            ...(provider.executable !== undefined ? { executable: provider.executable } : {}),
+            ...(provider.settingSources !== undefined ? { settingSources: provider.settingSources } : {}),
+            permissionMode: provider.permissionMode,
+            ...(provider.allowDangerouslySkipPermissions !== undefined
+                ? { allowDangerouslySkipPermissions: provider.allowDangerouslySkipPermissions }
+                : {}),
+            ...(provider.disallowedTools !== undefined ? { disallowedTools: provider.disallowedTools } : {}),
+            ...(provider.env !== undefined ? { env: provider.env } : {}),
+            systemPrompt: body
+                ? { type: "preset", preset: "claude_code", append: body }
+                : undefined,
+            onCheckpoint() { },
+        };
+    },
+    resolveLaunchProvider: ({ common, instance, model, effort, access, webSearch }) => {
+        if (instance.kind !== CLAUDE_AGENT_SDK_PROVIDER) {
+            throw new Error(`resolveLaunchProvider expected ${CLAUDE_AGENT_SDK_PROVIDER}`);
+        }
+        const claudeInstance = instance;
+        const permissionMode = access === "read"
+            ? "plan"
+            : access === "write"
+                ? "acceptEdits"
+                : access === "auto"
+                    ? "bypassPermissions"
+                    : "default";
+        return Object.freeze({
+            ...common,
+            kind: CLAUDE_AGENT_SDK_PROVIDER,
+            ...(claudeInstance.executable !== undefined ? { executable: claudeInstance.executable } : {}),
+            ...(model !== undefined ? { model } : {}),
+            ...(effort !== undefined ? { effort } : {}),
+            ...(claudeInstance.settingSources !== undefined ? { settingSources: claudeInstance.settingSources } : {}),
+            permissionMode,
+            ...(permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
+            ...(webSearch === "disabled" ? { disallowedTools: ["WebSearch"] } : {}),
+            ...(claudeInstance.env !== undefined ? { env: claudeInstance.env } : {}),
+        });
+    },
+    parseLaunchProvider: (provider, common) => {
+        exactKeys(provider, [
+            "name",
+            "source",
+            "kind",
+            "executable",
+            "model",
+            "effort",
+            "settingSources",
+            "permissionMode",
+            "allowDangerouslySkipPermissions",
+            "disallowedTools",
+            "env",
+        ], "provider");
+        const modes = new Set(["default", "plan", "acceptEdits", "bypassPermissions"]);
+        const permissionMode = requiredEnum(provider, "permissionMode", "provider", modes);
+        if (permissionMode === "bypassPermissions") {
+            if (provider.allowDangerouslySkipPermissions !== true) {
+                throw snapshotError("provider.allowDangerouslySkipPermissions", "must be true for bypassPermissions");
+            }
+        }
+        else if ("allowDangerouslySkipPermissions" in provider) {
+            throw snapshotError("provider.allowDangerouslySkipPermissions", "is only valid for bypassPermissions");
+        }
+        let settingSources;
+        if ("settingSources" in provider) {
+            if (!Array.isArray(provider.settingSources))
+                throw snapshotError("provider.settingSources", "must be an array");
+            settingSources = Object.freeze(provider.settingSources.map((source, index) => {
+                if (typeof source !== "string" || !CLAUDE_SETTING_SOURCES.has(source)) {
+                    throw snapshotError(`provider.settingSources[${index}]`, "has an invalid setting source");
+                }
+                return source;
+            }));
+        }
+        let disallowedTools;
+        if ("disallowedTools" in provider) {
+            if (!Array.isArray(provider.disallowedTools) ||
+                provider.disallowedTools.length !== 1 ||
+                provider.disallowedTools[0] !== "WebSearch") {
+                throw snapshotError("provider.disallowedTools", "must equal ['WebSearch']");
+            }
+            disallowedTools = Object.freeze(["WebSearch"]);
+        }
+        const executable = optionalString(provider, "executable", "provider");
+        const model = optionalString(provider, "model", "provider");
+        const effort = optionalString(provider, "effort", "provider");
+        const env = optionalStringRecord(provider, "env");
+        return Object.freeze({
+            ...common,
+            kind: CLAUDE_AGENT_SDK_PROVIDER,
+            ...(executable !== undefined ? { executable } : {}),
+            ...(model !== undefined ? { model } : {}),
+            ...(effort !== undefined ? { effort } : {}),
+            ...(settingSources !== undefined ? { settingSources } : {}),
+            permissionMode,
+            ...(permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
+            ...(disallowedTools !== undefined ? { disallowedTools } : {}),
+            ...(env !== undefined ? { env } : {}),
+        });
+    },
+    applyEffort: (provider, effort) => Object.freeze({ ...provider, effort }),
+    providerEffortAndModel: (provider) => {
+        const resolved = provider;
+        return { model: resolved.model, effort: resolved.effort };
+    },
+    attachLoader: (terms, ports) => {
+        if (terms.provider !== CLAUDE_AGENT_SDK_PROVIDER)
+            return terms;
+        const loader = ports.claudeAgentSdk;
+        return loader ? { ...terms, loader } : terms;
+    },
+    nativePolicyOwnership: () => null,
+    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onIngress }) => {
+        if (terms.provider !== CLAUDE_AGENT_SDK_PROVIDER) {
+            throw new Error(`startLive expected ${CLAUDE_AGENT_SDK_PROVIDER}`);
+        }
+        const claudeTerms = terms;
+        const claudeOptions = {
+            model: claudeTerms.model,
+            executable: claudeTerms.executable,
+            effort: claudeTerms.effort,
+            env: claudeTerms.env,
+            signal,
+            permissionMode: claudeTerms.permissionMode,
+            settingSources: claudeTerms.settingSources,
+            allowDangerouslySkipPermissions: claudeTerms.allowDangerouslySkipPermissions,
+            disallowedTools: claudeTerms.disallowedTools,
+            systemPrompt: claudeTerms.systemPrompt,
+            onSyncCheckpoint,
+            onEvidence: claudeTerms.onEvidence,
+            onIngress,
+            initialTurn: claudeTerms.initialTurn,
+            loader: claudeTerms.loader,
+        };
+        const { startClaudeAgentSdk: start } = await import("./adapter.js");
+        if (reviveTerms) {
+            const session = admitResumeShape(claudeSessionSchema, reviveTerms.session, reviveTerms.resumePath);
+            return start(claudeTerms.prompt, claudeTerms.workdir, {
+                ...claudeOptions,
+                sessionId: session.sessionId,
+            });
+        }
+        return start(claudeTerms.prompt, claudeTerms.workdir, claudeOptions);
+    },
+};

package/build/agents/providers/claude-agent-sdk/session-schema.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const claudeSessionSchema = z.object({ sessionId: z.string().trim().min(1) });