@hailer/mcp 0.1.16 → 0.2.1

package/dist/lib/context-manager.js

@@ -1,431 +0,0 @@
-"use strict";
-/**
- * Context Manager
- *
- * Handles token counting and automatic summarization to prevent "prompt too long" errors.
- * Uses character-based token estimation and provider-specific limits with safety margins.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContextManager = void 0;
-exports.getContextManager = getContextManager;
-const logger_1 = require("./logger");
-const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
-const openai_1 = __importDefault(require("openai"));
-// ================================================================================
-// CONTEXT MANAGER
-// ================================================================================
-class ContextManager {
-    logger;
-    config;
-    // Provider limits (max context window)
-    PROVIDER_LIMITS = {
-        anthropic: 200_000, // Claude Sonnet 4
-        openai: 128_000, // GPT-4o
-    };
-    constructor(config = {}) {
-        this.config = {
-            safetyMarginPercent: 25,
-            enableAutoSummarization: true,
-            maxSummarizationChunks: 10,
-            ...config,
-        };
-        this.logger = (0, logger_1.createLogger)({ component: "ContextManager" });
-        this.logger.info("ContextManager initialized", {
-            safetyMargin: `${this.config.safetyMarginPercent}%`,
-            autoSummarization: this.config.enableAutoSummarization,
-            maxChunks: this.config.maxSummarizationChunks,
-        });
-    }
-    // ================================================================================
-    // TOKEN COUNTING
-    // ================================================================================
-    /**
-     * Estimate tokens from text using character-based approximation
-     * Formula: 1 token ≈ 4 characters
-     */
-    estimateTokens(text) {
-        return Math.ceil(text.length / 4);
-    }
-    /**
-     * Calculate token limits for a provider with safety margin
-     */
-    getTokenLimits(provider) {
-        const maxTokens = this.PROVIDER_LIMITS[provider];
-        const safetyMargin = this.config.safetyMarginPercent / 100;
-        const safeTokens = Math.floor(maxTokens * (1 - safetyMargin));
-        return { maxTokens, safeTokens, safetyMargin };
-    }
-    /**
-     * Count tokens for system prompt
-     */
-    countSystemPromptTokens(systemPrompt) {
-        if (typeof systemPrompt === 'string') {
-            return this.estimateTokens(systemPrompt);
-        }
-        // Handle array or complex system prompt formats
-        const text = JSON.stringify(systemPrompt);
-        return this.estimateTokens(text);
-    }
-    /**
-     * Count tokens for messages array
-     */
-    countMessagesTokens(messages) {
-        let total = 0;
-        for (const message of messages) {
-            // Handle different message formats
-            if (typeof message.content === 'string') {
-                total += this.estimateTokens(message.content);
-            }
-            else if (Array.isArray(message.content)) {
-                // Anthropic format with content blocks
-                for (const block of message.content) {
-                    if (block.type === 'text' && block.text) {
-                        total += this.estimateTokens(block.text);
-                    }
-                    else if (block.type === 'tool_result' && block.content) {
-                        total += this.estimateTokens(typeof block.content === 'string' ? block.content : JSON.stringify(block.content));
-                    }
-                    else {
-                        // Other content types (tool_use, etc.)
-                        total += this.estimateTokens(JSON.stringify(block));
-                    }
-                }
-            }
-            else if (message.content) {
-                // Fallback: stringify the content
-                total += this.estimateTokens(JSON.stringify(message.content));
-            }
-            // Add overhead for role and metadata (~10 tokens per message)
-            total += 10;
-        }
-        return total;
-    }
-    /**
-     * Count tokens for tools definitions
-     */
-    countToolsTokens(tools) {
-        if (!tools || tools.length === 0) {
-            return 0;
-        }
-        // Estimate tools definition size
-        const toolsText = JSON.stringify(tools);
-        return this.estimateTokens(toolsText);
-    }
-    /**
-     * Count total tokens for a complete prompt
-     */
-    countTokens(systemPrompt, messages, tools, provider) {
-        const limits = this.getTokenLimits(provider);
-        const systemPromptTokens = this.countSystemPromptTokens(systemPrompt);
-        const messagesTokens = this.countMessagesTokens(messages);
-        const toolsTokens = this.countToolsTokens(tools);
-        const totalTokens = systemPromptTokens + messagesTokens + toolsTokens;
-        const exceedsLimit = totalTokens > limits.safeTokens;
-        return {
-            totalTokens,
-            systemPromptTokens,
-            messagesTokens,
-            toolsTokens,
-            exceedsLimit,
-            provider,
-            limit: limits,
-        };
-    }
-    // ================================================================================
-    // MESSAGE SPLITTING
-    // ================================================================================
-    /**
-     * Split messages into logical groups based on tool call patterns
-     * Groups together: assistant message with tool_use -> tool results
-     */
-    splitIntoToolResultGroups(messages, provider) {
-        const groups = [];
-        let currentGroup = [];
-        let startIndex = 0;
-        for (let i = 0; i < messages.length; i++) {
-            const message = messages[i];
-            currentGroup.push(message);
-            // Check if this completes a tool call cycle
-            const isToolResult = provider === 'anthropic'
-                ? (Array.isArray(message.content) && message.content.some((c) => c.type === 'tool_result'))
-                : message.role === 'tool';
-            if (isToolResult) {
-                // End current group
-                const tokens = this.countMessagesTokens(currentGroup);
-                groups.push({
-                    messages: [...currentGroup],
-                    tokens,
-                    startIndex,
-                    endIndex: i,
-                });
-                currentGroup = [];
-                startIndex = i + 1;
-            }
-        }
-        // Add any remaining messages as final group
-        if (currentGroup.length > 0) {
-            const tokens = this.countMessagesTokens(currentGroup);
-            groups.push({
-                messages: currentGroup,
-                tokens,
-                startIndex,
-                endIndex: messages.length - 1,
-            });
-        }
-        return groups;
-    }
-    /**
-     * Split tool result groups into chunks that fit within safe limits
-     */
-    splitIntoChunks(groups, systemPromptTokens, userQueryTokens, provider) {
-        const limits = this.getTokenLimits(provider);
-        const baseTokens = systemPromptTokens + userQueryTokens + 1000; // +1000 for overhead and instructions
-        const availableTokens = limits.safeTokens - baseTokens;
-        const chunks = [];
-        let currentChunk = [];
-        let currentChunkTokens = 0;
-        for (const group of groups) {
-            if (currentChunkTokens + group.tokens > availableTokens && currentChunk.length > 0) {
-                // Current chunk is full, start new chunk
-                chunks.push([...currentChunk]);
-                currentChunk = [group];
-                currentChunkTokens = group.tokens;
-            }
-            else {
-                // Add to current chunk
-                currentChunk.push(group);
-                currentChunkTokens += group.tokens;
-            }
-        }
-        // Add final chunk
-        if (currentChunk.length > 0) {
-            chunks.push(currentChunk);
-        }
-        return chunks;
-    }
-    // ================================================================================
-    // SUMMARIZATION
-    // ================================================================================
-    /**
-     * Summarize a chunk of tool results using the LLM
-     */
-    async summarizeChunk(systemPrompt, userQuery, toolResultGroups, provider, chunkIndex, totalChunks) {
-        // Flatten groups into messages
-        const messages = toolResultGroups.flatMap(group => group.messages);
-        const summarizationInstruction = `You are analyzing tool call results to condense them while preserving all relevant information.
-
-Context: This is chunk ${chunkIndex + 1} of ${totalChunks} being processed.
-
-Instructions:
-1. Review the tool calls and their results below
-2. Extract and preserve ALL relevant information, data, and insights
-3. Remove redundant or unnecessary details
-4. Maintain the logical flow and relationships between data
-5. Keep important identifiers (IDs, names, dates, etc.)
-6. Provide a concise summary that captures everything important
-
-Output your condensed analysis focusing on the key information needed to answer the user's question.`;
-        try {
-            if (provider === 'anthropic') {
-                return await this.summarizeWithAnthropic(systemPrompt, userQuery, messages, summarizationInstruction);
-            }
-            else {
-                return await this.summarizeWithOpenAI(systemPrompt, userQuery, messages, summarizationInstruction);
-            }
-        }
-        catch (error) {
-            this.logger.error("Failed to summarize chunk", error, {
-                chunkIndex,
-                totalChunks,
-                provider,
-            });
-            // Fallback: return truncated messages
-            const fallback = messages
-                .map(m => JSON.stringify(m).substring(0, 1000))
-                .join('\n')
-                .substring(0, 10000);
-            return `[Summarization failed, showing truncated results]\n${fallback}`;
-        }
-    }
-    /**
-     * Summarize using Anthropic
-     */
-    async summarizeWithAnthropic(systemPrompt, userQuery, messages, instruction) {
-        if (!this.config.anthropicApiKey) {
-            throw new Error("Anthropic API key not configured");
-        }
-        const client = new sdk_1.default({ apiKey: this.config.anthropicApiKey });
-        // Build prompt for summarization
-        const summarizationMessages = [
-            {
-                role: "user",
-                content: userQuery,
-            },
-            ...messages,
-            {
-                role: "user",
-                content: instruction,
-            },
-        ];
-        const response = await client.messages.create({
-            model: "claude-sonnet-4-20250514",
-            max_tokens: 4000,
-            temperature: 0.3, // Lower temperature for more focused summarization
-            system: systemPrompt,
-            messages: summarizationMessages,
-        });
-        const text = response.content
-            .filter(content => content.type === "text")
-            .map(content => content.text)
-            .join("\n");
-        return text;
-    }
-    /**
-     * Summarize using OpenAI
-     */
-    async summarizeWithOpenAI(systemPrompt, userQuery, messages, instruction) {
-        if (!this.config.openaiApiKey) {
-            throw new Error("OpenAI API key not configured");
-        }
-        const client = new openai_1.default({ apiKey: this.config.openaiApiKey });
-        // Build prompt for summarization
-        const summarizationMessages = [
-            { role: "system", content: systemPrompt },
-            { role: "user", content: userQuery },
-            ...messages,
-            { role: "user", content: instruction },
-        ];
-        const response = await client.chat.completions.create({
-            model: "gpt-4o",
-            max_tokens: 4000,
-            temperature: 0.3,
-            messages: summarizationMessages,
-        });
-        return response.choices[0]?.message?.content || "[No summary generated]";
-    }
-    /**
-     * Main summarization orchestration
-     */
-    async summarizeContext(systemPrompt, messages, provider, userQuery) {
-        if (!this.config.enableAutoSummarization) {
-            throw new Error("Auto-summarization is disabled");
-        }
-        const startTime = Date.now();
-        this.logger.info("Starting context summarization", {
-            provider,
-            messageCount: messages.length,
-            originalTokens: this.countMessagesTokens(messages),
-        });
-        // Extract user query from first user message if not provided
-        if (!userQuery) {
-            const firstUserMessage = messages.find(m => m.role === 'user');
-            userQuery = firstUserMessage?.content || "Process the tool results";
-        }
-        const systemPromptTokens = this.countSystemPromptTokens(systemPrompt);
-        const userQueryTokens = this.estimateTokens(userQuery || "");
-        // Split messages into logical groups
-        const groups = this.splitIntoToolResultGroups(messages, provider);
-        this.logger.info("Split messages into tool result groups", {
-            groupCount: groups.length,
-            groups: groups.map(g => ({
-                messageCount: g.messages.length,
-                tokens: g.tokens,
-                range: `${g.startIndex}-${g.endIndex}`,
-            })),
-        });
-        // Split groups into chunks that fit within limits
-        const chunks = this.splitIntoChunks(groups, systemPromptTokens, userQueryTokens, provider);
-        if (chunks.length > this.config.maxSummarizationChunks) {
-            this.logger.warn("Too many chunks required", {
-                chunksNeeded: chunks.length,
-                maxAllowed: this.config.maxSummarizationChunks,
-            });
-            throw new Error(`Context too large: requires ${chunks.length} chunks but max is ${this.config.maxSummarizationChunks}`);
-        }
-        this.logger.info("Split groups into chunks for summarization", {
-            chunkCount: chunks.length,
-            chunks: chunks.map((chunk, i) => ({
-                index: i,
-                groupCount: chunk.length,
-                tokens: chunk.reduce((sum, g) => sum + g.tokens, 0),
-            })),
-        });
-        // Summarize chunks in parallel
-        const summarizationPromises = chunks.map((chunk, index) => this.summarizeChunk(systemPrompt, userQuery, chunk, provider, index, chunks.length));
-        const summaries = await Promise.all(summarizationPromises);
-        // Build summarized messages
-        const summarizedMessages = summaries.map((summary, index) => {
-            if (provider === 'anthropic') {
-                return {
-                    role: "user",
-                    content: `[Summarized tool results ${index + 1}/${summaries.length}]\n${summary}`,
-                };
-            }
-            else {
-                return {
-                    role: "assistant",
-                    content: `[Summarized tool results ${index + 1}/${summaries.length}]\n${summary}`,
-                };
-            }
-        });
-        const originalTokens = this.countMessagesTokens(messages);
-        const summarizedTokens = this.countMessagesTokens(summarizedMessages);
-        const reductionPercent = Math.round(((originalTokens - summarizedTokens) / originalTokens) * 100);
-        const duration = Date.now() - startTime;
-        this.logger.info("Context summarization complete", {
-            duration,
-            chunksProcessed: chunks.length,
-            originalTokens,
-            summarizedTokens,
-            reductionPercent: `${reductionPercent}%`,
-            originalMessages: messages.length,
-            summarizedMessages: summarizedMessages.length,
-        });
-        return {
-            summarizedMessages,
-            originalTokens,
-            summarizedTokens,
-            chunksProcessed: chunks.length,
-            reductionPercent,
-        };
-    }
-    // ================================================================================
-    // HELPER METHODS
-    // ================================================================================
-    /**
-     * Check if token count exceeds safe limit
-     */
-    exceedsLimit(tokenCount, provider) {
-        const limits = this.getTokenLimits(provider);
-        return tokenCount > limits.safeTokens;
-    }
-    /**
-     * Get warning threshold (80% of safe limit)
-     */
-    approachingLimit(tokenCount, provider) {
-        const limits = this.getTokenLimits(provider);
-        return tokenCount > limits.safeTokens * 0.8;
-    }
-    /**
-     * Get provider limits info
-     */
-    getProviderLimits(provider) {
-        return this.getTokenLimits(provider);
-    }
-}
-exports.ContextManager = ContextManager;
-// ================================================================================
-// EXPORTS
-// ================================================================================
-// Export singleton instance
-let contextManagerInstance = null;
-function getContextManager(config) {
-    if (!contextManagerInstance) {
-        contextManagerInstance = new ContextManager(config);
-    }
-    return contextManagerInstance;
-}
-//# sourceMappingURL=context-manager.js.map

