akm-cli 0.9.1 → 0.9.2-alpha.1

package/dist/integrations/agent/engine-resolution.js

@@ -8,59 +8,74 @@ import { formatExtraParamsIssue, validateExtraParams } from "../../core/extra-pa
 import { collectSensitiveValues } from "../../core/redaction.js";
 import { getHarness } from "../harnesses/index.js";
 import { DEFAULT_AGENT_TIMEOUT_MS, DEFAULT_LLM_TIMEOUT_MS } from "./config.js";
-import { resolveLlmModel, resolveModel } from "./model-aliases.js";
 import { getBuiltinAgentProfile } from "./profiles.js";
 function hasOwn(value, key) {
     return Object.hasOwn(value, key);
 }
+function ownValue(value, key) {
+    return hasOwn(value, key) ? value[key] : undefined;
+}
+function sterileRecord(value) {
+    return Object.assign(Object.create(null), value);
+}
 function envName(reference) {
     const match = /^\$(?:\{)?([A-Za-z_][A-Za-z0-9_]*)(?:\})?$/.exec(reference);
     return match?.[1];
 }
 function selectedEngineName(config, layers, llmOnly) {
     for (let index = layers.length - 1; index >= 0; index--) {
-        if (layers[index]?.engine !== undefined)
-            return layers[index]?.engine;
+        const layer = layers[index];
+        if (!layer)
+            continue;
+        const engine = ownValue(layer, "engine");
+        if (engine !== undefined)
+            return engine;
     }
-    return llmOnly ? config.defaults?.llmEngine : config.defaults?.engine;
+    const defaults = ownValue(config, "defaults");
+    return defaults ? ownValue(defaults, llmOnly ? "llmEngine" : "engine") : undefined;
 }
 function resolveEngineConfig(name, config) {
-    const engine = config.engines?.[name];
+    const engines = ownValue(config, "engines");
+    const engine = engines && hasOwn(engines, name) ? engines[name] : undefined;
     if (!engine) {
         throw new ConfigError(`Engine "${name}" is not configured.`, "INVALID_CONFIG_FILE");
     }
     return engine;
 }
 function resolveCredential(name, engine, config) {
-    if (engine.apiKey !== undefined) {
-        const explicit = envName(engine.apiKey);
+    const apiKey = ownValue(engine, "apiKey");
+    if (apiKey !== undefined) {
+        const explicit = envName(apiKey);
         if (!explicit)
             throw new ConfigError(`Engine "${name}" has an invalid symbolic apiKey reference.`, "INVALID_CONFIG_FILE");
         return { names: [explicit], required: true };
     }
     const specific = `AKM_ENGINE_${name.toUpperCase().replaceAll("-", "_")}_API_KEY`;
-    return config.defaults?.llmEngine === name
+    const defaults = ownValue(config, "defaults");
+    return (defaults ? ownValue(defaults, "llmEngine") : undefined) === name
         ? { names: [specific, "AKM_LLM_API_KEY"], required: false }
         : { names: [specific], required: false };
 }
 /**
- * Read a credential descriptor's value out of `process.env`: the FIRST
- * non-empty trimmed value across `names`, in declared order. A `required`
- * descriptor that resolves to nothing is a config error naming its PRIMARY
- * variable — the one an operator is told to set.
- *
- * The ONE env-credential seam. The live-config dispatch boundary
- * ({@link materializeLlmConnection}) and the FROZEN workflow dispatch boundary
- * (`materializeFrozenLlm` in `workflows/exec/unit-dispatch.ts`, whose frozen
- * snapshots carry a structurally identical descriptor) both read through it, so
- * lookup order and the failure message cannot drift between them.
+ * Lookup-only credential projection used by redaction inventories. Returns the
+ * first non-empty trimmed value without enforcing a required descriptor.
  */
-export function resolveCredentialFromEnv(credential) {
+export function lookupCredentialFromEnv(credential, envSource = process.env) {
     for (const name of credential?.names ?? []) {
-        const candidate = process.env[name]?.trim();
+        const candidate = envSource[name]?.trim();
         if (candidate)
             return candidate;
     }
+    return undefined;
+}
+/**
+ * The enforcing env-credential seam. Live and frozen dispatch use the same
+ * ordered lookup; a missing required descriptor names its primary variable.
+ */
+export function resolveCredentialFromEnv(credential, envSource = process.env) {
+    const value = lookupCredentialFromEnv(credential, envSource);
+    if (value)
+        return value;
     if (credential?.required) {
         throw new ConfigError(`Required engine credential ${credential.names[0]} is not set.`, "INVALID_CONFIG_FILE");
     }
@@ -69,7 +84,7 @@ export function resolveCredentialFromEnv(credential) {
 /** Collect materialized engine credentials for output and persistence redaction. */
 export function collectEngineCredentialValues(config, envSource = process.env) {
     const values = new Set();
-    for (const [name, engine] of Object.entries(config.engines ?? {})) {
+    for (const [name, engine] of Object.entries(ownValue(config, "engines") ?? {})) {
         if (engine.kind !== "llm")
             continue;
         for (const envVar of resolveCredential(name, engine, config)?.names ?? []) {
@@ -87,6 +102,25 @@ function effectiveTimeout(engine, layers, fallback) {
     }
     return hasOwn(engine, "timeoutMs") ? (engine.timeoutMs ?? null) : fallback;
 }
+function rawLlmConnection(engine) {
+    const connection = {
+        provider: ownValue(engine, "provider"),
+        endpoint: ownValue(engine, "endpoint"),
+        model: ownValue(engine, "model"),
+        temperature: ownValue(engine, "temperature"),
+        maxTokens: ownValue(engine, "maxTokens"),
+        supportsJsonSchema: ownValue(engine, "supportsJsonSchema"),
+        extraParams: ownValue(engine, "extraParams"),
+        contextLength: ownValue(engine, "contextLength"),
+        enableThinking: ownValue(engine, "enableThinking"),
+        reasoningEffort: ownValue(engine, "reasoningEffort"),
+    };
+    for (const key of Object.keys(connection)) {
+        if (connection[key] === undefined)
+            delete connection[key];
+    }
+    return connection;
+}
 export function resolveLlmEngineUse(config, layers, options = {}) {
     const name = selectedEngineName(config, layers, true);
     if (!name) {
@@ -98,49 +132,44 @@ export function resolveLlmEngineUse(config, layers, options = {}) {
     if (engine.kind !== "llm") {
         throw new ConfigError(`Engine "${name}" is not an LLM engine.`, "INVALID_CONFIG_FILE");
     }
-    let connection = {
-        provider: engine.provider,
-        endpoint: engine.endpoint,
-        model: engine.model,
-        temperature: engine.temperature,
-        maxTokens: engine.maxTokens,
-        supportsJsonSchema: engine.supportsJsonSchema,
-        extraParams: engine.extraParams,
-        contextLength: engine.contextLength,
-        enableThinking: engine.enableThinking,
-    };
+    let connection = rawLlmConnection(engine);
     for (const layer of layers) {
-        if (layer.llm)
-            connection = deepMergeConfig(connection, layer.llm);
-        if (layer.model !== undefined)
-            connection.model = layer.model;
+        const llm = ownValue(layer, "llm");
+        const model = ownValue(layer, "model");
+        if (llm)
+            connection = deepMergeConfig(connection, llm);
+        if (model !== undefined)
+            connection.model = model;
     }
     for (const key of Object.keys(connection)) {
         if (connection[key] === undefined)
             delete connection[key];
     }
-    connection.model = resolveLlmModel(connection.model, name, config.modelAliases);
     return {
         engine: name,
-        connection: connection,
+        connection: sterileRecord(connection),
         credential: resolveCredential(name, engine, config),
         timeoutMs: effectiveTimeout(engine, layers, DEFAULT_LLM_TIMEOUT_MS),
     };
 }
 /** Read a resolved symbolic credential only at the runtime dispatch boundary. */
-export function materializeLlmConnection(resolved) {
-    if (resolved.connection.extraParams !== undefined) {
-        const issue = validateExtraParams(resolved.connection.extraParams)[0];
+export function materializeLlmConnectionWithCredential(resolved, credentialValue) {
+    const extraParams = ownValue(resolved.connection, "extraParams");
+    if (extraParams !== undefined) {
+        const issue = validateExtraParams(extraParams)[0];
         if (issue) {
             throw new ConfigError(formatExtraParamsIssue(`Engine "${resolved.engine}" extraParams`, issue), "INVALID_CONFIG_FILE");
         }
     }
-    const apiKey = resolveCredentialFromEnv(resolved.credential);
-    return {
+    return sterileRecord({
         ...resolved.connection,
-        ...(apiKey ? { apiKey } : {}),
+        ...(credentialValue ? { apiKey: credentialValue } : {}),
         timeoutMs: resolved.timeoutMs,
-    };
+    });
+}
+/** Read and inject one resolved symbolic credential at the runtime boundary. */
+export function materializeLlmConnection(resolved, envSource = process.env) {
+    return materializeLlmConnectionWithCredential(resolved, resolveCredentialFromEnv(resolved.credential, envSource));
 }
 function lowerAgentEngine(name, engine, config) {
     const harness = getHarness(engine.platform);
@@ -150,25 +179,23 @@ function lowerAgentEngine(name, engine, config) {
     const platform = harness.id;
     const sdk = platform === "opencode-sdk";
     const builtin = getBuiltinAgentProfile(platform);
-    const profile = {
+    const bin = ownValue(engine, "bin");
+    const args = ownValue(engine, "args");
+    const workspace = ownValue(engine, "workspace");
+    const model = ownValue(engine, "model");
+    const profile = sterileRecord({
         name,
         platform,
-        bin: engine.bin ?? builtin?.bin ?? (sdk ? "opencode" : platform),
-        args: engine.args ?? builtin?.args ?? [],
+        personaChannel: sdk ? "native" : (harness.agentBuilder?.personaChannel ?? "prompt"),
+        bin: bin ?? builtin?.bin ?? (sdk ? "opencode" : platform),
+        args: args ?? builtin?.args ?? [],
         stdio: "captured",
         ...(builtin?.env ? { env: builtin.env } : {}),
         envPassthrough: builtin?.envPassthrough ?? [],
         parseOutput: "text",
-        ...(engine.workspace ? { workspace: path.resolve(engine.workspace) } : {}),
-        ...(engine.model
-            ? {
-                model: resolveModel(engine.model, platform, engine.modelAliases, config.modelAliases),
-                modelIsExact: true,
-            }
-            : {}),
-        ...(engine.modelAliases ? { modelAliases: engine.modelAliases } : {}),
-        ...(config.modelAliases ? { globalModelAliases: config.modelAliases } : {}),
-    };
+        ...(workspace ? { workspace: path.resolve(workspace) } : {}),
+        ...(model ? { model } : {}),
+    });
     if (!sdk) {
         return {
             kind: "agent",
@@ -177,7 +204,8 @@ function lowerAgentEngine(name, engine, config) {
             timeoutMs: hasOwn(engine, "timeoutMs") ? (engine.timeoutMs ?? null) : DEFAULT_AGENT_TIMEOUT_MS,
         };
     }
-    const fallbackName = engine.llmEngine ?? config.defaults?.llmEngine;
+    const defaults = ownValue(config, "defaults");
+    const fallbackName = ownValue(engine, "llmEngine") ?? (defaults ? ownValue(defaults, "llmEngine") : undefined);
     const fallback = fallbackName
         ? resolveLlmEngineUse(config, [{ engine: fallbackName }], { optional: true })
         : undefined;
@@ -214,31 +242,3 @@ export function resolveEngine(name, config) {
     }
     return lowerAgentEngine(name, engine, config);
 }
-export function resolveDefaultEngine(config) {
-    const name = config.defaults?.engine;
-    if (!name)
-        throw new ConfigError("No default engine is configured.", "INVALID_CONFIG_FILE");
-    return resolveEngine(name, config);
-}
-// ── AkmConfig convenience wrappers (moved from core/config/config.ts, WI-9.8
-// KILL 3, D.3 edge A) ────────────────────────────────────────────────────────
-//
-// Moved verbatim: `config.ts` previously called `materializeLlmConnection` +
-// `resolveLlmEngineUse` directly for these two wrappers, which is what made
-// config.ts import this module — and this module imported `LlmConnectionConfig`
-// back from config.ts, closing a 2-file cycle. config.ts CANNOT re-export
-// these (a re-export is still a graph edge to this file), so the small number
-// of call sites that used to import them from "core/config/config" now import
-// them from here instead (see D.3 edge A "callers compose instead").
-/** Resolve and materialize the configured default LLM engine at dispatch time. */
-export function requireLlmConfig(config) {
-    return materializeLlmConnection(resolveLlmEngineUse(config, []));
-}
-/**
- * Like {@link requireLlmConfig} but returns `undefined` instead of throwing
- * when no LLM is configured. Use in code paths where the LLM is optional.
- */
-export function getDefaultLlmConfig(config) {
-    const resolved = resolveLlmEngineUse(config, [], { optional: true });
-    return resolved ? materializeLlmConnection(resolved) : undefined;
-}