@dexto/core 1.2.6 → 1.4.0

package/dist/llm/services/vercel.js

@@ -2,32 +2,21 @@ import {
   __decorateElement,
   __decoratorStart,
   __runInitializers
-} from "../../chunk-C6A6W6XS.js";
+} from "../../chunk-PTJYTZNU.js";
 var _VercelLLMService_decorators, _init;
-import {
-  generateText,
-  streamText,
-  APICallError,
-  stepCountIs
-} from "ai";
 import { DextoLogComponent } from "../../logger/v2/types.js";
-import { jsonSchema } from "ai";
 import { ContextManager } from "../../context/manager.js";
-import { summarizeToolContentForText } from "../../context/utils.js";
-import { shouldIncludeRawToolResult } from "../../utils/debug.js";
-import { getMaxInputTokensForModel, getEffectiveMaxInputTokens } from "../registry.js";
-import { DextoRuntimeError } from "../../errors/DextoRuntimeError.js";
-import { LLMErrorCode } from "../error-codes.js";
-import { ErrorScope, ErrorType } from "../../errors/types.js";
-import { toError } from "../../utils/error-conversion.js";
-import { ToolErrorCode } from "../../tools/error-codes.js";
+import { getEffectiveMaxInputTokens, getMaxInputTokensForModel } from "../registry.js";
 import { VercelMessageFormatter } from "../formatters/vercel.js";
-import { createTokenizer } from "../tokenizer/factory.js";
 import { InstrumentClass } from "../../telemetry/decorators.js";
 import { trace, context, propagation } from "@opentelemetry/api";
