feat(tarko-agent): implement context compression strategies

Add comprehensive context compression system to prevent context window overflow:

- Four built-in strategies: sliding_window, structured_summary, tool_response_compression, smart_truncation
- Inspired by Manus (external storage), Claude Code (8-section summary), Gemini CLI (sliding window)
- Configurable compression thresholds and strategies
- Automatic compression triggers and manual compression support
- Integration with Agent message history and event stream
- Comprehensive test coverage and documentation
- Backward compatible with existing Agent configurations

Strategies:
- sliding_window: Keeps recent messages (Gemini CLI approach, 70% threshold)
- structured_summary: Creates structured summaries (Claude Code approach, 92% threshold)
- tool_response_compression: Compresses large tool responses (Manus approach)
- smart_truncation: Intelligent message selection based on importance scoring

Features:
- Token counting and context window management
- Compression statistics and monitoring
- Strategy registry for custom implementations
- Event stream integration for compression notifications
- Graceful fallbacks and error handling

Author: ulivz

multimodal/tarko/agent-interface/src/agent-options.ts

@@ -241,6 +241,64 @@ export interface AgentOptions
     AgentMiscOptions,
     AgentWorkspaceOptions {}
 
+/**
+ * Context compression configuration options
+ */
+export interface AgentContextCompressionOptions {
+  /**
+   * Whether context compression is enabled
+   * 
+   * @defaultValue `true`
+   */
+  enabled?: boolean;
+
+  /**
+   * Compression strategy to use
+   * 
+   * Built-in strategies:
+   * - 'sliding_window': Keeps recent messages (Gemini CLI approach)
+   * - 'structured_summary': Creates structured summaries (Claude Code approach)
+   * - 'tool_response_compression': Compresses large tool responses (Manus approach)
+   * - 'smart_truncation': Intelligent message selection
+   * 
+   * @defaultValue `'sliding_window'`
+   */
+  strategy?: string;
+
+  /**
+   * Threshold for triggering compression (0-1, percentage of context window)
+   * 
+   * @defaultValue `0.7` (70%)
+   */
+  compressionThreshold?: number;
+
+  /**
+   * Target size after compression (0-1, percentage of original size)
+   * 
+   * @defaultValue `0.3` (30%)
+   */
+  targetCompressionRatio?: number;
+
+  /**
+   * Minimum number of messages to preserve
+   * 
+   * @defaultValue `5`
+   */
+  minMessagesToKeep?: number;
+
+  /**
+   * Maximum number of compression attempts per session
+   * 
+   * @defaultValue `10`
+   */
+  maxCompressionAttempts?: number;
+
+  /**
+   * Custom configuration for specific strategies
+   */
+  strategyConfig?: Record<string, any>;
+}
+
 /**
  * Options for configuring agent context behavior (e.g. message history)
  */
@@ -255,4 +313,13 @@ export interface AgentContextAwarenessOptions {
    * This helps optimize token usage while preserving important conversation context.
    */
   maxImagesCount?: number;
+
+  /**
+   * Context compression configuration
+   * 
+   * Controls how the agent manages context window limits through compression strategies.
+   * When enabled, the agent will automatically compress older conversation history
+   * when approaching context window limits.
+   */
+  compression?: AgentContextCompressionOptions;
 }

multimodal/tarko/agent/src/agent/message-history.ts

@@ -10,9 +10,12 @@ import {
   ChatCompletionMessageParam,
   ChatCompletionContentPart,
   ToolCallResult,
+  AgentContextAwarenessOptions,
 } from '@tarko/agent-interface';
 import { convertToMultimodalToolCallResult } from '../utils/multimodal';
 import { getLogger, isTest } from '@tarko/shared-utils';
