@dexto/core 1.2.4 → 1.2.6

package/dist/llm/services/vercel.js

@@ -10,7 +10,7 @@ import {
   APICallError,
   stepCountIs
 } from "ai";
-import { logger } from "../../logger/index.js";
+import { DextoLogComponent } from "../../logger/v2/types.js";
 import { jsonSchema } from "ai";
 import { ContextManager } from "../../context/manager.js";
 import { summarizeToolContentForText } from "../../context/utils.js";
@@ -24,7 +24,7 @@ import { ToolErrorCode } from "../../tools/error-codes.js";
 import { VercelMessageFormatter } from "../formatters/vercel.js";
 import { createTokenizer } from "../tokenizer/factory.js";
 import { InstrumentClass } from "../../telemetry/decorators.js";
-import { trace } from "@opentelemetry/api";
+import { trace, context, propagation } from "@opentelemetry/api";
 _VercelLLMService_decorators = [InstrumentClass({
   prefix: "llm.vercel",
   excludeMethods: ["getModelId", "getAllTools", "formatTools", "validateToolSupport"]
@@ -37,21 +37,23 @@ class VercelLLMService {
   sessionEventBus;
   sessionId;
   toolSupportCache = /* @__PURE__ */ new Map();
+  logger;
   /**
    * Helper to extract model ID from LanguageModel union type (string | LanguageModelV2)
    */
   getModelId() {
     return typeof this.model === "string" ? this.model : this.model.modelId;
   }
-  constructor(toolManager, model, systemPromptManager, historyProvider, sessionEventBus, config, sessionId, resourceManager) {
+  constructor(toolManager, model, systemPromptManager, historyProvider, sessionEventBus, config, sessionId, resourceManager, logger) {
+    this.logger = logger.createChild(DextoLogComponent.LLM);
     this.model = model;
     this.config = config;
     this.toolManager = toolManager;
     this.sessionEventBus = sessionEventBus;
     this.sessionId = sessionId;
-    const formatter = new VercelMessageFormatter();
-    const tokenizer = createTokenizer(config.provider, this.getModelId());
-    const maxInputTokens = getEffectiveMaxInputTokens(config);
+    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,
@@ -60,10 +62,11 @@ class VercelLLMService {
       tokenizer,
       historyProvider,
       sessionId,
-      resourceManager
+      resourceManager,
+      this.logger
       // compressionStrategies uses default
     );
-    logger.debug(
+    this.logger.debug(
       `[VercelLLMService] Initialized for model: ${this.getModelId()}, provider: ${this.config.provider}, temperature: ${this.config.temperature}, maxOutputTokens: ${this.config.maxOutputTokens}`
     );
   }
@@ -71,7 +74,7 @@ class VercelLLMService {
     return this.toolManager.getAllTools();
   }
   formatTools(tools) {
-    logger.debug(`Formatting tools for vercel`);
+    this.logger.debug(`Formatting tools for vercel`);
     return Object.keys(tools).reduce((acc, toolName) => {
       const tool = tools[toolName];
       if (tool) {
@@ -80,10 +83,10 @@ class VercelLLMService {
           execute: async (args, options) => {
             const callId = options.toolCallId;
             try {
-              logger.debug(
+              this.logger.debug(
                 `[vercel] Emitting toolCall event for ${toolName} with callId ${callId}`
               );
-              this.sessionEventBus.emit("llmservice:toolCall", {
+              this.sessionEventBus.emit("llm:tool-call", {
                 toolName,
                 args,
                 callId
@@ -99,10 +102,10 @@ class VercelLLMService {
                 rawResult,
                 { success: true }
               );
-              logger.debug(
+              this.logger.debug(
                 `[vercel] Emitting toolResult event for ${toolName} with callId ${callId}`
               );
-              this.sessionEventBus.emit("llmservice:toolResult", {
+              this.sessionEventBus.emit("llm:tool-result", {
                 toolName,
                 callId,
                 success: true,
@@ -131,7 +134,7 @@ class VercelLLMService {
                   errorResult,
                   { success: false }
                 );
-                this.sessionEventBus.emit("llmservice:toolResult", {
+                this.sessionEventBus.emit("llm:tool-result", {
                   toolName,
                   callId,
                   success: false,
@@ -139,7 +142,7 @@ class VercelLLMService {
                   ...shouldIncludeRawToolResult() ? { rawResult: errorResult } : {}
                 });
               } catch (persistErr) {
-                logger.error(
+                this.logger.error(
                   `Failed to persist error result for ${toolName}: ${String(persistErr)}`
                 );
               }
@@ -158,11 +161,11 @@ class VercelLLMService {
       return this.toolSupportCache.get(modelKey);
     }
     if (!this.config.baseURL) {
-      logger.debug(`Skipping tool validation for ${modelKey} - no custom baseURL`);
+      this.logger.debug(`Skipping tool validation for ${modelKey} - no custom baseURL`);
       this.toolSupportCache.set(modelKey, true);
       return true;
     }
-    logger.debug(`Testing tool support for custom endpoint model: ${modelKey}`);
+    this.logger.debug(`Testing tool support for custom endpoint model: ${modelKey}`);
     const testTool = {
       test_tool: {
         inputSchema: jsonSchema({
@@ -181,16 +184,16 @@ class VercelLLMService {
         stopWhen: stepCountIs(1)
       });
       this.toolSupportCache.set(modelKey, true);
-      logger.debug(`Model ${modelKey} supports tools`);
+      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);
-        logger.debug(`Model ${modelKey} does not support tools`);
+        this.logger.debug(`Model ${modelKey} does not support tools`);
         return false;
       }
-      logger.debug(
+      this.logger.debug(
         `Tool validation error for ${modelKey}, assuming supported: ${errorMessage}`
       );
       this.toolSupportCache.set(modelKey, true);
@@ -198,57 +201,80 @@ class VercelLLMService {
     }
   }
   async completeTask(textInput, options, imageData, fileData, stream) {
-    logger.debug(
-      `[VercelLLMService] addUserMessage(text ~${textInput.length} chars, image=${Boolean(
-        imageData
-      )}, file=${Boolean(fileData)})`
-    );
-    await this.contextManager.addUserMessage(textInput, imageData, fileData);
-    const tools = await this.toolManager.getAllTools();
-    logger.silly(
-      `[VercelLLMService] Tools before formatting: ${JSON.stringify(tools, null, 2)}`
-    );
-    const formattedTools = this.formatTools(tools);
-    logger.silly(
-      `[VercelLLMService] Formatted tools: ${JSON.stringify(formattedTools, null, 2)}`
-    );
-    let fullResponse = "";
-    this.sessionEventBus.emit("llmservice: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;
-    logger.silly(
-      `Messages (potentially compressed): ${JSON.stringify(formattedMessages, null, 2)}`
+    const activeSpan = trace.getActiveSpan();
+    const currentContext = context.active();
+    const provider = this.config.provider;
+    const model = this.getModelId();
+    if (activeSpan) {
+      activeSpan.setAttribute("llm.provider", provider);
+      activeSpan.setAttribute("llm.model", model);
+    }
+    const existingBaggage = propagation.getBaggage(currentContext);
+    const baggageEntries = {};
+    if (existingBaggage) {
+      existingBaggage.getAllEntries().forEach(([key, entry]) => {
+        baggageEntries[key] = entry;
+      });
+    }
+    baggageEntries["llm.provider"] = { value: provider };
+    baggageEntries["llm.model"] = { value: model };
+    const updatedContext = propagation.setBaggage(
+      currentContext,
+      propagation.createBaggage(baggageEntries)
     );
-    logger.silly(`Tools: ${JSON.stringify(formattedTools, null, 2)}`);
-    logger.debug(`Estimated tokens being sent to Vercel provider: ${tokensUsed}`);
-    if (stream) {
-      fullResponse = await this.streamText(
-        formattedMessages,
-        formattedTools,
-        this.config.maxIterations,
-        options?.signal
+    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)}`
       );
-    } else {
-      fullResponse = await this.generateText(
-        formattedMessages,
-        formattedTools,
-        this.config.maxIterations,
-        options?.signal
+      const formattedTools = this.formatTools(tools);
+      this.logger.silly(
+        `[VercelLLMService] Formatted tools: ${JSON.stringify(formattedTools, null, 2)}`
       );
-    }
-    if (options?.signal?.aborted) {
-      return fullResponse;
-    }
-    return fullResponse || `Reached maximum number of steps (${this.config.maxIterations}) without a final response.`;
+      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.`;
+    });
   }
   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);
-    logger.debug(
+    this.logger.debug(
       `vercel generateText:Generating text with messages (${estimatedTokens} estimated tokens)`
     );
     const temperature = this.config.temperature;
@@ -256,7 +282,7 @@ class VercelLLMService {
     const supportsTools = await this.validateToolSupport();
     const effectiveTools = supportsTools ? tools : {};
     if (!supportsTools && Object.keys(tools).length > 0) {
-      logger.debug(
+      this.logger.debug(
         `Model ${this.getModelId()} does not support tools, using empty tools object for generation`
       );
     }
@@ -268,13 +294,13 @@ class VercelLLMService {
         tools: effectiveTools,
         ...signal ? { abortSignal: signal } : {},
         onStepFinish: async (step) => {
-          logger.debug(`Step iteration: ${stepIteration}`);
+          this.logger.debug(`Step iteration: ${stepIteration}`);
           stepIteration++;
-          logger.debug(`Step finished, text: ${step.text}`);
-          logger.debug(
+          this.logger.debug(`Step finished, text: ${step.text}`);
+          this.logger.debug(
             `Step finished, step tool calls: ${JSON.stringify(step.toolCalls, null, 2)}`
           );
-          logger.debug(
+          this.logger.debug(
             `Step finished, step tool results: ${JSON.stringify(step.toolResults, null, 2)}`
           );
         },
@@ -282,7 +308,7 @@ class VercelLLMService {
         ...includeMaxOutputTokens ? { maxOutputTokens } : {},
         ...temperature !== void 0 && { temperature }
       });
-      this.sessionEventBus.emit("llmservice:response", {
+      this.sessionEventBus.emit("llm:response", {
         content: response.text,
         ...response.reasoningText && { reasoning: response.reasoningText },
         provider: this.config.provider,
@@ -303,8 +329,8 @@ class VercelLLMService {
           }
         }
       });
-      const activeSpan = trace.getActiveSpan();
-      if (activeSpan) {
+      const activeSpan2 = trace.getActiveSpan();
+      if (activeSpan2) {
         const attributes = {};
         if (response.totalUsage.inputTokens !== void 0) {
           attributes["gen_ai.usage.input_tokens"] = response.totalUsage.inputTokens;
@@ -318,7 +344,7 @@ class VercelLLMService {
         if (response.totalUsage.reasoningTokens !== void 0) {
           attributes["gen_ai.usage.reasoning_tokens"] = response.totalUsage.reasoningTokens;
         }
-        activeSpan.setAttributes(attributes);
+        activeSpan2.setAttributes(attributes);
       }
       await this.contextManager.processLLMResponse(response);
       if (typeof response.totalUsage.totalTokens === "number") {
@@ -326,17 +352,24 @@ class VercelLLMService {
       }
       return response.text;
     } catch (err) {
-      this.mapProviderError(err, "generate");
+      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) {
-        throw new DextoRuntimeError(
+        return new DextoRuntimeError(
           LLMErrorCode.RATE_LIMIT_EXCEEDED,
           ErrorScope.LLM,
           ErrorType.RATE_LIMIT,
@@ -353,7 +386,7 @@ class VercelLLMService {
         );
       }
       if (status === 408) {
-        throw new DextoRuntimeError(
+        return new DextoRuntimeError(
           LLMErrorCode.GENERATION_FAILED,
           ErrorScope.LLM,
           ErrorType.TIMEOUT,
@@ -368,7 +401,7 @@ class VercelLLMService {
           }
         );
       }
-      throw new DextoRuntimeError(
+      return new DextoRuntimeError(
         LLMErrorCode.GENERATION_FAILED,
         ErrorScope.LLM,
         ErrorType.THIRD_PARTY,
@@ -383,38 +416,44 @@ class VercelLLMService {
         }
       );
     }
-    throw err;
+    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) {
-      logger.debug(
+      this.logger.debug(
         `Model ${this.getModelId()} does not support tools, using empty tools object for streaming`
       );
     }
     let streamErr;
     const includeMaxOutputTokens = typeof maxOutputTokens === "number";
-    const response = streamText({
+    let response;
+    response = streamText({
       model: this.model,
       messages,
       tools: effectiveTools,
       ...signal ? { abortSignal: signal } : {},
       onChunk: (chunk) => {
-        logger.debug(`Chunk type: ${chunk.chunk.type}`);
+        this.logger.debug(`Chunk type: ${chunk.chunk.type}`);
         if (chunk.chunk.type === "text-delta") {
-          this.sessionEventBus.emit("llmservice:chunk", {
-            type: "text",
+          this.sessionEventBus.emit("llm:chunk", {
+            chunkType: "text",
             content: chunk.chunk.text,
             isComplete: false
           });
         } else if (chunk.chunk.type === "reasoning-delta") {
-          this.sessionEventBus.emit("llmservice:chunk", {
-            type: "reasoning",
+          this.sessionEventBus.emit("llm:chunk", {
+            chunkType: "reasoning",
             content: chunk.chunk.text,
             isComplete: false
           });
@@ -424,9 +463,9 @@ class VercelLLMService {
       // Vercel triggers onAbort instead of onError for cancelled streams.
       // This is where cancellation logic should be handled properly.
       onError: (error) => {
-        const err = toError(error);
-        logger.error(`Error in streamText: ${err?.stack ?? err}`, null, "red");
-        this.sessionEventBus.emit("llmservice: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
@@ -434,13 +473,13 @@ class VercelLLMService {
         streamErr = error;
       },
       onStepFinish: async (step) => {
-        logger.debug(`Step iteration: ${stepIteration}`);
+        this.logger.debug(`Step iteration: ${stepIteration}`);
         stepIteration++;
-        logger.debug(`Step finished, text: ${step.text}`);
-        logger.debug(
+        this.logger.debug(`Step finished, text: ${step.text}`);
+        this.logger.debug(
           `Step finished, step tool calls: ${JSON.stringify(step.toolCalls, null, 2)}`
         );
-        logger.debug(
+        this.logger.debug(
           `Step finished, step tool results: ${JSON.stringify(step.toolResults, null, 2)}`
         );
       },
@@ -449,16 +488,28 @@ class VercelLLMService {
       ...includeMaxOutputTokens ? { maxOutputTokens } : {},
       ...temperature !== void 0 && { temperature }
     });
-    const [finalText, usage, reasoningText] = await Promise.all([
-      response.text,
-      response.totalUsage,
-      response.reasoningText
-    ]);
-    response.totalUsage;
     if (streamErr) {
       return "";
     }
-    this.sessionEventBus.emit("llmservice:response", {
+    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,
@@ -473,8 +524,8 @@ class VercelLLMService {
         ...usage.totalTokens !== void 0 && { totalTokens: usage.totalTokens }
       }
     });
-    const activeSpan = trace.getActiveSpan();
-    if (activeSpan) {
+    const activeSpan2 = trace.getActiveSpan();
+    if (activeSpan2) {
       const attributes = {};
       if (usage.inputTokens !== void 0) {
         attributes["gen_ai.usage.input_tokens"] = usage.inputTokens;
@@ -488,13 +539,13 @@ class VercelLLMService {
       if (usage.reasoningTokens !== void 0) {
         attributes["gen_ai.usage.reasoning_tokens"] = usage.reasoningTokens;
       }
-      activeSpan.setAttributes(attributes);
+      activeSpan2.setAttributes(attributes);
     }
     if (typeof usage.totalTokens === "number") {
       this.contextManager.updateActualTokenCount(usage.totalTokens);
     }
     await this.contextManager.processLLMStreamResponse(response);
-    logger.silly(`streamText response object: ${JSON.stringify(response, null, 2)}`);
+    this.logger.silly(`streamText response object: ${JSON.stringify(response, null, 2)}`);
     return finalText;
   }
   /**
@@ -508,12 +559,13 @@ class VercelLLMService {
       modelMaxInputTokens = getMaxInputTokensForModel(
         this.config.provider,
         // Use our internal provider name
-        this.getModelId()
+        this.getModelId(),
+        this.logger
       );
     } catch (error) {
       if (error instanceof DextoRuntimeError && error.code === LLMErrorCode.MODEL_UNKNOWN) {
         modelMaxInputTokens = configuredMaxTokens;
-        logger.debug(
+        this.logger.debug(
           `Could not find model ${this.getModelId()} in LLM registry to get max tokens. Using configured max tokens: ${configuredMaxTokens}.`
         );
       } else {

package/dist/llm/tokenizer/factory.cjs

@@ -25,10 +25,10 @@ var import_openai = require("./openai.js");
 var import_anthropic = require("./anthropic.js");
 var import_google = require("./google.js");
 var import_default = require("./default.js");
-function createTokenizer(provider, model) {
+function createTokenizer(provider, model, logger) {
   switch (provider) {
     case "openai":
-      return new import_openai.OpenAITokenizer(model);
+      return new import_openai.OpenAITokenizer(model, logger);
     case "anthropic":
       return new import_anthropic.AnthropicTokenizer();
     case "google":

package/dist/llm/tokenizer/factory.d.ts

@@ -1,10 +1,12 @@
 import { ITokenizer } from './types.js';
 import type { LLMProvider } from '../types.js';
+import type { IDextoLogger } from '../../logger/v2/types.js';
 /**
  * Creates the appropriate tokenizer for the specified provider and model
  * @param provider The LLM provider name (case-insensitive)
  * @param model The specific model name (used by some tokenizers)
+ * @param logger The logger instance for logging
  * @returns An appropriate tokenizer implementation, or DefaultTokenizer if no specific implementation exists
  */
-export declare function createTokenizer(provider: LLMProvider, model: string): ITokenizer;
+export declare function createTokenizer(provider: LLMProvider, model: string, logger: IDextoLogger): ITokenizer;
 //# sourceMappingURL=factory.d.ts.map

package/dist/llm/tokenizer/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/llm/tokenizer/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAKxC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU,CAchF"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/llm/tokenizer/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAKxC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC3B,QAAQ,EAAE,WAAW,EACrB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,YAAY,GACrB,UAAU,CAcZ"}

package/dist/llm/tokenizer/factory.js

@@ -3,10 +3,10 @@ import { OpenAITokenizer } from "./openai.js";
 import { AnthropicTokenizer } from "./anthropic.js";
 import { GoogleTokenizer } from "./google.js";
 import { DefaultTokenizer } from "./default.js";
-function createTokenizer(provider, model) {
+function createTokenizer(provider, model, logger) {
   switch (provider) {
     case "openai":
-      return new OpenAITokenizer(model);
+      return new OpenAITokenizer(model, logger);
     case "anthropic":
       return new AnthropicTokenizer();
     case "google":

package/dist/llm/tokenizer/openai.cjs

@@ -23,7 +23,7 @@ __export(openai_exports, {
 module.exports = __toCommonJS(openai_exports);
 var import_types = require("./types.js");
 var import_module = require("module");
-var import_logger = require("../../logger/index.js");
+var import_types2 = require("../../logger/v2/types.js");
 const import_meta = {};
 const FALLBACK_ENCODING = "cl100k_base";
 class OpenAITokenizer {
@@ -31,29 +31,36 @@ class OpenAITokenizer {
   // Store original model name for context/logging
   encoding;
   // Tiktoken encoding instance
+  logger;
   /**
    * Initializes the tokenizer for a specific OpenAI model or compatible model.
    * @param model The OpenAI model name (e.g., 'gpt-5') or a custom model name.
+   * @param logger The logger instance for logging.
    * @throws TokenizationError if tiktoken initialization fails for both specific model and fallback.
    */
-  constructor(model) {
+  constructor(model, logger) {
     this.modelName = model;
+    this.logger = logger.createChild(import_types2.DextoLogComponent.LLM);
     try {
       const { encoding_for_model } = loadTiktoken();
       this.encoding = encoding_for_model(model);
-      import_logger.logger.debug(`Initialized tiktoken with specific encoding for model: ${model}`);
+      this.logger.debug(`Initialized tiktoken with specific encoding for model: ${model}`);
     } catch (error) {
-      import_logger.logger.warn(
+      this.logger.warn(
         `Could not get specific encoding for model '${this.modelName}'. Falling back to '${FALLBACK_ENCODING}'. Error: ${error instanceof Error ? error.message : String(error)}`
       );
       try {
         const { get_encoding } = loadTiktoken();
         this.encoding = get_encoding(FALLBACK_ENCODING);
-        import_logger.logger.debug(`Initialized tiktoken with fallback encoding: ${FALLBACK_ENCODING}`);
+        this.logger.debug(
+          `Initialized tiktoken with fallback encoding: ${FALLBACK_ENCODING}`
+        );
       } catch (fallbackError) {
-        import_logger.logger.error(
+        this.logger.error(
           `Failed to initialize tiktoken with specific model '${this.modelName}' or fallback '${FALLBACK_ENCODING}'.`,
-          fallbackError
+          {
+            error: fallbackError instanceof Error ? fallbackError.message : String(fallbackError)
+          }
         );
         throw new import_types.TokenizationError(
           `Failed to initialize tiktoken for model '${this.modelName}' using specific or fallback encoding ('${FALLBACK_ENCODING}'): ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`
@@ -73,9 +80,9 @@ class OpenAITokenizer {
       const tokens = this.encoding.encode(text);
       return tokens.length;
     } catch (error) {
-      import_logger.logger.error(
+      this.logger.error(
         `Tiktoken encoding failed for model ${this.modelName} (using encoding: ${this.encoding.name}):`,
-        error
+        { error: error instanceof Error ? error.message : String(error) }
       );
       throw new import_types.TokenizationError(
         `Encoding failed for text snippet using model ${this.modelName}.`

package/dist/llm/tokenizer/openai.d.ts

@@ -1,4 +1,5 @@
 import { ITokenizer } from './types.js';
+import type { IDextoLogger } from '../../logger/v2/types.js';
 /**
  * Tokenizer for OpenAI models using the tiktoken library.
  * Attempts to use the specific model's encoding, falls back to a common base encoding ('cl100k_base')
@@ -7,12 +8,14 @@ import { ITokenizer } from './types.js';
 export declare class OpenAITokenizer implements ITokenizer {
     private modelName;
     private encoding;
+    private logger;
     /**
      * Initializes the tokenizer for a specific OpenAI model or compatible model.
      * @param model The OpenAI model name (e.g., 'gpt-5') or a custom model name.
+     * @param logger The logger instance for logging.
      * @throws TokenizationError if tiktoken initialization fails for both specific model and fallback.
      */
-    constructor(model: string);
+    constructor(model: string, logger: IDextoLogger);
     /**
      * Counts the tokens in the text using the determined encoding.
      * @param text Text content to count tokens for

package/dist/llm/tokenizer/openai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/llm/tokenizer/openai.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAqB,MAAM,YAAY,CAAC;AAQ3D;;;;GAIG;AACH,qBAAa,eAAgB,YAAW,UAAU;IAC9C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAW;IAE3B;;;;OAIG;gBACS,KAAK,EAAE,MAAM;IA6BzB;;;;;OAKG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAgBjC;;;OAGG;IACH,IAAI,IAAI,IAAI;IAMZ,eAAe,IAAI,MAAM;CAG5B"}
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/llm/tokenizer/openai.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAqB,MAAM,YAAY,CAAC;AAG3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAM7D;;;;GAIG;AACH,qBAAa,eAAgB,YAAW,UAAU;IAC9C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,MAAM,CAAe;IAE7B;;;;;OAKG;gBACS,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY;IAqC/C;;;;;OAKG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAgBjC;;;OAGG;IACH,IAAI,IAAI,IAAI;IAMZ,eAAe,IAAI,MAAM;CAG5B"}