veryfront 0.1.868 → 0.1.869

package/esm/src/provider/local/local-engine.js

@@ -5,7 +5,7 @@
  * local LLM inference. Provides lazy model loading and streaming text
  * generation via async generators.
  *
- * Uses ONNX Runtime for inference with q4 quantization — NOT q4f16
+ * Uses ONNX Runtime for inference with q4 quantization, not q4f16,
  * due to a known ONNX bug with f16 LayerNorm on CPU.
  *
  * @module provider/local
@@ -14,7 +14,7 @@ import { serverLogger } from "../../utils/index.js";
 import { createError, toError } from "../../errors/veryfront-error.js";
 import { importTransformers } from "../../platform/compat/opaque-deps.js";
 import { DEFAULT_LOCAL_MODEL, resolveLocalModel } from "./model-catalog.js";
-import { throwIfLocalAIDisabled } from "./env.js";
+import { getLocalAIDevice, getLocalAIThinkingEnabled, throwIfLocalAIDisabled, } from "./env.js";
 import { createPipelineCache } from "./pipeline-cache.js";
 const logger = serverLogger.component("local-llm");
 /** Default maximum new tokens for local model generation */
@@ -25,7 +25,7 @@ const DEFAULT_MAX_NEW_TOKENS = 512;
  *
  * Transformers.js (>=3.x) does not expose a `stop_strings` generate option,
  * so we decode the running sequence with the tokenizer and match the stop
- * strings against the suffix — the documented `stopping_criteria` mechanism.
+ * strings against the suffix through the documented `stopping_criteria` mechanism.
  *
  * Transformers.js passes the full sequence (prompt + generated tokens) to
  * `_call` on every step. We must scan only the generated suffix: if a system
@@ -101,9 +101,9 @@ export async function getTransformers() {
         // expected: ONNX runtime not available in some environments (e.g. compiled binaries)
         throw toError(createError({
             type: "no_ai_available",
-            message: "Local AI model unavailable — native ONNX Runtime is not supported in this environment " +
-                "(e.g. compiled binaries). Set VERYFRONT_API_TOKEN and VERYFRONT_PROJECT_SLUG, or " +
-                "configure OPENAI_API_KEY, ANTHROPIC_API_KEY, or GOOGLE_API_KEY to use a cloud provider instead.",
+            message: "Local AI model unavailable. Native ONNX Runtime is not supported in this environment " +
+                "(e.g. compiled binaries). Run veryfront login, set VERYFRONT_API_TOKEN, or " +
+                "configure OPENAI_API_KEY, ANTHROPIC_API_KEY, or GOOGLE_API_KEY to use a cloud provider.",
         }));
     }
     // Configure cache directory for model files
@@ -113,6 +113,47 @@ export async function getTransformers() {
     transformersModule = mod;
     return mod;
 }