+import { TurnExecutor } from "../executor/turn-executor.js";
+import { MessageQueueService } from "../../session/message-queue.js";
+import { DextoRuntimeError } from "../../errors/DextoRuntimeError.js";
+import { LLMErrorCode } from "../error-codes.js";
 _VercelLLMService_decorators = [InstrumentClass({
   prefix: "llm.vercel",
-  excludeMethods: ["getModelId", "getAllTools", "formatTools", "validateToolSupport"]
+  excludeMethods: ["getModelId", "getAllTools", "createTurnExecutor"]
 })];
 class VercelLLMService {
   model;
@@ -36,8 +25,9 @@ class VercelLLMService {
   contextManager;
   sessionEventBus;
   sessionId;
-  toolSupportCache = /* @__PURE__ */ new Map();
   logger;
+  resourceManager;
+  messageQueue;
   /**
    * Helper to extract model ID from LanguageModel union type (string | LanguageModelV2)
    */
@@ -51,20 +41,19 @@ class VercelLLMService {
     this.toolManager = toolManager;
     this.sessionEventBus = sessionEventBus;
     this.sessionId = sessionId;
+    this.resourceManager = resourceManager;
+    this.messageQueue = new MessageQueueService(this.sessionEventBus, this.logger);
     const formatter = new VercelMessageFormatter(this.logger);
-    const tokenizer = createTokenizer(config.provider, this.getModelId(), this.logger);
     const maxInputTokens = getEffectiveMaxInputTokens(config, this.logger);
     this.contextManager = new ContextManager(
       config,
       formatter,
       systemPromptManager,
       maxInputTokens,
-      tokenizer,
       historyProvider,
       sessionId,
       resourceManager,
       this.logger
-      // compressionStrategies uses default
     );
     this.logger.debug(
       `[VercelLLMService] Initialized for model: ${this.getModelId()}, provider: ${this.config.provider}, temperature: ${this.config.temperature}, maxOutputTokens: ${this.config.maxOutputTokens}`
@@ -73,134 +62,40 @@ class VercelLLMService {
   getAllTools() {
     return this.toolManager.getAllTools();
   }
-  formatTools(tools) {
-    this.logger.debug(`Formatting tools for vercel`);
-    return Object.keys(tools).reduce((acc, toolName) => {
-      const tool = tools[toolName];
-      if (tool) {
-        acc[toolName] = {
-          inputSchema: jsonSchema(tool.parameters),
-          execute: async (args, options) => {
-            const callId = options.toolCallId;
-            try {
-              this.logger.debug(
-                `[vercel] Emitting toolCall event for ${toolName} with callId ${callId}`
-              );
-              this.sessionEventBus.emit("llm:tool-call", {
-                toolName,
-                args,
-                callId
-              });
-              const rawResult = await this.toolManager.executeTool(
-                toolName,
-                args,
-                this.sessionId
-              );
-              const persisted = await this.contextManager.addToolResult(
-                callId,
-                toolName,
-                rawResult,
-                { success: true }
-              );
-              this.logger.debug(
-                `[vercel] Emitting toolResult event for ${toolName} with callId ${callId}`
-              );
-              this.sessionEventBus.emit("llm:tool-result", {
-                toolName,
-                callId,
-                success: true,
-                sanitized: persisted,
-                ...shouldIncludeRawToolResult() ? { rawResult } : {}
-              });
-              const summaryText = summarizeToolContentForText(persisted.content);
-              return summaryText;
-            } catch (err) {
-              let errorResult;
-              let errorFlags = "";
-              if (err instanceof DextoRuntimeError && err.code === ToolErrorCode.EXECUTION_DENIED) {
-                errorResult = { error: err.message, denied: true };
-                errorFlags = " (denied)";
-              } else if (err instanceof DextoRuntimeError && err.code === ToolErrorCode.CONFIRMATION_TIMEOUT) {
-                errorResult = { error: err.message, denied: true, timeout: true };
-                errorFlags = " (timeout)";
-              } else {
-                const message = err instanceof Error ? err.message : String(err);
-                errorResult = { error: message };
-              }
-              try {
-                const persisted = await this.contextManager.addToolResult(
-                  callId,
-                  toolName,
-                  errorResult,
-                  { success: false }
-                );
-                this.sessionEventBus.emit("llm:tool-result", {
-                  toolName,
-                  callId,
-                  success: false,
-                  sanitized: persisted,
-                  ...shouldIncludeRawToolResult() ? { rawResult: errorResult } : {}
-                });
-              } catch (persistErr) {
-                this.logger.error(
-                  `Failed to persist error result for ${toolName}: ${String(persistErr)}`
-                );
-              }
-              return `Tool ${toolName} failed${errorFlags}: ${errorResult.error}`;
-            }
-          },
-          ...tool.description && { description: tool.description }
-        };
-      }
-      return acc;
-    }, {});
-  }
-  async validateToolSupport() {
-    const modelKey = `${this.config.provider}:${this.getModelId()}:${this.config.baseURL ?? ""}`;
-    if (this.toolSupportCache.has(modelKey)) {
-      return this.toolSupportCache.get(modelKey);
-    }
-    if (!this.config.baseURL) {
-      this.logger.debug(`Skipping tool validation for ${modelKey} - no custom baseURL`);
-      this.toolSupportCache.set(modelKey, true);
-      return true;
-    }
-    this.logger.debug(`Testing tool support for custom endpoint model: ${modelKey}`);
-    const testTool = {
-      test_tool: {
-        inputSchema: jsonSchema({
-          type: "object",
-          properties: {},
-          additionalProperties: false
-        }),
-        execute: async () => ({ result: "test" })
-      }
-    };
-    try {
-      await generateText({
-        model: this.model,
-        messages: [{ role: "user", content: "Hello" }],
-        tools: testTool,
-        stopWhen: stepCountIs(1)
-      });
-      this.toolSupportCache.set(modelKey, true);
-      this.logger.debug(`Model ${modelKey} supports tools`);
-      return true;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      if (errorMessage.includes("does not support tools")) {
-        this.toolSupportCache.set(modelKey, false);
-        this.logger.debug(`Model ${modelKey} does not support tools`);
-        return false;
-      }
-      this.logger.debug(
-        `Tool validation error for ${modelKey}, assuming supported: ${errorMessage}`
-      );
-      this.toolSupportCache.set(modelKey, true);
-      return true;
-    }
+  /**
+   * Create a TurnExecutor instance for executing the agent loop.
+   */
+  createTurnExecutor(externalSignal) {
+    return new TurnExecutor(
+      this.model,
+      this.toolManager,
+      this.contextManager,
+      this.sessionEventBus,
+      this.resourceManager,
+      this.sessionId,
+      {
+        maxSteps: this.config.maxIterations,
+        maxOutputTokens: this.config.maxOutputTokens,
+        temperature: this.config.temperature,
+        baseURL: this.config.baseURL
+      },
+      { provider: this.config.provider, model: this.getModelId() },
+      this.logger,
+      this.messageQueue,
+      void 0,
+      // modelLimits - TurnExecutor will use defaults
+      externalSignal
+    );
   }
-  async completeTask(textInput, options, imageData, fileData, stream) {
+  /**
+   * Stream a response for the given content.
+   * Primary method for running conversations with multi-image support.
+   *
+   * @param content - String or ContentPart[] (text, images, files)
+   * @param options - { signal?: AbortSignal }
+   * @returns The assistant's text response
+   */
+  async stream(content, options) {
     const activeSpan = trace.getActiveSpan();
     const currentContext = context.active();
     const provider = this.config.provider;
@@ -223,331 +118,14 @@ class VercelLLMService {
       propagation.createBaggage(baggageEntries)
     );
     return await context.with(updatedContext, async () => {
-      await this.contextManager.addUserMessage(textInput, imageData, fileData);
-      const tools = await this.toolManager.getAllTools();
-      this.logger.silly(
-        `[VercelLLMService] Tools before formatting: ${JSON.stringify(tools, null, 2)}`
-      );
-      const formattedTools = this.formatTools(tools);
-      this.logger.silly(
-        `[VercelLLMService] Formatted tools: ${JSON.stringify(formattedTools, null, 2)}`
-      );
-      let fullResponse = "";
-      this.sessionEventBus.emit("llm:thinking");
-      const prepared = await this.contextManager.getFormattedMessagesWithCompression(
-        { mcpManager: this.toolManager.getMcpManager() },
-        { provider: this.config.provider, model: this.getModelId() }
-      );
-      const formattedMessages = prepared.formattedMessages;
-      const tokensUsed = prepared.tokensUsed;
-      this.logger.silly(
-        `Messages (potentially compressed): ${JSON.stringify(formattedMessages, null, 2)}`
-      );
-      this.logger.silly(`Tools: ${JSON.stringify(formattedTools, null, 2)}`);
-      this.logger.debug(`Estimated tokens being sent to Vercel provider: ${tokensUsed}`);
-      if (stream) {
-        fullResponse = await this.streamText(
-          formattedMessages,
-          formattedTools,
-          this.config.maxIterations,
-          options?.signal
-        );
-      } else {
-        fullResponse = await this.generateText(
-          formattedMessages,
-          formattedTools,
-          this.config.maxIterations,
-          options?.signal
-        );
-      }
-      if (options?.signal?.aborted) {
-        return fullResponse;
-      }
-      return fullResponse || `Reached maximum number of steps (${this.config.maxIterations}) without a final response.`;
+      const parts = typeof content === "string" ? [{ type: "text", text: content }] : content;
+      await this.contextManager.addUserMessage(parts);
+      const executor = this.createTurnExecutor(options?.signal);
+      const contributorContext = { mcpManager: this.toolManager.getMcpManager() };
+      const result = await executor.execute(contributorContext, true);
+      return result.text ?? "";
     });
   }
-  async generateText(messages, tools, maxSteps = 50, signal) {
-    const activeSpan = trace.getActiveSpan();
-    if (activeSpan) {
-      activeSpan.setAttribute("llm.provider", this.config.provider);
-      activeSpan.setAttribute("llm.model", this.getModelId());
-    }
-    let stepIteration = 0;
-    const estimatedTokens = Math.ceil(JSON.stringify(messages, null, 2).length / 4);
-    this.logger.debug(
-      `vercel generateText:Generating text with messages (${estimatedTokens} estimated tokens)`
-    );
-    const temperature = this.config.temperature;
-    const maxOutputTokens = this.config.maxOutputTokens;
-    const supportsTools = await this.validateToolSupport();
-    const effectiveTools = supportsTools ? tools : {};
-    if (!supportsTools && Object.keys(tools).length > 0) {
-      this.logger.debug(
-        `Model ${this.getModelId()} does not support tools, using empty tools object for generation`
-      );
-    }
-    try {
-      const includeMaxOutputTokens = typeof maxOutputTokens === "number";
-      const response = await generateText({
-        model: this.model,
-        messages,
-        tools: effectiveTools,
-        ...signal ? { abortSignal: signal } : {},
-        onStepFinish: async (step) => {
-          this.logger.debug(`Step iteration: ${stepIteration}`);
-          stepIteration++;
-          this.logger.debug(`Step finished, text: ${step.text}`);
-          this.logger.debug(
-            `Step finished, step tool calls: ${JSON.stringify(step.toolCalls, null, 2)}`
-          );
-          this.logger.debug(
-            `Step finished, step tool results: ${JSON.stringify(step.toolResults, null, 2)}`
-          );
-        },
-        stopWhen: stepCountIs(maxSteps),
-        ...includeMaxOutputTokens ? { maxOutputTokens } : {},
-        ...temperature !== void 0 && { temperature }
-      });
-      this.sessionEventBus.emit("llm:response", {
-        content: response.text,
-        ...response.reasoningText && { reasoning: response.reasoningText },
-        provider: this.config.provider,
-        model: this.getModelId(),
-        router: "vercel",
-        tokenUsage: {
-          ...response.totalUsage.inputTokens !== void 0 && {
-            inputTokens: response.totalUsage.inputTokens
-          },
-          ...response.totalUsage.outputTokens !== void 0 && {
-            outputTokens: response.totalUsage.outputTokens
-          },
-          ...response.totalUsage.reasoningTokens !== void 0 && {
-            reasoningTokens: response.totalUsage.reasoningTokens
-          },
-          ...response.totalUsage.totalTokens !== void 0 && {
-            totalTokens: response.totalUsage.totalTokens
-          }
-        }
-      });
-      const activeSpan2 = trace.getActiveSpan();
-      if (activeSpan2) {
-        const attributes = {};
-        if (response.totalUsage.inputTokens !== void 0) {
-          attributes["gen_ai.usage.input_tokens"] = response.totalUsage.inputTokens;
-        }
-        if (response.totalUsage.outputTokens !== void 0) {
-          attributes["gen_ai.usage.output_tokens"] = response.totalUsage.outputTokens;
-        }
-        if (response.totalUsage.totalTokens !== void 0) {
-          attributes["gen_ai.usage.total_tokens"] = response.totalUsage.totalTokens;
-        }
-        if (response.totalUsage.reasoningTokens !== void 0) {
-          attributes["gen_ai.usage.reasoning_tokens"] = response.totalUsage.reasoningTokens;
-        }
-        activeSpan2.setAttributes(attributes);
-      }
-      await this.contextManager.processLLMResponse(response);
-      if (typeof response.totalUsage.totalTokens === "number") {
-        this.contextManager.updateActualTokenCount(response.totalUsage.totalTokens);
-      }
-      return response.text;
-    } catch (err) {
-      const error = this.mapProviderError(err, "generate");
-      this.sessionEventBus.emit("llm:error", {
-        error,
-        context: "generateText",
-        recoverable: false
-      });
-      return "";
-    }
-  }
-  mapProviderError(err, phase) {
-    if (APICallError.isInstance?.(err)) {
-      this.logger.error(`APICallError in mapProviderError: ${JSON.stringify(err, null, 2)}`);
-      const status = err.statusCode;
-      const headers = err.responseHeaders || {};
-      const retryAfter = headers["retry-after"] ? Number(headers["retry-after"]) : void 0;
-      const body = typeof err.responseBody === "string" ? err.responseBody : JSON.stringify(err.responseBody ?? "");
-      if (status === 429) {
-        return new DextoRuntimeError(
-          LLMErrorCode.RATE_LIMIT_EXCEEDED,
-          ErrorScope.LLM,
-          ErrorType.RATE_LIMIT,
-          `Rate limit exceeded${body ? ` - ${body}` : ""}`,
-          {
-            sessionId: this.sessionId,
-            provider: this.config.provider,
-            model: this.getModelId(),
-            status,
-            retryAfter,
-            body,
-            phase
-          }
-        );
-      }
-      if (status === 408) {
-        return new DextoRuntimeError(
-          LLMErrorCode.GENERATION_FAILED,
-          ErrorScope.LLM,
-          ErrorType.TIMEOUT,
-          `Provider timed out${body ? ` - ${body}` : ""}`,
-          {
-            sessionId: this.sessionId,
-            provider: this.config.provider,
-            model: this.getModelId(),
-            status,
-            body,
-            phase
-          }
-        );
-      }
-      return new DextoRuntimeError(
-        LLMErrorCode.GENERATION_FAILED,
-        ErrorScope.LLM,
-        ErrorType.THIRD_PARTY,
-        `Provider error ${status}${body ? ` - ${body}` : ""}`,
-        {
-          sessionId: this.sessionId,
-          provider: this.config.provider,
-          model: this.getModelId(),
-          status,
-          body,
-          phase
-        }
-      );
-    }
-    return toError(err, this.logger);
-  }
-  // Updated streamText to behave like generateText - returns string and handles message processing internally
-  async streamText(messages, tools, maxSteps = 10, signal) {
-    const activeSpan = trace.getActiveSpan();
-    if (activeSpan) {
-      activeSpan.setAttribute("llm.provider", this.config.provider);
-      activeSpan.setAttribute("llm.model", this.getModelId());
-    }
-    let stepIteration = 0;
-    const temperature = this.config.temperature;
-    const maxOutputTokens = this.config.maxOutputTokens;
-    const supportsTools = await this.validateToolSupport();
-    const effectiveTools = supportsTools ? tools : {};
-    if (!supportsTools && Object.keys(tools).length > 0) {
-      this.logger.debug(
-        `Model ${this.getModelId()} does not support tools, using empty tools object for streaming`
-      );
-    }
-    let streamErr;
-    const includeMaxOutputTokens = typeof maxOutputTokens === "number";
-    let response;
-    response = streamText({
-      model: this.model,
-      messages,
-      tools: effectiveTools,
-      ...signal ? { abortSignal: signal } : {},
-      onChunk: (chunk) => {
-        this.logger.debug(`Chunk type: ${chunk.chunk.type}`);
-        if (chunk.chunk.type === "text-delta") {
-          this.sessionEventBus.emit("llm:chunk", {
-            chunkType: "text",
-            content: chunk.chunk.text,
-            isComplete: false
-          });
-        } else if (chunk.chunk.type === "reasoning-delta") {
-          this.sessionEventBus.emit("llm:chunk", {
-            chunkType: "reasoning",
-            content: chunk.chunk.text,
-            isComplete: false
-          });
-        }
-      },
-      // TODO: Add onAbort handler when we implement partial response handling.
-      // Vercel triggers onAbort instead of onError for cancelled streams.
-      // This is where cancellation logic should be handled properly.
-      onError: (error) => {
-        const err = this.mapProviderError(error, "stream");
-        this.logger.error(`Error in streamText after parsing: ${err.toString()}`);
-        this.sessionEventBus.emit("llm:error", {
-          error: err,
-          context: "streamText",
-          recoverable: false
-        });
-        streamErr = error;
-      },
-      onStepFinish: async (step) => {
-        this.logger.debug(`Step iteration: ${stepIteration}`);
-        stepIteration++;
-        this.logger.debug(`Step finished, text: ${step.text}`);
-        this.logger.debug(
-          `Step finished, step tool calls: ${JSON.stringify(step.toolCalls, null, 2)}`
-        );
-        this.logger.debug(
-          `Step finished, step tool results: ${JSON.stringify(step.toolResults, null, 2)}`
-        );
-      },
-      // No onFinish: we finalize after the stream completes below.
-      stopWhen: stepCountIs(maxSteps),
-      ...includeMaxOutputTokens ? { maxOutputTokens } : {},
-      ...temperature !== void 0 && { temperature }
-    });
-    if (streamErr) {
-      return "";
-    }
-    let finalText;
-    let usage;
-    let reasoningText;
-    try {
-      [finalText, usage, reasoningText] = await Promise.all([
-        response.text,
-        response.totalUsage,
-        response.reasoningText
-      ]);
-    } catch (_error) {
-      this.logger.debug(
-        `streamText finalization failed while awaiting text/usage/reasoning: ${String(_error)}`
-      );
-      return "";
-    }
-    this.logger.debug(`streamText finalText: ${finalText}`);
-    this.logger.debug(`streamText usage: ${JSON.stringify(usage, null, 2)}`);
-    this.logger.debug(`streamText reasoningText: ${reasoningText}`);
-    this.sessionEventBus.emit("llm:response", {
-      content: finalText,
-      ...reasoningText && { reasoning: reasoningText },
-      provider: this.config.provider,
-      model: this.getModelId(),
-      router: "vercel",
-      tokenUsage: {
-        ...usage.inputTokens !== void 0 && { inputTokens: usage.inputTokens },
-        ...usage.outputTokens !== void 0 && { outputTokens: usage.outputTokens },
-        ...usage.reasoningTokens !== void 0 && {
-          reasoningTokens: usage.reasoningTokens
-        },
-        ...usage.totalTokens !== void 0 && { totalTokens: usage.totalTokens }
-      }
-    });
-    const activeSpan2 = trace.getActiveSpan();
-    if (activeSpan2) {
-      const attributes = {};
-      if (usage.inputTokens !== void 0) {
-        attributes["gen_ai.usage.input_tokens"] = usage.inputTokens;
-      }
-      if (usage.outputTokens !== void 0) {
-        attributes["gen_ai.usage.output_tokens"] = usage.outputTokens;
-      }
-      if (usage.totalTokens !== void 0) {
-        attributes["gen_ai.usage.total_tokens"] = usage.totalTokens;
-      }
-      if (usage.reasoningTokens !== void 0) {
-        attributes["gen_ai.usage.reasoning_tokens"] = usage.reasoningTokens;
-      }
-      activeSpan2.setAttributes(attributes);
-    }
-    if (typeof usage.totalTokens === "number") {
-      this.contextManager.updateActualTokenCount(usage.totalTokens);
-    }
-    await this.contextManager.processLLMStreamResponse(response);
-    this.logger.silly(`streamText response object: ${JSON.stringify(response, null, 2)}`);
-    return finalText;
-  }
   /**
    * Get configuration information about the LLM service
    * @returns Configuration object with provider and model information
@@ -558,7 +136,6 @@ class VercelLLMService {
     try {
       modelMaxInputTokens = getMaxInputTokensForModel(
         this.config.provider,
-        // Use our internal provider name
         this.getModelId(),
         this.logger
       );
@@ -573,9 +150,7 @@ class VercelLLMService {
       }
     }
     return {
-      router: "vercel",
       provider: this.config.provider,
-      // Use our internal provider name
       model: this.model,
       configuredMaxInputTokens: configuredMaxTokens,
       modelMaxInputTokens
@@ -587,6 +162,12 @@ class VercelLLMService {
   getContextManager() {
     return this.contextManager;
   }
+  /**
+   * Get the message queue for external access (e.g., queueing messages while busy)
+   */
+  getMessageQueue() {
+    return this.messageQueue;
+  }
 }
 _init = __decoratorStart(null);
 VercelLLMService = __decorateElement(_init, 0, "VercelLLMService", _VercelLLMService_decorators, VercelLLMService);

package/dist/llm/types.cjs

@@ -19,7 +19,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var types_exports = {};
 __export(types_exports, {
   LLM_PROVIDERS: () => LLM_PROVIDERS,
-  LLM_ROUTERS: () => LLM_ROUTERS,
   SUPPORTED_FILE_TYPES: () => SUPPORTED_FILE_TYPES
 });
 module.exports = __toCommonJS(types_exports);
@@ -32,11 +31,9 @@ const LLM_PROVIDERS = [
   "xai",
   "cohere"
 ];
-const LLM_ROUTERS = ["vercel", "in-built"];
 const SUPPORTED_FILE_TYPES = ["pdf", "image", "audio"];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LLM_PROVIDERS,
-  LLM_ROUTERS,
   SUPPORTED_FILE_TYPES
 });

package/dist/llm/types.d.ts

@@ -1,14 +1,7 @@
 export declare const LLM_PROVIDERS: readonly ["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere"];
 export type LLMProvider = (typeof LLM_PROVIDERS)[number];
-export declare const LLM_ROUTERS: readonly ["vercel", "in-built"];
-export type LLMRouter = (typeof LLM_ROUTERS)[number];
 export declare const SUPPORTED_FILE_TYPES: readonly ["pdf", "image", "audio"];
 export type SupportedFileType = (typeof SUPPORTED_FILE_TYPES)[number];
-/**
- * LLMRouter defines the routing backend for LLM service instantiation.
- * 'vercel' = use Vercel LLM service, 'in-built' = use in-built LLM service
- * This type is now defined in the registry as the source of truth.
- */
 /**
  * Context interface for message formatters.
  * Provides runtime information for model-aware processing.
@@ -22,7 +15,14 @@ export interface LLMContext {
 export interface LLMUpdateContext {
     provider?: LLMProvider;
     model?: string;
-    router?: LLMRouter;
     suggestedAction?: string;
 }
+export interface TokenUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    reasoningTokens?: number;
+    totalTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+}
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/llm/types.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,aAAa,0FAQhB,CAAC;AACX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAM,WAAW,iCAAkC,CAAC;AAC3D,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAErD,eAAO,MAAM,oBAAoB,oCAAqC,CAAC;AACvE,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEtE;;;;GAIG;AACH;;;GAGG;AAEH,MAAM,WAAW,UAAU;IACvB,mDAAmD;IACnD,QAAQ,EAAE,WAAW,CAAC;IAEtB,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC;CACjB;AAGD,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/llm/types.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,aAAa,0FAQhB,CAAC;AACX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAM,oBAAoB,oCAAqC,CAAC;AACvE,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEtE;;;GAGG;AAEH,MAAM,WAAW,UAAU;IACvB,mDAAmD;IACnD,QAAQ,EAAE,WAAW,CAAC;IAEtB,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC;CACjB;AAGD,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,UAAU;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B"}

package/dist/llm/types.js

@@ -1,4 +1,4 @@
-import "../chunk-C6A6W6XS.js";
+import "../chunk-PTJYTZNU.js";
 const LLM_PROVIDERS = [
   "openai",
   "openai-compatible",
@@ -8,10 +8,8 @@ const LLM_PROVIDERS = [
   "xai",
   "cohere"
 ];
-const LLM_ROUTERS = ["vercel", "in-built"];
 const SUPPORTED_FILE_TYPES = ["pdf", "image", "audio"];
 export {
   LLM_PROVIDERS,
-  LLM_ROUTERS,
   SUPPORTED_FILE_TYPES
 };

package/dist/llm/validation.js

@@ -1,4 +1,4 @@
-import "../chunk-C6A6W6XS.js";
+import "../chunk-PTJYTZNU.js";
 import { validateModelFileSupport, getAllowedMimeTypes } from "./registry.js";
 import { ok, fail } from "../utils/result.js";
 import { ErrorScope, ErrorType } from "../errors/types.js";