akm-cli 0.9.16 → 0.9.17-alpha.10

package/dist/integrations/agent/execution-preparation.js

@@ -1,98 +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 { cloneExecutionJsonObject } from "../../execution/json.js";
-import { withEngineFallback } from "./engine-fallback.js";
-import { planExecutionCascade, } from "./execution-cascade.js";
-import { executionEngineDefinitionsFromConfig } from "./execution-definitions.js";
-import { loadModelMap } from "./model-map.js";
-function own(value, key) {
-    return Object.hasOwn(value, key);
-}
-function requestedToolNames(tools) {
-    if (tools === null)
-        return Object.freeze([]);
-    if (typeof tools === "string") {
-        return Object.freeze(tools
-            .split(",")
-            .map((tool) => tool.trim())
-            .filter(Boolean));
-    }
-    if (Array.isArray(tools))
-        return Object.freeze(tools.map((tool) => tool.trim()).filter(Boolean));
-    const structured = tools;
-    // The portable structured spelling is a boolean allow/deny map. Opaque or
-    // nested provider policy cannot be reduced to tool names without guessing,
-    // so a host name allowlist must deny it (an explicit "*" may still allow it).
-    if (Object.values(structured).some((value) => typeof value !== "boolean"))
-        return undefined;
-    return Object.freeze(Object.keys(structured).filter((tool) => structured[tool] === true));
-}
-/** The production authorizer: executable assets may only narrow a host-owned ceiling. */
-export function toolAuthorizerFromConfig(config) {
-    const allowed = new Set(config.execution?.allowedTools ?? []);
-    return (input) => {
-        const requested = requestedToolNames(input.tools);
-        const permitted = allowed.has("*") || requested?.every((tool) => allowed.has(tool)) === true;
-        return Object.freeze({
-            status: permitted ? "allowed" : "denied",
-            policy: "config-execution-allowed-tools",
-        });
-    };
-}
-/** Pure common cascade composition once caller-specific sources are rendered. */
-export function planPreparedExecution(options) {
-    return planExecutionCascade({
-        command: options.command,
-        ...(own(options, "conversation") ? { conversation: options.conversation } : {}),
-        ...(own(options, "persona") ? { persona: options.persona } : {}),
-        layers: {
-            installation: {
-                id: "installation-defaults",
-                values: options.installationEngine === undefined ? {} : { engine: options.installationEngine },
-            },
-            ...(options.agentLayer ? { agent: options.agentLayer } : {}),
-            command: options.commandLayer,
-            ...(options.invocationDefaults
-                ? { invocationDefaults: { id: "invocation-defaults", values: options.invocationDefaults } }
-                : {}),
-            ...(options.current ? { current: { id: "current-invocation", values: options.current } } : {}),
-        },
-        engines: options.engines,
-        modelMap: options.modelMap,
-        invocationKind: options.invocationKind,
-        ...(options.authorizeTools ? { authorizeTools: options.authorizeTools } : {}),
-    });
-}
-/**
- * The one planner adapter for already-rendered command/persona content.
- * Direct, task, improve, proposal, and workflow callers contribute named
- * layers here; none may rebuild engine/model precedence around the cascade.
- */
-export function prepareResolvedExecution(options) {
-    const inputConfig = cloneExecutionJsonObject(options.config, "execution preparation input config");
-    const fallback = withEngineFallback(inputConfig);
-    const config = cloneExecutionJsonObject(fallback.config, "execution preparation resolved config");
-    const defaults = own(config, "defaults") ? config.defaults : undefined;
-    const installationEngine = defaults && own(defaults, "engine") ? defaults.engine : undefined;
-    const plan = planPreparedExecution({
-        command: options.command,
-        ...(own(options, "conversation") ? { conversation: options.conversation } : {}),
-        ...(own(options, "persona") ? { persona: options.persona } : {}),
-        ...(installationEngine === undefined ? {} : { installationEngine }),
-        ...(options.agentLayer ? { agentLayer: options.agentLayer } : {}),
-        commandLayer: options.commandLayer,
-        ...(options.invocationDefaults ? { invocationDefaults: options.invocationDefaults } : {}),
-        ...(options.current ? { current: options.current } : {}),
-        engines: executionEngineDefinitionsFromConfig(config),
-        modelMap: options.modelMap ?? loadModelMap({ engines: config.engines }).map,
-        invocationKind: options.invocationKind,
-        authorizeTools: options.authorizeTools ?? toolAuthorizerFromConfig(config),
-    });
-    return Object.freeze({
-        plan,
-        request: plan.request,
-        config,
-        ...(fallback.fallbackEngineName ? { fallbackEngineName: fallback.fallbackEngineName } : {}),
-    });
-}