+async function ensureWebGpuAvailable() {
+    if (typeof navigator === "undefined" || !("gpu" in navigator)) {
+        throw toError(createError({
+            type: "no_ai_available",
+            message: "Local AI WebGPU unavailable. This runtime does not expose navigator.gpu. " +
+                "Use VERYFRONT_LOCAL_AI_DEVICE=cpu or run in a runtime with WebGPU support.",
+        }));
+    }
+    const gpu = navigator.gpu;
+    const adapter = await gpu?.requestAdapter?.();
+    if (!adapter) {
+        throw toError(createError({
+            type: "no_ai_available",
+            message: "Local AI WebGPU unavailable. No WebGPU adapter was found. " +
+                "Use VERYFRONT_LOCAL_AI_DEVICE=cpu or run on a machine with a supported GPU.",
+        }));
+    }
+}
+async function getLocalInferenceDevice() {
+    const device = getLocalAIDevice();
+    if (device === "webgpu") {
+        await ensureWebGpuAvailable();
+    }
+    return device;
+}
+function formatDType(dtype) {
+    return typeof dtype === "string" ? dtype : JSON.stringify(dtype);
+}
+function getConditionalModelConstructor(transformers, modelInfo) {
+    switch (modelInfo.modelClass) {
+        case "gemma4":
+            return transformers.Gemma4ForConditionalGeneration;
+        case "qwen3_5":
+            return transformers.Qwen3_5ForConditionalGeneration;
+        default:
+            throw toError(createError({
+                type: "config",
+                message: `Local model "${modelInfo.hfId}" requires a supported conditional-generation model class.`,
+            }));
+    }
+}
 /**
  * Bounded, dedup-aware cache of text-generation pipelines keyed by HuggingFace
  * model id. Only loads a model on a cold cache miss; concurrent loads of the
@@ -121,10 +162,10 @@ export async function getTransformers() {
 const textGenerationPipelines = createPipelineCache(async (modelInfo) => {
     try {
         const transformers = await getTransformers();
-        logger.info(`Loading local model: ${modelInfo.hfId} (${modelInfo.dtype}, ~${modelInfo.sizeMB}MB)...`);
+        logger.info(`Loading local model: ${modelInfo.hfId} (${formatDType(modelInfo.dtype)}, ${modelInfo.device}, ~${modelInfo.sizeMB}MB)...`);
         const pipe = (await transformers.pipeline("text-generation", modelInfo.hfId, {
             dtype: modelInfo.dtype,
-            device: "cpu",
+            device: modelInfo.device,
         }));
         logger.info(`Model loaded: ${modelInfo.hfId}`);
         return pipe;
@@ -140,28 +181,151 @@ const textGenerationPipelines = createPipelineCache(async (modelInfo) => {
             transformersModule = null;
             throw toError(createError({
                 type: "no_ai_available",
-                message: "Local AI model unavailable — native ONNX Runtime is not supported in this environment " +
-                    "(e.g. compiled binaries). Set VERYFRONT_API_TOKEN and VERYFRONT_PROJECT_SLUG, or " +
-                    "configure OPENAI_API_KEY, ANTHROPIC_API_KEY, or GOOGLE_API_KEY to use a cloud provider instead.",
+                message: "Local AI model unavailable. Native ONNX Runtime is not supported in this environment " +
+                    "(e.g. compiled binaries). Run veryfront login, set VERYFRONT_API_TOKEN, or " +
+                    "configure OPENAI_API_KEY, ANTHROPIC_API_KEY, or GOOGLE_API_KEY to use a cloud provider.",
             }));
         }
         throw error;
     }
 });
+const conditionalGenerationRuntimes = createPipelineCache(async (modelInfo) => {
+    try {
+        const transformers = await getTransformers();
+        const ModelClass = getConditionalModelConstructor(transformers, modelInfo);
+        logger.info(`Loading local model: ${modelInfo.hfId} (${formatDType(modelInfo.dtype)}, ${modelInfo.device}, ~${modelInfo.sizeMB}MB)...`);
+        const [processor, model] = await Promise.all([
+            transformers.AutoProcessor.from_pretrained(modelInfo.hfId),
+            ModelClass.from_pretrained(modelInfo.hfId, {
+                dtype: modelInfo.dtype,
+                device: modelInfo.device,
+            }),
+        ]);
+        logger.info(`Model loaded: ${modelInfo.hfId}`);
+        return { processor, model };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes("onnx") || msg.includes("ONNX") ||
+            msg.includes("dlopen") || msg.includes("dynamic linking") ||
+            msg.includes("native module") || msg.includes("SharedArrayBuffer")) {
+            transformersModule = null;
+            throw toError(createError({
+                type: "no_ai_available",
+                message: "Local AI model unavailable. Native ONNX Runtime is not supported in this environment " +
+                    "(e.g. compiled binaries). Run veryfront login, set VERYFRONT_API_TOKEN, or " +
+                    "configure OPENAI_API_KEY, ANTHROPIC_API_KEY, or GOOGLE_API_KEY to use a cloud provider.",
+            }));
+        }
+        throw error;
+    }
+});
+function getModelCacheKey(modelInfo, device) {
+    return `${modelInfo.hfId}:${device}`;
+}
+async function loadLocalRuntime(modelInfo) {
+    const device = await getLocalInferenceDevice();
+    const loadInfo = { ...modelInfo, device };
+    const cacheKey = getModelCacheKey(modelInfo, device);
+    return modelInfo.engine === "conditional-generation"
+        ? conditionalGenerationRuntimes.load(cacheKey, loadInfo)
+        : textGenerationPipelines.load(cacheKey, loadInfo);
+}
+function toConditionalMessages(messages) {
+    return messages.map((message) => ({
+        role: message.role,
+        content: [{ type: "text", text: message.content }],
+    }));
+}
+export function buildConditionalGenerateOptions(options, transformers, tokenizer, streamer) {
+    const { maxNewTokens = DEFAULT_MAX_NEW_TOKENS, temperature = 0.7, topP, topK, stopSequences, } = options;
+    const generateOptions = {
+        max_new_tokens: maxNewTokens,
+        temperature,
+        top_p: topP,
+        top_k: topK,
+        do_sample: temperature > 0,
+        streamer,
+    };
+    if (stopSequences && stopSequences.length > 0) {
+        generateOptions.stopping_criteria = buildStopStringCriteria(transformers, tokenizer, stopSequences);
+    }
+    return generateOptions;
+}
+export function buildConditionalChatTemplateOptions(modelInfo) {
+    return {
+        add_generation_prompt: true,
+        ...(modelInfo.modelClass === "gemma4" ? { enable_thinking: getLocalAIThinkingEnabled() } : {}),
+    };
+}
+async function prepareConditionalInputs(runtime, modelInfo, messages) {
+    const prompt = runtime.processor.apply_chat_template(toConditionalMessages(messages), buildConditionalChatTemplateOptions(modelInfo));
+    if (modelInfo.modelClass === "gemma4") {
+        return await runtime.processor(prompt, undefined, undefined, {
+            add_special_tokens: false,
+        });
+    }
+    return await runtime.processor(prompt);
+}
+async function* generateConditionalStream(modelInfo, messages, options) {
+    const runtime = await loadLocalRuntime(modelInfo);
+    const transformers = await getTransformers();
+    const inputs = await prepareConditionalInputs(runtime, modelInfo, messages);
+    const tokenQueue = [];
+    let resolveWaiting = null;
+    let done = false;
+    function flushWaiting() {
+        if (resolveWaiting) {
+            resolveWaiting();
+            resolveWaiting = null;
+        }
+    }
+    const streamer = new transformers.TextStreamer(runtime.processor.tokenizer, {
+        skip_prompt: true,
+        skip_special_tokens: true,
+        callback_function: (text) => {
+            tokenQueue.push(text);
+            flushWaiting();
+        },
+    });
+    const generatePromise = (async () => {
+        try {
+            await runtime.model.generate({
+                ...inputs,
+                ...buildConditionalGenerateOptions(options, transformers, runtime.processor.tokenizer, streamer),
+            });
+        }
+        finally {
+            done = true;
+            flushWaiting();
+        }
+    })();
+    while (true) {
+        while (tokenQueue.length > 0) {
+            yield tokenQueue.shift();
+        }
+        if (done)
+            break;
+        await new Promise((resolve) => {
+            resolveWaiting = resolve;
+        });
+    }
+    await generatePromise;
+}
 /**
  * Load a text-generation pipeline for the given model.
  * Returns a cached pipeline if already loaded.
  */
