akm-cli 0.9.24 → 0.9.25-alpha.1

package/dist/llm/index-passes.js

@@ -1,8 +1,8 @@
 // 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 { warn } from "../core/warn.js";
 import { cloneExecutionJsonObject } from "../execution/json.js";
+import { MODEL_WORK_TOOLS } from "../execution/source.js";
 import { buildExecution, resolveExecution } from "../integrations/agent/execution.js";
 const NO_LOWERING_NOTICES = Object.freeze([]);
 function own(value, key) {
@@ -38,16 +38,13 @@ export function resolveIndexPassExecution(passName, config) {
         ...indexExecutionDefaults(defaults),
         ...(!own(defaults, "engine") && fallbackLlmEngine ? { engine: fallbackLlmEngine } : {}),
     };
+    // Under the model-work tool policy, so an engine that cannot confine it is refused here.
     const prepared = resolveExecution({
         content: "",
         config,
         invocationDefaults,
-        current: indexExecutionDefaults(pass),
+        current: { ...indexExecutionDefaults(pass), tools: MODEL_WORK_TOOLS },
     });
     const lowered = buildExecution(prepared.request, prepared.runner);
-    if (lowered.runner.kind !== "llm") {
-        warn("[akm] Index pass %s requires an LLM engine; %s is not one. Skipping this pass.", passName, selectedEngine);
-        return Object.freeze({ runner: undefined, notices: NO_LOWERING_NOTICES });
-    }
     return Object.freeze({ runner: lowered.runner, notices: lowered.notices });
 }

package/dist/llm/memory-infer.js

@@ -21,6 +21,7 @@ import memoryInferUserPrompt from "../assets/prompts/memory-infer-user.md" with
 import { toErrorMessage } from "../core/common.js";
 import { parseEmbeddedJsonResponse } from "../core/parse.js";
 import { warn } from "../core/warn.js";
+import { runnerLlmConnection } from "../integrations/agent/runner.js";
 import { callStructured } from "./structured-call.js";
 const SYSTEM_PROMPT = memoryInferSystemPrompt;
 const USER_PROMPT_PREFIX = memoryInferUserPrompt;
