@hailer/mcp 0.0.1

package/dist/lib/context-manager.js

@@ -0,0 +1,431 @@
+"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/logger.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Unified Logger for Hailer MCP Server
+ * Based on backend logger pattern
+ * - Production: OpenTelemetry to Victoria Logs
+ * - Development: Console output only
+ * - Proper dependency injection pattern
+ */
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+export interface LogContext {
+    operation?: string;
+    endpoint?: string;
+    activityId?: string;
+    workflowId?: string;
+    discussionId?: string;
+    userId?: string;
+    duration?: number;
+    provider?: string;
+    toolName?: string;
+    requestId?: string;
+    botId?: string;
+    workspaceId?: string;
+    component?: string;
+    [key: string]: any;
+}
+export declare enum LogTag {
+    SYSTEM = "system",
+    API_CALL = "api_call",
+    TOOL_CALL = "tool_call",
+    MCP_ACTIVITY = "mcp_activity",
+    AUTH = "auth",
+    WEBSOCKET = "websocket",
+    ERROR = "error"
+}
+export declare class Logger {
+    private otelLogger?;
+    private level;
+    private context;
+    private isProduction;
+    constructor(context?: LogContext, level?: LogLevel);
+    private initializeOtelLogger;
+    private shouldLog;
+    private generateRequestId;
+    private logToOtel;
+    private log;
+    private getEmoji;
+    debug(message: string, context?: LogContext, tag?: LogTag): void;
+    info(message: string, context?: LogContext, tag?: LogTag): void;
+    warn(message: string, context?: LogContext, tag?: LogTag): void;
+    error(message: string, error?: Error | unknown, context?: LogContext, tag?: LogTag): void;
+    apiCall(operation: string, endpoint: string, params?: any, context?: LogContext): void;
+    apiSuccess(operation: string, endpoint: string, duration?: number, context?: LogContext): void;
+    apiError(operation: string, endpoint: string, error: Error | unknown, duration?: number, context?: LogContext): void;
+    toolCall(toolName: string, provider: string, args?: any, context?: LogContext): void;
+    toolSuccess(toolName: string, provider: string, duration?: number, context?: LogContext): void;
+    toolError(toolName: string, provider: string, error: Error | unknown, duration?: number, context?: LogContext): void;
+    mcpActivity(activity: string, context?: LogContext): void;
+    socketFallback(operation: string, reason: string, context?: LogContext): void;
+    auth(message: string, context?: LogContext): void;
+    authError(message: string, error?: Error | unknown, context?: LogContext): void;
+    child(additionalContext: LogContext): Logger;
+    setLevel(level: LogLevel): void;
+}
+/**
+ * Logger factory function - replaces the old singleton pattern
+ * Use this to create loggers with specific context
+ */
+export declare function createLogger(context?: LogContext): Logger;
+export declare function getDefaultLogger(): Logger;
+//# sourceMappingURL=logger.d.ts.map