-function loadPipeline(modelInfo) {
-    return textGenerationPipelines.load(modelInfo.hfId, modelInfo);
+async function loadPipeline(modelInfo) {
+    return await loadLocalRuntime(modelInfo);
 }
 /**
  * Eagerly verify that the local AI runtime (@huggingface/transformers + ONNX)
  * is available by loading the default model pipeline.
  *
  * Call this *before* creating the HTTP response stream so that failures surface
- * as a thrown error (→ 503) rather than being swallowed inside a ReadableStream
- * (→ 200 with in-band SSE error).
+ * as a thrown error (503) rather than being swallowed inside a ReadableStream
+ * (200 with in-band SSE error).
  *
  * In compiled binaries, `import("@huggingface/transformers")` itself fails
  * because `onnxruntime-node` eagerly `require()`s a native `.node` addon at
@@ -173,7 +337,7 @@ function loadPipeline(modelInfo) {
  */
 export async function verifyLocalRuntime(modelId) {
     const modelInfo = resolveLocalModel(modelId || DEFAULT_LOCAL_MODEL);
-    await loadPipeline(modelInfo);
+    await loadLocalRuntime(modelInfo);
 }
 /**
  * Generate text in a streaming fashion using an async generator.
@@ -182,9 +346,13 @@ export async function verifyLocalRuntime(modelId) {
  */
 export async function* generateStream(modelId, messages, options = {}) {
     const modelInfo = resolveLocalModel(modelId);
+    if (modelInfo.engine === "conditional-generation") {
+        yield* generateConditionalStream(modelInfo, messages, options);
+        return;
+    }
     const pipe = await loadPipeline(modelInfo);
     const transformers = await getTransformers();
-    // Use a queue to bridge TextStreamer callbacks → async generator
+    // Use a queue to bridge TextStreamer callbacks to an async generator.
     const tokenQueue = [];
     let resolveWaiting = null;
     let done = false;
@@ -243,12 +411,16 @@ export async function generate(modelId, messages, options = {}) {
  */
 export async function preloadModel(modelId) {
     const modelInfo = resolveLocalModel(modelId);
-    await loadPipeline(modelInfo);
+    await loadLocalRuntime(modelInfo);
 }
 /**
  * Check if a model is currently loaded in memory.
  */
 export function isModelLoaded(modelId) {
     const modelInfo = resolveLocalModel(modelId);
-    return textGenerationPipelines.has(modelInfo.hfId);
+    const device = getLocalAIDevice();
+    const cacheKey = getModelCacheKey(modelInfo, device);
+    return modelInfo.engine === "conditional-generation"
+        ? conditionalGenerationRuntimes.has(cacheKey)
+        : textGenerationPipelines.has(cacheKey);
 }

package/esm/src/provider/local/model-catalog.d.ts

@@ -10,7 +10,11 @@ export interface ModelInfo {
     /** HuggingFace model repository ID */
     hfId: string;
     /** Quantization dtype for ONNX Runtime */
-    dtype: "q4" | "q8" | "fp16" | "fp32";
+    dtype: ModelDType | Record<string, ModelDType>;
+    /** Runtime path required by the model. */
+    engine?: "text-generation" | "conditional-generation";
+    /** Transformers.js model class used by conditional-generation models. */
+    modelClass?: "gemma4" | "qwen3_5";
     /** Approximate download size in MB */
     sizeMB: number;
     /** Human-readable description */
@@ -18,8 +22,9 @@ export interface ModelInfo {
     /** Pooling strategy for embedding models (default: "mean") */
     pooling?: "mean" | "last_token";
 }
+export type ModelDType = "q4" | "q8" | "q4f16" | "fp16" | "fp32";
 /** Default model used when no specific model ID is provided */
-export declare const DEFAULT_LOCAL_MODEL = "smollm2-135m";
+export declare const DEFAULT_LOCAL_MODEL = "qwen3.5-0.8b";
 /** Default embedding model used when no specific model ID is provided */
 export declare const DEFAULT_LOCAL_EMBEDDING_MODEL = "all-MiniLM-L6-v2";
 /**
@@ -28,8 +33,7 @@ export declare const DEFAULT_LOCAL_EMBEDDING_MODEL = "all-MiniLM-L6-v2";
  */
 export declare function resolveLocalEmbeddingModel(modelId: string): ModelInfo;
 /**
- * Resolve a friendly model ID to its HuggingFace model info.
- * Falls back to treating the ID as a raw HuggingFace repository ID.
+ * Resolve a supported local model ID to its HuggingFace model info.
  */
 export declare function resolveLocalModel(modelId: string): ModelInfo;
 /**

package/esm/src/provider/local/model-catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model-catalog.d.ts","sourceRoot":"","sources":["../../../../src/src/provider/local/model-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,SAAS;IACxB,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,KAAK,EAAE,IAAI,GAAG,IAAI,GAAG,MAAM,GAAG,MAAM,CAAC;IACrC,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,OAAO,CAAC,EAAE,MAAM,GAAG,YAAY,CAAC;CACjC;AAyCD,+DAA+D;AAC/D,eAAO,MAAM,mBAAmB,iBAAiB,CAAC;AAmClD,yEAAyE;AACzE,eAAO,MAAM,6BAA6B,qBAAqB,CAAC;AAEhE;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAUrE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAW5D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,EAAE,CAE3C"}
+{"version":3,"file":"model-catalog.d.ts","sourceRoot":"","sources":["../../../../src/src/provider/local/model-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,MAAM,WAAW,SAAS;IACxB,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,KAAK,EAAE,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAC/C,0CAA0C;IAC1C,MAAM,CAAC,EAAE,iBAAiB,GAAG,wBAAwB,CAAC;IACtD,yEAAyE;IACzE,UAAU,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAClC,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,OAAO,CAAC,EAAE,MAAM,GAAG,YAAY,CAAC;CACjC;AAED,MAAM,MAAM,UAAU,GAAG,IAAI,GAAG,IAAI,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;AAuCjE,+DAA+D;AAC/D,eAAO,MAAM,mBAAmB,iBAAiB,CAAC;AAmClD,yEAAyE;AACzE,eAAO,MAAM,6BAA6B,qBAAqB,CAAC;AAEhE;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAUrE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAU5D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,EAAE,CAE3C"}

package/esm/src/provider/local/model-catalog.js

@@ -6,46 +6,45 @@
  *
  * @module provider/local
  */
+import { createError, toError } from "../../errors/veryfront-error.js";
 /**
  * Catalog of supported local models.
  *
- * **Important:** Only `q4` quantization is used — `q4f16` has a known
- * ONNX Runtime bug with LayerNorm on CPU that produces NaN outputs.
+ * Keep this list intentionally small. Local model support means the model has
+ * been smoke-tested through the Veryfront local runtime.
  */
 const MODEL_CATALOG = {
-    "smollm2-135m": {
-        hfId: "HuggingFaceTB/SmolLM2-135M-Instruct",
-        dtype: "q4",
-        sizeMB: 100,
-        description: "SmolLM2 135M — fast, lightweight chat model",
-    },
-    "smollm2-360m": {
-        hfId: "HuggingFaceTB/SmolLM2-360M-Instruct",
-        dtype: "q4",
-        sizeMB: 250,
-        description: "SmolLM2 360M — better quality, still fast",
+    "qwen3.5-0.8b": {
+        hfId: "onnx-community/Qwen3.5-0.8B-ONNX",
+        dtype: {
+            embed_tokens: "q4",
+            vision_encoder: "fp16",
+            decoder_model_merged: "q4",
+        },
+        engine: "conditional-generation",
+        modelClass: "qwen3_5",
+        sizeMB: 900,
+        description: "Qwen3.5 0.8B - compact current-generation Qwen model",
     },
-    "smollm2-1.7b": {
-        hfId: "HuggingFaceTB/SmolLM2-1.7B-Instruct",
+    "gemma4-e2b-it": {
+        hfId: "onnx-community/gemma-4-E2B-it-ONNX",
         dtype: "q4",
-        sizeMB: 1000,
-        description: "SmolLM2 1.7B — highest quality local model",
+        engine: "conditional-generation",
+        modelClass: "gemma4",
+        sizeMB: 1800,
+        description: "Gemma 4 E2B IT - compact current-generation Gemma model",
     },
-    "qwen3-1.7b": {
-        hfId: "onnx-community/Qwen3-1.7B-ONNX",
+    "gemma4-e4b-it": {
+        hfId: "onnx-community/gemma-4-E4B-it-ONNX",
         dtype: "q4",
-        sizeMB: 1200,
-        description: "Qwen3 1.7B — strong multilingual reasoning and tool use",
-    },
-    "gemma3-1b": {
-        hfId: "onnx-community/gemma-3-1b-it-ONNX",
-        dtype: "q4",
-        sizeMB: 700,
-        description: "Gemma 3 1B — Google's compact instruction-tuned model",
+        engine: "conditional-generation",
+        modelClass: "gemma4",
+        sizeMB: 6000,
+        description: "Gemma 4 E4B IT - larger current-generation Gemma model",
     },
 };
 /** Default model used when no specific model ID is provided */
-export const DEFAULT_LOCAL_MODEL = "smollm2-135m";
+export const DEFAULT_LOCAL_MODEL = "qwen3.5-0.8b";
 /**
  * Catalog of supported local embedding models.
  *
@@ -56,26 +55,26 @@ const EMBEDDING_MODEL_CATALOG = {
         hfId: "Xenova/all-MiniLM-L6-v2",
         dtype: "q4",
         sizeMB: 23,
-        description: "All-MiniLM-L6-v2 — fast 384-dim embeddings",
+        description: "All-MiniLM-L6-v2 - fast 384-dim embeddings",
     },
     "nomic-embed-text-v1.5": {
         hfId: "nomic-ai/nomic-embed-text-v1.5",
         dtype: "q4",
         sizeMB: 130,
-        description: "Nomic Embed Text v1.5 — 768-dim, variable-length embeddings",
+        description: "Nomic Embed Text v1.5 - 768-dim, variable-length embeddings",
     },
     "bge-base-en-v1.5": {
         hfId: "Xenova/bge-base-en-v1.5",
         dtype: "q4",
         sizeMB: 110,
-        description: "BGE Base EN v1.5 — 768-dim, strong English embeddings",
+        description: "BGE Base EN v1.5 - 768-dim, strong English embeddings",
     },
     "qwen3-embedding-0.6b": {
         hfId: "onnx-community/Qwen3-Embedding-0.6B-ONNX",
         dtype: "q8",
         sizeMB: 620,
         pooling: "last_token",
-        description: "Qwen3 Embedding 0.6B — SOTA multilingual embeddings",
+        description: "Qwen3 Embedding 0.6B - SOTA multilingual embeddings",
     },
 };
 /** Default embedding model used when no specific model ID is provided */
@@ -96,20 +95,16 @@ export function resolveLocalEmbeddingModel(modelId) {
     };
 }
 /**
- * Resolve a friendly model ID to its HuggingFace model info.
- * Falls back to treating the ID as a raw HuggingFace repository ID.
+ * Resolve a supported local model ID to its HuggingFace model info.
  */
 export function resolveLocalModel(modelId) {
     const catalogEntry = MODEL_CATALOG[modelId];
     if (catalogEntry)
         return catalogEntry;
-    // Treat as raw HuggingFace model ID (e.g. "HuggingFaceTB/SmolLM2-135M-Instruct")
-    return {
-        hfId: modelId,
-        dtype: "q4",
-        sizeMB: 0,
-        description: `Custom model: ${modelId}`,
-    };
+    throw toError(createError({
+        type: "config",
+        message: `Unsupported local model "${modelId}". Supported local models: ${getLocalModelIds().join(", ")}.`,
+    }));
 }
 /**
  * Get all available local model IDs.

package/esm/src/provider/local/model-runtime-adapter.js

@@ -24,7 +24,7 @@ const DEFAULT_MAX_NEW_TOKENS = 512;
 function convertPrompt(prompt) {
     const messages = [];
     for (const msg of prompt) {
-        // Skip tool messages — local models don't support tool calling
+        // Skip tool messages. Local models do not support tool calling.
         if (msg.role === "tool")
             continue;
         const mappedRole = msg.role === "system"
@@ -79,7 +79,7 @@ export function createLocalModel(modelId) {
         async doGenerate(options) {
             const messages = convertPrompt(options.prompt);
             const genOptions = toGenerateOptions(options);
-            logger.debug(`[local] doGenerate: ${messages.length} messages → ${resolvedId}`);
+            logger.debug(`[local] doGenerate: ${messages.length} messages -> ${resolvedId}`);
             const text = await generate(resolvedId, messages, genOptions);
             return {
                 content: [{ type: "text", text }],
@@ -93,7 +93,7 @@ export function createLocalModel(modelId) {
             };
         },
         async doStream(options) {
-            // Eagerly check if local AI is disabled — must throw before creating the
+            // Eagerly check if local AI is disabled. This must throw before creating the
             // ReadableStream, otherwise the 200 response headers are already committed.
             // Note: getTransformers() in local-engine.ts also checks this, but we need
             // the check here too because doStream creates a ReadableStream wrapper and
@@ -101,7 +101,7 @@ export function createLocalModel(modelId) {
             throwIfLocalAIDisabled();
             const messages = convertPrompt(options.prompt);
             const genOptions = toGenerateOptions(options);
-            logger.debug(`[local] doStream: ${messages.length} messages → ${resolvedId}`);
+            logger.debug(`[local] doStream: ${messages.length} messages -> ${resolvedId}`);
             const textId = `text-${Date.now()}`;
             const stream = new ReadableStream({
                 async start(controller) {
@@ -140,7 +140,7 @@ export function createLocalModel(modelId) {
                         controller.close();
                     }
                     catch (error) {
-                        // Let no_ai_available propagate — the chat handler needs it
+                        // Let no_ai_available propagate. The chat handler needs it
                         // for a proper 503 response instead of a 200 with in-band error.
                         const vfError = fromError(error);
                         if (vfError?.type === "no_ai_available")

package/esm/src/provider/model-registry.d.ts

@@ -24,16 +24,6 @@ export type ModelProviderFactory = (modelId: string) => ModelRuntime;
  * ```
  */
 export declare function registerModelProvider(name: string, factory: ModelProviderFactory): void;
-/**
- * Find the first cloud provider with a valid API key.
- *
- * Returns a "provider/model" string that can be passed to `resolveModel`,
- * or `null` if no cloud provider is available.
- *
- * This is intentionally a **query** — it does NOT resolve the model.
- * The caller (agent runtime) decides whether to use it.
- */
-export declare function findAvailableCloudModel(): string | null;
 /**
  * Resolve a "provider/model" string to a framework-compatible model runtime.
  *
@@ -59,8 +49,8 @@ export declare function getRegisteredModelProviders(): string[];
  * For real local-engine models (created by `createLocalModel()`) this
  * eagerly loads the ONNX pipeline to surface `no_ai_available` errors
  * **before** the HTTP response stream is created. Must happen before the
- * ReadableStream so the chat handler can return a proper 503 (with
- * browser-fallback info) rather than a 200 with an in-band SSE error.
+ * ReadableStream so the chat handler can return a proper 503 rather than a
+ * 200 with an in-band SSE error.
  *
  * Uses the `_isVfLocalModel` marker set by `createLocalModel()` to
  * distinguish real local-engine models from mock/custom providers that

package/esm/src/provider/model-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model-registry.d.ts","sourceRoot":"","sources":["../../../src/src/provider/model-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAyBH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C,sDAAsD;AACtD,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,YAAY,CAAC;AAOrE;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,oBAAoB,GAC5B,IAAI,CAEN;AAgMD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,GAAG,IAAI,CAWvD;AAMD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,YAAY,CA6D9D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGtD;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,EAAE,CAGtD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,YAAY,GAClB,OAAO,CAAC,IAAI,CAAC,CAKf;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAG1C"}
+{"version":3,"file":"model-registry.d.ts","sourceRoot":"","sources":["../../../src/src/provider/model-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAeH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,sDAAsD;AACtD,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,YAAY,CAAC;AAOrE;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,oBAAoB,GAC5B,IAAI,CAEN;AAsJD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,YAAY,CAuC9D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGtD;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,EAAE,CAGtD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,YAAY,GAClB,OAAO,CAAC,IAAI,CAAC,CAKf;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAG1C"}