akm-cli 0.9.24 → 0.9.25-alpha.2

package/dist/llm/feature-gate.js

@@ -1,6 +1,7 @@
 // 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 { DEFAULT_LLM_TIMEOUT_MS } from "../integrations/agent/config.js";
 /**
  * For each feature key, return the effective enabled state by reading the
  * 0.9.0 config shape.
@@ -37,14 +38,11 @@ export function isLlmFeatureEnabled(config, feature, improveEnabled) {
         return false;
     return resolver(config);
 }
-/**
- * Default hard timeout for every bounded in-tree LLM call.
- */
-const DEFAULT_TIMEOUT_MS = 600_000;
 /**
  * Run `fn()` only if `isLlmFeatureEnabled(config, feature)` is `true`. On
  * disablement, throw, or timeout, return `fallback` (or — if it is a
- * thunk — the value produced by calling it).
+ * thunk — the value produced by calling it). The timeout aborts the signal
+ * `fn` receives, so the work it started stops too.
  */
 export async function tryLlmFeature(feature, config, fn, fallback, opts) {
     const resolveFallback = async () => typeof fallback === "function" ? await fallback() : fallback;
@@ -52,10 +50,10 @@ export async function tryLlmFeature(feature, config, fn, fallback, opts) {
         opts?.onFallback?.({ feature, reason: "disabled" });
         return resolveFallback();
     }
-    const timeoutMs = opts && Object.hasOwn(opts, "timeoutMs") ? (opts.timeoutMs ?? null) : DEFAULT_TIMEOUT_MS;
+    const timeoutMs = opts && Object.hasOwn(opts, "timeoutMs") ? (opts.timeoutMs ?? null) : DEFAULT_LLM_TIMEOUT_MS;
     try {
         if (timeoutMs === null || timeoutMs <= 0) {
-            return await fn();
+            return await fn(new AbortController().signal);
         }
         return await runWithTimeout(fn, timeoutMs, feature);
     }
@@ -97,11 +95,16 @@ export class LlmFeatureTimeoutError extends Error {
 }
 async function runWithTimeout(fn, timeoutMs, feature) {
     let timer;
+    const controller = new AbortController();
     try {
         return await new Promise((resolve, reject) => {
-            timer = setTimeout(() => reject(new LlmFeatureTimeoutError(feature, timeoutMs)), timeoutMs);
+            timer = setTimeout(() => {
+                const timedOut = new LlmFeatureTimeoutError(feature, timeoutMs);
+                controller.abort(timedOut);
+                reject(timedOut);
+            }, timeoutMs);
             Promise.resolve()
-                .then(() => fn())
+                .then(() => fn(controller.signal))
                 .then(resolve, reject);
         });
     }

package/dist/llm/index-passes.js

@@ -1,7 +1,6 @@
 // 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 { buildExecution, resolveExecution } from "../integrations/agent/execution.js";
 const NO_LOWERING_NOTICES = Object.freeze([]);
@@ -38,16 +37,14 @@ 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),
+        modelWork: true,
     });
     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,7 @@
 // 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 { DEFAULT_LLM_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 +23,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_LLM_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 +51,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_LLM_TIMEOUT_MS;
+    }
     return Object.keys(out).length > 0 ? out : undefined;
 }
 function requireTerminalUserMessage(messages) {
@@ -59,8 +67,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 +94,28 @@ 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),
+            modelWork: true,
         });
         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

package/dist/output/shapes/passthrough.js

@@ -43,6 +43,7 @@ const PASSTHROUGH_COMMANDS = [
     "extract",
     "health",
     "improve",
+    "improve-judge",
     "improve-report",
     "import",
     "index",