@astrosheep/keiyaku 2.9.3 → 2.9.5

package/build/agents/harness/router.js

@@ -1,30 +1,4 @@
-import { FlowError } from "../../flow-error.js";
-import { SUBAGENT_SESSION_VERSION, subagentSessionEnvelopeSchema, } from "../session.js";
-import { startClaudeAgentSdk, claudeSessionSchema, } from "../providers/claude-agent-sdk/adapter.js";
-import { startCodexAppServer, codexAppServerSessionSchema, } from "../providers/codex-app-server/adapter.js";
-import { startCodexSdk, codexThreadSchema, } from "../providers/codex-sdk.js";
-import { startOpencode, opencodeSessionSchema, } from "../providers/opencode-sdk/adapter.js";
-import { startPi, piSessionSchema, } from "../providers/pi/adapter.js";
-function admitResumeShape(provider, 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 !== provider) {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' was created with provider '${session.provider}', but the selected subagent resolves to '${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;
-}
-function assertNever(_value) {
-    throw new Error("Unhandled provider");
-}
+import { getProviderRegistration } from "../providers/registry.js";
 export async function startLiveProjection(terms, signal, reviveTerms, onIngress, observer) {
     const onSyncCheckpoint = observer
         ? (control, checkpoint) => {
@@ -38,164 +12,14 @@ export async function startLiveProjection(terms, signal, reviveTerms, onIngress,
             observer.onDeliveryOpportunity(control);
         }
         : undefined;
-    switch (terms.provider) {
-        case "pi": {
-            if (reviveTerms) {
-                const session = admitResumeShape("pi", piSessionSchema, reviveTerms.session, reviveTerms.resumePath);
-                return startPi(terms.prompt, terms.workdir, {
-                    model: terms.model,
-                    thinkingLevel: terms.thinkingLevel,
-                    signal,
-                    sessionFile: session.sessionFile,
-                    appendSystemPromptOverride: terms.appendSystemPromptOverride,
-                    onSyncCheckpoint,
-                    onEvidence: terms.onEvidence,
-                    onIngress,
-                    initialTurn: terms.initialTurn,
-                    loader: terms.loader,
-                });
-            }
-            return startPi(terms.prompt, terms.workdir, {
-                model: terms.model,
-                thinkingLevel: terms.thinkingLevel,
-                signal,
-                appendSystemPromptOverride: terms.appendSystemPromptOverride,
-                onSyncCheckpoint,
-                onEvidence: terms.onEvidence,
-                onIngress,
-                initialTurn: terms.initialTurn,
-                loader: terms.loader,
-            });
-        }
-        case "claude-agent-sdk": {
-            const claudeOptions = {
-                model: terms.model,
-                executable: terms.executable,
-                effort: terms.effort,
-                env: terms.env,
-                signal,
-                permissionMode: terms.permissionMode,
-                settingSources: terms.settingSources,
-                allowDangerouslySkipPermissions: terms.allowDangerouslySkipPermissions,
-                disallowedTools: terms.disallowedTools,
-                systemPrompt: terms.systemPrompt,
-                onSyncCheckpoint,
-                onEvidence: terms.onEvidence,
-                onIngress,
-                initialTurn: terms.initialTurn,
-                loader: terms.loader,
-            };
-            if (reviveTerms) {
-                const session = admitResumeShape("claude-agent-sdk", claudeSessionSchema, reviveTerms.session, reviveTerms.resumePath);
-                return startClaudeAgentSdk(terms.prompt, terms.workdir, {
-                    ...claudeOptions,
-                    sessionId: session.sessionId,
-                });
-            }
-            return startClaudeAgentSdk(terms.prompt, terms.workdir, claudeOptions);
-        }
-        case "codex-app-server": {
-            if (reviveTerms) {
-                const session = admitResumeShape("codex-app-server", codexAppServerSessionSchema, reviveTerms.session, reviveTerms.resumePath);
-                return startCodexAppServer(terms.prompt, terms.workdir, {
-                    model: terms.model,
-                    effort: terms.effort,
-                    profile: terms.profile,
-                    config: terms.config,
-                    sandboxPolicy: terms.sandboxPolicy,
-                    approvalPolicy: terms.approvalPolicy,
-                    executable: terms.executable,
-                    env: terms.env,
-                    signal,
-                    threadId: session.threadId,
-                    codexHome: session.codexHome,
-                    developerInstructions: terms.developerInstructions,
-                    onSyncCheckpoint,
-                    onDeliveryOpportunity,
-                    onEvidence: terms.onEvidence,
-                    onIngress,
-                    initialTurn: terms.initialTurn,
-                });
-            }
-            return startCodexAppServer(terms.prompt, terms.workdir, {
-                model: terms.model,
-                effort: terms.effort,
-                profile: terms.profile,
-                config: terms.config,
-                sandboxPolicy: terms.sandboxPolicy,
-                approvalPolicy: terms.approvalPolicy,
-                executable: terms.executable,
-                env: terms.env,
-                signal,
-                developerInstructions: terms.developerInstructions,
-                onSyncCheckpoint,
-                onDeliveryOpportunity,
-                onEvidence: terms.onEvidence,
-                onIngress,
-                initialTurn: terms.initialTurn,
-            });
-        }
-        case "codex-sdk": {
-            if (reviveTerms) {
-                const session = admitResumeShape("codex-sdk", codexThreadSchema, reviveTerms.session, reviveTerms.resumePath);
-                return startCodexSdk(terms.prompt, terms.workdir, {
-                    model: terms.model,
-                    profile: terms.profile,
-                    config: terms.config,
-                    threadOptions: terms.threadOptions,
-                    executable: terms.executable,
-                    signal,
-                    threadId: session.threadId,
-                    onEvidence: terms.onEvidence,
-                    onIngress,
-                    initialTurn: terms.initialTurn,
-                    codexConstructor: terms.codexConstructor,
-                });
-            }
-            return startCodexSdk(terms.prompt, terms.workdir, {
-                model: terms.model,
-                profile: terms.profile,
-                config: terms.config,
-                threadOptions: terms.threadOptions,
-                executable: terms.executable,
-                signal,
-                onEvidence: terms.onEvidence,
-                onIngress,
-                initialTurn: terms.initialTurn,
-                codexConstructor: terms.codexConstructor,
-            });
-        }
-        case "opencode-sdk": {
-            if (reviveTerms) {
-                const session = admitResumeShape("opencode-sdk", opencodeSessionSchema, reviveTerms.session, reviveTerms.resumePath);
-                return startOpencode(terms.prompt, terms.workdir, {
-                    model: terms.model,
-                    effort: terms.effort,
-                    executable: terms.executable,
-                    env: terms.env,
-                    signal,
-                    sessionId: session.sessionId,
-                    onSyncCheckpoint,
-                    onDeliveryOpportunity,
-                    onEvidence: terms.onEvidence,
-                    onIngress,
-                    initialTurn: terms.initialTurn,
-                });
-            }
-            return startOpencode(terms.prompt, terms.workdir, {
-                model: terms.model,
-                effort: terms.effort,
-                executable: terms.executable,
-                env: terms.env,
-                signal,
-                onSyncCheckpoint,
-                onDeliveryOpportunity,
-                onEvidence: terms.onEvidence,
-                onIngress,
-                initialTurn: terms.initialTurn,
-            });
-        }
-        default:
-            return assertNever(terms);
-    }
+    const registration = getProviderRegistration(terms.provider);
+    return registration.startLive({
+        terms,
+        signal,
+        reviveTerms,
+        onSyncCheckpoint,
+        onDeliveryOpportunity,
+        onIngress,
+        observer,
+    });
 }

package/build/agents/harness/runtime.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { getConfig } from "../../config/env.js";
 import { DISABLE_SUBAGENT_SPAWN_ENV_KEY } from "../../config/env-keys.js";
+export const PROVIDER_ABORT_SETTLEMENT_TIMEOUT_MS = 5_000;
 export function sha256Utf8(value) {
     const bytes = Buffer.from(value, "utf8");
     return { sha256: createHash("sha256").update(bytes).digest("hex"), byteLength: bytes.byteLength };
@@ -33,10 +34,22 @@ export function emitProviderEvidence(callback, evidence, diagnostic) {
         reportFailure();
     }
 }
-export function createAbortError(message) {
-    const error = new Error(message);
-    error.name = "AbortError";
-    return error;
+export { createAbortError } from "./provider-adapter.js";
+export async function awaitProviderAbortSettlement(provider, settlement, operation = "graceful abort could not prove provider terminal settlement") {
+    let timer;
+    const deadline = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+            reject(new Error(`${provider} ${operation} within ${PROVIDER_ABORT_SETTLEMENT_TIMEOUT_MS}ms`));
+        }, PROVIDER_ABORT_SETTLEMENT_TIMEOUT_MS);
+        timer.unref?.();
+    });
+    try {
+        return await Promise.race([settlement, deadline]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
 }
 export function coerceString(value) {
     return typeof value === "string" && value.trim().length > 0 ? value : undefined;

package/build/agents/harness/session.js

@@ -0,0 +1,15 @@
+import { isSubagentProvider } from "../../keiyaku.js";
+import { SUBAGENT_SESSION_VERSION, subagentSessionEnvelopeSchema, } from "../session.js";
+import { getProviderRegistration } from "../providers/registry.js";
+/** Validate a continuation envelope through its owning provider schema. */
+export function isRecoverableSessionEnvelope(provider, value) {
+    if (!isSubagentProvider(provider))
+        return false;
+    const envelope = subagentSessionEnvelopeSchema.safeParse(value);
+    if (!envelope.success)
+        return false;
+    if (envelope.data.provider !== provider || envelope.data.version !== SUBAGENT_SESSION_VERSION) {
+        return false;
+    }
+    return getProviderRegistration(provider).sessionSchema.safeParse(envelope.data.handle).success;
+}

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

@@ -1,91 +1,11 @@
-import * as path from "node:path";
 import { FlowError } from "../../flow-error.js";
+import { getProviderRegistration, isSubagentProvider, } from "../providers/registry.js";
+import { exactKeys, objectAt, optionalString, requiredEnum, requiredString, snapshotError, } from "./parse-helpers.js";
 const ACCESS_VALUES = new Set(["read", "write", "auto"]);
 const NETWORK_VALUES = new Set(["disabled", "enabled"]);
 const WEB_SEARCH_VALUES = new Set(["disabled", "cached", "live"]);
 const AKUMA_SOURCES = new Set(["builtin", "user", "project"]);
 const PROVIDER_SOURCES = new Set(["builtin", "global", "project"]);
-const CLAUDE_SETTING_SOURCES = new Set(["project", "user", "local"]);
-function snapshotError(fieldPath, message) {
-    return new Error(`Invalid resolved Akuma launch snapshot at ${fieldPath}: ${message}`);
-}
-function isPlainObject(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        return false;
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
-function objectAt(value, fieldPath) {
-    if (!isPlainObject(value))
-        throw snapshotError(fieldPath, "must be a plain JSON object");
-    return value;
-}
-function exactKeys(value, allowed, fieldPath) {
-    const allowedSet = new Set(allowed);
-    for (const key of Object.keys(value)) {
-        if (!allowedSet.has(key))
-            throw snapshotError(`${fieldPath}.${key}`, "is an unknown field");
-    }
-}
-function requiredString(value, key, fieldPath, allowBlank = false) {
-    const item = value[key];
-    if (typeof item !== "string" || (!allowBlank && item.trim().length === 0)) {
-        throw snapshotError(`${fieldPath}.${key}`, allowBlank ? "must be a string" : "must be a nonblank string");
-    }
-    return item;
-}
-function optionalString(value, key, fieldPath) {
-    if (!(key in value))
-        return undefined;
-    return requiredString(value, key, fieldPath);
-}
-function requiredEnum(value, key, fieldPath, values) {
-    const item = requiredString(value, key, fieldPath);
-    if (!values.has(item))
-        throw snapshotError(`${fieldPath}.${key}`, `has invalid value '${item}'`);
-    return item;
-}
-function cloneJson(value, fieldPath, ancestors = new Set()) {
-    if (value === null || typeof value === "string" || typeof value === "boolean")
-        return value;
-    if (typeof value === "number") {
-        if (!Number.isFinite(value))
-            throw snapshotError(fieldPath, "contains a non-finite number");
-        return value;
-    }
-    if (typeof value !== "object")
-        throw snapshotError(fieldPath, "contains a non-JSON value");
-    if (ancestors.has(value))
-        throw snapshotError(fieldPath, "contains a cycle");
-    ancestors.add(value);
-    try {
-        if (Array.isArray(value)) {
-            return Object.freeze(value.map((item, index) => cloneJson(item, `${fieldPath}[${index}]`, ancestors)));
-        }
-        if (!isPlainObject(value))
-            throw snapshotError(fieldPath, "contains a non-plain JSON object");
-        const result = {};
-        for (const [key, item] of Object.entries(value)) {
-            Object.defineProperty(result, key, {
-                value: cloneJson(item, `${fieldPath}.${key}`, ancestors),
-                enumerable: true,
-                configurable: true,
-                writable: true,
-            });
-        }
-        return Object.freeze(result);
-    }
-    finally {
-        ancestors.delete(value);
-    }
-}
-function cloneJsonObject(value, fieldPath) {
-    const cloned = cloneJson(value, fieldPath);
-    if (!isPlainObject(cloned)) {
-        throw snapshotError(fieldPath, "must be a plain JSON object");
-    }
-    return cloned;
-}
 function effortOptionsFrom(akuma) {
     if (!("effortOptions" in akuma))
         return undefined;
@@ -118,21 +38,7 @@ function assertEffortRequiresModel(model, effort, kind, akumaName) {
     throw new FlowError("INVALID_EFFORT_OVERRIDE", `Effort '${effort}' requires an explicit model.`);
 }
 function providerEffortAndModel(provider) {
-    switch (provider.kind) {
-        case "codex-sdk": {
-            const model = typeof provider.threadOptions.model === "string" ? provider.threadOptions.model : undefined;
-            const effort = typeof provider.threadOptions.modelReasoningEffort === "string"
-                ? provider.threadOptions.modelReasoningEffort
-                : undefined;
-            return { model, effort };
-        }
-        case "codex-app-server":
-        case "claude-agent-sdk":
-        case "opencode-sdk":
-            return { model: provider.model, effort: provider.effort };
-        case "pi":
-            return { model: provider.model, effort: provider.thinkingLevel };
-    }
+    return getProviderRegistration(provider.kind).providerEffortAndModel(provider);
 }
 function assertSnapshotEffortRequiresModel(snapshot) {
     const fromAkuma = { model: snapshot.akuma.model, effort: snapshot.akuma.effort };
@@ -141,7 +47,8 @@ function assertSnapshotEffortRequiresModel(snapshot) {
     }
     const fromProvider = providerEffortAndModel(snapshot.provider);
     if (fromProvider.effort !== undefined && fromProvider.model === undefined) {
-        throw snapshotError(`provider.${snapshot.provider.kind === "codex-sdk" ? "threadOptions.modelReasoningEffort" : snapshot.provider.kind === "pi" ? "thinkingLevel" : "effort"}`, "requires an explicit model");
+        const effortField = getProviderRegistration(snapshot.provider.kind).effortField;
+        throw snapshotError(`provider.${effortField}`, "requires an explicit model");
     }
 }
 function parsePolicy(value) {
@@ -184,133 +91,14 @@ function parseProviderCommon(provider) {
         source: requiredEnum(provider, "source", "provider", PROVIDER_SOURCES),
     };
 }
-function optionalJsonObject(provider, key) {
-    return key in provider ? cloneJsonObject(provider[key], `provider.${key}`) : undefined;
-}
-function optionalStringRecord(provider, key) {
-    if (!(key in provider))
-        return undefined;
-    const value = provider[key];
-    if (!isPlainObject(value))
-        throw snapshotError(`provider.${key}`, "must be a plain JSON object");
-    const result = {};
-    for (const [entryKey, entryValue] of Object.entries(value)) {
-        if (typeof entryValue !== "string") {
-            throw snapshotError(`provider.${key}.${entryKey}`, "must be a string");
-        }
-        result[entryKey] = entryValue;
-    }
-    return Object.freeze(result);
-}
-function parseSandboxPolicy(value) {
-    const sandbox = objectAt(value, "provider.sandboxPolicy");
-    exactKeys(sandbox, ["type", "writableRoots", "networkAccess", "excludeTmpdirEnvVar", "excludeSlashTmp"], "provider.sandboxPolicy");
-    if (sandbox.type !== "workspaceWrite")
-        throw snapshotError("provider.sandboxPolicy.type", "must equal 'workspaceWrite'");
-    if (!Array.isArray(sandbox.writableRoots) || sandbox.writableRoots.length === 0) {
-        throw snapshotError("provider.sandboxPolicy.writableRoots", "must be a nonempty array");
-    }
-    const roots = sandbox.writableRoots.map((root, index) => {
-        if (typeof root !== "string" || !path.isAbsolute(root) || path.resolve(root) !== root) {
-            throw snapshotError(`provider.sandboxPolicy.writableRoots[${index}]`, "must be a lexically normalized absolute path");
-        }
-        return root;
-    });
-    if (new Set(roots).size !== roots.length) {
-        throw snapshotError("provider.sandboxPolicy.writableRoots", "must not contain duplicates");
-    }
-    for (const key of ["networkAccess", "excludeTmpdirEnvVar", "excludeSlashTmp"]) {
-        if (typeof sandbox[key] !== "boolean")
-            throw snapshotError(`provider.sandboxPolicy.${key}`, "must be a boolean");
-    }
-    Object.freeze(roots);
-    return Object.freeze({
-        type: "workspaceWrite",
-        writableRoots: roots,
-        networkAccess: sandbox.networkAccess,
-        excludeTmpdirEnvVar: sandbox.excludeTmpdirEnvVar,
-        excludeSlashTmp: sandbox.excludeSlashTmp,
-    });
-}
 function parseProvider(value) {
     const provider = objectAt(value, "provider");
     const kind = requiredString(provider, "kind", "provider");
-    const common = parseProviderCommon(provider);
-    switch (kind) {
-        case "codex-sdk": {
-            exactKeys(provider, ["name", "source", "kind", "executable", "profile", "config", "threadOptions"], "provider");
-            if (!("threadOptions" in provider))
-                throw snapshotError("provider.threadOptions", "is required");
-            const executable = optionalString(provider, "executable", "provider");
-            const profile = optionalString(provider, "profile", "provider");
-            const config = optionalJsonObject(provider, "config");
-            return Object.freeze({ ...common, kind, ...(executable !== undefined ? { executable } : {}), ...(profile !== undefined ? { profile } : {}), ...(config !== undefined ? { config } : {}), threadOptions: cloneJsonObject(provider.threadOptions, "provider.threadOptions") });
-        }
-        case "codex-app-server": {
-            exactKeys(provider, ["name", "source", "kind", "executable", "profile", "config", "model", "effort", "sandboxPolicy", "approvalPolicy", "env"], "provider");
-            if ("approvalPolicy" in provider && provider.approvalPolicy !== "never")
-                throw snapshotError("provider.approvalPolicy", "must equal 'never'");
-            const executable = optionalString(provider, "executable", "provider");
-            const profile = optionalString(provider, "profile", "provider");
-            const config = optionalJsonObject(provider, "config");
-            const model = optionalString(provider, "model", "provider");
-            const effort = optionalString(provider, "effort", "provider");
-            const sandboxPolicy = "sandboxPolicy" in provider ? parseSandboxPolicy(provider.sandboxPolicy) : undefined;
-            const env = optionalStringRecord(provider, "env");
-            return Object.freeze({ ...common, kind, ...(executable !== undefined ? { executable } : {}), ...(profile !== undefined ? { profile } : {}), ...(config !== undefined ? { config } : {}), ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { effort } : {}), ...(sandboxPolicy !== undefined ? { sandboxPolicy } : {}), ...(provider.approvalPolicy === "never" ? { approvalPolicy: "never" } : {}), ...(env !== undefined ? { env } : {}) });
-        }
-        case "claude-agent-sdk": {
-            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, ...(executable !== undefined ? { executable } : {}), ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { effort } : {}), ...(settingSources !== undefined ? { settingSources } : {}), permissionMode, ...(permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}), ...(disallowedTools !== undefined ? { disallowedTools } : {}), ...(env !== undefined ? { env } : {}) });
-        }
-        case "opencode-sdk": {
-            exactKeys(provider, ["name", "source", "kind", "executable", "model", "effort", "env"], "provider");
-            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, ...(executable !== undefined ? { executable } : {}), ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { effort } : {}), ...(env !== undefined ? { env } : {}) });
-        }
-        case "pi": {
-            exactKeys(provider, ["name", "source", "kind", "model", "thinkingLevel", "env"], "provider");
-            const model = optionalString(provider, "model", "provider");
-            const thinkingLevel = optionalString(provider, "thinkingLevel", "provider");
-            const env = optionalStringRecord(provider, "env");
-            return Object.freeze({ ...common, kind, ...(model !== undefined ? { model } : {}), ...(thinkingLevel !== undefined ? { thinkingLevel } : {}), ...(env !== undefined ? { env } : {}) });
-        }
-        default:
-            throw snapshotError("provider.kind", `has invalid value '${kind}'`);
+    if (!isSubagentProvider(kind)) {
+        throw snapshotError("provider.kind", `has invalid value '${kind}'`);
     }
