akm-cli 0.10.261012-beta → 0.10.261014-beta

package/dist/llm/embedders/local.js

@@ -2,48 +2,49 @@
 // 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/.
 /**
- * Local embedder backed by the external @huggingface/transformers package.
+ * Local embedder: a BERT-family embedding model run with onnxruntime-node,
+ * its text encoded by @huggingface/tokenizers, mean-pooled over the attention
+ * mask and L2-normalised.
  *
- * Encapsulates the transformer pipeline lifecycle as instance state on a
- * `LocalEmbedder` so tests can construct fresh instances without leaking
- * pipelines across tests. The facade in `../embedder.ts` keeps a single
- * shared instance for the production code path.
+ * Encapsulates the model's lifecycle as instance state on a `LocalEmbedder` so
+ * tests can construct fresh instances without leaking loaded models across
+ * tests. The facade in `../embedder.ts` keeps a single shared instance for the
+ * production code path.
  */
+import fs from "node:fs";
 import path from "node:path";
-import { getCacheDir } from "../../core/paths.js";
-import { warn } from "../../core/warn.js";
+import { preloadOnnxRuntimeLibrary } from "../../standalone/onnxruntime-library.js";
+import { ensureLocalModelFiles } from "./local-model-files.js";
 /**
- * Default local transformer model for embeddings.
+ * Default local model for embeddings.
  * `bge-small-en-v1.5` scores higher on MTEB benchmarks than the previous
  * `all-MiniLM-L6-v2` at the same 384-dimension footprint.
  */
 export const DEFAULT_LOCAL_MODEL = "Xenova/bge-small-en-v1.5";
