akm-cli 0.9.1 → 0.9.2-alpha.2

package/dist/workflows/ir/freeze.js

@@ -1,320 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import path from "node:path";
-import { deepMergeConfig } from "../../core/config/deep-merge.js";
-import { ConfigError, UsageError } from "../../core/errors.js";
-import { DEFAULT_AGENT_TIMEOUT_MS, DEFAULT_LLM_TIMEOUT_MS } from "../../integrations/agent/config.js";
-import { FALLBACK_ANNOUNCEMENT, NO_ENGINE_MESSAGE_SUFFIX, NO_ENGINE_REMEDY, withEngineFallback, } from "../../integrations/agent/engine-fallback.js";
-import { resolveLlmEngineUse, } from "../../integrations/agent/engine-resolution.js";
-import { resolveLlmModel, resolveModel } from "../../integrations/agent/model-aliases.js";
-import { getBuiltinAgentProfile } from "../../integrations/agent/profiles.js";
-import { HARNESS_BY_ID } from "../../integrations/harnesses/index.js";
-import { defaultLlmEngineConcurrency, defaultMapConcurrency, workflowMaxConcurrency } from "../concurrency-policy.js";
-import { projectExecCore } from "../program/schema.js";
-import { DEFAULT_EXEC_TIMEOUT_MS } from "../resource-limits.js";
-import { compileWorkflowPlan } from "./compile.js";
-import { decodeWorkflowPlanV3, WORKFLOW_IR_VERSION } from "./schema.js";
-/**
- * The only source-to-runtime boundary. Source compilation remains pure; engine
- * selection and every dispatch-significant setting are resolved here once.
- */
-export function compileResolveFreezeWorkflow(asset, inputConfig, options = {}) {
-    // Applied ONCE, before any resolution: every engine lookup below (selection,
-    // snapshots, the gate judge) then sees one config and needs no fallback
-    // awareness of its own.
-    const { config, fallbackEngineName } = withEngineFallback(inputConfig);
-    // Announce only if the fallback candidate is what a unit actually froze to:
-    // `defaults.engine` is the lowest-precedence selector, so a document- or
-    // unit-level `engine:` still wins and must not be reported as opencode's.
-    let usedFallbackEngine = false;
-    const preliminary = (options.compile ?? compilePlan)(asset);
-    const engines = {};
-    const maxConcurrency = frozenConcurrency(config);
-    const mapDefaultConcurrency = frozenMapDefaultConcurrency(config);
-    const documentDefaults = asset.document.defaults;
-    // Keyed by stepId, NOT by array position. Compile is 1:1 and order-preserving
-    // today, so `asset.document.steps[index]` happened to line up with
-    // `preliminary.steps[index]` — but nothing enforces that, and a compile pass
-    // that ever filtered or reordered steps would silently attribute one step's
-    // engine/model/timeout overrides to a different step. Every draft step
-    // already carries its `stepId`, so look the source up by it.
-    const sourceStepsById = new Map(asset.document.steps.map((step) => [step.id, step]));
-    const freezeInvocation = (unit, stepId) => {
-        const layers = [...(documentDefaults ? [documentDefaults] : []), ...(unit ? [unit] : [])];
-        const name = selectedEngine(config, layers);
-        if (!name)
-            throw new ConfigError(
-            // Reached only when the implicit opencode-sdk fallback did not apply
-            // either, so the remedy names both routes.
-            `This workflow ${NO_ENGINE_MESSAGE_SUFFIX} Set defaults.engine or workflow defaults.engine.`, "INVALID_CONFIG_FILE", NO_ENGINE_REMEDY);
-        if (name === fallbackEngineName)
-            usedFallbackEngine = true;
-        const engine = engineDefinition(config, name);
-        addSnapshot(config, name, engines);
-        const model = exactModel(config, name, engine, layers);
-        const timeoutMs = effectiveTimeout(config, engine, layers);
-        // Merge llm overrides REGARDLESS of engine kind so a non-llm engine with
-        // overrides anywhere in its layer stack (unit `llm:` or document
-        // `defaults.llm`) is detected instead of silently dropped. SDK engines'
-        // legitimate LLM *fallback* (`llmEngine`) is a separate mechanism — it
-        // never contributes to `layers`, so it cannot false-positive here.
-        const llm = mergedLlmOverrides(layers);
-        if (engine.kind !== "llm" && llm !== undefined) {
-            throw new ConfigError(`Workflow step "${stepId}" uses engine "${name}", which is an agent engine and cannot receive llm: ` +
-                `overrides — llm: tuning (from the step's unit or defaults.llm) applies only to engines of kind "llm". ` +
-                `Remove the llm: block or select an LLM engine for this step.`, "INVALID_CONFIG_FILE");
-        }
-        return { engine: name, model, timeoutMs, ...(llm ? { llm } : {}) };
-    };
-    /**
-     * Resolve an exec unit's wall-clock budget at the single freeze boundary:
-     * unit `timeout:` → document `defaults.timeout` → {@link DEFAULT_EXEC_TIMEOUT_MS}.
-     * There is no engine layer to consult — an exec unit names no engine — and
-     * `null` (the author's `timeout: none`) is honored as genuinely unbounded,
-     * exactly like `effectiveTimeout`'s null.
-     */
-    const freezeExec = (exec, unit) => {
-        const layers = [...(documentDefaults ? [documentDefaults] : []), ...(unit ? [unit] : [])];
-        const declared = layeredTimeout(layers);
-        const timeoutMs = declared === undefined ? DEFAULT_EXEC_TIMEOUT_MS : declared;
-        // The shared structural projection, plus the one thing freezing adds: the
-        // RESOLVED timeout. The default allowlist stays the ABSENCE of both env
-        // keys — one encoding per state, which is what keeps the canonical hash
-        // preimage stable. `command` is non-empty by parser construction.
-        const core = projectExecCore(exec);
-        return {
-            ...core,
-            command: core.command,
-            timeoutMs,
-        };
-    };
-    const freezeUnit = (node, stepId, unit) => ({
-        kind: "unit",
-        id: node.id,
-        instructions: node.instructions,
-        templating: node.templating ?? "verbatim",
-        ...(node.inputs && node.inputs.length > 0 ? { inputs: node.inputs } : {}),
-        // An exec unit dispatches a child process, so it freezes an exec spec and
-        // NO invocation — engine selection is skipped entirely, which is why an
-        // exec-only workflow runs on an install with no engines configured at all.
-        ...(node.exec ? { exec: freezeExec(node.exec, unit) } : { invocation: freezeInvocation(unit, stepId) }),
-        ...(node.schema ? { schema: node.schema } : {}),
-        ...(node.retry ? { retry: node.retry } : {}),
-        onError: node.onError,
-        ...(node.env ? { env: node.env } : {}),
-        isolation: node.isolation ?? "none",
-        ...(node.source ? { source: node.source } : {}),
-    });
-    const steps = preliminary.steps.map((step) => {
-        const sourceStep = sourceStepsById.get(step.stepId);
-        const sourceUnit = sourceStep?.map ? sourceStep.map.unit : sourceStep?.unit;
-        const root = step.root
-            ? step.root.kind === "map"
-                ? {
-                    kind: "map",
-                    id: step.root.id,
-                    over: step.root.over,
-                    template: freezeUnit(step.root.template, step.stepId, sourceUnit),
-                    // `?? ` — not `||` — keeps an authored `concurrency: 1` (explicit
-                    // opt-out, serial) distinguishable from an unset one (the default).
-                    concurrency: step.root.concurrency ?? mapDefaultConcurrency,
-                    reducer: step.root.reducer,
-                    ...(step.root.source ? { source: step.root.source } : {}),
-                }
-                : freezeUnit(step.root, step.stepId, sourceUnit)
-            : undefined;
-        const criteria = step.gate.criteria;
-        const judge = criteria.length === 0 ? null : freezeGateJudge(config, engines);
-        const gate = {
-            kind: "gate",
-            id: `${step.stepId}.gate`,
-            stepId: step.stepId,
-            criteria,
-            maxLoops: step.gate.maxLoops ?? 1,
-            judge,
-        };
-        return {
-            stepId: step.stepId,
-            title: step.title,
-            sequenceIndex: step.sequenceIndex,
-            ...(root ? { root } : {}),
-            ...(step.route ? { route: step.route } : {}),
-            ...(step.outputSchema ? { outputSchema: step.outputSchema } : {}),
-            gate,
-        };
-    });
-    const plan = decodeWorkflowPlanV3({
-        irVersion: WORKFLOW_IR_VERSION,
-        title: preliminary.title,
-        ...(preliminary.params ? { params: preliminary.params } : {}),
-        ...(preliminary.paramSchemas ? { paramSchemas: preliminary.paramSchemas } : {}),
-        ...(preliminary.budget ? { budget: preliminary.budget } : {}),
-        execution: { maxConcurrency, engines },
-        steps,
-    });
-    // `usedFallbackEngine` IS the candidate-won predicate, so use the constant
-    // directly rather than re-asking a helper to compare a name with itself.
-    const engineAnnouncement = usedFallbackEngine ? FALLBACK_ANNOUNCEMENT : undefined;
-    return {
-        warnings: preliminary.warnings,
-        ...(engineAnnouncement ? { engineAnnouncement } : {}),
-        plan,
-    };
-}
-function compilePlan(asset) {
-    const compiled = compileWorkflowPlan(asset.document, asset.title);
-    if (!compiled.ok)
-        throw new UsageError(compiled.errors.map((error) => `${asset.path}:${error.line}: ${error.message}`).join("\n"));
-    return { ...compiled.plan, warnings: compiled.warnings };
-}
-function selectedEngine(config, layers) {
-    for (let index = layers.length - 1; index >= 0; index--)
-        if (layers[index]?.engine !== undefined)
-            return layers[index]?.engine;
-    return config.defaults?.engine;
-}
-function engineDefinition(config, name) {
-    const engine = config.engines?.[name];
-    if (!engine)
-        throw new ConfigError(`Engine "${name}" is not configured.`, "INVALID_CONFIG_FILE");
-    return engine;
-}
-function exactModel(config, name, engine, layers) {
-    let selected;
-    for (const layer of layers)
-        if (layer.model !== undefined)
-            selected = layer.model;
-    selected ??= engine.model;
-    if (!selected) {
-        if (engine.kind === "llm")
-            throw new ConfigError(`LLM engine "${name}" has no model.`, "INVALID_CONFIG_FILE");
-        if (engine.platform === "opencode-sdk") {
-            const fallbackName = engine.llmEngine ?? config.defaults?.llmEngine;
-            if (fallbackName) {
-                const fallback = engineDefinition(config, fallbackName);
-                if (fallback.kind !== "llm") {
-                    throw new ConfigError(`SDK engine "${name}" fallback "${fallbackName}" is not an LLM engine.`, "INVALID_CONFIG_FILE");
-                }
-                return exactModel(config, fallbackName, fallback, []);
-            }
-        }
-        return null;
-    }
-    if (engine.kind === "llm")
-        return resolveLlmModel(selected, name, config.modelAliases);
-    return resolveModel(selected, engine.platform, engine.modelAliases, config.modelAliases);
-}
-/**
- * Newest-layer-first scan for a declared `timeoutMs` across authoring layers
- * (document `defaults`, then the unit). Returns `undefined` when no layer
- * declares one; an explicit `timeoutMs: null` ("unbounded") wins over deeper
- * layers — hence `hasOwn`, not a value test. The ONE definition of authoring
- * timeout precedence, shared by engine and exec freezing.
- */
-function layeredTimeout(layers) {
-    for (let index = layers.length - 1; index >= 0; index--) {
-        if (Object.hasOwn(layers[index] ?? {}, "timeoutMs"))
-            return layers[index]?.timeoutMs ?? null;
-    }
-    return undefined;
-}
-function effectiveTimeout(config, engine, layers) {
-    const declared = layeredTimeout(layers);
-    if (declared !== undefined)
-        return declared;
-    if (Object.hasOwn(engine, "timeoutMs"))
-        return engine.timeoutMs ?? null;
-    if (engine.kind === "llm")
-        return DEFAULT_LLM_TIMEOUT_MS;
-    if (engine.platform === "opencode-sdk") {
-        const fallbackName = engine.llmEngine ?? config.defaults?.llmEngine;
-        if (fallbackName) {
-            const fallback = engineDefinition(config, fallbackName);
-            if (fallback.kind === "llm") {
-                return Object.hasOwn(fallback, "timeoutMs") ? (fallback.timeoutMs ?? null) : DEFAULT_LLM_TIMEOUT_MS;
-            }
-        }
-    }
-    return DEFAULT_AGENT_TIMEOUT_MS;
-}
-function mergedLlmOverrides(layers) {
-    let merged;
-    for (const layer of layers)
-        if (layer.llm)
-            merged = deepMergeConfig(merged ?? {}, layer.llm);
-    return merged;
-}
-function addSnapshot(config, name, target) {
-    if (target[name])
-        return;
-    const engine = engineDefinition(config, name);
-    if (engine.kind === "llm") {
-        const resolved = resolveLlmEngineUse(config, [{ engine: name }]);
-        const snapshot = {
-            name,
-            kind: "llm",
-            endpoint: engine.endpoint,
-            model: exactModel(config, name, engine, []),
-            concurrency: defaultLlmEngineConcurrency(engine.endpoint, engine.concurrency),
-            ...(engine.provider ? { provider: engine.provider } : {}),
-            ...(resolved.credential ? { credential: resolved.credential } : {}),
-            ...(engine.temperature !== undefined ? { temperature: engine.temperature } : {}),
-            ...(engine.maxTokens !== undefined ? { maxTokens: engine.maxTokens } : {}),
-            ...(engine.supportsJsonSchema !== undefined ? { supportsJsonSchema: engine.supportsJsonSchema } : {}),
-            ...(engine.extraParams ? { extraParams: engine.extraParams } : {}),
-            ...(engine.contextLength !== undefined ? { contextLength: engine.contextLength } : {}),
-            ...(engine.enableThinking !== undefined ? { enableThinking: engine.enableThinking } : {}),
-        };
-        target[name] = snapshot;
-        return;
-    }
-    const harness = HARNESS_BY_ID.get(engine.platform);
-    if (!harness?.capabilities.agentDispatch)
-        throw new ConfigError(`Engine "${name}" cannot dispatch platform ${engine.platform}.`, "INVALID_CONFIG_FILE");
-    const sdk = engine.platform === "opencode-sdk";
-    const builtin = getBuiltinAgentProfile(engine.platform);
-    const fallback = sdk ? (engine.llmEngine ?? config.defaults?.llmEngine ?? null) : null;
-    if (fallback)
-        addSnapshot(config, fallback, target);
-    const snapshot = {
-        name,
-        kind: "agent",
-        runnerKind: sdk ? "sdk" : "agent",
-        platform: engine.platform,
-        bin: engine.bin ?? builtin?.bin ?? (sdk ? "opencode" : engine.platform),
-        args: [...(engine.args ?? builtin?.args ?? [])],
-        workspace: engine.workspace ? path.resolve(engine.workspace) : null,
-        envPassthrough: [...(builtin?.envPassthrough ?? [])],
-        commandBuilder: engine.platform,
-        fallbackLlmEngine: fallback,
-    };
-    target[name] = snapshot;
-}
-function freezeGateJudge(config, engines) {
-    const name = config.workflow?.judgeEngine;
-    if (!name) {
-        throw new ConfigError("This workflow declares completion criteria but no verification engine is configured. Set workflow.judgeEngine to a named LLM or agent engine.", "INVALID_CONFIG_FILE");
-    }
-    const engine = engineDefinition(config, name);
-    addSnapshot(config, name, engines);
-    return {
-        engine: name,
-        model: exactModel(config, name, engine, []),
-        timeoutMs: effectiveTimeout(config, engine, []),
-    };
-}
-function frozenConcurrency(config) {
-    const configured = config.workflow?.maxConcurrency;
-    return workflowMaxConcurrency(typeof configured === "number" && Number.isFinite(configured) ? configured : undefined);
-}
-/**
- * Width to freeze into a `map` node that declared no `concurrency:`. Resolved
- * HERE, at the single freeze boundary, so the number lands in `plan_json` and
- * an in-flight run keeps the width it started with even if this default (or
- * the config key) changes underneath it.
- */
-function frozenMapDefaultConcurrency(config) {
-    const configured = config.workflow?.defaultMapConcurrency;
-    return defaultMapConcurrency(typeof configured === "number" ? configured : undefined);
-}

package/dist/workflows/runtime/document-cache.js

@@ -1,13 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-const cache = new WeakMap();
-export function cacheWorkflowDocument(entry, doc) {
-    cache.set(entry, doc);
-}
-export function takeWorkflowDocument(entry) {
-    const doc = cache.get(entry);
-    if (doc !== undefined)
-        cache.delete(entry);
-    return doc;
-}