+    const common = parseProviderCommon(provider);
+    return getProviderRegistration(kind).parseLaunchProvider(provider, common);
 }
 export function parseResolvedAkumaLaunchSnapshot(value) {
     const snapshot = objectAt(value, "resolved Akuma launch snapshot");
@@ -321,7 +109,11 @@ export function parseResolvedAkumaLaunchSnapshot(value) {
         throw snapshotError("akuma", "is required");
     if (!("provider" in snapshot))
         throw snapshotError("provider", "is required");
-    const parsed = Object.freeze({ version: 1, akuma: parseAkuma(snapshot.akuma), provider: parseProvider(snapshot.provider) });
+    const parsed = Object.freeze({
+        version: 1,
+        akuma: parseAkuma(snapshot.akuma),
+        provider: parseProvider(snapshot.provider),
+    });
     assertSnapshotEffortRequiresModel(parsed);
     return parsed;
 }
@@ -329,20 +121,7 @@ export function applySnapshotEffort(snapshot, effort) {
     assertEffortAllowed(effort, snapshot.akuma.effortOptions);
     assertEffortRequiresModel(snapshot.akuma.model, effort, "override");
     const akuma = { ...snapshot.akuma, effort };
-    let provider;
-    switch (snapshot.provider.kind) {
-        case "codex-sdk":
-            provider = { ...snapshot.provider, threadOptions: { ...snapshot.provider.threadOptions, modelReasoningEffort: effort } };
-            break;
-        case "codex-app-server":
-        case "claude-agent-sdk":
-        case "opencode-sdk":
-            provider = { ...snapshot.provider, effort };
-            break;
-        case "pi":
-            provider = { ...snapshot.provider, thinkingLevel: effort };
-            break;
-    }
+    const provider = getProviderRegistration(snapshot.provider.kind).applyEffort(snapshot.provider, effort);
     return parseResolvedAkumaLaunchSnapshot({ version: 1, akuma, provider });
 }
 export { assertEffortAllowed, assertEffortRequiresModel };

package/build/agents/launch-snapshot/parse-helpers.js

@@ -0,0 +1,114 @@
+import * as path from "node:path";
+export function snapshotError(fieldPath, message) {
+    return new Error(`Invalid resolved Akuma launch snapshot at ${fieldPath}: ${message}`);
+}
+export function isPlainObject(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+export function objectAt(value, fieldPath) {
+    if (!isPlainObject(value))
+        throw snapshotError(fieldPath, "must be a plain JSON object");
+    return value;
+}
+export function exactKeys(value, allowed, fieldPath) {
+    const allowedSet = new Set(allowed);
+    for (const key of Object.keys(value)) {
+        if (!allowedSet.has(key))
+            throw snapshotError(`${fieldPath}.${key}`, "is an unknown field");
+    }
+}
+export function requiredString(value, key, fieldPath, allowBlank = false) {
+    const item = value[key];
+    if (typeof item !== "string" || (!allowBlank && item.trim().length === 0)) {
+        throw snapshotError(`${fieldPath}.${key}`, allowBlank ? "must be a string" : "must be a nonblank string");
+    }
+    return item;
+}
+export function optionalString(value, key, fieldPath) {
+    if (!(key in value))
+        return undefined;
+    return requiredString(value, key, fieldPath);
+}
+export function requiredEnum(value, key, fieldPath, values) {
+    const item = requiredString(value, key, fieldPath);
+    if (!values.has(item))
+        throw snapshotError(`${fieldPath}.${key}`, `has invalid value '${item}'`);
+    return item;
+}
+function cloneJson(value, fieldPath, ancestors = new Set()) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw snapshotError(fieldPath, "contains a non-finite number");
+        return value;
+    }
+    if (typeof value !== "object")
+        throw snapshotError(fieldPath, "contains a non-JSON value");
+    if (ancestors.has(value))
+        throw snapshotError(fieldPath, "contains a cycle");
+    ancestors.add(value);
+    try {
+        if (Array.isArray(value)) {
+            return Object.freeze(value.map((item, index) => cloneJson(item, `${fieldPath}[${index}]`, ancestors)));
+        }
+        if (!isPlainObject(value))
+            throw snapshotError(fieldPath, "contains a non-plain JSON object");
+        const result = {};
+        for (const [key, item] of Object.entries(value)) {
+            Object.defineProperty(result, key, {
+                value: cloneJson(item, `${fieldPath}.${key}`, ancestors),
+                enumerable: true,
+                configurable: true,
+                writable: true,
+            });
+        }
+        return Object.freeze(result);
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+export function cloneJsonObject(value, fieldPath) {
+    const cloned = cloneJson(value, fieldPath);
+    if (!isPlainObject(cloned)) {
+        throw snapshotError(fieldPath, "must be a plain JSON object");
+    }
+    return cloned;
+}
+export function optionalJsonObject(provider, key) {
+    return key in provider ? cloneJsonObject(provider[key], `provider.${key}`) : undefined;
+}
+export function optionalStringRecord(provider, key) {
+    if (!(key in provider))
+        return undefined;
+    const value = provider[key];
+    if (!isPlainObject(value))
+        throw snapshotError(`provider.${key}`, "must be a plain JSON object");
+    const result = {};
+    for (const [entryKey, entryValue] of Object.entries(value)) {
+        if (typeof entryValue !== "string") {
+            throw snapshotError(`provider.${key}.${entryKey}`, "must be a string");
+        }
+        result[entryKey] = entryValue;
+    }
+    return Object.freeze(result);
+}
+export function parseAbsoluteRootList(value, fieldPath) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw snapshotError(fieldPath, "must be a nonempty array");
+    }
+    const roots = value.map((root, index) => {
+        if (typeof root !== "string" || !path.isAbsolute(root) || path.resolve(root) !== root) {
+            throw snapshotError(`${fieldPath}[${index}]`, "must be a lexically normalized absolute path");
+        }
+        return root;
+    });
+    if (new Set(roots).size !== roots.length) {
+        throw snapshotError(fieldPath, "must not contain duplicates");
+    }
+    return Object.freeze(roots);
+}