-/** Type-guard: true when the value looks like a batch Tensor (has .dims). */
-function isBatchTensor(v) {
-    return (v !== null &&
-        typeof v === "object" &&
-        v.data instanceof Float32Array &&
-        "dims" in v &&
-        Array.isArray(v.dims) &&
-        v.dims.length === 2 &&
-        v.dims.every((dim) => Number.isInteger(dim) && dim > 0));
-}
-function isEnabledEnvironmentFlag(value) {
-    return /^(?:1|true|yes|on)$/i.test(value?.trim() ?? "");
+/** The runtime the local embedder reports once its model has loaded. */
+export const LOCAL_EMBEDDING_RUNTIME = "onnxruntime-node";
+/**
+ * The embedding runtime is not usable on this machine. `platform`: onnxruntime-node
+ * has no native library for it, so keyword search is all there is. `load`: it has
+ * one, which did not load (a missing package or addon, a `noexec` temp or cache
+ * directory).
+ */
+export class LocalRuntimeUnavailableError extends Error {
+    kind;
+    constructor(message, kind) {
+        super(message);
+        this.kind = kind;
+    }
 }
-const realTransformersLoader = () => import("@huggingface/transformers");
-let transformersLoader = realTransformersLoader;
-/** TEST-ONLY. Swap the transformers module loader; pass undefined to restore. */
-export function _setTransformersLoaderForTests(fake) {
-    transformersLoader = fake ?? realTransformersLoader;
+let pipelineLoader = loadOnnxPipeline;
+/** TEST-ONLY. Swap the model loader; pass undefined to restore. */
+export function _setLocalPipelineLoaderForTests(fake) {
+    pipelineLoader = fake ?? loadOnnxPipeline;
 }
-const LOCAL_EMBEDDER_DTYPE = "fp32";
-const LOCAL_EMBEDDER_FALLBACK_DTYPE = "auto";
 /**
- * Maximum texts per batch for the local transformers pipeline. The pipeline
- * can run genuine batched inference over a string array; 32 is a safe default
- * that fits well inside most model context budgets while providing 10–50×
- * throughput improvement over one-at-a-time calls on the cold minority.
+ * Maximum texts per batch for the local model. 32 is a safe default that fits
+ * well inside most model context budgets while providing 10–50× throughput
+ * improvement over one-at-a-time calls on the cold minority.
  */
 const LOCAL_BATCH_SIZE = 32;
 /**
@@ -54,6 +55,105 @@ const LOCAL_BATCH_SIZE = 32;
 function resolveLocalModelName(overrideModel) {
     return overrideModel || DEFAULT_LOCAL_MODEL;
 }
+/**
+ * A standalone binary built for a target with no native library (`none`) must not
+ * bundle the package: its addon for that platform does not exist. The bundler
+ * drops only the branch a build constant rules out, so the import sits in an
+ * `else`, not after the `throw`.
+ */
+async function importOnnxRuntime() {
+    if (typeof AKM_STANDALONE_NATIVE_MODULE !== "undefined" && AKM_STANDALONE_NATIVE_MODULE === "./native/none") {
+        throw new Error("no native library is available for this platform");
+    }
+    else {
+        await preloadOnnxRuntimeLibrary();
+        return import("onnxruntime-node");
+    }
+}
+/**
+ * Whether onnxruntime-node has a native library for this machine. A standalone
+ * binary knows from its build (`none`). The package has one for glibc Linux
+ * x64/arm64, Apple-silicon macOS and Windows x64/arm64, and none for musl Linux
+ * or Intel macOS.
+ */
+function hasNativeLibrary() {
+    if (typeof AKM_STANDALONE_NATIVE_MODULE !== "undefined")
+        return AKM_STANDALONE_NATIVE_MODULE !== "./native/none";
+    if (process.platform === "linux") {
+        const header = process.report?.getReport()?.header;
+        if (!header?.glibcVersionRuntime)
+            return false;
+    }
+    return ["linux-x64", "linux-arm64", "darwin-arm64", "win32-x64", "win32-arm64"].includes(`${process.platform}-${process.arch}`);
+}
+async function loadOnnxRuntime() {
+    try {
+        return await importOnnxRuntime();
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        const kind = hasNativeLibrary() ? "load" : "platform";
+        // Only the package itself missing calls for a reinstall; a platform it ships no addon for (Intel macOS) fails on
+        // `../bin/napi-v6/<platform>/<arch>/onnxruntime_binding.node` and is reported below.
+        if (kind === "load" && /Cannot find (?:module|package) ['"]onnxruntime-node['"]/.test(msg)) {
+            throw new LocalRuntimeUnavailableError("Semantic search requires onnxruntime-node. Reinstall akm-cli.", kind);
+        }
+        throw new LocalRuntimeUnavailableError(`Failed to load the embedding runtime (onnxruntime-node): ${msg}. Semantic search with the local model is unavailable; keyword search still works.`, kind);
+    }
+}
+/** The mean of one text's token vectors (padding excluded), scaled to unit length. */
+function meanPooled(hidden, offset, tokens, dim) {
+    const vector = new Float32Array(dim);
+    for (let token = 0; token < tokens; token++) {
+        for (let k = 0; k < dim; k++)
+            vector[k] = vector[k] + hidden[offset + token * dim + k];
+    }
+    let norm = 0;
+    for (let k = 0; k < dim; k++) {
+        vector[k] = vector[k] / tokens;
+        norm += vector[k] ** 2;
+    }
+    return vector.map((value) => value / Math.sqrt(norm));
+}
+async function loadOnnxPipeline(modelName) {
+    const ort = await loadOnnxRuntime();
+    const { Tokenizer } = await import("@huggingface/tokenizers");
+    const modelDir = await ensureLocalModelFiles(modelName);
+    const readJson = (file) => JSON.parse(fs.readFileSync(path.join(modelDir, file), "utf8"));
+    const tokenizerConfig = readJson("tokenizer_config.json");
+    const tokenizer = new Tokenizer(readJson("tokenizer.json"), tokenizerConfig);
+    const maxLength = typeof tokenizerConfig.model_max_length === "number" ? tokenizerConfig.model_max_length : Number.POSITIVE_INFINITY;
+    const session = await ort.InferenceSession.create(path.join(modelDir, "onnx", "model.onnx"), {
+        executionProviders: ["cpu"],
+        logSeverityLevel: 3,
+    });
+    return async (texts) => {
+        // A text longer than the model's maximum is cut to it. Shorter ones are padded
+        // to the longest in the batch; the mask keeps padding out of the pooling.
+        const encoded = texts.map((text) => tokenizer.encode(text).ids.slice(0, maxLength));
+        const length = Math.max(...encoded.map((row) => row.length));
+        const ids = new BigInt64Array(texts.length * length);
+        const mask = new BigInt64Array(texts.length * length);
+        encoded.forEach((row, i) => {
+            row.forEach((id, j) => {
+                ids[i * length + j] = BigInt(id);
+                mask[i * length + j] = 1n;
+            });
+        });
+        const dims = [texts.length, length];
+        const inputs = {
+            input_ids: new ort.Tensor("int64", ids, dims),
+            attention_mask: new ort.Tensor("int64", mask, dims),
+            token_type_ids: new ort.Tensor("int64", new BigInt64Array(texts.length * length), dims),
+        };
+        // Models that take fewer inputs (no token_type_ids) are fed only theirs.
+        const feeds = Object.fromEntries(session.inputNames.flatMap((name) => (inputs[name] ? [[name, inputs[name]]] : [])));
+        const outputs = await session.run(feeds);
+        const hidden = (outputs.last_hidden_state ?? outputs.token_embeddings ?? outputs.logits)?.data;
+        const dim = hidden.length / (texts.length * length);
+        return encoded.map((row, i) => meanPooled(hidden, i * length * dim, row.length, dim));
+    };
+}
 export class LocalEmbedder {
     defaultModel;
     /**
@@ -63,6 +163,8 @@ export class LocalEmbedder {
      */
     pipelinePromise;
     pipelineModelName;
+    /** The runtime this embedder embeds with: set once a model has loaded, `undefined` before. */
+    runtime;
     constructor(defaultModel) {
         this.defaultModel = defaultModel;
     }
@@ -70,6 +172,7 @@ export class LocalEmbedder {
     reset() {
         this.pipelinePromise = undefined;
         this.pipelineModelName = undefined;
+        this.runtime = undefined;
     }
     async embed(text, signal) {
         if (signal?.aborted) {
@@ -79,8 +182,8 @@ export class LocalEmbedder {
     }
     /**
      * Embed a batch of texts. Processes in chunks of `LOCAL_BATCH_SIZE` (32) so
-     * the transformers pipeline can run genuine batched inference rather than one
-     * call per text. Each chunk is checked against the AbortSignal between calls.
+     * the model can run genuine batched inference rather than one call per text.
+     * Each chunk is checked against the AbortSignal between calls.
      *
      * `onBatch`, when given, fires once per chunk (indices into `texts` + the
      * chunk's embeddings) as it completes (#954) — parity with
@@ -100,24 +203,7 @@ export class LocalEmbedder {
                 throw signal.reason instanceof Error ? signal.reason : new Error("embedding interrupted");
             }
             const chunk = texts.slice(i, i + LOCAL_BATCH_SIZE);
-            // @huggingface/transformers 4.2 returns a single batch Tensor. Validate
-            // that exact shape and propagate inference failures without re-executing
-            // the same inputs through a second runtime path.
-            const batchResult = await pipeline(chunk, {
-                pooling: "mean",
-                normalize: true,
-            });
-            if (!isBatchTensor(batchResult)) {
-                throw new Error("unexpected pipeline return shape for batch input");
-            }
-            const [batch, dim] = batchResult.dims;
-            if (batch !== chunk.length || batchResult.data.length !== batch * dim) {
-                throw new Error("unexpected pipeline return shape for batch input");
-            }
-            const chunkEmbeddings = [];
-            for (let row = 0; row < chunk.length; row++) {
-                chunkEmbeddings.push(Array.from(batchResult.data.subarray(row * dim, (row + 1) * dim)));
-            }
+            const chunkEmbeddings = (await pipeline(chunk)).map((vector) => Array.from(vector));
             results.push(...chunkEmbeddings);
             onBatch?.(Array.from({ length: chunk.length }, (_, row) => i + row), chunkEmbeddings);
         }
@@ -126,13 +212,13 @@ export class LocalEmbedder {
     /** Embed using a model name override (used by the facade for per-call model overrides). */
     async embedWithModel(text, modelName) {
         const pipeline = await this.getPipeline(modelName);
-        const result = await pipeline(text, { pooling: "mean", normalize: true });
-        return Array.from(result.data);
+        const [vector] = await pipeline([text]);
+        return Array.from(vector);
     }
     /**
-     * Eagerly load (or return the cached) underlying pipeline. Used by
-     * availability checks that want to surface model-download failures
-     * without performing a real embed call.
+     * Eagerly load (or return the cached) model. Used by availability checks
+     * that want to surface model-download and runtime failures without
+     * performing a real embed call.
      */
     async getPipeline(modelName) {
         const resolvedModel = resolveLocalModelName(modelName);
@@ -142,36 +228,10 @@ export class LocalEmbedder {
         }
         if (!this.pipelinePromise) {
             this.pipelineModelName = resolvedModel;
-            this.pipelinePromise = (async () => {
-                // Ensure HuggingFace model cache lives in a stable location outside
-                // node_modules so it survives package reinstalls.
-                if (!process.env.HF_HOME) {
-                    process.env.HF_HOME = path.join(getCacheDir(), "models");
-                }
-                let pipeline;
-                try {
-                    const mod = await transformersLoader();
-                    // Transformers.js 4.x defaults its filesystem cache underneath the
-                    // installed package and no longer derives it from HF_HOME. Point the
-                    // public runtime setting at our stable cache explicitly so package
-                    // reinstalls and test-sandbox HOME rotation do not re-download the
-                    // model. The exact pinned 4.2 module owns this public environment.
-                    mod.env.cacheDir = process.env.HF_HOME;
-                    if (isEnabledEnvironmentFlag(process.env.HF_HUB_OFFLINE)) {
-                        mod.env.allowRemoteModels = false;
-                    }
-                    pipeline = mod.pipeline;
-                }
-                catch (importError) {
-                    const msg = importError instanceof Error ? importError.message : String(importError);
-                    if (/Cannot find (?:module|package)|MODULE_NOT_FOUND|ERR_MODULE_NOT_FOUND|Cannot resolve/i.test(msg)) {
-                        throw new Error("Semantic search requires @huggingface/transformers. Reinstall akm-cli.");
-                    }
-                    throw new Error(`Failed to load embedding runtime: ${msg}. Check platform compatibility.`);
-                }
-                const pipelineFn = pipeline;
-                return createLocalPipeline(pipelineFn, resolvedModel);
-            })();
+            this.pipelinePromise = pipelineLoader(resolvedModel).then((pipeline) => {
+                this.runtime = LOCAL_EMBEDDING_RUNTIME;
+                return pipeline;
+            });
             // HI-13: Clear the cached promise on failure so the next call retries
             // instead of permanently rejecting every subsequent call with the same error.
             this.pipelinePromise.catch(() => {
@@ -182,32 +242,3 @@ export class LocalEmbedder {
         return this.pipelinePromise;
     }
 }
-async function createLocalPipeline(pipelineFn, modelName) {
-    try {
-        return await pipelineFn("feature-extraction", modelName, { dtype: LOCAL_EMBEDDER_DTYPE });
-    }
-    catch (error) {
-        if (!shouldRetryWithoutExplicitDtype(error)) {
-            throw error;
-        }
-        warn('Local embedding model "%s" rejected explicit dtype "%s"; retrying with explicit fallback dtype "%s".', modelName, LOCAL_EMBEDDER_DTYPE, LOCAL_EMBEDDER_FALLBACK_DTYPE);
-        return pipelineFn("feature-extraction", modelName, { dtype: LOCAL_EMBEDDER_FALLBACK_DTYPE });
-    }
-}
-function shouldRetryWithoutExplicitDtype(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return /dtype|fp32|precision|quant/i.test(message);
-}
-/**
- * Check whether the declared Transformers dependency can be resolved without
- * loading a model.
- */
-export function isTransformersAvailable() {
-    try {
-        import.meta.resolve("@huggingface/transformers");
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/llm/embedders/remote.js

@@ -9,12 +9,10 @@
  */
 import { abortableDelay, backoffDelay, fetchWithTimeout, isHttpUrl, readBodyWithByteCap } from "../../core/common.js";
 import { concurrentMap } from "../../core/concurrent.js";
-import { resolveSecret } from "../../core/config/config.js";
-import { ENV_REFERENCE_PATTERN, SECRET_STORE_REFERENCE_PATTERN } from "../../core/config/schema/primitives.js";
+import { apiKeyReference, readCredential, resolveApiKey } from "../../core/config/credentials.js";
 import { defaultConcurrencyForEndpoint } from "../../core/loopback.js";
-import { redactErrorBody, redactSensitiveText } from "../../core/redaction.js";
+import { redactErrorBody, redactSensitiveText, redactUrlCredentials } from "../../core/redaction.js";
 import { warnVerbose } from "../../core/warn.js";
-import { resolveSecretFromStore } from "../../sources/snapshot-fetchers/secret-seam.js";
 /**
  * Upper bound on the number of documents in one HTTP request, independent of
  * the token budget below. Overridable via `config.batchSize`. Purely a
@@ -752,9 +750,12 @@ export class RemoteEmbedder {
         }
         return results;
     }
+    resolveKey() {
+        return resolveApiKey(this.config.apiKey, embeddingSlot(this.config), this.config.endpoint ?? "");
+    }
     buildHeaders() {
         const headers = { "Content-Type": "application/json" };
-        const resolvedKey = resolveSecret(this.config.apiKey, resolveSecretFromStore);
+        const resolvedKey = this.resolveKey();
         if (resolvedKey) {
             headers.Authorization = `Bearer ${resolvedKey}`;
         }
@@ -770,7 +771,7 @@ export class RemoteEmbedder {
      * far unredacted and uncapped, at readBodyWithByteCap's 10 MB default.
      */
     safeErrorBody(body) {
-        const resolvedKey = resolveSecret(this.config.apiKey, resolveSecretFromStore);
+        const resolvedKey = this.resolveKey();
         return redactSensitiveText(redactErrorBody(body), resolvedKey ? [resolvedKey] : []);
     }
 }
@@ -813,7 +814,7 @@ export function normalizeEmbeddingEndpoint(endpoint) {
 function embeddingEndpointPathHint(endpoint) {
     const normalizedEndpoint = normalizeEmbeddingEndpoint(endpoint);
     if (normalizedEndpoint !== endpoint) {
-        return ` Check that your endpoint includes the full embeddings path (for example "${normalizedEndpoint}", not just "${endpoint}").`;
+        return ` Check that your endpoint includes the full embeddings path (for example "${redactUrlCredentials(normalizedEndpoint)}", not just "${redactUrlCredentials(endpoint)}").`;
     }
     return "";
 }
@@ -842,22 +843,24 @@ function resolveOllamaOptions(config) {
 export function hasRemoteEndpoint(config) {
     return isHttpUrl(config.endpoint);
 }
+/** Where the embedding key is stored: the serving connection's slot when a connection serves the model, else the embedding service's own. */
+function embeddingSlot(config) {
+    return config.credentialName !== undefined ? { connection: config.credentialName } : { service: "embedding" };
+}
 /**
- * Describe WHERE an `embedding.apiKey` came from, never its value — the
- * actionable outcome of the #953 field gap: `resolveSecret` throws on an
- * unresolvable `secret://` reference, so a keyless request can only mean
- * `embedding.apiKey` was absent from the config the run actually loaded (a
- * different config root, scope, or a config edited after the run started).
- * A default-level progress line naming the credential's SOURCE (this
- * helper), printed once before the first provider request, lets a field run
- * self-diagnose that without ever surfacing the secret itself.
+ * Describe WHERE the embedding key comes from, never its value: the `$VAR`
+ * reference in `embedding.apiKey` (or its default connection's), the key in
+ * `credentials.json` filed under `embedding` (or under that connection's
+ * name), or nothing. A keyless request can only mean neither was present in the
+ * config the run actually loaded (a different config root, scope, or a config
+ * edited after the run started). A default-level progress line naming the
+ * credential's SOURCE (this helper), printed once before the first provider
+ * request, lets a field run self-diagnose that without ever surfacing the
+ * secret itself (#953).
  */
-export function describeEmbeddingCredential(apiKey) {
-    if (!apiKey)
-        return "none configured";
-    if (SECRET_STORE_REFERENCE_PATTERN.test(apiKey))
-        return `${apiKey} (store)`;
-    if (ENV_REFERENCE_PATTERN.test(apiKey))
-        return `${apiKey} (env)`;
-    return "literal apiKey";
+export function describeEmbeddingCredential(config) {
+    const reference = apiKeyReference(config.apiKey);
+    if (reference)
+        return `${reference} (env)`;
+    return readCredential(embeddingSlot(config), config.endpoint ?? "") ? "credentials.json" : "none configured";
 }

package/dist/llm/embedders/types.js

@@ -6,7 +6,7 @@
  *
  * Lives next to {@link EmbeddingVector} so importers (notably `db.ts`)
  * can pull just the math without dragging in the embedder facade and its
- * transitive Transformers.js runtime import chain.
+ * transitive embedding runtime import chain.
  *
  * Returns 0 when the vectors have different dimensions — silently
  * computing on a truncated view would produce meaningless scores.

package/dist/llm/index-passes.js

@@ -1,50 +1,44 @@
 // 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 { buildExecution, resolveExecution } from "../integrations/agent/execution.js";
+import { SHIPPED_ALIAS } from "../core/config/model-aliases.js";
+import { ConfigError } from "../core/errors.js";
+import { executionDefaultsOf } from "../execution/source.js";
+import { buildExecution, resolveExecution, shippedAlias } from "../integrations/agent/execution.js";
 const NO_LOWERING_NOTICES = Object.freeze([]);
-function own(value, key) {
-    return value !== undefined && Object.hasOwn(value, key);
-}
-/** Adapt one index invocation layer into the shared execution vocabulary. */
-function indexExecutionDefaults(layer) {
-    if (!layer)
-        return {};
-    return {
-        ...(own(layer, "engine") ? { engine: layer.engine } : {}),
-        ...(own(layer, "model") ? { model: layer.model } : {}),
-        ...(own(layer, "timeoutMs") ? { timeout: layer.timeoutMs } : {}),
-        ...(own(layer, "llm") && layer.llm !== undefined
-            ? { inference: cloneExecutionJsonObject(layer.llm, "index pass LLM inference") }
-            : {}),
-    };
-}
 /**
- * Resolve standalone index passes from the index section only. Improve
- * strategies own improve-triggered calls and are intentionally not consulted.
+ * Resolve standalone index passes from the index section only (the index-wide
+ * settings, then the pass's own). Improve strategies own improve-triggered calls
+ * and are intentionally not consulted. No runner when the pass is off or no
+ * connection or harness is configured.
  */
 export function resolveIndexPassExecution(passName, config) {
     const pass = config.index?.[passName];
     if (pass?.enabled === false)
         return Object.freeze({ runner: undefined, notices: NO_LOWERING_NOTICES });
-    const defaults = config.index?.defaults;
-    const fallbackLlmEngine = config.defaults?.llmEngine;
-    const selectedEngine = pass?.engine ?? defaults?.engine ?? fallbackLlmEngine;
-    if (!selectedEngine)
-        return Object.freeze({ runner: undefined, notices: NO_LOWERING_NOTICES });
-    const invocationDefaults = {
-        ...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);
-    return Object.freeze({ runner: lowered.runner, notices: lowered.notices });
+    try {
+        // Under the model-work tool policy: confined where the harness can be, unrestricted (with a notice) elsewhere.
+        const prepared = resolveExecution({
+            content: "",
+            config,
+            layers: [
+                shippedAlias(SHIPPED_ALIAS.index),
+                {
+                    id: "index",
+                    kind: "invocation-defaults",
+                    values: executionDefaultsOf(config.index),
+                },
+                { id: `index.${passName}`, kind: "invocation-defaults", values: executionDefaultsOf(pass) },
+            ],
+            modelWork: true,
+        });
+        const lowered = buildExecution(prepared.request, prepared.runner);
+        return Object.freeze({ runner: lowered.runner, notices: lowered.notices });
+    }
+    catch (error) {
+        if (error instanceof ConfigError && error.code === "LLM_NOT_CONFIGURED") {
+            return Object.freeze({ runner: undefined, notices: NO_LOWERING_NOTICES });
+        }
+        throw error;
+    }
 }