dartmind 17.0.0

package/dist/engine/V16ContextWindowManager.js

@@ -0,0 +1,700 @@
+/**
+ * FlutterAI V16 - Context Window Manager
+ * Issue 5.1: Context Window Management
+ * Issue 5.2: Automatic Truncation Strategies
+ *
+ * CRITICAL DESIGN:
+ * 1. Token estimation with content-type awareness
+ * 2. 4 truncation strategies: FIFO, Priority, Summarize, Hybrid
+ * 3. Integration with ResourceMonitor (95% abort)
+ * 4. Automatic trimming at warning threshold (80%)
+ * 5. Critical threshold enforcement (90%)
+ *
+ * Integrates:
+ * - ResourceMonitor (abort at 95%)
+ * - DoomLoopDetector (track context patterns)
+ * - ErrorSurface (structured errors)
+ *
+ * @module engine/V16ContextWindowManager
+ * @version 16.0.0
+ */
+import { EventEmitter } from 'events';
+import { nanoid } from 'nanoid';
+import { createResourceMonitor } from './ResourceMonitor.js';
+// ============================================================================
+// Constants
+// ============================================================================
+const DEFAULT_CONFIG = {
+    maxTokens: 128000,
+    warningThreshold: 0.8,
+    criticalThreshold: 0.9,
+    abortThreshold: 0.95,
+    strategy: 'hybrid',
+    preserveSystemMessages: true,
+    preservePinnedMessages: true,
+    minMessages: 2,
+    autoTrim: true,
+    enableResourceMonitor: true,
+};
+/**
+ * Token estimation rates by content type
+ * These are approximations - actual tokenization varies
+ */
+const TOKENS_PER_CHAR = {
+    text: 0.25, // ~4 chars per token for English
+    code: 0.35, // Code tends to be more token-dense
+    json: 0.30, // JSON has structure overhead
+    markdown: 0.28, // Similar to text with formatting
+    image: 0.0, // Images use fixed token counts
+    binary: 0.50, // Base64 is dense
+};
+/**
+ * Fixed token overhead per message role
+ */
+const ROLE_OVERHEAD = {
+    system: 4,
+    user: 4,
+    assistant: 4,
+    tool: 6,
+};
+/**
+ * Default importance by role
+ */
+const DEFAULT_IMPORTANCE = {
+    system: 0.95, // System messages are critical
+    user: 0.7, // User messages are important
+    assistant: 0.6, // Assistant responses
+    tool: 0.5, // Tool results
+};
+// ============================================================================
+// V16ContextWindowManager Class
+// ============================================================================
+export class V16ContextWindowManager extends EventEmitter {
+    config;
+    window;
+    resourceMonitor = null;
+    // Stats
+    totalTruncations = 0;
+    totalTokensFreed = 0;
+    constructor(config = {}) {
+        super();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        // Initialize context window
+        this.window = {
+            id: nanoid(),
+            messages: [],
+            totalTokens: 0,
+            maxTokens: this.config.maxTokens,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        };
+        // Initialize resource monitor if enabled
+        if (this.config.enableResourceMonitor) {
+            this.resourceMonitor = createResourceMonitor({
+                maxContextTokens: this.config.maxTokens,
+                abortThreshold: this.config.abortThreshold,
+                warningThreshold: this.config.warningThreshold,
+            });
+        }
+    }
+    // ==========================================================================
+    // Message Management
+    // ==========================================================================
+    /**
+     * Add a message to the context window
+     */
+    addMessage(role, content, options = {}) {
+        const contentType = options.contentType ?? this.detectContentType(content);
+        const tokens = options.tokens ?? this.estimateTokens(content, contentType, role);
+        const importance = options.importance ?? this.calculateImportance(role, content, contentType);
+        const message = {
+            id: nanoid(),
+            role,
+            content,
+            contentType,
+            timestamp: Date.now(),
+            tokens,
+            importance,
+            pinned: options.pinned ?? false,
+            metadata: options.metadata,
+        };
+        // Add to window
+        this.window.messages.push(message);
+        this.window.totalTokens += tokens;
+        this.window.updatedAt = Date.now();
+        // Update resource monitor
+        if (this.resourceMonitor) {
+            this.resourceMonitor.addTokens(tokens);
+        }
+        this.emit('message:added', message);
+        // Check thresholds
+        this.checkThresholds();
+        return message;
+    }
+    /**
+     * Remove a message by ID
+     */
+    removeMessage(messageId) {
+        const index = this.window.messages.findIndex((m) => m.id === messageId);
+        if (index === -1)
+            return false;
+        const [removed] = this.window.messages.splice(index, 1);
+        this.window.totalTokens -= removed.tokens;
+        this.window.updatedAt = Date.now();
+        this.emit('message:removed', removed);
+        return true;
+    }
+    /**
+     * Pin a message (prevent truncation)
+     */
+    pinMessage(messageId) {
+        const message = this.window.messages.find((m) => m.id === messageId);
+        if (!message)
+            return false;
+        message.pinned = true;
+        return true;
+    }
+    /**
+     * Unpin a message
+     */
+    unpinMessage(messageId) {
+        const message = this.window.messages.find((m) => m.id === messageId);
+        if (!message)
+            return false;
+        message.pinned = false;
+        return true;
+    }
+    /**
+     * Update message importance
+     */
+    setImportance(messageId, importance) {
+        const message = this.window.messages.find((m) => m.id === messageId);
+        if (!message)
+            return false;
+        message.importance = Math.max(0, Math.min(1, importance));
+        return true;
+    }
+    /**
+     * Get all messages
+     */
+    getMessages() {
+        return [...this.window.messages];
+    }
+    /**
+     * Get messages by role
+     */
+    getMessagesByRole(role) {
+        return this.window.messages.filter((m) => m.role === role);
+    }
+    /**
+     * Get last N messages
+     */
+    getLastMessages(count) {
+        return this.window.messages.slice(-count);
+    }
+    /**
+     * Get messages for API (formatted for Anthropic)
+     */
+    getMessagesForAPI() {
+        return this.window.messages
+            .filter((m) => m.role === 'user' || m.role === 'assistant')
+            .map((m) => ({
+            role: m.role,
+            content: m.content,
+        }));
+    }
+    // ==========================================================================
+    // Token Management
+    // ==========================================================================
+    /**
+     * Estimate tokens for content
+     */
+    estimateTokens(content, contentType = 'text', role) {
+        // Base token count from content
+        const charCount = content.length;
+        const rate = TOKENS_PER_CHAR[contentType];
+        let tokens = Math.ceil(charCount * rate);
+        // Add role overhead
+        if (role) {
+            tokens += ROLE_OVERHEAD[role];
+        }
+        return tokens;
+    }
+    /**
+     * Get remaining token capacity
+     */
+    getRemainingTokens() {
+        return Math.max(0, this.window.maxTokens - this.window.totalTokens);
+    }
+    /**
+     * Check if content fits
+     */
+    canFit(content, contentType = 'text') {
+        const tokens = this.estimateTokens(content, contentType);
+        return tokens <= this.getRemainingTokens();
+    }
+    /**
+     * Get current usage percentage
+     */
+    getUsagePercent() {
+        return this.window.totalTokens / this.window.maxTokens;
+    }
+    // ==========================================================================
+    // Truncation Strategies
+    // ==========================================================================
+    /**
+     * Truncate context to target tokens
+     */
+    truncate(targetTokens, strategy) {
+        const target = targetTokens ?? Math.floor(this.config.maxTokens * 0.7);
+        const strat = strategy ?? this.config.strategy;
+        if (this.window.totalTokens <= target) {
+            return {
+                removed: [],
+                summarized: [],
+                tokensFreed: 0,
+                newTotalTokens: this.window.totalTokens,
+                strategy: strat,
+            };
+        }
+        let result;
+        switch (strat) {
+            case 'fifo':
+                result = this.truncateFIFO(target);
+                break;
+            case 'priority':
+                result = this.truncateByPriority(target);
+                break;
+            case 'summarize':
+                result = this.truncateWithSummary(target);
+                break;
+            case 'hybrid':
+            default:
+                result = this.truncateHybrid(target);
+                break;
+        }
+        this.totalTruncations++;
+        this.totalTokensFreed += result.tokensFreed;
+        this.emit('truncated', result);
+        return result;
+    }
+    /**
+     * FIFO truncation - remove oldest messages first
+     */
+    truncateFIFO(targetTokens) {
+        const removed = [];
+        let tokensFreed = 0;
+        while (this.window.totalTokens > targetTokens &&
+            this.window.messages.length > this.config.minMessages) {
+            const candidate = this.findTrimmableMessage('oldest');
+            if (!candidate)
+                break;
+            const index = this.window.messages.indexOf(candidate);
+            if (index === -1)
+                break;
+            this.window.messages.splice(index, 1);
+            tokensFreed += candidate.tokens;
+            this.window.totalTokens -= candidate.tokens;
+            removed.push(candidate);
+        }
+        this.window.updatedAt = Date.now();
+        return {
+            removed,
+            summarized: [],
+            tokensFreed,
+            newTotalTokens: this.window.totalTokens,
+            strategy: 'fifo',
+        };
+    }
+    /**
+     * Priority truncation - remove lowest importance first
+     */
+    truncateByPriority(targetTokens) {
+        const removed = [];
+        let tokensFreed = 0;
+        // Get candidates sorted by importance (ascending)
+        const candidates = this.window.messages
+            .filter((m) => this.isTrimmable(m))
+            .sort((a, b) => a.importance - b.importance);
+        for (const candidate of candidates) {
+            if (this.window.totalTokens <= targetTokens)
+                break;
+            if (this.window.messages.length <= this.config.minMessages)
+                break;
+            const index = this.window.messages.indexOf(candidate);
+            if (index === -1)
+                continue;
+            this.window.messages.splice(index, 1);
+            tokensFreed += candidate.tokens;
+            this.window.totalTokens -= candidate.tokens;
+            removed.push(candidate);
+        }
+        this.window.updatedAt = Date.now();
+        return {
+            removed,
+            summarized: [],
+            tokensFreed,
+            newTotalTokens: this.window.totalTokens,
+            strategy: 'priority',
+        };
+    }
+    /**
+     * Summarize truncation - compress old messages
+     */
+    truncateWithSummary(targetTokens) {
+        const summarized = [];
+        let tokensFreed = 0;
+        // Find old messages to summarize
+        const oldMessages = this.window.messages
+            .filter((m) => this.isTrimmable(m))
+            .slice(0, Math.floor(this.window.messages.length / 2));
+        if (oldMessages.length >= 3) {
+            // Create summary
+            const summaryContent = this.createSummary(oldMessages);
+            const summaryTokens = this.estimateTokens(summaryContent, 'text', 'system');
+            const originalTokens = oldMessages.reduce((sum, m) => sum + m.tokens, 0);
+            // Only summarize if it saves tokens
+            if (summaryTokens < originalTokens * 0.5) {
+                // Remove old messages
+                for (const msg of oldMessages) {
+                    const index = this.window.messages.indexOf(msg);
+                    if (index !== -1) {
+                        this.window.messages.splice(index, 1);
+                        this.window.totalTokens -= msg.tokens;
+                        summarized.push(msg);
+                    }
+                }
+                // Insert summary
+                const summaryMessage = {
+                    id: nanoid(),
+                    role: 'system',
+                    content: summaryContent,
+                    contentType: 'text',
+                    timestamp: Date.now(),
+                    tokens: summaryTokens,
+                    importance: 0.7,
+                    pinned: false,
+                    metadata: { isSummary: true, summarizedCount: oldMessages.length },
+                };
+                // Insert after existing system messages
+                const insertIndex = this.window.messages.findIndex((m) => m.role !== 'system');
+                this.window.messages.splice(insertIndex === -1 ? 0 : insertIndex, 0, summaryMessage);
+                this.window.totalTokens += summaryTokens;
+                tokensFreed = originalTokens - summaryTokens;
+            }
+        }
+        // Fall back to FIFO if still over limit
+        if (this.window.totalTokens > targetTokens) {
+            const fifoResult = this.truncateFIFO(targetTokens);
+            return {
+                removed: fifoResult.removed,
+                summarized,
+                tokensFreed: tokensFreed + fifoResult.tokensFreed,
+                newTotalTokens: this.window.totalTokens,
+                strategy: 'summarize',
+            };
+        }
+        this.window.updatedAt = Date.now();
+        return {
+            removed: [],
+            summarized,
+            tokensFreed,
+            newTotalTokens: this.window.totalTokens,
+            strategy: 'summarize',
+        };
+    }
+    /**
+     * Hybrid truncation - combine strategies
+     */
+    truncateHybrid(targetTokens) {
+        // First try summarization
+        const summaryResult = this.truncateWithSummary(Math.floor((this.window.totalTokens + targetTokens) / 2));
+        // Then apply priority trimming if needed
+        if (this.window.totalTokens > targetTokens) {
+            const priorityResult = this.truncateByPriority(targetTokens);
+            return {
+                removed: [...summaryResult.removed, ...priorityResult.removed],
+                summarized: summaryResult.summarized,
+                tokensFreed: summaryResult.tokensFreed + priorityResult.tokensFreed,
+                newTotalTokens: this.window.totalTokens,
+                strategy: 'hybrid',
+            };
+        }
+        return { ...summaryResult, strategy: 'hybrid' };
+    }
+    // ==========================================================================
+    // Helper Methods
+    // ==========================================================================
+    /**
+     * Find a trimmable message
+     */
+    findTrimmableMessage(mode) {
+        const candidates = this.window.messages.filter((m) => this.isTrimmable(m));
+        if (candidates.length === 0)
+            return undefined;
+        if (mode === 'oldest') {
+            return candidates[0];
+        }
+        else {
+            return candidates.reduce((lowest, current) => current.importance < lowest.importance ? current : lowest);
+        }
+    }
+    /**
+     * Check if a message can be trimmed
+     */
+    isTrimmable(message) {
+        if (message.pinned && this.config.preservePinnedMessages)
+            return false;
+        if (message.role === 'system' && this.config.preserveSystemMessages)
+            return false;
+        return true;
+    }
+    /**
+     * Create summary of messages
+     */
+    createSummary(messages) {
+        const userMessages = messages.filter((m) => m.role === 'user');
+        const assistantMessages = messages.filter((m) => m.role === 'assistant');
+        // Extract key topics
+        const topics = new Set();
+        for (const msg of messages) {
+            const words = msg.content.split(/\s+/).slice(0, 30);
+            words.forEach((w) => {
+                if (w.length > 5 && !w.startsWith('http')) {
+                    topics.add(w.toLowerCase().replace(/[^a-z]/g, ''));
+                }
+            });
+        }
+        return (`[Previous conversation summary: ${userMessages.length} user messages, ` +
+            `${assistantMessages.length} assistant responses. ` +
+            `Topics discussed: ${Array.from(topics).slice(0, 5).join(', ')}]`);
+    }
+    /**
+     * Detect content type from content
+     */
+    detectContentType(content) {
+        // Check for code patterns
+        if (/^(import|export|const|let|var|function|class|def|fn|pub)\s/.test(content)) {
+            return 'code';
+        }
+        // Check for JSON
+        if (/^\s*[\[{]/.test(content) && /[\]}]\s*$/.test(content)) {
+            try {
+                JSON.parse(content);
+                return 'json';
+            }
+            catch {
+                // Not valid JSON
+            }
+        }
+        // Check for markdown
+        if (/^#+\s|^\*\*|^-\s|\[.*\]\(.*\)/.test(content)) {
+            return 'markdown';
+        }
+        return 'text';
+    }
+    /**
+     * Calculate message importance
+     */
+    calculateImportance(role, content, contentType) {
+        let importance = DEFAULT_IMPORTANCE[role];
+        // Code is more important
+        if (contentType === 'code')
+            importance += 0.1;
+        // Very long messages are slightly less important
+        if (content.length > 5000)
+            importance -= 0.1;
+        // Clamp to 0-1
+        return Math.max(0, Math.min(1, importance));
+    }
+    /**
+     * Check thresholds and emit events / auto-trim
+     */
+    checkThresholds() {
+        const usage = this.getUsagePercent();
+        if (usage >= this.config.abortThreshold) {
+            this.emit('threshold:abort', { usage });
+            // Check resource monitor
+            if (this.resourceMonitor) {
+                try {
+                    this.resourceMonitor.enforceLimit();
+                }
+                catch {
+                    // Resource exhaustion - let it bubble up
+                }
+            }
+        }
+        else if (usage >= this.config.criticalThreshold) {
+            this.emit('threshold:critical', { usage });
+            // Auto-trim in critical zone
+            if (this.config.autoTrim) {
+                this.truncate(Math.floor(this.config.maxTokens * 0.7));
+            }
+        }
+        else if (usage >= this.config.warningThreshold) {
+            this.emit('threshold:warning', { usage });
+        }
+    }
+    // ==========================================================================
+    // Statistics & Health
+    // ==========================================================================
+    /**
+     * Get comprehensive statistics
+     */
+    getStats() {
+        const messagesByRole = {
+            system: 0,
+            user: 0,
+            assistant: 0,
+            tool: 0,
+        };
+        const tokensByRole = {
+            system: 0,
+            user: 0,
+            assistant: 0,
+            tool: 0,
+        };
+        let pinnedCount = 0;
+        let oldestTimestamp = Date.now();
+        for (const message of this.window.messages) {
+            messagesByRole[message.role]++;
+            tokensByRole[message.role] += message.tokens;
+            if (message.pinned)
+                pinnedCount++;
+            if (message.timestamp < oldestTimestamp) {
+                oldestTimestamp = message.timestamp;
+            }
+        }
+        const usage = this.getUsagePercent();
+        let health;
+        if (usage >= this.config.abortThreshold) {
+            health = 'danger';
+        }
+        else if (usage >= this.config.criticalThreshold) {
+            health = 'critical';
+        }
+        else if (usage >= this.config.warningThreshold) {
+            health = 'warning';
+        }
+        else {
+            health = 'healthy';
+        }
+        return {
+            totalMessages: this.window.messages.length,
+            totalTokens: this.window.totalTokens,
+            usagePercent: usage * 100,
+            messagesByRole,
+            tokensByRole,
+            avgTokensPerMessage: this.window.messages.length > 0
+                ? this.window.totalTokens / this.window.messages.length
+                : 0,
+            pinnedCount,
+            oldestMessageAge: Date.now() - oldestTimestamp,
+            health,
+        };
+    }
+    /**
+     * Get health status
+     */
+    getHealth() {
+        const usage = this.getUsagePercent();
+        const healthy = usage < this.config.criticalThreshold;
+        return {
+            healthy,
+            usage,
+            message: healthy
+                ? `Context healthy: ${(usage * 100).toFixed(1)}% used`
+                : `Context critical: ${(usage * 100).toFixed(1)}% used`,
+        };
+    }
+    /**
+     * Get current window state
+     */
+    getWindow() {
+        return { ...this.window, messages: [...this.window.messages] };
+    }
+    // ==========================================================================
+    // Reset & Clear
+    // ==========================================================================
+    /**
+     * Clear all messages
+     */
+    clear() {
+        this.window.messages = [];
+        this.window.totalTokens = 0;
+        this.window.updatedAt = Date.now();
+        if (this.resourceMonitor) {
+            this.resourceMonitor.reset();
+        }
+        this.emit('cleared');
+    }
+    /**
+     * Reset to new window
+     */
+    reset() {
+        this.clear();
+        this.window.id = nanoid();
+        this.window.createdAt = Date.now();
+        this.emit('reset');
+    }
+    /**
+     * Set max tokens
+     */
+    setMaxTokens(maxTokens) {
+        this.config.maxTokens = maxTokens;
+        this.window.maxTokens = maxTokens;
+        if (this.resourceMonitor) {
+            // Create new resource monitor with updated limit
+            this.resourceMonitor = createResourceMonitor({
+                maxContextTokens: maxTokens,
+                abortThreshold: this.config.abortThreshold,
+                warningThreshold: this.config.warningThreshold,
+            });
+        }
+        this.checkThresholds();
+    }
+    /**
+     * Set truncation strategy
+     */
+    setStrategy(strategy) {
+        this.config.strategy = strategy;
+    }
+}
+// ============================================================================
+// Factory Functions
+// ============================================================================
+/**
+ * Create V16ContextWindowManager with standard configuration
+ */
+export function createV16ContextWindowManager(config) {
+    return new V16ContextWindowManager(config);
+}
+/**
+ * Create V16ContextWindowManager for Claude 3.5 Sonnet (200K context)
+ */
+export function createSonnetContextManager() {
+    return new V16ContextWindowManager({
+        maxTokens: 200000,
+        warningThreshold: 0.75,
+        criticalThreshold: 0.85,
+        abortThreshold: 0.95,
+        strategy: 'hybrid',
+    });
+}
+/**
+ * Create V16ContextWindowManager for Claude 3.5 Haiku (200K context)
+ */
+export function createHaikuContextManager() {
+    return new V16ContextWindowManager({
+        maxTokens: 200000,
+        warningThreshold: 0.8,
+        criticalThreshold: 0.9,
+        abortThreshold: 0.95,
+        strategy: 'fifo', // Haiku is cheaper, use simpler strategy
+    });
+}
+// ============================================================================
+// Exports
+// ============================================================================
+export default V16ContextWindowManager;
+//# sourceMappingURL=V16ContextWindowManager.js.map