@astrosheep/keiyaku 2.9.2 → 2.9.4

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);
+}

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;