@dexto/core 1.3.0 → 1.5.0

package/dist/context/manager.js

@@ -1,15 +1,9 @@
-import "../chunk-C6A6W6XS.js";
+import "../chunk-PTJYTZNU.js";
 import { randomUUID } from "crypto";
-import { MiddleRemovalStrategy } from "./compression/middle-removal.js";
-import { OldestRemovalStrategy } from "./compression/oldest-removal.js";
+import { isSystemMessage, isUserMessage, isAssistantMessage, isToolMessage } from "./types.js";
 import { DextoLogComponent } from "../logger/v2/types.js";
 import { eventBus } from "../events/index.js";
-import {
-  countMessagesTokens,
-  sanitizeToolResult,
-  expandBlobReferences,
-  isLikelyBase64String
-} from "./utils.js";
+import { expandBlobReferences, isLikelyBase64String, filterCompacted } from "./utils.js";
 import { ContextError } from "./errors.js";
 class ContextManager {
   /**
@@ -28,27 +22,6 @@ class ContextManager {
    * Maximum number of tokens allowed in the conversation (if specified)
    */
   maxInputTokens;
-  /**
-   * Actual token count from the last LLM response.
-   * Used for more accurate token estimation in hybrid approach.
-   */
-  lastActualTokenCount = 0;
-  /**
-   * Compression threshold as a percentage of maxInputTokens.
-   * When estimated tokens exceed (maxInputTokens * threshold), compression is triggered.
-   */
-  compressionThreshold = 0.8;
-  // 80% threshold
-  /**
-   * Tokenizer used for counting tokens and enabling compression (if specified)
-   */
-  tokenizer;
-  /**
-   * The sequence of compression strategies to apply when maxInputTokens is exceeded.
-   * The order in this array matters, as strategies are applied sequentially until
-   * the token count is within the limit.
-   */
-  compressionStrategies;
   historyProvider;
   sessionId;
   /**
@@ -63,26 +36,19 @@ class ContextManager {
    * @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 maxInputTokens Maximum token limit for the conversation history.
    * @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 resourceManager 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)
-  ]) {
+  constructor(llmConfig, formatter, systemPromptManager, maxInputTokens, historyProvider, sessionId, resourceManager, 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(
@@ -149,117 +115,177 @@ class ContextManager {
     return data;
   }
   /**
-   * Returns the current token count of the conversation history.
-   * @returns Promise that resolves to the number of tokens in the current history
+   * Returns the configured maximum number of input tokens for the conversation.
    */
-  async getTokenCount() {
-    const history = await this.historyProvider.getHistory();
-    return countMessagesTokens(history, this.tokenizer, void 0, this.logger);
+  getMaxInputTokens() {
+    return this.maxInputTokens;
+  }
+  /**
+   * Assembles and returns the current system prompt by invoking the SystemPromptManager.
+   */
+  async getSystemPrompt(context) {
+    const prompt = await this.systemPromptManager.build(context);
+    this.logger.debug(`[SystemPrompt] Built system prompt:
+${prompt}`);
+    return prompt;
   }
   /**
-   * Returns the total token count that will be sent to the LLM provider,
-   * including system prompt, formatted messages, and provider-specific overhead.
-   * This provides a more accurate estimate than getTokenCount() alone.
+   * Gets the raw conversation history
+   * Returns a defensive copy to prevent modification
    *
-   * @param context The DynamicContributorContext for system prompt contributors
-   * @returns Promise that resolves to the total number of tokens that will be sent to the provider
+   * @returns Promise that resolves to a read-only copy of the conversation history
    */
-  async getTotalTokenCount(context) {
-    try {
-      const systemPrompt = await this.getSystemPrompt(context);
-      let history = await this.historyProvider.getHistory();
-      const systemPromptTokens = this.tokenizer.countTokens(systemPrompt);
-      history = await this.compressHistoryIfNeeded(history, systemPromptTokens);
-      const historyTokens = countMessagesTokens(
-        history,
-        this.tokenizer,
-        void 0,
-        this.logger
-      );
-      const formattingOverhead = Math.ceil((systemPromptTokens + historyTokens) * 0.05);
-      const totalTokens = systemPromptTokens + historyTokens + formattingOverhead;
-      this.logger.debug(
-        `Token breakdown - System: ${systemPromptTokens}, History: ${historyTokens}, Overhead: ${formattingOverhead}, Total: ${totalTokens}`
-      );
-      return totalTokens;
-    } catch (error) {
-      this.logger.error(
-        `Error calculating total token count: ${error instanceof Error ? error.message : String(error)}`,
-        { error }
-      );
-      return this.getTokenCount();
-    }
+  async getHistory() {
+    const history = await this.historyProvider.getHistory();
+    return [...history];
   }
   /**
-   * Returns the configured maximum number of input tokens for the conversation.
+   * Flush any pending history updates to durable storage.
+   * Should be called at turn boundaries (after streaming completes, on cancel, on error).
+   * This ensures all message updates are persisted before returning control to the caller.
    */
-  getMaxInputTokens() {
-    return this.maxInputTokens;
+  async flush() {
+    await this.historyProvider.flush();
   }
   /**
-   * Updates the ContextManager configuration when LLM config changes.
-   * This is called when DextoAgent.switchLLM() updates the LLM configuration.
+   * Clears the context window without deleting history.
    *
-   * @param newMaxInputTokens New maximum token limit
-   * @param newTokenizer Optional new tokenizer if provider changed
-   * @param newFormatter Optional new formatter if provider/router changed
+   * This adds a "context clear" marker to the conversation history. When the
+   * context is loaded for LLM via getFormattedMessagesWithCompression(),
+   * filterCompacted() excludes all messages before this marker.
+   *
+   * The full history remains in the database for review via /resume or session history.
    */
-  updateConfig(newMaxInputTokens, newTokenizer, newFormatter) {
-    const oldMaxInputTokens = this.maxInputTokens;
-    this.maxInputTokens = newMaxInputTokens;
-    if (newTokenizer) {
-      this.tokenizer = newTokenizer;
-    }
-    if (newFormatter) {
-      this.formatter = newFormatter;
-    }
-    this.logger.debug(
-      `ContextManager config updated: maxInputTokens ${oldMaxInputTokens} -> ${newMaxInputTokens}`
-    );
+  async clearContext() {
+    const clearMarker = {
+      id: `clear-${Date.now()}`,
+      role: "assistant",
+      content: [{ type: "text", text: "[Context cleared]" }],
+      timestamp: Date.now(),
+      metadata: {
+        isSummary: true,
+        clearedAt: Date.now()
+      }
+    };
+    await this.addMessage(clearMarker);
+    this.logger.debug(`Context cleared for session: ${this.sessionId}`);
   }
   /**
-   * Updates the actual token count from the last LLM response.
-   * This enables hybrid token counting for more accurate estimates.
-   *
-   * @param actualTokens The actual token count reported by the LLM provider
+   * Appends text to an existing assistant message.
+   * Used for streaming responses.
    */
-  updateActualTokenCount(actualTokens) {
-    this.lastActualTokenCount = actualTokens;
-    this.logger.debug(`Updated actual token count to: ${actualTokens}`);
+  async appendAssistantText(messageId, text) {
+    const history = await this.historyProvider.getHistory();
+    const messageIndex = history.findIndex((m) => m.id === messageId);
+    if (messageIndex === -1) {
+      throw ContextError.messageNotFound(messageId);
+    }
+    const message = history[messageIndex];
+    if (!message) {
+      throw ContextError.messageNotFound(messageId);
+    }
+    if (message.role !== "assistant") {
+      throw ContextError.messageNotAssistant(messageId);
+    }
+    if (message.content === null) {
+      message.content = [{ type: "text", text }];
+    } else if (Array.isArray(message.content)) {
+      const lastPart = message.content[message.content.length - 1];
+      if (lastPart && lastPart.type === "text") {
+        lastPart.text += text;
+      } else {
+        message.content.push({ type: "text", text });
+      }
+    }
+    await this.historyProvider.updateMessage(message);
   }
   /**
-   * Estimates if new input would trigger compression using hybrid approach.
-   * Combines actual tokens from last response with estimated tokens for new input.
-   *
-   * @param newInputTokens Estimated tokens for the new user input
-   * @returns True if compression should be triggered
+   * Adds a tool call to an existing assistant message.
+   * Used for streaming responses.
    */
-  shouldCompress(newInputTokens) {
-    const estimatedTotal = this.lastActualTokenCount + newInputTokens;
-    const compressionTrigger = this.maxInputTokens * this.compressionThreshold;
-    this.logger.debug(
-      `Compression check: actual=${this.lastActualTokenCount}, newInput=${newInputTokens}, total=${estimatedTotal}, trigger=${compressionTrigger}`
-    );
-    return estimatedTotal > compressionTrigger;
+  async addToolCall(messageId, toolCall) {
+    const history = await this.historyProvider.getHistory();
+    const messageIndex = history.findIndex((m) => m.id === messageId);
+    if (messageIndex === -1) {
+      throw ContextError.messageNotFound(messageId);
+    }
+    const message = history[messageIndex];
+    if (!message) {
+      throw ContextError.messageNotFound(messageId);
+    }
+    if (message.role !== "assistant") {
+      throw ContextError.messageNotAssistant(messageId);
+    }
+    if (!message.toolCalls) {
+      message.toolCalls = [];
+    }
+    message.toolCalls.push(toolCall);
+    await this.historyProvider.updateMessage(message);
   }
   /**
-   * Assembles and returns the current system prompt by invoking the SystemPromptManager.
+   * Updates an existing assistant message with new properties.
+   * Used for finalizing streaming responses (e.g. adding token usage).
    */
-  async getSystemPrompt(context) {
-    const prompt = await this.systemPromptManager.build(context);
-    this.logger.debug(`[SystemPrompt] Built system prompt:
-${prompt}`);
-    return prompt;
+  async updateAssistantMessage(messageId, updates) {
+    const history = await this.historyProvider.getHistory();
+    const messageIndex = history.findIndex((m) => m.id === messageId);
+    if (messageIndex === -1) {
+      throw ContextError.messageNotFound(messageId);
+    }
+    const message = history[messageIndex];
+    if (!message) {
+      throw ContextError.messageNotFound(messageId);
+    }
+    if (message.role !== "assistant") {
+      throw ContextError.messageNotAssistant(messageId);
+    }
+    Object.assign(message, updates);
+    await this.historyProvider.updateMessage(message);
   }
   /**
-   * Gets the raw conversation history
-   * Returns a defensive copy to prevent modification
+   * Marks tool messages as compacted (pruned).
+   * Sets the compactedAt timestamp - content transformation happens at format time
+   * in getFormattedMessagesWithCompression(). Original content is preserved in
+   * storage for debugging/audit.
    *
-   * @returns Promise that resolves to a read-only copy of the conversation history
+   * Used by TurnExecutor's pruneOldToolOutputs() to reclaim token space
+   * by marking old tool outputs that are no longer needed for context.
+   *
+   * @param messageIds Array of message IDs to mark as compacted
+   * @returns Number of messages successfully marked
    */
-  async getHistory() {
+  async markMessagesAsCompacted(messageIds) {
+    if (messageIds.length === 0) {
+      return 0;
+    }
     const history = await this.historyProvider.getHistory();
-    return [...history];
+    const timestamp = Date.now();
+    let markedCount = 0;
+    for (const messageId of messageIds) {
+      const message = history.find((m) => m.id === messageId);
+      if (!message) {
+        this.logger.warn(`markMessagesAsCompacted: Message ${messageId} not found`);
+        continue;
+      }
+      if (message.role !== "tool") {
+        this.logger.warn(
+          `markMessagesAsCompacted: Message ${messageId} is not a tool message (role=${message.role})`
+        );
+        continue;
+      }
+      if (message.compactedAt) {
+        continue;
+      }
+      message.compactedAt = timestamp;
+      await this.historyProvider.updateMessage(message);
+      markedCount++;
+    }
+    if (markedCount > 0) {
+      this.logger.debug(
+        `markMessagesAsCompacted: Marked ${markedCount} messages as compacted`
+      );
+    }
+    return markedCount;
   }
   /**
    * Adds a message to the conversation history.
@@ -272,10 +298,7 @@ ${prompt}`);
   async addMessage(message) {
     switch (message.role) {
       case "user":
-        if (
-          // Allow array content for user messages
-          !(Array.isArray(message.content) && message.content.length > 0) && (typeof message.content !== "string" || message.content.trim() === "")
-        ) {
+        if (!Array.isArray(message.content) || message.content.length === 0) {
           throw ContextError.userMessageContentInvalid();
         }
         break;
@@ -291,7 +314,6 @@ ${prompt}`);
           }
         }
         message.provider = this.llmConfig.provider;
-        message.router = this.llmConfig.router;
         message.model = this.llmConfig.model;
         break;
       case "tool":
@@ -299,14 +321,16 @@ ${prompt}`);
           throw ContextError.toolMessageFieldsMissing();
         }
         break;
-      case "system":
+      case "system": {
         this.logger.warn(
-          "ContextManager: Adding system message directly to history. Use setSystemPrompt instead."
+          "ContextManager: Adding system message directly to history. Use SystemPromptManager instead."
         );
-        if (typeof message.content !== "string" || message.content.trim() === "") {
+        const textContent = message.content?.filter((p) => p.type === "text").map((p) => p.text).join("");
+        if (!textContent || textContent.trim() === "") {
           throw ContextError.systemMessageContentInvalid();
         }
         break;
+      }
     }
     if (!message.id) {
       message.id = randomUUID();
@@ -322,57 +346,64 @@ ${prompt}`);
     this.logger.debug(`ContextManager: History now contains ${history.length} messages`);
   }
   /**
-   * Adds a user message to the conversation
-   * Can include image data for multimodal input
+   * Adds a user message to the conversation.
+   * Supports multiple images and files via ContentPart[].
    *
-   * @param textContent The user message content
-   * @param imageData Optional image data for multimodal input
-   * @param fileData Optional file data for file input
-   * @throws Error if content is empty or not a string
+   * @param content Array of content parts (text, images, files)
+   * @throws Error if content is empty or invalid
    */
-  async addUserMessage(textContent, imageData, fileData) {
-    if (typeof textContent !== "string" || textContent.trim() === "" && !imageData && !fileData) {
+  async addUserMessage(content) {
+    if (!Array.isArray(content) || content.length === 0) {
       throw ContextError.userMessageContentEmpty();
     }
-    const finalTextContent = textContent.trim() || (imageData || fileData ? "" : textContent);
-    const messageParts = [];
-    if (finalTextContent) {
-      messageParts.push({ type: "text", text: finalTextContent });
-    }
-    if (imageData) {
-      const processedImage = await this.processUserInput(imageData.image, {
-        mimeType: imageData.mimeType || "image/jpeg",
-        source: "user"
-      });
-      messageParts.push({
-        type: "image",
-        image: processedImage,
-        mimeType: imageData.mimeType || "image/jpeg"
-      });
+    const hasText = content.some((p) => p.type === "text" && p.text.trim() !== "");
+    const hasAttachment = content.some((p) => p.type === "image" || p.type === "file");
+    if (!hasText && !hasAttachment) {
+      throw ContextError.userMessageContentEmpty();
     }
-    if (fileData) {
-      const metadata = {
-        mimeType: fileData.mimeType,
-        source: "user"
-      };
-      if (fileData.filename) {
-        metadata.originalName = fileData.filename;
+    const processedParts = [];
+    for (const part of content) {
+      if (part.type === "text") {
+        if (part.text.trim()) {
+          processedParts.push({ type: "text", text: part.text });
+        }
+      } else if (part.type === "image") {
+        const processedImage = await this.processUserInput(part.image, {
+          mimeType: part.mimeType || "image/jpeg",
+          source: "user"
+        });
+        processedParts.push({
+          type: "image",
+          image: processedImage,
+          mimeType: part.mimeType || "image/jpeg"
+        });
+      } else if (part.type === "file") {
+        const metadata = {
+          mimeType: part.mimeType,
+          source: "user"
+        };
+        if (part.filename) {
+          metadata.originalName = part.filename;
+        }
+        const processedData = await this.processUserInput(part.data, metadata);
+        processedParts.push({
+          type: "file",
+          data: processedData,
+          mimeType: part.mimeType,
+          ...part.filename && { filename: part.filename }
+        });
       }
-      const processedData = await this.processUserInput(fileData.data, metadata);
-      messageParts.push({
-        type: "file",
-        data: processedData,
-        mimeType: fileData.mimeType,
-        ...fileData.filename && { filename: fileData.filename }
-      });
-    }
-    if (messageParts.length === 0) {
-      messageParts.push({ type: "text", text: finalTextContent });
     }
-    this.logger.debug(
-      `ContextManager: Adding user message: ${JSON.stringify(messageParts, null, 2)}`
-    );
-    await this.addMessage({ role: "user", content: messageParts });
+    const textParts = processedParts.filter((p) => p.type === "text");
+    const imageParts = processedParts.filter((p) => p.type === "image");
+    const fileParts = processedParts.filter((p) => p.type === "file");
+    this.logger.info("User message received", {
+      textParts: textParts.length,
+      imageParts: imageParts.length,
+      fileParts: fileParts.length,
+      totalParts: processedParts.length
+    });
+    await this.addMessage({ role: "user", content: processedParts });
   }
   /**
    * Adds an assistant message to the conversation
@@ -387,54 +418,50 @@ ${prompt}`);
     if (content === null && (!toolCalls || toolCalls.length === 0)) {
       throw ContextError.assistantMessageContentOrToolsRequired();
     }
+    const contentArray = content !== null ? [{ type: "text", text: content }] : null;
     await this.addMessage({
       role: "assistant",
-      content,
+      content: contentArray,
       ...toolCalls && toolCalls.length > 0 && { toolCalls },
       ...metadata?.tokenUsage && { tokenUsage: metadata.tokenUsage },
       ...metadata?.reasoning && { reasoning: metadata.reasoning }
     });
   }
   /**
-   * Adds a tool result message to the conversation
+   * Adds a tool result message to the conversation.
+   * The result must already be sanitized - this method only persists it.
+   *
+   * Success status is read from sanitizedResult.meta.success (single source of truth).
    *
    * @param toolCallId ID of the tool call this result is responding to
    * @param name Name of the tool that executed
-   * @param result The result returned by the tool
+   * @param sanitizedResult The already-sanitized result to store (includes success in meta)
+   * @param metadata Optional approval-related metadata
    * @throws Error if required parameters are missing
    */
-  async addToolResult(toolCallId, name, result, options) {
+  async addToolResult(toolCallId, name, sanitizedResult, metadata) {
     if (!toolCallId || !name) {
       throw ContextError.toolCallIdNameRequired();
     }
-    const blobService = this.resourceManager.getBlobStore();
-    const sanitizeOptions = {
-      blobStore: blobService,
-      toolName: name,
-      toolCallId
-    };
-    if (options?.success !== void 0) {
-      sanitizeOptions.success = options.success;
-    }
-    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"})`
+    const summary = sanitizedResult.content.map(
+      (p) => p.type === "text" ? `text(${p.text.length})` : p.type === "image" ? `image(${p.mimeType || "image"})` : p.type === "ui-resource" ? `ui-resource(${p.uri})` : `file(${p.mimeType || "file"})`
     ).join(", ");
     this.logger.debug(`ContextManager: Storing tool result (parts) for ${name}: [${summary}]`);
     await this.addMessage({
       role: "tool",
-      content: sanitized.content,
+      content: sanitizedResult.content,
       toolCallId,
-      name
+      name,
+      // Success status comes from sanitizedResult.meta (single source of truth)
+      success: sanitizedResult.meta.success,
+      // Persist approval metadata for frontend display after reload
+      ...metadata?.requireApproval !== void 0 && {
+        requireApproval: metadata.requireApproval
+      },
+      ...metadata?.approvalStatus !== void 0 && {
+        approvalStatus: metadata.approvalStatus
+      }
     });
-    return sanitized;
-  }
-  /**
-   * Sets the system prompt for the conversation
-   *
-   * @param prompt The system prompt text
-   */
-  setSystemPrompt(_prompt) {
   }
   /**
    * Gets the conversation history formatted for the target LLM provider.
@@ -478,13 +505,28 @@ ${prompt}`);
     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 };
+        if (isSystemMessage(message) || isAssistantMessage(message)) {
+          return message;
+        }
+        if (isUserMessage(message)) {
+          const expandedContent = await expandBlobReferences(
+            message.content,
+            this.resourceManager,
+            this.logger,
+            allowedMediaTypes
+          );
+          return { ...message, content: expandedContent };
+        }
+        if (isToolMessage(message)) {
+          const expandedContent = await expandBlobReferences(
+            message.content,
+            this.resourceManager,
+            this.logger,
+            allowedMediaTypes
+          );
+          return { ...message, content: expandedContent };
+        }
+        return message;
       })
     );
     const prompt = systemPrompt ?? await this.getSystemPrompt(contributorContext);
@@ -493,7 +535,7 @@ ${prompt}`);
   /**
    * Gets the conversation ready for LLM consumption with proper flow:
    * 1. Get system prompt
-   * 2. Get history and compress if needed
+   * 2. Get history and filter (exclude pre-summary messages)
    * 3. Format messages
    * This method implements the correct ordering to avoid circular dependencies.
    *
@@ -503,25 +545,39 @@ ${prompt}`);
    */
   async getFormattedMessagesWithCompression(contributorContext, llmContext) {
     const systemPrompt = await this.getSystemPrompt(contributorContext);
-    const systemPromptTokens = this.tokenizer.countTokens(systemPrompt);
-    let history = await this.historyProvider.getHistory();
-    history = await this.compressHistoryIfNeeded(history, systemPromptTokens);
+    const fullHistory = await this.historyProvider.getHistory();
+    let history = filterCompacted(fullHistory);
+    if (history.length < fullHistory.length) {
+      this.logger.debug(
+        `filterCompacted: Reduced history from ${fullHistory.length} to ${history.length} messages (summary present)`
+      );
+    }
+    const compactedCount = history.filter((m) => m.role === "tool" && m.compactedAt).length;
+    if (compactedCount > 0) {
+      history = history.map((msg) => {
+        if (msg.role === "tool" && msg.compactedAt) {
+          return {
+            ...msg,
+            content: [
+              { type: "text", text: "[Old tool result content cleared]" }
+            ]
+          };
+        }
+        return msg;
+      });
+      this.logger.debug(
+        `Transformed ${compactedCount} compacted tool messages to placeholders`
+      );
+    }
     const formattedMessages = await this.getFormattedMessages(
       contributorContext,
       llmContext,
       systemPrompt,
       history
     );
-    const historyTokens = countMessagesTokens(history, this.tokenizer, void 0, this.logger);
-    const formattingOverhead = Math.ceil((systemPromptTokens + historyTokens) * 0.05);
-    const tokensUsed = systemPromptTokens + historyTokens + formattingOverhead;
-    this.logger.debug(
-      `Final token breakdown - System: ${systemPromptTokens}, History: ${historyTokens}, Overhead: ${formattingOverhead}, Total: ${tokensUsed}`
-    );
     return {
       formattedMessages,
-      systemPrompt,
-      tokensUsed
+      systemPrompt
     };
   }
   /**
@@ -531,9 +587,8 @@ ${prompt}`);
    * @returns Formatted system prompt or null/undefined based on formatter implementation
    * @throws Error if formatting fails
    */
-  async getFormattedSystemPrompt(context) {
-    const systemPrompt = await this.getSystemPrompt(context);
-    return this.formatter.formatSystemPrompt?.(systemPrompt);
+  async getFormattedSystemPrompt(_context) {
+    return this.formatter.formatSystemPrompt?.();
   }
   /**
    * Resets the conversation history
@@ -545,109 +600,6 @@ ${prompt}`);
       `ContextManager: Conversation history cleared for session ${this.sessionId}`
     );
   }
-  /**
-   * Checks if history compression is needed based on token count and applies strategies.
-   *
-   * @param history The conversation history to potentially compress
-   * @param systemPromptTokens The actual token count of the system prompt
-   * @returns The potentially compressed history
-   */
-  async compressHistoryIfNeeded(history, systemPromptTokens) {
-    let currentTotalTokens = countMessagesTokens(
-      history,
-      this.tokenizer,
-      void 0,
-      this.logger
-    );
-    currentTotalTokens += systemPromptTokens;
-    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) {
-      this.logger.debug(
-        `ContextManager: History compression not needed. Total token count: ${currentTotalTokens}, Max tokens: ${this.maxInputTokens}`
-      );
-      return history;
-    }
-    this.logger.info(
-      `ContextManager: History exceeds token limit (${currentTotalTokens} > ${this.maxInputTokens}). Applying compression strategies sequentially.`
-    );
-    const initialLength = history.length;
-    let workingHistory = [...history];
-    const targetHistoryTokens = this.maxInputTokens - systemPromptTokens;
-    for (const strategy of this.compressionStrategies) {
-      const strategyName = strategy.constructor.name;
-      this.logger.debug(`ContextManager: Applying ${strategyName}...`);
-      try {
-        workingHistory = strategy.compress(
-          [...workingHistory],
-          this.tokenizer,
-          targetHistoryTokens
-          // Use target tokens that account for system prompt
-        );
-      } catch (error) {
-        this.logger.error(
-          `ContextManager: Error applying ${strategyName}: ${error instanceof Error ? error.message : String(error)}`,
-          { error }
-        );
-        break;
-      }
-      const historyTokens = countMessagesTokens(
-        workingHistory,
-        this.tokenizer,
-        void 0,
-        this.logger
-      );
-      currentTotalTokens = historyTokens + systemPromptTokens;
-      const messagesRemoved = initialLength - workingHistory.length;
-      if (currentTotalTokens <= this.maxInputTokens) {
-        this.logger.debug(
-          `ContextManager: Compression successful after ${strategyName}. New total count: ${currentTotalTokens}, messages removed: ${messagesRemoved}`
-        );
-        break;
-      }
-    }
-    return workingHistory;
-  }
-  /**
-   * Parses a raw LLM stream response, converts it into internal messages and adds them to the history.
-   *
-   * @param response The stream response from the LLM provider
-   */
-  async processLLMStreamResponse(response) {
-    if (this.formatter.parseStreamResponse) {
-      const msgs = await this.formatter.parseStreamResponse(response) ?? [];
-      for (const msg of msgs) {
-        try {
-          await this.addMessage(msg);
-        } catch (error) {
-          this.logger.error(
-            `ContextManager: Failed to process LLM stream response message for session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-    } else {
-      await this.processLLMResponse(response);
-    }
-  }
-  /**
-   * Parses a raw LLM response, converts it into internal messages and adds them to the history.
-   *
-   * @param response The response from the LLM provider
-   */
-  async processLLMResponse(response) {
-    const msgs = this.formatter.parseResponse(response) ?? [];
-    for (const msg of msgs) {
-      try {
-        await this.addMessage(msg);
-      } catch (error) {
-        this.logger.error(
-          `ContextManager: Failed to process LLM response message for session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  }
 }
 export {
   ContextManager