package/dist/integrations/agent/inline-execution.js

@@ -1,74 +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 { createInlineResolvedCommand, } from "../../execution/resolved-request.js";
-import { executionEngineDefinitionFromRunner } from "./execution-definitions.js";
-import { planPreparedExecution, prepareResolvedExecution } from "./execution-preparation.js";
-import { MODEL_MAP_VERSION } from "./model-map.js";
-const EMPTY_EXACT_MODEL_MAP = Object.freeze({
-    version: MODEL_MAP_VERSION,
-    aliases: Object.freeze(Object.create(null)),
-});
-function own(value, key) {
-    return Object.hasOwn(value, key);
-}
-/**
- * Resolve anonymous command content through the same far-to-near cascade used
- * by stored commands. Tasks, workflows, and internal model work adapt their
- * already-rendered content here rather than rebuilding engine/model precedence.
- */
-export function prepareInlineExecution(options) {
-    const command = createInlineResolvedCommand({
-        template: options.content,
-        ...(own(options, "argumentInput") ? { argumentInput: options.argumentInput } : {}),
-        content: options.content,
-    });
-    return prepareResolvedExecution({
-        command,
-        config: options.config,
-        invocationKind: options.invocationKind,
-        ...(own(options, "conversation") ? { conversation: options.conversation } : {}),
-        ...(own(options, "persona") ? { persona: options.persona } : {}),
-        commandLayer: { id: "inline-command", values: {} },
-        ...(options.invocationDefaults ? { invocationDefaults: options.invocationDefaults } : {}),
-        ...(options.current ? { current: options.current } : {}),
-        ...(options.modelMap ? { modelMap: options.modelMap } : {}),
-        ...(options.authorizeTools ? { authorizeTools: options.authorizeTools } : {}),
-    });
-}
-/**
- * Prepare anonymous work from an already-resolved runner without reading live
- * config or interpreting aliases. Used by resume-safe workflow/judge and by
- * improve/proposal calls that already froze runner material.
- */
-export function prepareInlineExecutionWithRunner(options) {
-    const command = createInlineResolvedCommand({
-        template: options.content,
-        ...(own(options, "argumentInput") ? { argumentInput: options.argumentInput } : {}),
-        content: options.content,
-    });
-    const material = executionEngineDefinitionFromRunner(options.runner, own(options, "sdkFallbackModelFromRequest")
-        ? { sdkFallbackModelFromRequest: options.sdkFallbackModelFromRequest === true }
-        : {});
-    const engines = Object.create(null);
-    Object.defineProperty(engines, material.engineName, {
-        value: material.definition,
-        enumerable: true,
-        configurable: false,
-        writable: false,
-    });
-    const plan = planPreparedExecution({
-        command,
-        ...(own(options, "conversation") ? { conversation: options.conversation } : {}),
-        ...(own(options, "persona") ? { persona: options.persona } : {}),
-        installationEngine: material.engineName,
-        commandLayer: { id: "inline-command", values: {} },
-        ...(options.invocationDefaults ? { invocationDefaults: options.invocationDefaults } : {}),
-        ...(options.current ? { current: options.current } : {}),
-        engines: Object.freeze(engines),
-        modelMap: options.modelMap ?? EMPTY_EXACT_MODEL_MAP,
-        invocationKind: options.invocationKind,
-        ...(options.authorizeTools ? { authorizeTools: options.authorizeTools } : {}),
-    });
-    return Object.freeze({ plan, request: plan.request, runner: material.runner });
-}