@dexto/core 1.2.4 → 1.2.5

package/dist/context/manager.js

@@ -1,7 +1,7 @@
 import "../chunk-C6A6W6XS.js";
 import { MiddleRemovalStrategy } from "./compression/middle-removal.js";
 import { OldestRemovalStrategy } from "./compression/oldest-removal.js";
-import { logger } from "../logger/index.js";
+import { DextoLogComponent } from "../logger/v2/types.js";
 import { eventBus } from "../events/index.js";
 import {
   countMessagesTokens,
@@ -56,6 +56,38 @@ class ContextManager {
    * before passing messages to the LLM formatter.
    */
   resourceManager;
+  logger;
+  /**
+   * Creates a new ContextManager instance
+   * @param llmConfig The validated LLM configuration.
+   * @param formatter Formatter implementation for the target LLM provider
+   * @param systemPromptManager SystemPromptManager instance for the conversation
+   * @param maxInputTokens Maximum token limit for the conversation history. Triggers compression if exceeded and a tokenizer is provided.
+   * @param tokenizer Tokenizer implementation used for counting tokens and enabling compression.
+   * @param historyProvider Session-scoped ConversationHistoryProvider instance for managing conversation history
+   * @param sessionId Unique identifier for the conversation session (readonly, for debugging)
+   * @param compressionStrategies Optional array of compression strategies to apply when token limits are exceeded
+   * @param resourceManager Optional ResourceManager for resolving blob references in messages
+   * @param logger Logger instance for logging
+   */
+  constructor(llmConfig, formatter, systemPromptManager, maxInputTokens, tokenizer, historyProvider, sessionId, resourceManager, logger, compressionStrategies = [
+    new MiddleRemovalStrategy({}, logger),
+    new OldestRemovalStrategy({}, logger)
+  ]) {
+    this.llmConfig = llmConfig;
+    this.formatter = formatter;
+    this.systemPromptManager = systemPromptManager;
+    this.maxInputTokens = maxInputTokens;
+    this.tokenizer = tokenizer;
+    this.historyProvider = historyProvider;
+    this.sessionId = sessionId;
+    this.compressionStrategies = compressionStrategies;
+    this.resourceManager = resourceManager;
+    this.logger = logger.createChild(DextoLogComponent.CONTEXT);
+    this.logger.debug(
+      `ContextManager: Initialized for session ${sessionId} - history will be managed by ${historyProvider.constructor.name}`
+    );
+  }
   /**
    * Get the ResourceManager instance
    */
@@ -99,58 +131,29 @@ class ContextManager {
           originalName: metadata.originalName,
           source: metadata.source || "user"
         });
-        logger.info(
+        this.logger.info(
           `Stored user input as blob: ${blobRef.uri} (${estimatedSize} bytes, ${metadata.mimeType})`
         );
-        eventBus.emit("dexto:resourceCacheInvalidated", {
+        eventBus.emit("resource:cache-invalidated", {
           resourceUri: blobRef.uri,
           serverName: "internal",
           action: "blob_stored"
         });
         return `@${blobRef.uri}`;
       } catch (error) {
-        logger.warn(`Failed to store user input as blob: ${String(error)}`);
+        this.logger.warn(`Failed to store user input as blob: ${String(error)}`);
         return data;
       }
     }
     return data;
   }
-  /**
-   * Creates a new ContextManager instance
-   * @param llmConfig The validated LLM configuration.
-   * @param formatter Formatter implementation for the target LLM provider
-   * @param systemPromptManager SystemPromptManager instance for the conversation
-   * @param maxInputTokens Maximum token limit for the conversation history. Triggers compression if exceeded and a tokenizer is provided.
-   * @param tokenizer Tokenizer implementation used for counting tokens and enabling compression.
-   * @param historyProvider Session-scoped ConversationHistoryProvider instance for managing conversation history
-   * @param sessionId Unique identifier for the conversation session (readonly, for debugging)
-   * @param compressionStrategies Optional array of compression strategies to apply when token limits are exceeded
-   * @param resourceManager Optional ResourceManager for resolving blob references in messages
-   */
-  constructor(llmConfig, formatter, systemPromptManager, maxInputTokens, tokenizer, historyProvider, sessionId, resourceManager, compressionStrategies = [
-    new MiddleRemovalStrategy(),
-    new OldestRemovalStrategy()
-  ]) {
-    this.llmConfig = llmConfig;
-    this.formatter = formatter;
-    this.systemPromptManager = systemPromptManager;
-    this.maxInputTokens = maxInputTokens;
-    this.tokenizer = tokenizer;
-    this.historyProvider = historyProvider;
-    this.sessionId = sessionId;
-    this.compressionStrategies = compressionStrategies;
-    this.resourceManager = resourceManager;
-    logger.debug(
-      `ContextManager: Initialized for session ${sessionId} - history will be managed by ${historyProvider.constructor.name}`
-    );
-  }
   /**
    * Returns the current token count of the conversation history.
    * @returns Promise that resolves to the number of tokens in the current history
    */
   async getTokenCount() {
     const history = await this.historyProvider.getHistory();
-    return countMessagesTokens(history, this.tokenizer);
+    return countMessagesTokens(history, this.tokenizer, void 0, this.logger);
   }
   /**
    * Returns the total token count that will be sent to the LLM provider,
@@ -166,15 +169,23 @@ class ContextManager {
       let history = await this.historyProvider.getHistory();
       const systemPromptTokens = this.tokenizer.countTokens(systemPrompt);
       history = await this.compressHistoryIfNeeded(history, systemPromptTokens);
-      const historyTokens = countMessagesTokens(history, this.tokenizer);
+      const historyTokens = countMessagesTokens(
+        history,
+        this.tokenizer,
+        void 0,
+        this.logger
+      );
       const formattingOverhead = Math.ceil((systemPromptTokens + historyTokens) * 0.05);
       const totalTokens = systemPromptTokens + historyTokens + formattingOverhead;
-      logger.debug(
+      this.logger.debug(
         `Token breakdown - System: ${systemPromptTokens}, History: ${historyTokens}, Overhead: ${formattingOverhead}, Total: ${totalTokens}`
       );
       return totalTokens;
     } catch (error) {
-      logger.error("Error calculating total token count:", error);
+      this.logger.error(
+        `Error calculating total token count: ${error instanceof Error ? error.message : String(error)}`,
+        { error }
+      );
       return this.getTokenCount();
     }
   }
@@ -201,7 +212,7 @@ class ContextManager {
     if (newFormatter) {
       this.formatter = newFormatter;
     }
-    logger.debug(
+    this.logger.debug(
       `ContextManager config updated: maxInputTokens ${oldMaxInputTokens} -> ${newMaxInputTokens}`
     );
   }
@@ -213,7 +224,7 @@ class ContextManager {
    */
   updateActualTokenCount(actualTokens) {
     this.lastActualTokenCount = actualTokens;
-    logger.debug(`Updated actual token count to: ${actualTokens}`);
+    this.logger.debug(`Updated actual token count to: ${actualTokens}`);
   }
   /**
    * Estimates if new input would trigger compression using hybrid approach.
@@ -225,7 +236,7 @@ class ContextManager {
   shouldCompress(newInputTokens) {
     const estimatedTotal = this.lastActualTokenCount + newInputTokens;
     const compressionTrigger = this.maxInputTokens * this.compressionThreshold;
-    logger.debug(
+    this.logger.debug(
       `Compression check: actual=${this.lastActualTokenCount}, newInput=${newInputTokens}, total=${estimatedTotal}, trigger=${compressionTrigger}`
     );
     return estimatedTotal > compressionTrigger;
@@ -235,7 +246,7 @@ class ContextManager {
    */
   async getSystemPrompt(context) {
     const prompt = await this.systemPromptManager.build(context);
-    logger.debug(`[SystemPrompt] Built system prompt:
+    this.logger.debug(`[SystemPrompt] Built system prompt:
 ${prompt}`);
     return prompt;
   }
@@ -288,7 +299,7 @@ ${prompt}`);
         }
         break;
       case "system":
-        logger.warn(
+        this.logger.warn(
           "ContextManager: Adding system message directly to history. Use setSystemPrompt instead."
         );
         if (typeof message.content !== "string" || message.content.trim() === "") {
@@ -296,12 +307,12 @@ ${prompt}`);
         }
         break;
     }
-    logger.debug(
+    this.logger.debug(
       `ContextManager: Adding message to history provider: ${JSON.stringify(message, null, 2)}`
     );
     await this.historyProvider.saveMessage(message);
     const history = await this.historyProvider.getHistory();
-    logger.debug(`ContextManager: History now contains ${history.length} messages`);
+    this.logger.debug(`ContextManager: History now contains ${history.length} messages`);
   }
   /**
    * Adds a user message to the conversation
@@ -351,7 +362,7 @@ ${prompt}`);
     if (messageParts.length === 0) {
       messageParts.push({ type: "text", text: finalTextContent });
     }
-    logger.debug(
+    this.logger.debug(
       `ContextManager: Adding user message: ${JSON.stringify(messageParts, null, 2)}`
     );
     await this.addMessage({ role: "user", content: messageParts });
@@ -398,11 +409,11 @@ ${prompt}`);
     if (options?.success !== void 0) {
       sanitizeOptions.success = options.success;
     }
-    const sanitized = await sanitizeToolResult(result, sanitizeOptions);
+    const sanitized = await sanitizeToolResult(result, sanitizeOptions, this.logger);
     const summary = sanitized.content.map(
       (p) => p.type === "text" ? `text(${p.text.length})` : p.type === "image" ? `image(${p.mimeType || "image"})` : `file(${p.mimeType || "file"})`
     ).join(", ");
-    logger.debug(`ContextManager: Storing tool result (parts) for ${name}: [${summary}]`);
+    this.logger.debug(`ContextManager: Storing tool result (parts) for ${name}: [${summary}]`);
     await this.addMessage({
       role: "tool",
       content: sanitized.content,
@@ -442,27 +453,28 @@ ${prompt}`);
           llmContext.provider,
           llmContext.model
         );
-        allowedMediaTypes = fileTypesToMimePatterns(supportedFileTypes);
-        logger.debug(
+        allowedMediaTypes = fileTypesToMimePatterns(supportedFileTypes, this.logger);
+        this.logger.debug(
           `Using model capabilities for media filtering: ${allowedMediaTypes.join(", ")}`
         );
       } catch (error) {
-        logger.warn(
+        this.logger.warn(
           `Could not determine model capabilities, allowing all media types: ${String(error)}`
         );
         allowedMediaTypes = void 0;
       }
     } else {
-      logger.debug(
+      this.logger.debug(
         `Using user-configured allowedMediaTypes: ${allowedMediaTypes.join(", ")}`
       );
     }
-    logger.debug("Resolving blob references in message history before formatting");
+    this.logger.debug("Resolving blob references in message history before formatting");
     messageHistory = await Promise.all(
       messageHistory.map(async (message) => {
         const expandedContent = await expandBlobReferences(
           message.content,
           this.resourceManager,
+          this.logger,
           allowedMediaTypes
         );
         return { ...message, content: expandedContent };
@@ -493,10 +505,10 @@ ${prompt}`);
       systemPrompt,
       history
     );
-    const historyTokens = countMessagesTokens(history, this.tokenizer);
+    const historyTokens = countMessagesTokens(history, this.tokenizer, void 0, this.logger);
     const formattingOverhead = Math.ceil((systemPromptTokens + historyTokens) * 0.05);
     const tokensUsed = systemPromptTokens + historyTokens + formattingOverhead;
-    logger.debug(
+    this.logger.debug(
       `Final token breakdown - System: ${systemPromptTokens}, History: ${historyTokens}, Overhead: ${formattingOverhead}, Total: ${tokensUsed}`
     );
     return {
@@ -522,7 +534,9 @@ ${prompt}`);
    */
   async resetConversation() {
     await this.historyProvider.clearHistory();
-    logger.debug(`ContextManager: Conversation history cleared for session ${this.sessionId}`);
+    this.logger.debug(
+      `ContextManager: Conversation history cleared for session ${this.sessionId}`
+    );
   }
   /**
    * Checks if history compression is needed based on token count and applies strategies.
@@ -532,19 +546,24 @@ ${prompt}`);
    * @returns The potentially compressed history
    */
   async compressHistoryIfNeeded(history, systemPromptTokens) {
-    let currentTotalTokens = countMessagesTokens(history, this.tokenizer);
+    let currentTotalTokens = countMessagesTokens(
+      history,
+      this.tokenizer,
+      void 0,
+      this.logger
+    );
     currentTotalTokens += systemPromptTokens;
-    logger.debug(`ContextManager: Checking if history compression is needed.`);
-    logger.debug(
-      `History tokens: ${countMessagesTokens(history, this.tokenizer)}, System prompt tokens: ${systemPromptTokens}, Total: ${currentTotalTokens}`
+    this.logger.debug(`ContextManager: Checking if history compression is needed.`);
+    this.logger.debug(
+      `History tokens: ${countMessagesTokens(history, this.tokenizer, void 0, this.logger)}, System prompt tokens: ${systemPromptTokens}, Total: ${currentTotalTokens}`
     );
     if (currentTotalTokens <= this.maxInputTokens) {
-      logger.debug(
+      this.logger.debug(
         `ContextManager: History compression not needed. Total token count: ${currentTotalTokens}, Max tokens: ${this.maxInputTokens}`
       );
       return history;
     }
-    logger.info(
+    this.logger.info(
       `ContextManager: History exceeds token limit (${currentTotalTokens} > ${this.maxInputTokens}). Applying compression strategies sequentially.`
     );
     const initialLength = history.length;
@@ -552,7 +571,7 @@ ${prompt}`);
     const targetHistoryTokens = this.maxInputTokens - systemPromptTokens;
     for (const strategy of this.compressionStrategies) {
       const strategyName = strategy.constructor.name;
-      logger.debug(`ContextManager: Applying ${strategyName}...`);
+      this.logger.debug(`ContextManager: Applying ${strategyName}...`);
       try {
         workingHistory = strategy.compress(
           [...workingHistory],
@@ -561,14 +580,22 @@ ${prompt}`);
           // Use target tokens that account for system prompt
         );
       } catch (error) {
-        logger.error(`ContextManager: Error applying ${strategyName}:`, error);
+        this.logger.error(
+          `ContextManager: Error applying ${strategyName}: ${error instanceof Error ? error.message : String(error)}`,
+          { error }
+        );
         break;
       }
-      const historyTokens = countMessagesTokens(workingHistory, this.tokenizer);
+      const historyTokens = countMessagesTokens(
+        workingHistory,
+        this.tokenizer,
+        void 0,
+        this.logger
+      );
       currentTotalTokens = historyTokens + systemPromptTokens;
       const messagesRemoved = initialLength - workingHistory.length;
       if (currentTotalTokens <= this.maxInputTokens) {
-        logger.debug(
+        this.logger.debug(
           `ContextManager: Compression successful after ${strategyName}. New total count: ${currentTotalTokens}, messages removed: ${messagesRemoved}`
         );
         break;
@@ -588,7 +615,7 @@ ${prompt}`);
         try {
           await this.addMessage(msg);
         } catch (error) {
-          logger.error(
+          this.logger.error(
             `ContextManager: Failed to process LLM stream response message for session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
           );
         }
@@ -608,7 +635,7 @@ ${prompt}`);
       try {
         await this.addMessage(msg);
       } catch (error) {
-        logger.error(
+        this.logger.error(
           `ContextManager: Failed to process LLM response message for session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
         );
       }