@dexto/core 1.4.0 → 1.5.1

package/dist/llm/executor/turn-executor.js

@@ -11,17 +11,19 @@ import {
 } from "ai";
 import { trace } from "@opentelemetry/api";
 import { StreamProcessor } from "./stream-processor.js";
+import { buildProviderOptions } from "./provider-options.js";
 import { DextoLogComponent } from "../../logger/v2/types.js";
 import { defer } from "../../utils/defer.js";
 import { DextoRuntimeError } from "../../errors/DextoRuntimeError.js";
 import { ErrorScope, ErrorType } from "../../errors/types.js";
 import { LLMErrorCode } from "../error-codes.js";
 import { toError } from "../../utils/error-conversion.js";
-import { isOverflow } from "../../context/compression/overflow.js";
-import { ReactiveOverflowStrategy } from "../../context/compression/reactive-overflow.js";
+import { isOverflow } from "../../context/compaction/overflow.js";
+import { ReactiveOverflowStrategy } from "../../context/compaction/strategies/reactive-overflow.js";
 const toolSupportCache = /* @__PURE__ */ new Map();
+const LOCAL_PROVIDERS = ["ollama", "local"];
 class TurnExecutor {
-  constructor(model, toolManager, contextManager, eventBus, resourceManager, sessionId, config, llmContext, logger, messageQueue, modelLimits, externalSignal) {
+  constructor(model, toolManager, contextManager, eventBus, resourceManager, sessionId, config, llmContext, logger, messageQueue, modelLimits, externalSignal, compactionStrategy) {
     this.model = model;
     this.toolManager = toolManager;
     this.contextManager = contextManager;
@@ -35,8 +37,10 @@ class TurnExecutor {
     this.externalSignal = externalSignal;
     this.logger = logger.createChild(DextoLogComponent.EXECUTOR);
     this.stepAbortController = new AbortController();
-    if (modelLimits) {
-      this.compressionStrategy = new ReactiveOverflowStrategy(model, {}, this.logger);
+    if (compactionStrategy !== void 0) {
+      this.compactionStrategy = compactionStrategy;
+    } else if (modelLimits) {
+      this.compactionStrategy = new ReactiveOverflowStrategy(model, {}, this.logger);
     }
   }
   logger;
@@ -45,8 +49,7 @@ class TurnExecutor {
    * This allows soft cancel (abort current step) while still continuing with queued messages.
    */
   stepAbortController;
-  // TODO: improve compression configurability
-  compressionStrategy = null;
+  compactionStrategy = null;
   /**
    * Map to track approval metadata by toolCallId.
    * Used to pass approval info from tool execution to result persistence.
@@ -79,6 +82,24 @@ class TurnExecutor {
       let lastText = "";
       this.eventBus.emit("llm:thinking");
       const supportsTools = await this.validateToolSupport();
+      if (!supportsTools) {
+        const modelKey = `${this.llmContext.provider}:${this.llmContext.model}`;
+        this.eventBus.emit("llm:unsupported-input", {
+          errors: [
+            `Model '${modelKey}' does not support tool calling.`,
+            "You can still chat, but the model will not be able to use tools or execute commands."
+          ],
+          provider: this.llmContext.provider,
+          model: this.llmContext.model,
+          details: {
+            feature: "tool-calling",
+            supported: false
+          }
+        });
+        this.logger.warn(
+          `Model ${modelKey} does not support tools - continuing without tool calling`
+        );
+      }
       let currentAbortHandler = null;
       try {
         while (true) {
@@ -115,6 +136,11 @@ class TurnExecutor {
             streaming,
             this.approvalMetadata
           );
+          const providerOptions = buildProviderOptions({
+            provider: this.llmContext.provider,
+            model: this.llmContext.model,
+            reasoningEffort: this.config.reasoningEffort
+          });
           const result = await streamProcessor.process(
             () => streamText({
               model: this.model,
@@ -128,6 +154,10 @@ class TurnExecutor {
               ...this.config.temperature !== void 0 && {
                 temperature: this.config.temperature
               },
+              // Provider-specific options (caching, reasoning, etc.)
+              ...providerOptions !== void 0 && {
+                providerOptions
+              },
               // Log stream-level errors (tool errors, API errors during streaming)
               onError: (error) => {
                 this.logger.error("Stream error", { error });
@@ -231,20 +261,25 @@ class TurnExecutor {
    * Validates if the current model supports tools.
    * Uses a static cache to avoid repeated validation calls.
    *
-   * For models using custom baseURL endpoints, makes a test call to verify tool support.
-   * Built-in providers without baseURL are assumed to support tools.
+   * For local providers (Ollama, local) and custom baseURL endpoints, makes a test call to verify tool support.
+   * Known cloud providers without baseURL are assumed to support tools.
    */
   async validateToolSupport() {
     const modelKey = `${this.llmContext.provider}:${this.llmContext.model}:${this.config.baseURL ?? ""}`;
     if (toolSupportCache.has(modelKey)) {
       return toolSupportCache.get(modelKey);
     }
-    if (!this.config.baseURL) {
-      this.logger.debug(`Skipping tool validation for ${modelKey} - no custom baseURL`);
+    const isLocalProvider = LOCAL_PROVIDERS.includes(this.llmContext.provider);
+    if (!this.config.baseURL && !isLocalProvider) {
+      this.logger.debug(
+        `Skipping tool validation for ${modelKey} - known cloud provider without custom baseURL`
+      );
       toolSupportCache.set(modelKey, true);
       return true;
     }
-    this.logger.debug(`Testing tool support for custom endpoint model: ${modelKey}`);
+    this.logger.debug(
+      `Testing tool support for ${isLocalProvider ? "local provider" : "custom endpoint"} model: ${modelKey}`
+    );
     const testTool = {
       test_tool: {
         inputSchema: jsonSchema({
@@ -274,7 +309,9 @@ class TurnExecutor {
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (errorMessage.includes("does not support tools")) {
         toolSupportCache.set(modelKey, false);
-        this.logger.debug(`Model ${modelKey} does not support tools`);
+        this.logger.debug(
+          `Detected that model ${modelKey} does not support tool calling - tool functionality will be disabled`
+        );
         return false;
       }
       this.logger.debug(
@@ -555,7 +592,7 @@ class TurnExecutor {
    * Check if context has overflowed based on actual token usage from API.
    */
   checkAndHandleOverflow(tokens) {
-    if (!this.modelLimits || !this.compressionStrategy) {
+    if (!this.modelLimits || !this.compactionStrategy) {
       return false;
     }
     return isOverflow(tokens, this.modelLimits);
@@ -570,16 +607,16 @@ class TurnExecutor {
    * @param originalTokens The actual input token count from API that triggered overflow
    */
   async compress(originalTokens) {
-    if (!this.compressionStrategy) {
+    if (!this.compactionStrategy) {
       return;
     }
     this.logger.info(
       `Context overflow detected (${originalTokens} tokens), running compression`
     );
     const history = await this.contextManager.getHistory();
-    const summaryMessages = await this.compressionStrategy.compress(history);
+    const summaryMessages = await this.compactionStrategy.compact(history);
     if (summaryMessages.length === 0) {
-      this.logger.debug("Compression returned no summary (history too short)");
+      this.logger.debug("Compaction returned no summary (history too short)");
       return;
     }
     for (const summary of summaryMessages) {
@@ -588,17 +625,17 @@ class TurnExecutor {
     const { filterCompacted, estimateMessagesTokens } = await import("../../context/utils.js");
     const updatedHistory = await this.contextManager.getHistory();
     const filteredHistory = filterCompacted(updatedHistory);
-    const compressedTokens = estimateMessagesTokens(filteredHistory);
-    this.eventBus.emit("context:compressed", {
+    const compactedTokens = estimateMessagesTokens(filteredHistory);
+    this.eventBus.emit("context:compacted", {
       originalTokens,
-      compressedTokens,
+      compactedTokens,
       originalMessages: history.length,
-      compressedMessages: filteredHistory.length,
-      strategy: this.compressionStrategy.name,
+      compactedMessages: filteredHistory.length,
+      strategy: this.compactionStrategy.name,
       reason: "overflow"
     });
     this.logger.info(
-      `Compression complete: ${originalTokens} \u2192 ~${compressedTokens} tokens (${history.length} \u2192 ${filteredHistory.length} messages after filtering)`
+      `Compaction complete: ${originalTokens} \u2192 ~${compactedTokens} tokens (${history.length} \u2192 ${filteredHistory.length} messages after filtering)`
     );
   }
   /**

package/dist/llm/formatters/vercel.cjs

@@ -59,9 +59,17 @@ class VercelMessageFormatter {
       filteredHistory = [...history];
     }
     if (systemPrompt) {
+      const modelLower = context.model.toLowerCase();
+      const isClaudeModel = modelLower.includes("claude");
+      const isAnthropicProvider = context.provider === "anthropic" || context.provider === "bedrock" && isClaudeModel || context.provider === "vertex" && isClaudeModel;
       formatted.push({
         role: "system",
-        content: systemPrompt
+        content: systemPrompt,
+        ...isAnthropicProvider && {
+          providerOptions: {
+            anthropic: { cacheControl: { type: "ephemeral" } }
+          }
+        }
       });
     }
     const pendingToolCalls = /* @__PURE__ */ new Map();
@@ -183,12 +191,16 @@ class VercelMessageFormatter {
         } else {
           parsed = rawArgs ?? {};
         }
-        contentParts.push({
+        const toolCallPart = {
           type: "tool-call",
           toolCallId: toolCall.id,
           toolName: toolCall.function.name,
           input: parsed
-        });
+        };
+        if (toolCall.providerOptions) {
+          toolCallPart.providerOptions = toolCall.providerOptions;
+        }
+        contentParts.push(toolCallPart);
       }
       const firstToolCall = msg.toolCalls?.[0];
       if (firstToolCall) {

package/dist/llm/formatters/vercel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vercel.d.ts","sourceRoot":"","sources":["../../../src/llm/formatters/vercel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAiD,MAAM,IAAI,CAAC;AACtF,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAiC,MAAM,wBAAwB,CAAC;AAE7F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAmB7D;;;;;;;;;;GAUG;AACH,qBAAa,sBAAsB;IAC/B,OAAO,CAAC,MAAM,CAAe;gBAEjB,MAAM,EAAE,YAAY;IAGhC;;;;;;OAMG;IACH,MAAM,CACF,OAAO,EAAE,QAAQ,CAAC,eAAe,EAAE,CAAC,EACpC,OAAO,EAAE,UAAU,EACnB,YAAY,EAAE,MAAM,GAAG,IAAI,GAC5B,YAAY,EAAE;IAwIjB;;;;;;OAMG;IACH,kBAAkB,IAAI,IAAI;IAK1B,OAAO,CAAC,sBAAsB;IAuE9B,OAAO,CAAC,iBAAiB;CAoE5B"}
+{"version":3,"file":"vercel.d.ts","sourceRoot":"","sources":["../../../src/llm/formatters/vercel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAiD,MAAM,IAAI,CAAC;AACtF,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAiC,MAAM,wBAAwB,CAAC;AAE7F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAmB7D;;;;;;;;;;GAUG;AACH,qBAAa,sBAAsB;IAC/B,OAAO,CAAC,MAAM,CAAe;gBAEjB,MAAM,EAAE,YAAY;IAGhC;;;;;;OAMG;IACH,MAAM,CACF,OAAO,EAAE,QAAQ,CAAC,eAAe,EAAE,CAAC,EACpC,OAAO,EAAE,UAAU,EACnB,YAAY,EAAE,MAAM,GAAG,IAAI,GAC5B,YAAY,EAAE;IAsJjB;;;;;;OAMG;IACH,kBAAkB,IAAI,IAAI;IAK1B,OAAO,CAAC,sBAAsB;IA8E9B,OAAO,CAAC,iBAAiB;CAoE5B"}

package/dist/llm/formatters/vercel.js

@@ -37,9 +37,17 @@ class VercelMessageFormatter {
       filteredHistory = [...history];
     }
     if (systemPrompt) {
+      const modelLower = context.model.toLowerCase();
+      const isClaudeModel = modelLower.includes("claude");
+      const isAnthropicProvider = context.provider === "anthropic" || context.provider === "bedrock" && isClaudeModel || context.provider === "vertex" && isClaudeModel;
       formatted.push({
         role: "system",
-        content: systemPrompt
+        content: systemPrompt,
+        ...isAnthropicProvider && {
+          providerOptions: {
+            anthropic: { cacheControl: { type: "ephemeral" } }
+          }
+        }
       });
     }
     const pendingToolCalls = /* @__PURE__ */ new Map();
@@ -161,12 +169,16 @@ class VercelMessageFormatter {
         } else {
           parsed = rawArgs ?? {};
         }
-        contentParts.push({
+        const toolCallPart = {
           type: "tool-call",
           toolCallId: toolCall.id,
           toolName: toolCall.function.name,
           input: parsed
-        });
+        };
+        if (toolCall.providerOptions) {
+          toolCallPart.providerOptions = toolCall.providerOptions;
+        }
+        contentParts.push(toolCallPart);
       }
       const firstToolCall = msg.toolCalls?.[0];
       if (firstToolCall) {

package/dist/llm/index.cjs

@@ -3,6 +3,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -14,6 +18,12 @@ var __copyProps = (to, from, except, desc) => {
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var llm_exports = {};
+__export(llm_exports, {
+  getOpenRouterModelContextLength: () => import_openrouter_model_registry.getOpenRouterModelContextLength,
+  getOpenRouterModelInfo: () => import_openrouter_model_registry.getOpenRouterModelInfo,
+  lookupOpenRouterModel: () => import_openrouter_model_registry.lookupOpenRouterModel,
+  refreshOpenRouterModelCache: () => import_openrouter_model_registry.refreshOpenRouterModelCache
+});
 module.exports = __toCommonJS(llm_exports);
 __reExport(llm_exports, require("./errors.js"), module.exports);
 __reExport(llm_exports, require("./error-codes.js"), module.exports);
@@ -22,13 +32,20 @@ __reExport(llm_exports, require("./validation.js"), module.exports);
 __reExport(llm_exports, require("./types.js"), module.exports);
 __reExport(llm_exports, require("./services/index.js"), module.exports);
 __reExport(llm_exports, require("./schemas.js"), module.exports);
+var import_openrouter_model_registry = require("./providers/openrouter-model-registry.js");
+__reExport(llm_exports, require("./providers/local/index.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  getOpenRouterModelContextLength,
+  getOpenRouterModelInfo,
+  lookupOpenRouterModel,
+  refreshOpenRouterModelCache,
   ...require("./errors.js"),
   ...require("./error-codes.js"),
   ...require("./registry.js"),
   ...require("./validation.js"),
   ...require("./types.js"),
   ...require("./services/index.js"),
-  ...require("./schemas.js")
+  ...require("./schemas.js"),
+  ...require("./providers/local/index.js")
 });

package/dist/llm/index.d.ts

@@ -5,4 +5,6 @@ export * from './validation.js';
 export * from './types.js';
 export * from './services/index.js';
 export * from './schemas.js';
+export { lookupOpenRouterModel, refreshOpenRouterModelCache, getOpenRouterModelContextLength, getOpenRouterModelInfo, type LookupStatus, type OpenRouterModelInfo, } from './providers/openrouter-model-registry.js';
+export * from './providers/local/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/llm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/llm/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/llm/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,OAAO,EACH,qBAAqB,EACrB,2BAA2B,EAC3B,+BAA+B,EAC/B,sBAAsB,EACtB,KAAK,YAAY,EACjB,KAAK,mBAAmB,GAC3B,MAAM,0CAA0C,CAAC;AAGlD,cAAc,4BAA4B,CAAC"}

package/dist/llm/index.js

@@ -1,3 +1,4 @@
+import "../chunk-PTJYTZNU.js";
 export * from "./errors.js";
 export * from "./error-codes.js";
 export * from "./registry.js";
@@ -5,3 +6,16 @@ export * from "./validation.js";
 export * from "./types.js";
 export * from "./services/index.js";
 export * from "./schemas.js";
+import {
+  lookupOpenRouterModel,
+  refreshOpenRouterModelCache,
+  getOpenRouterModelContextLength,
+  getOpenRouterModelInfo
+} from "./providers/openrouter-model-registry.js";
+export * from "./providers/local/index.js";
+export {
+  getOpenRouterModelContextLength,
+  getOpenRouterModelInfo,
+  lookupOpenRouterModel,
+  refreshOpenRouterModelCache
+};

package/dist/llm/providers/local/ai-sdk-adapter.cjs

@@ -0,0 +1,308 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ai_sdk_adapter_exports = {};
+__export(ai_sdk_adapter_exports, {
+  createLocalLanguageModel: () => createLocalLanguageModel
+});
+module.exports = __toCommonJS(ai_sdk_adapter_exports);
+var import_node_llama_provider = require("./node-llama-provider.js");
+var import_errors = require("./errors.js");
+var import_registry = require("./registry.js");
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var os = __toESM(require("os"), 1);
+function getModelsDirectory() {
+  return path.join(os.homedir(), ".dexto", "models");
+}
+function getInstalledModelInfo(modelId) {
+  const stateFile = path.join(getModelsDirectory(), "state.json");
+  try {
+    if (!fs.existsSync(stateFile)) {
+      return null;
+    }
+    const content = fs.readFileSync(stateFile, "utf-8");
+    const state = JSON.parse(content);
+    return state.installed[modelId] ?? null;
+  } catch {
+    return null;
+  }
+}
+function getCustomModelFilePath(modelId) {
+  const customModelsFile = path.join(getModelsDirectory(), "custom-models.json");
+  try {
+    if (!fs.existsSync(customModelsFile)) {
+      return null;
+    }
+    const content = fs.readFileSync(customModelsFile, "utf-8");
+    const storage = JSON.parse(content);
+    const customModel = storage.models.find(
+      (m) => m.name === modelId && m.provider === "local" && m.filePath
+    );
+    return customModel?.filePath ?? null;
+  } catch {
+    return null;
+  }
+}
+function createLocalLanguageModel(config) {
+  return new LocalLanguageModel(config);
+}
+class LocalLanguageModel {
+  specificationVersion = "v2";
+  provider = "local";
+  modelId;
+  // Local models don't support URL-based content natively
+  supportedUrls = {};
+  config;
+  session = null;
+  loadedModel = null;
+  initPromise = null;
+  deviceName = "Local";
+  constructor(config) {
+    this.modelId = config.modelId;
+    this.config = config;
+  }
+  /**
+   * Initialize the model lazily on first use.
+   */
+  async ensureInitialized() {
+    if (this.session) {
+      return;
+    }
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = this.initialize();
+    return this.initPromise;
+  }
+  async initialize() {
+    const {
+      modelId,
+      modelPath: directPath,
+      contextSize,
+      // Let node-llama-cpp default to "auto" if not specified
+      gpuLayers = -1,
+      threads
+    } = this.config;
+    const isInstalled = await (0, import_node_llama_provider.isNodeLlamaCppInstalled)();
+    if (!isInstalled) {
+      throw import_errors.LocalModelError.nodeLlamaNotInstalled();
+    }
+    let modelPath;
+    if (directPath) {
+      modelPath = directPath;
+    } else {
+      const installedModel = getInstalledModelInfo(modelId);
+      if (installedModel) {
+        modelPath = installedModel.filePath;
+      } else {
+        const customPath = getCustomModelFilePath(modelId);
+        if (customPath) {
+          modelPath = customPath;
+        } else {
+          const registryModel = (0, import_registry.getLocalModelById)(modelId);
+          if (!registryModel) {
+            throw import_errors.LocalModelError.modelNotFound(modelId);
+          }
+          throw import_errors.LocalModelError.modelNotDownloaded(modelId);
+        }
+      }
+    }
+    const loadConfig = {
+      modelPath,
+      gpuLayers
+    };
+    if (contextSize !== void 0) {
+      loadConfig.contextSize = contextSize;
+    }
+    if (threads !== void 0) {
+      loadConfig.threads = threads;
+    }
+    this.loadedModel = await (0, import_node_llama_provider.loadModel)(loadConfig);
+    this.deviceName = this.loadedModel.gpuInfo.deviceName || "Local";
+    this.session = await this.loadedModel.createSession();
+  }
+  /**
+   * Non-streaming text generation (V2 interface).
+   */
+  async doGenerate(options) {
+    await this.ensureInitialized();
+    const prompt = this.formatPrompt(options);
+    const maxTokens = options.maxOutputTokens ?? 1024;
+    const temperature = options.temperature ?? 0.7;
+    const promptOptions = {
+      maxTokens,
+      temperature
+    };
+    if (options.abortSignal) {
+      promptOptions.signal = options.abortSignal;
+    }
+    const response = await this.session.prompt(prompt, promptOptions);
+    const inputTokens = Math.ceil(prompt.length / 4);
+    const outputTokens = Math.ceil(response.length / 4);
+    const content = [{ type: "text", text: response }];
+    const finishReason = "stop";
+    const usage = {
+      inputTokens,
+      outputTokens,
+      totalTokens: inputTokens + outputTokens
+    };
+    const warnings = [];
+    return {
+      content,
+      finishReason,
+      usage,
+      providerMetadata: {
+        local: {
+          device: this.deviceName
+        }
+      },
+      warnings
+    };
+  }
+  /**
+   * Streaming text generation (V2 interface).
+   */
+  async doStream(options) {
+    await this.ensureInitialized();
+    const prompt = this.formatPrompt(options);
+    const maxTokens = options.maxOutputTokens ?? 1024;
+    const temperature = options.temperature ?? 0.7;
+    const inputTokens = Math.ceil(prompt.length / 4);
+    let outputTokens = 0;
+    const session = this.session;
+    const textId = "text-0";
+    const streamPromptOptions = {
+      maxTokens,
+      temperature,
+      onToken: (_token) => {
+      }
+    };
+    if (options.abortSignal) {
+      streamPromptOptions.signal = options.abortSignal;
+    }
+    let controller;
+    const stream = new ReadableStream({
+      async start(ctrl) {
+        controller = ctrl;
+        controller.enqueue({
+          type: "stream-start",
+          warnings: []
+        });
+        controller.enqueue({
+          type: "text-start",
+          id: textId
+        });
+        try {
+          streamPromptOptions.onToken = (token) => {
+            outputTokens += 1;
+            controller.enqueue({
+              type: "text-delta",
+              id: textId,
+              delta: token
+            });
+          };
+          await session.prompt(prompt, streamPromptOptions);
+          controller.enqueue({
+            type: "text-end",
+            id: textId
+          });
+          controller.enqueue({
+            type: "finish",
+            finishReason: "stop",
+            usage: {
+              inputTokens,
+              outputTokens,
+              totalTokens: inputTokens + outputTokens
+            }
+          });
+          controller.close();
+        } catch (error) {
+          if (error instanceof Error && error.name === "AbortError") {
+            controller.enqueue({
+              type: "text-end",
+              id: textId
+            });
+            controller.enqueue({
+              type: "finish",
+              finishReason: "stop",
+              usage: {
+                inputTokens,
+                outputTokens,
+                totalTokens: inputTokens + outputTokens
+              }
+            });
+            controller.close();
+          } else {
+            controller.enqueue({
+              type: "error",
+              error
+            });
+            controller.close();
+          }
+        }
+      }
+    });
+    return {
+      stream
+    };
+  }
+  /**
+   * Format the prompt from AI SDK message format.
+   */
+  formatPrompt(options) {
+    const parts = [];
+    if (options.prompt && Array.isArray(options.prompt)) {
+      for (const message of options.prompt) {
+        if (message.role === "system") {
+          parts.push(`System: ${message.content}`);
+        } else if (message.role === "user") {
+          if (Array.isArray(message.content)) {
+            const textParts = message.content.filter((p) => p.type === "text").map((p) => p.text);
+            if (textParts.length > 0) {
+              parts.push(`User: ${textParts.join("\n")}`);
+            }
+          }
+        } else if (message.role === "assistant") {
+          if (Array.isArray(message.content)) {
+            const textParts = message.content.filter((p) => p.type === "text").map((p) => p.text);
+            if (textParts.length > 0) {
+              parts.push(`Assistant: ${textParts.join("\n")}`);
+            }
+          }
+        }
+      }
+    }
+    parts.push("Assistant:");
+    return parts.join("\n\n");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLocalLanguageModel
+});