package/dist/lib/prompt-length-manager.d.ts

@@ -1,81 +0,0 @@
-/**
- * Prompt Length Manager
- * Handles prompt length validation, truncation, and debugging
- */
-export interface PromptComponent {
-    type: 'system' | 'user' | 'assistant' | 'tool_result' | 'tool_call';
-    content: string;
-    source?: string;
-    originalLength?: number;
-    truncated?: boolean;
-    originalContent?: string;
-    truncatedAt?: number;
-    truncationReason?: string;
-}
-export interface PromptAnalysis {
-    totalCharacters: number;
-    estimatedTokens: number;
-    components: PromptComponent[];
-    truncationApplied: boolean;
-    warnings: string[];
-}
-export interface TruncationConfig {
-    maxTotalTokens: number;
-    maxUserMessagesTokens: number;
-    maxTotalCharacters: number;
-    maxUserMessagesCharacters: number;
-    anthropicContextWindow: number;
-    openaiContextWindow: number;
-    preserveSystemPrompt: boolean;
-    preserveUserMessages: boolean;
-    preserveAssistantResponses: boolean;
-    truncateToolResponsesFirst: boolean;
-}
-export declare const DEFAULT_TRUNCATION_CONFIG: TruncationConfig;
-export declare class PromptLengthManager {
-    private logger;
-    private config;
-    constructor(config?: Partial<TruncationConfig>);
-    /**
-     * Estimate token count from character count
-     * Rough approximation: 1 token ≈ 4 characters for English text
-     */
-    private estimateTokens;
-    /**
-     * Count exact characters and estimate tokens for a text
-     */
-    private analyzeText;
-    /**
-     * Truncate text intelligently, preserving structure when possible
-     */
-    private truncateText;
-    /**
-     * Analyze prompt components and build analysis
-     */
-    analyzePrompt(components: PromptComponent[]): PromptAnalysis;
-    /**
-     * No longer truncate individual tool responses - only when total prompt exceeds limits
-     * This method now just passes through content unchanged and logs for monitoring
-     * TEMPORARILY DISABLED - Even monitoring/logging is disabled
-     */
-    truncateToolResponse(content: string, toolName: string): string;
-    /**
-     * Apply smart token-based truncation optimized for Claude 4
-     * TEMPORARILY DISABLED - All truncation logic commented out for testing
-     */
-    truncatePrompt(analysis: PromptAnalysis): PromptAnalysis;
-    /**
-     * Check if a provider-specific error indicates prompt too long
-     */
-    isPromptTooLongError(error: Error, provider: 'anthropic' | 'openai'): boolean;
-    /**
-     * Log comprehensive debug information about prompt structure
-     */
-    logPromptDebugInfo(analysis: PromptAnalysis, provider: string, botId?: string): void;
-    /**
-     * Generate a quick truncation summary for debugging
-     */
-    generateTruncationSummary(analysis: PromptAnalysis): string;
-}
-export declare const promptLengthManager: PromptLengthManager;
-//# sourceMappingURL=prompt-length-manager.d.ts.map