@@ -34,9 +35,9 @@ const PROMPT_PLACEHOLDERS = new Set([
     "2-3 sentence compressed body preserving key facts verbatim",
 ]);
 /**
- * Strict JSON Schema for the derived-memory payload. Sent to providers that
- * opt in via `runner.connection.supportsJsonSchema = true`; the client
- * silently drops the schema for providers that don't.
+ * Strict JSON Schema for the derived-memory payload. Sent as `response_format`
+ * unless the engine sets `supportsJsonSchema: false`; the client drops it once
+ * for a provider that rejects it.
  *
  * Extends the responseSchema lift (PR 1, asset-writers-investigation §5) to
  * the memory-inference path. Mirrors the validation gate below
@@ -89,8 +90,8 @@ export async function compressMemoryToDerivedMemory(llmRunner, body, signal, akm
         ],
         request: {
             // The engine's or the process's configured temperature; 0.1 only when neither sets one.
-            temperature: llmRunner.connection.temperature ?? 0.1,
-            timeoutMs: llmRunner.timeoutMs,
+            temperature: runnerLlmConnection(llmRunner)?.temperature ?? 0.1,
+            ...(Object.hasOwn(llmRunner, "timeoutMs") ? { timeoutMs: llmRunner.timeoutMs } : {}),
             signal,
             responseSchema: DERIVED_MEMORY_JSON_SCHEMA,
             onRetryAttempt,

package/dist/llm/structured-call.js

@@ -2,6 +2,8 @@
 // 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 { ConfigError } from "../core/errors.js";
+import { MODEL_WORK_TOOLS } from "../execution/source.js";
+import { DEFAULT_MODEL_WORK_TIMEOUT_MS } from "../integrations/agent/config.js";
 import { buildExecution, resolveExecution } from "../integrations/agent/execution.js";
 import { runExecution } from "../integrations/agent/runner-dispatch.js";
 import { isContextSizeError, LlmCallError } from "./client.js";
@@ -22,8 +24,12 @@ export function classifyLlmError(err) {
 function own(value, key) {
     return value !== undefined && Object.hasOwn(value, key);
 }
-/** @internal Exact request-to-cascade projection, exported for presence-semantics contracts. */
-export function resolveStructuredCurrent(current, request) {
+/**
+ * @internal Exact request-to-cascade projection, exported for presence-semantics contracts.
+ * Model work is bounded: with no timeout from the request or the runner, it
+ * gets {@link DEFAULT_MODEL_WORK_TIMEOUT_MS} on every runner kind.
+ */
+export function resolveStructuredCurrent(current, request, runner) {
     const out = current ? { ...current } : {};
     const requestHasInference = own(request, "temperature") || own(request, "maxTokens") || own(request, "enableThinking");
     const baseInference = current?.inference && typeof current.inference === "object" && !Array.isArray(current.inference)
@@ -46,6 +52,9 @@ export function resolveStructuredCurrent(current, request) {
     }
     if (own(request, "timeoutMs"))
         out.timeout = request?.timeoutMs ?? null;
+    else if (runner && !Object.hasOwn(runner, "timeoutMs") && !own(current, "timeout")) {
+        out.timeout = DEFAULT_MODEL_WORK_TIMEOUT_MS;
+    }
     return Object.keys(out).length > 0 ? out : undefined;
 }
 function requireTerminalUserMessage(messages) {
@@ -59,8 +68,17 @@ function requireTerminalUserMessage(messages) {
     };
 }
 function dispatchFailure(result) {
-    const message = result.error ?? result.stderr ?? result.reason ?? "LLM dispatch failed";
-    return result.llmErrorCode ? new LlmCallError(message, result.llmErrorCode) : new Error(message);
+    const message = result.error ?? result.stderr ?? result.reason ?? "dispatch failed";
+    const error = result.llmErrorCode ? new LlmCallError(message, result.llmErrorCode) : new Error(message);
+    return Object.assign(error, { reason: result.reason, result });
+}
+/** The runner's failure reason (`timeout`, `aborted`, …) a failed dispatch threw with, whatever its kind. */
+export function dispatchFailureReason(err) {
+    return err instanceof Error ? err.reason : undefined;
+}
+/** The failed dispatch's own result (an agent's exit code and stderr, say), whatever its kind. */
+export function dispatchFailureResult(err) {
+    return err instanceof Error ? err.result : undefined;
 }
 export async function callStructured(opts) {
     const { feature, akmConfig, enabled, messages, request, parse, onError, fallback, onFallback } = opts;
@@ -77,23 +95,27 @@ export async function callStructured(opts) {
     }
     const runner = opts.runner;
     if (!runner)
-        throw new TypeError("callStructured requires a resolved LLM runner");
+        throw new TypeError("callStructured requires a resolved runner");
     const terminal = requireTerminalUserMessage(messages);
+    // `gateSignal` aborts when the feature gate's timeout fires, so the dispatch stops with it.
+    // Every structured call is unattended model work, so it runs under the model-work tool policy.
     const prepareInvocation = () => {
-        const current = resolveStructuredCurrent(opts.current, request);
         const prepared = resolveExecution({
             content: terminal.content,
             conversation: terminal.conversation,
             runner,
-            ...(current ? { current } : {}),
+            current: { ...resolveStructuredCurrent(opts.current, request, runner), tools: MODEL_WORK_TOOLS },
         });
         const lowered = buildExecution(prepared.request, prepared.runner);
         opts.onNotices?.(lowered.notices);
-        return async () => {
+        return async (gateSignal) => {
+            const signal = request?.signal && gateSignal ? AbortSignal.any([request.signal, gateSignal]) : (request?.signal ?? gateSignal);
+            const runOptions = { ...request?.runOptions, ...(signal ? { signal } : {}) };
             const result = await runExecution(lowered, {
                 ...(request?.chat ? { chat: request.chat } : {}),
+                ...(request?.runSdk ? { runSdk: request.runSdk } : {}),
                 ...(request?.onRetryAttempt ? { onRetryAttempt: request.onRetryAttempt } : {}),
-                ...(own(request, "signal") ? { runOptions: { signal: request?.signal } } : {}),
+                ...(Object.keys(runOptions).length > 0 ? { runOptions } : {}),
             });
             if (!result.ok)
                 throw dispatchFailure(result);
@@ -111,9 +133,9 @@ export async function callStructured(opts) {
     const invoke = prepareInvocation();
     // GATED: run through `tryLlmFeature`. A throw inside is classified ONCE and
     // routed to `onError`; `tryLlmFeature` returns `fallback` on disablement/timeout.
-    const outcome = await tryLlmFeature(feature, akmConfig, async () => {
+    const outcome = await tryLlmFeature(feature, akmConfig, async (gateSignal) => {
         try {
-            return { kind: "value", value: await invoke() };
+            return { kind: "value", value: await invoke(gateSignal) };
         }
         catch (err) {
             // Credential materialization remains dispatch-owned, so a missing