+import { ContextManager } from '../context-compression/context-manager';
+import { CompressionTrigger } from '../context-compression/types';
 
 /**
  * Interface for image information in messages
@@ -35,6 +38,9 @@ interface ImageReference {
  */
 export class MessageHistory {
   private logger = getLogger('MessageHistory');
+  private contextManager?: ContextManager;
+  private sessionId?: string;
+  private iteration = 0;
 
   /**
    * Creates a new MessageHistory instance
@@ -44,11 +50,35 @@ export class MessageHistory {
    *                         When specified, limits the total number of images in the conversation history
    *                         to prevent context window overflow. Images beyond this limit will be
    *                         replaced with text placeholders to preserve context while reducing token usage.
+   * @param contextAwarenessOptions - Optional context awareness options including compression
    */
   constructor(
     private eventStream: AgentEventStream.Processor,
     private maxImagesCount?: number,
-  ) {}
+    private contextAwarenessOptions?: AgentContextAwarenessOptions,
+  ) {
+    // Initialize context manager if compression is enabled
+    if (this.contextAwarenessOptions?.compression?.enabled !== false) {
+      this.contextManager = new ContextManager(this.contextAwarenessOptions?.compression);
+    }
+  }
+
+  /**
+   * Update session information for compression tracking
+   * @param sessionId Current session identifier
+   * @param iteration Current iteration number
+   * @param modelId Model identifier for token counting
+   * @param provider Model provider
+   */
+  updateSession(sessionId: string, iteration: number, modelId?: string, provider?: string): void {
+    this.sessionId = sessionId;
+    this.iteration = iteration;
+    
+    // Update context manager with model information
+    if (this.contextManager && modelId && provider) {
+      this.contextManager.updateModel(modelId, provider);
+    }
+  }
 
   /**
    * Convert events to message history format for LLM context
@@ -59,11 +89,11 @@ export class MessageHistory {
    * @param systemPrompt The base system prompt to include
    * @param tools Available tools to enhance the system prompt
    */
-  toMessageHistory(
+  async toMessageHistory(
     toolCallEngine: ToolCallEngine,
     customSystemPrompt: string,
     tools: Tool[] = [],
-  ): ChatCompletionMessageParam[] {
+  ): Promise<ChatCompletionMessageParam[]> {
     const baseSystemPrompt = this.getSystemPromptWithTime(customSystemPrompt);
     // Start with the enhanced system message
     const enhancedSystemPrompt = toolCallEngine.preparePrompt(baseSystemPrompt, tools);
@@ -83,6 +113,50 @@ export class MessageHistory {
     // Create a unified processing path with optional image limiting
     this.processEvents(events, messages, toolCallEngine);
 
+    // Apply context compression if enabled
+    if (this.contextManager && this.sessionId) {
+      const compressionCheck = await this.contextManager.shouldCompress(
+        messages,
+        events,
+        this.sessionId,
+        this.iteration
+      );
+
+      if (compressionCheck.shouldCompress) {
+        this.logger.info(
+          `Context compression triggered: ${compressionCheck.currentTokens} tokens, reason: ${compressionCheck.reason}`
+        );
+
+        try {
+          const compressionResult = await this.contextManager.compress(
+            messages,
+            events,
+            this.sessionId,
+            this.iteration,
+            compressionCheck.reason
+          );
+
+          // Send compression event to event stream
+          const compressionEvent = this.eventStream.createEvent('system', {
+            level: 'info',
+            message: `Context compressed: ${compressionResult.stats.originalMessageCount} → ${compressionResult.stats.compressedMessageCount} messages (${(compressionResult.stats.compressionRatio * 100).toFixed(1)}% reduction)`,
+            details: {
+              strategy: compressionResult.stats.strategy,
+              originalTokens: compressionResult.stats.originalTokens,
+              compressedTokens: compressionResult.stats.compressedTokens,
+              compressionRatio: compressionResult.stats.compressionRatio,
+            },
+          });
+          this.eventStream.sendEvent(compressionEvent);
+
+          return compressionResult.messages;
+        } catch (error) {
+          this.logger.error(`Context compression failed: ${error}`);
+          // Fall back to original messages if compression fails
+        }
+      }
+    }
+
     return messages;
   }
 

multimodal/tarko/agent/src/agent/runner/llm-processor.ts

@@ -57,6 +57,7 @@ export class LLMProcessor {
     this.messageHistory = new MessageHistory(
       this.eventStream,
       this.contextAwarenessOptions?.maxImagesCount,
+      this.contextAwarenessOptions,
     );
     this.enableStreamingToolCallEvents = enableStreamingToolCallEvents;
     this.enableMetrics = enableMetrics;
@@ -188,8 +189,11 @@ export class LLMProcessor {
       this.toolProcessor.setExecutionTools(finalTools);
     }
 
+    // Update session information for compression tracking
+    this.messageHistory.updateSession(sessionId, iteration, currentModel.id, currentModel.provider);
+
     // Build messages for current iteration including enhanced system message
-    const messages = this.messageHistory.toMessageHistory(
+    const messages = await this.messageHistory.toMessageHistory(
       toolCallEngine,
       finalSystemPrompt,
       finalTools,