@loxia-labs/loxia-autopilot-one 1.0.1

package/src/services/conversationCompactionService.js

@@ -0,0 +1,637 @@
+/**
+ * ConversationCompactionService - Intelligent conversation compactization
+ *
+ * Purpose:
+ * - Compress long conversations while preserving critical information
+ * - Support multiple compaction strategies
+ * - Maintain conversation continuity and context
+ * - Enable agents to perform long-running tasks
+ *
+ * Strategies:
+ * 1. Summarization - AI-based intelligent summary (sandwich approach)
+ * 2. Truncation - Fast extraction for model switching
+ * 3. Aggressive - More aggressive summarization for retry scenarios
+ *
+ * Key Features:
+ * - Token-aware segment identification
+ * - Preservation guidelines (high/medium/low priority)
+ * - Quality validation
+ * - Model switching support
+ * - Comprehensive metadata tracking
+ */
+
+import {
+  COMPACTION_CONFIG,
+  COMPACTION_STRATEGIES,
+  TOKEN_COUNTING_MODES,
+} from '../utilities/constants.js';
+
+class ConversationCompactionService {
+  constructor(tokenCountingService, aiService, logger) {
+    this.tokenCountingService = tokenCountingService;
+    this.aiService = aiService;
+    this.logger = logger;
+
+    // Summary generation prompt template
+    this.summaryPromptTemplate = this._createSummaryPromptTemplate();
+  }
+
+  /**
+   * Main compaction entry point - determines strategy and executes
+   * @param {Array} messages - Original messages array
+   * @param {string} currentModel - Current model being used
+   * @param {string} targetModel - Target model (may differ if switching)
+   * @param {Object} options - Compaction options
+   * @returns {Promise<Object>} Compaction result with messages and metadata
+   */
+  async compactConversation(messages, currentModel, targetModel, options = {}) {
+    const startTime = Date.now();
+
+    try {
+      // Validate inputs
+      if (!Array.isArray(messages) || messages.length === 0) {
+        throw new Error('Messages array is required and cannot be empty');
+      }
+
+      if (messages.length < COMPACTION_CONFIG.MIN_MESSAGES_FOR_COMPACTION) {
+        this.logger.warn('Too few messages for compaction', {
+          messageCount: messages.length,
+          minimum: COMPACTION_CONFIG.MIN_MESSAGES_FOR_COMPACTION
+        });
+
+        return {
+          compactedMessages: messages,
+          strategy: 'none',
+          originalTokenCount: 0,
+          compactedTokenCount: 0,
+          reductionPercent: 0,
+          skipped: true,
+          reason: 'Too few messages'
+        };
+      }
+
+      // Determine strategy
+      const isModelSwitch = currentModel !== targetModel;
+      const isRetry = options.isRetry || false;
+
+      let strategy;
+      if (isModelSwitch) {
+        strategy = COMPACTION_STRATEGIES.TRUNCATION;
+      } else if (isRetry) {
+        strategy = COMPACTION_STRATEGIES.AGGRESSIVE;
+      } else {
+        strategy = options.strategy || COMPACTION_STRATEGIES.SUMMARIZATION;
+      }
+
+      this.logger.info('Starting conversation compaction', {
+        messageCount: messages.length,
+        currentModel,
+        targetModel,
+        strategy,
+        isModelSwitch,
+        isRetry
+      });
+
+      // Execute strategy
+      let result;
+      switch (strategy) {
+        case COMPACTION_STRATEGIES.SUMMARIZATION:
+          result = await this._compactWithSummarization(messages, currentModel, options);
+          break;
+
+        case COMPACTION_STRATEGIES.TRUNCATION:
+          result = await this._compactWithTruncation(messages, targetModel, options);
+          break;
+
+        case COMPACTION_STRATEGIES.AGGRESSIVE:
+          result = await this._compactWithAggressiveSummarization(messages, currentModel, options);
+          break;
+
+        default:
+          throw new Error(`Unknown compaction strategy: ${strategy}`);
+      }
+
+      // Add execution metadata
+      const executionTime = Date.now() - startTime;
+      result.executionTime = executionTime;
+      result.timestamp = new Date().toISOString();
+
+      this.logger.info('Compaction completed successfully', {
+        strategy: result.strategy,
+        originalMessages: messages.length,
+        compactedMessages: result.compactedMessages.length,
+        originalTokens: result.originalTokenCount,
+        compactedTokens: result.compactedTokenCount,
+        reductionPercent: result.reductionPercent.toFixed(2),
+        executionTime: `${executionTime}ms`
+      });
+
+      return result;
+
+    } catch (error) {
+      const executionTime = Date.now() - startTime;
+
+      this.logger.error('Compaction failed', {
+        error: error.message,
+        messageCount: messages.length,
+        currentModel,
+        targetModel,
+        executionTime: `${executionTime}ms`
+      });
+
+      throw error;
+    }
+  }
+
+  /**
+   * Strategy 1: Intelligent summarization with sandwich approach
+   * Preserves beginning (15%) + AI summary of middle + end (35%)
+   * @private
+   */
+  async _compactWithSummarization(messages, model, options) {
+    const strategy = COMPACTION_STRATEGIES.SUMMARIZATION;
+
+    // Count tokens in original conversation
+    const originalTokenCount = await this.tokenCountingService.estimateConversationTokens(
+      messages,
+      model,
+      TOKEN_COUNTING_MODES.ACCURATE
+    );
+
+    // Identify segments using token-based boundaries
+    const segments = await this._identifySegments(
+      messages,
+      model,
+      COMPACTION_CONFIG.BEGINNING_SEGMENT_PERCENTAGE,
+      COMPACTION_CONFIG.END_SEGMENT_PERCENTAGE
+    );
+
+    this.logger.debug('Segments identified for summarization', {
+      beginningMessages: segments.beginning.length,
+      middleMessages: segments.middle.length,
+      endMessages: segments.end.length,
+      middleStartIndex: segments.middleStartIndex,
+      middleEndIndex: segments.middleEndIndex,
+      totalMessages: messages.length
+    });
+
+    // Generate summary of middle segment
+    const summary = await this._generateSummary(
+      segments.middle,
+      model,
+      {
+        ...options,
+        middleStartIndex: segments.middleStartIndex,
+        middleEndIndex: segments.middleEndIndex
+      }
+    );
+
+    // Construct compacted conversation
+    const compactedMessages = [
+      ...segments.beginning,
+      summary,
+      ...segments.end
+    ];
+
+    // Count tokens in compacted conversation
+    const compactedTokenCount = await this.tokenCountingService.estimateConversationTokens(
+      compactedMessages,
+      model,
+      TOKEN_COUNTING_MODES.ACCURATE
+    );
+
+    // Calculate reduction
+    const reductionPercent = ((originalTokenCount - compactedTokenCount) / originalTokenCount) * 100;
+
+    return {
+      compactedMessages,
+      strategy,
+      originalTokenCount,
+      compactedTokenCount,
+      reductionPercent,
+      segments: {
+        beginningCount: segments.beginning.length,
+        middleCount: segments.middle.length,
+        endCount: segments.end.length,
+        summaryInserted: true
+      }
+    };
+  }
+
+  /**
+   * Strategy 2: Fast truncation for model switching
+   * Preserves beginning (30%) + separator + end (50%)
+   * No AI call required - fast extraction
+   * @private
+   */
+  async _compactWithTruncation(messages, targetModel, options) {
+    const strategy = COMPACTION_STRATEGIES.TRUNCATION;
+
+    // Get target context window
+    const targetContextWindow = this.tokenCountingService.getModelContextWindow(targetModel);
+    const targetTokenCount = Math.floor(targetContextWindow * 0.8); // Use 80% of context
+
+    // Count tokens in original conversation
+    const originalTokenCount = await this.tokenCountingService.estimateConversationTokens(
+      messages,
+      targetModel,
+      TOKEN_COUNTING_MODES.ACCURATE
+    );
+
+    // Identify segments using token-based boundaries (30% + 50%)
+    const segments = await this._identifySegments(
+      messages,
+      targetModel,
+      COMPACTION_CONFIG.TRUNCATION_BEGINNING_PERCENTAGE,
+      COMPACTION_CONFIG.TRUNCATION_END_PERCENTAGE
+    );
+
+    this.logger.debug('Segments identified for truncation', {
+      beginningMessages: segments.beginning.length,
+      middleMessages: segments.middle.length,
+      endMessages: segments.end.length,
+      targetTokenCount,
+      originalTokenCount
+    });
+
+    // Create separator message
+    const separatorMessage = {
+      role: 'system',
+      content: COMPACTION_CONFIG.COMPACTION_SEPARATOR_MESSAGE,
+      type: 'separator',
+      timestamp: new Date().toISOString(),
+      metadata: {
+        truncatedMessages: segments.middle.length,
+        reason: 'Model switch - middle section removed to fit target context window'
+      }
+    };
+
+    // Construct compacted conversation
+    const compactedMessages = [
+      ...segments.beginning,
+      separatorMessage,
+      ...segments.end
+    ];
+
+    // Count tokens in compacted conversation
+    const compactedTokenCount = await this.tokenCountingService.estimateConversationTokens(
+      compactedMessages,
+      targetModel,
+      TOKEN_COUNTING_MODES.ACCURATE
+    );
+
+    // Calculate reduction
+    const reductionPercent = ((originalTokenCount - compactedTokenCount) / originalTokenCount) * 100;
+
+    return {
+      compactedMessages,
+      strategy,
+      originalTokenCount,
+      compactedTokenCount,
+      reductionPercent,
+      segments: {
+        beginningCount: segments.beginning.length,
+        middleCount: segments.middle.length,
+        endCount: segments.end.length,
+        summaryInserted: false
+      }
+    };
+  }
+
+  /**
+   * Strategy 3: Aggressive summarization for retry scenarios
+   * More aggressive compression: 10% beginning + summary + 30% end
+   * @private
+   */
+  async _compactWithAggressiveSummarization(messages, model, options) {
+    const strategy = COMPACTION_STRATEGIES.AGGRESSIVE;
+
+    // Count tokens in original conversation
+    const originalTokenCount = await this.tokenCountingService.estimateConversationTokens(
+      messages,
+      model,
+      TOKEN_COUNTING_MODES.ACCURATE
+    );
+
+    // Identify segments with aggressive percentages
+    const segments = await this._identifySegments(
+      messages,
+      model,
+      COMPACTION_CONFIG.AGGRESSIVE_BEGINNING_PERCENTAGE,
+      COMPACTION_CONFIG.AGGRESSIVE_END_PERCENTAGE
+    );
+
+    this.logger.debug('Segments identified for aggressive compaction', {
+      beginningMessages: segments.beginning.length,
+      middleMessages: segments.middle.length,
+      endMessages: segments.end.length,
+      middleStartIndex: segments.middleStartIndex,
+      middleEndIndex: segments.middleEndIndex
+    });
+
+    // Generate summary with more aggressive compression instruction
+    const summary = await this._generateSummary(segments.middle, model, {
+      ...options,
+      aggressive: true,
+      middleStartIndex: segments.middleStartIndex,
+      middleEndIndex: segments.middleEndIndex
+    });
+
+    // Construct compacted conversation
+    const compactedMessages = [
+      ...segments.beginning,
+      summary,
+      ...segments.end
+    ];
+
+    // Count tokens in compacted conversation
+    const compactedTokenCount = await this.tokenCountingService.estimateConversationTokens(
+      compactedMessages,
+      model,
+      TOKEN_COUNTING_MODES.ACCURATE
+    );
+
+    // Calculate reduction
+    const reductionPercent = ((originalTokenCount - compactedTokenCount) / originalTokenCount) * 100;
+
+    return {
+      compactedMessages,
+      strategy,
+      originalTokenCount,
+      compactedTokenCount,
+      reductionPercent,
+      segments: {
+        beginningCount: segments.beginning.length,
+        middleCount: segments.middle.length,
+        endCount: segments.end.length,
+        summaryInserted: true
+      }
+    };
+  }
+
+  /**
+   * Identify conversation segments based on token counts
+   * @private
+   */
+  async _identifySegments(messages, model, beginningPercent, endPercent) {
+    // Calculate total tokens
+    const totalTokens = await this.tokenCountingService.estimateConversationTokens(
+      messages,
+      model,
+      TOKEN_COUNTING_MODES.ACCURATE
+    );
+
+    // Calculate target tokens for each segment
+    const beginningTargetTokens = Math.floor(totalTokens * beginningPercent);
+    const endTargetTokens = Math.floor(totalTokens * endPercent);
+
+    // Identify beginning segment (from start)
+    let beginningTokens = 0;
+    let beginningEndIndex = 0;
+
+    for (let i = 0; i < messages.length; i++) {
+      const messageTokens = await this.tokenCountingService.countTokens(
+        messages[i].content,
+        model,
+        TOKEN_COUNTING_MODES.CACHED
+      );
+
+      if (beginningTokens + messageTokens > beginningTargetTokens && i >= 2) {
+        // Ensure at least 2 messages in beginning (as per design doc)
+        break;
+      }
+
+      beginningTokens += messageTokens;
+      beginningEndIndex = i + 1;
+    }
+
+    // Identify end segment (from end, working backwards)
+    let endTokens = 0;
+    let endStartIndex = messages.length;
+
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const messageTokens = await this.tokenCountingService.countTokens(
+        messages[i].content,
+        model,
+        TOKEN_COUNTING_MODES.CACHED
+      );
+
+      if (endTokens + messageTokens > endTargetTokens) {
+        break;
+      }
+
+      endTokens += messageTokens;
+      endStartIndex = i;
+    }
+
+    // Ensure no overlap
+    if (endStartIndex < beginningEndIndex) {
+      endStartIndex = beginningEndIndex;
+    }
+
+    // Extract segments
+    const beginning = messages.slice(0, beginningEndIndex);
+    const middle = messages.slice(beginningEndIndex, endStartIndex);
+    const end = messages.slice(endStartIndex);
+
+    return {
+      beginning,
+      middle,
+      end,
+      middleStartIndex: beginningEndIndex,
+      middleEndIndex: endStartIndex - 1  // Inclusive end index
+    };
+  }
+
+  /**
+   * Generate AI summary of middle segment using GPT-4o-mini
+   * @private
+   */
+  async _generateSummary(middleMessages, model, options = {}) {
+    if (middleMessages.length === 0) {
+      return {
+        role: 'system',
+        content: `${COMPACTION_CONFIG.COMPACTION_SUMMARY_PREFIX} No messages to summarize.`,
+        type: 'summary',
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    // Format middle messages for summarization
+    const middleContent = middleMessages
+      .map(msg => `${msg.role}: ${msg.content}`)
+      .join('\n\n');
+
+    // Build summary prompt
+    const summaryPrompt = this.summaryPromptTemplate
+      .replace('{middle_segment}', middleContent)
+      .replace('{aggressive_instruction}', options.aggressive
+        ? '\n\nIMPORTANT: Be VERY aggressive in compression. Prioritize only the most critical information. Aim for maximum brevity while maintaining essential context.'
+        : '');
+
+    // Try primary model and fallbacks
+    const modelsToTry = [
+      COMPACTION_CONFIG.COMPACTION_MODEL,
+      ...COMPACTION_CONFIG.COMPACTION_MODEL_FALLBACKS
+    ];
+
+    let lastError = null;
+
+    for (const compactionModel of modelsToTry) {
+      try {
+        this.logger.debug('Generating summary', {
+          compactionModel,
+          middleMessageCount: middleMessages.length,
+          middleContentLength: middleContent.length,
+          aggressive: options.aggressive
+        });
+
+        // Call AI service
+        const response = await this.aiService.sendMessage(
+          compactionModel,
+          summaryPrompt,
+          {
+            systemPrompt: 'You are a conversation summarization expert. Your goal is to compress conversations while preserving critical information for continued interaction.',
+            maxTokens: COMPACTION_CONFIG.MAX_SUMMARY_TOKENS,
+            temperature: 0.3, // Lower temperature for consistency
+            sessionId: options.sessionId,
+            platformProvided: true // Use Loxia API key
+          }
+        );
+
+        const summaryContent = response.content.trim();
+
+        // Build index range string
+        const indexRange = (options.middleStartIndex !== undefined && options.middleEndIndex !== undefined)
+          ? `original messages ${options.middleStartIndex}-${options.middleEndIndex}`
+          : `${middleMessages.length} messages`;
+
+        this.logger.info('Summary generated successfully', {
+          compactionModel,
+          originalLength: middleContent.length,
+          summaryLength: summaryContent.length,
+          compressionRatio: (summaryContent.length / middleContent.length * 100).toFixed(2) + '%',
+          indexRange
+        });
+
+        // Return formatted summary message
+        return {
+          role: 'system',
+          content: `${COMPACTION_CONFIG.COMPACTION_SUMMARY_PREFIX} - ${indexRange}]\n\n${summaryContent}\n\n${COMPACTION_CONFIG.COMPACTION_SUMMARY_SUFFIX}`,
+          type: 'summary',
+          timestamp: new Date().toISOString(),
+          metadata: {
+            originalMessageCount: middleMessages.length,
+            originalStartIndex: options.middleStartIndex,
+            originalEndIndex: options.middleEndIndex,
+            compactionModel: compactionModel,
+            aggressive: options.aggressive || false
+          }
+        };
+
+      } catch (error) {
+        lastError = error;
+        this.logger.warn('Summary generation failed with model, trying next fallback', {
+          compactionModel,
+          error: error.message,
+          middleMessageCount: middleMessages.length
+        });
+        // Continue to next model
+      }
+    }
+
+    // All models failed, use fallback summary
+    this.logger.error('All summary generation attempts failed', {
+      modelsAttempted: modelsToTry.length,
+      lastError: lastError?.message,
+      middleMessageCount: middleMessages.length
+    });
+
+    // Fallback to simple truncated summary
+    const fallbackSummary = this._createFallbackSummary(middleMessages);
+
+    // Build index range string for fallback
+    const indexRange = (options.middleStartIndex !== undefined && options.middleEndIndex !== undefined)
+      ? `original messages ${options.middleStartIndex}-${options.middleEndIndex}`
+      : `${middleMessages.length} messages`;
+
+    return {
+      role: 'system',
+      content: `${COMPACTION_CONFIG.COMPACTION_SUMMARY_PREFIX} - ${indexRange}]\n\n${fallbackSummary}\n\n${COMPACTION_CONFIG.COMPACTION_SUMMARY_SUFFIX}`,
+      type: 'summary',
+      timestamp: new Date().toISOString(),
+      metadata: {
+        originalMessageCount: middleMessages.length,
+        originalStartIndex: options.middleStartIndex,
+        originalEndIndex: options.middleEndIndex,
+        fallback: true,
+        error: lastError?.message,
+        modelsAttempted: modelsToTry
+      }
+    };
+  }
+
+  /**
+   * Create fallback summary when AI generation fails
+   * @private
+   */
+  _createFallbackSummary(messages) {
+    const messageCount = messages.length;
+    const roles = messages.map(m => m.role);
+    const userCount = roles.filter(r => r === 'user').length;
+    const assistantCount = roles.filter(r => r === 'assistant').length;
+
+    return `[${messageCount} messages summarized - ${userCount} user messages, ${assistantCount} assistant responses. ` +
+           `Summary generation unavailable - middle section compressed for context management.]`;
+  }
+
+  /**
+   * Create summary prompt template with preservation guidelines
+   * @private
+   */
+  _createSummaryPromptTemplate() {
+    return `You are compacting a conversation to preserve critical information while reducing token count.
+
+CONTEXT: This is part of a longer conversation that needs compactization for continued processing.
+
+PRESERVATION GUIDELINES:
+
+HIGH PRIORITY (Always Preserve):
+- Future reference value: Information likely to be referenced again
+- Decisions and reasoning: WHY things were decided, not just what
+- API signatures and interfaces: Function definitions, method calls
+- Active dependencies: Information that ongoing work relies on
+- Error patterns and solutions: What failed and how it was fixed
+- Key facts and data: Specific numbers, names, configurations
+
+MEDIUM PRIORITY (Compress Intelligently):
+- Code blocks: Keep function signatures + brief description, compress implementation details
+- Working solutions: Essence and outcome, not every implementation step
+- Failed attempts: Brief mention of what didn't work and why, skip detailed troubleshooting
+- Repetitive content: Consolidate similar examples or explanations
+
+LOW PRIORITY (Heavily Compress/Remove):
+- Completed calculations: Keep results, skip intermediate steps
+- Verbose explanations: Summarize well-known concepts
+- Debug output: Skip terminal logs and error messages that served their purpose
+- Trial-and-error sequences: Skip multiple failed attempts with no lasting value
+- Acknowledgments and pleasantries: Skip "thank you", "sure", "okay" type exchanges
+
+CONVERSATION SEGMENT TO SUMMARIZE:
+{middle_segment}
+
+TASK: Create a concise summary that preserves logical flow and critical information. Focus on:
+1. Key decisions and their reasoning
+2. Important facts, data, and configurations
+3. Active context needed for continuation
+4. Problem-solving outcomes (skip the debugging process)
+5. Dependencies and interfaces that code/work relies on
+
+Someone reading this should understand the conversation progression and have all information needed for effective continuation.
+{aggressive_instruction}
+
+OUTPUT: Provide ONLY the summary text without preamble, explanation, or meta-commentary.`;
+  }
+}
+
+export default ConversationCompactionService;