@hailer/mcp 0.0.1

package/dist/lib/prompt-length-manager.js

@@ -0,0 +1,457 @@
+"use strict";
+/**
+ * Prompt Length Manager
+ * Handles prompt length validation, truncation, and debugging
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptLengthManager = exports.PromptLengthManager = exports.DEFAULT_TRUNCATION_CONFIG = void 0;
+const logger_1 = require("./logger");
+exports.DEFAULT_TRUNCATION_CONFIG = {
+    // Claude 4 optimized limits (leaving room for response)
+    maxTotalTokens: 150_000, // 150k tokens for Claude 4 
+    maxUserMessagesTokens: 20_000, // 20k tokens for user messages
+    // Character limits (fallback: 1 token ≈ 4 characters)
+    maxTotalCharacters: 600_000, // ~150k tokens
+    maxUserMessagesCharacters: 80_000, // ~20k tokens
+    // Provider context windows (in tokens)
+    anthropicContextWindow: 200_000, // Claude Sonnet 4
+    openaiContextWindow: 128_000, // GPT-4 Turbo
+    // New smart truncation strategy
+    preserveSystemPrompt: true, // Never truncate system prompts
+    preserveUserMessages: true, // Preserve up to 20k tokens
+    preserveAssistantResponses: true, // Preserve when possible
+    truncateToolResponsesFirst: true, // Tool responses are most expendable
+};
+class PromptLengthManager {
+    logger;
+    config;
+    constructor(config = {}) {
+        this.config = { ...exports.DEFAULT_TRUNCATION_CONFIG, ...config };
+        this.logger = (0, logger_1.createLogger)({ component: "PromptLengthManager" });
+    }
+    /**
+     * Estimate token count from character count
+     * Rough approximation: 1 token ≈ 4 characters for English text
+     */
+    estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+    }
+    /**
+     * Count exact characters and estimate tokens for a text
+     */
+    analyzeText(text) {
+        const characters = text.length;
+        const estimatedTokens = this.estimateTokens(text);
+        return { characters, estimatedTokens };
+    }
+    /**
+     * Truncate text intelligently, preserving structure when possible
+     */
+    truncateText(text, maxLength, source) {
+        if (text.length <= maxLength) {
+            return { text, truncated: false };
+        }
+        // Try to truncate at natural boundaries (paragraphs, sentences)
+        const truncated = text.substring(0, maxLength);
+        // Find last complete sentence or paragraph
+        const lastParagraph = truncated.lastIndexOf('\n\n');
+        const lastSentence = truncated.lastIndexOf('. ');
+        let cutPoint = maxLength;
+        let truncationMethod = 'hard_cutoff';
+        if (lastParagraph > maxLength * 0.7) {
+            cutPoint = lastParagraph;
+            truncationMethod = 'paragraph_boundary';
+        }
+        else if (lastSentence > maxLength * 0.8) {
+            cutPoint = lastSentence + 1;
+            truncationMethod = 'sentence_boundary';
+        }
+        const finalText = text.substring(0, cutPoint) + '\n\n[... Content truncated ...]';
+        const removedContent = text.substring(cutPoint);
+        this.logger.warn(`Truncated ${source}`, {
+            originalLength: text.length,
+            truncatedLength: finalText.length,
+            truncatedAt: cutPoint,
+            truncationMethod,
+            removedCharacters: removedContent.length,
+            reductionPercent: Math.round((1 - finalText.length / text.length) * 100),
+            source,
+            removedContentPreview: removedContent.substring(0, 200) + (removedContent.length > 200 ? '...' : ''),
+            originalContentPreview: text.substring(0, 200) + (text.length > 200 ? '...' : '')
+        });
+        return {
+            text: finalText,
+            truncated: true,
+            truncatedAt: cutPoint,
+            truncationMethod,
+            originalContent: text
+        };
+    }
+    /**
+     * Analyze prompt components and build analysis
+     */
+    analyzePrompt(components) {
+        let totalCharacters = 0;
+        let totalTokens = 0;
+        const warnings = [];
+        const processedComponents = [];
+        for (const component of components) {
+            const analysis = this.analyzeText(component.content);
+            totalCharacters += analysis.characters;
+            totalTokens += analysis.estimatedTokens;
+            processedComponents.push({
+                ...component,
+                originalLength: analysis.characters,
+            });
+            // TRUNCATION WARNINGS TEMPORARILY DISABLED FOR TESTING
+            /* COMMENTED OUT - RE-ENABLE BY UNCOMMENTING THIS BLOCK
+            // Check component token limits under new system
+            const componentTokens = this.estimateTokens(component.content);
+            
+            if (component.type === 'user' && componentTokens > this.config.maxUserMessagesTokens) {
+              warnings.push(`User message (${componentTokens} tokens) exceeds user message limit (${this.config.maxUserMessagesTokens} tokens)`);
+            }
+            
+            // Note: No individual limits for system prompts or tool responses under new logic
+            */ // END OF COMMENTED OUT WARNING LOGIC
+        }
+        // TOTAL TOKEN LIMIT WARNINGS TEMPORARILY DISABLED FOR TESTING
+        /* COMMENTED OUT - RE-ENABLE BY UNCOMMENTING THIS BLOCK
+        // Check total token limits (primary check under new system)
+        if (totalTokens > this.config.maxTotalTokens) {
+          warnings.push(`Total prompt (${totalTokens} tokens) exceeds Claude 4 limit (${this.config.maxTotalTokens} tokens)`);
+        }
+        */ // END OF COMMENTED OUT WARNING LOGIC
+        return {
+            totalCharacters,
+            estimatedTokens: totalTokens,
+            components: processedComponents,
+            truncationApplied: false,
+            warnings,
+        };
+    }
+    /**
+     * 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, toolName) {
+        // TRUNCATION AND MONITORING TEMPORARILY DISABLED FOR TESTING
+        return content; // Pass through unchanged with no logging
+        /* COMMENTED OUT - RE-ENABLE BY UNCOMMENTING THIS BLOCK
+        this.logger.debug(`Tool response processed (no individual limits)`, {
+          toolName,
+          length: content.length,
+          estimatedTokens: this.estimateTokens(content),
+          note: "Individual tool limits removed - truncation only happens at total prompt level"
+        });
+    
+        return content; // Pass through unchanged
+        */ // END OF COMMENTED OUT MONITORING LOGIC
+    }
+    /**
+     * Apply smart token-based truncation optimized for Claude 4
+     * TEMPORARILY DISABLED - All truncation logic commented out for testing
+     */
+    truncatePrompt(analysis) {
+        // TRUNCATION TEMPORARILY DISABLED FOR TESTING
+        this.logger.info("Truncation is temporarily disabled - returning prompt unchanged", {
+            originalTokens: analysis.estimatedTokens,
+            originalChars: analysis.totalCharacters,
+            tokenLimit: this.config.maxTotalTokens,
+            status: "DISABLED"
+        });
+        return analysis;
+        /* COMMENTED OUT - RE-ENABLE BY UNCOMMENTING THIS BLOCK
+        if (analysis.estimatedTokens <= this.config.maxTotalTokens) {
+          return analysis; // No truncation needed
+        }
+    
+        const targetTokenReduction = analysis.estimatedTokens - this.config.maxTotalTokens;
+        
+        this.logger.warn("Applying Claude 4 optimized prompt truncation", {
+          originalTokens: analysis.estimatedTokens,
+          originalChars: analysis.totalCharacters,
+          tokenLimit: this.config.maxTotalTokens,
+          targetTokenReduction,
+          truncationStrategy: "claude_4_smart_preservation"
+        });
+    
+        // Track unknown component types for debugging
+        const knownTypes = new Set(['system', 'user', 'assistant', 'tool_result', 'tool_call']);
+        const unknownComponents = analysis.components.filter(c => !knownTypes.has(c.type));
+        if (unknownComponents.length > 0) {
+          this.logger.info("Unknown prompt component types detected", {
+            unknownTypes: unknownComponents.map(c => ({ type: c.type, source: c.source, length: c.content.length })),
+            count: unknownComponents.length
+          });
+        }
+    
+        // Separate components by type for smart preservation
+        const systemComponents = analysis.components.filter(c => c.type === 'system');
+        const userComponents = analysis.components.filter(c => c.type === 'user');
+        const assistantComponents = analysis.components.filter(c => c.type === 'assistant' || c.type === 'tool_call');
+        const toolComponents = analysis.components.filter(c => c.type === 'tool_result');
+        const otherComponents = analysis.components.filter(c => !knownTypes.has(c.type));
+    
+        // Calculate current token usage by component type
+        const systemTokens = systemComponents.reduce((sum, c) => sum + this.estimateTokens(c.content), 0);
+        const userTokens = userComponents.reduce((sum, c) => sum + this.estimateTokens(c.content), 0);
+        const assistantTokens = assistantComponents.reduce((sum, c) => sum + this.estimateTokens(c.content), 0);
+        const toolTokens = toolComponents.reduce((sum, c) => sum + this.estimateTokens(c.content), 0);
+        const otherTokens = otherComponents.reduce((sum, c) => sum + this.estimateTokens(c.content), 0);
+    
+        this.logger.info("Component token breakdown", {
+          system: `${systemTokens} tokens (${systemComponents.length} components) - PRESERVED`,
+          user: `${userTokens} tokens (${userComponents.length} components) - PRESERVE UP TO 20k`,
+          assistant: `${assistantTokens} tokens (${assistantComponents.length} components) - PRESERVE WHEN POSSIBLE`,
+          tool_result: `${toolTokens} tokens (${toolComponents.length} components) - TRUNCATE FIRST`,
+          other: `${otherTokens} tokens (${otherComponents.length} components) - UNKNOWN TYPE`
+        });
+    
+        const truncatedComponents: PromptComponent[] = [];
+        let tokensUsed = 0;
+        let tokensReduced = 0;
+    
+        // Step 1: Always preserve system prompts (100%)
+        systemComponents.forEach(component => {
+          truncatedComponents.push({ ...component });
+          tokensUsed += this.estimateTokens(component.content);
+        });
+    
+        // Step 2: Preserve user messages up to 20k tokens
+        let userTokensUsed = 0;
+        userComponents.forEach(component => {
+          const componentTokens = this.estimateTokens(component.content);
+          if (userTokensUsed + componentTokens <= this.config.maxUserMessagesTokens) {
+            // Keep this user message fully
+            truncatedComponents.push({ ...component });
+            tokensUsed += componentTokens;
+            userTokensUsed += componentTokens;
+          } else if (userTokensUsed < this.config.maxUserMessagesTokens) {
+            // Partial truncation to fit within user message limit
+            const allowedTokens = this.config.maxUserMessagesTokens - userTokensUsed;
+            const allowedChars = Math.floor(allowedTokens * 4); // Approximate conversion
+            
+            const result = this.truncateText(component.content, allowedChars, component.source || 'user_message');
+            truncatedComponents.push({
+              ...component,
+              content: result.text,
+              truncated: result.truncated,
+              originalContent: result.originalContent,
+              truncatedAt: result.truncatedAt,
+              truncationReason: `User message truncated to fit within ${this.config.maxUserMessagesTokens} token limit for user messages`
+            });
+            
+            const actualTokens = this.estimateTokens(result.text);
+            tokensUsed += actualTokens;
+            userTokensUsed += actualTokens;
+            tokensReduced += componentTokens - actualTokens;
+            
+            if (result.truncated) {
+              this.logger.warn("User message truncated to fit limit", {
+                componentSource: component.source,
+                originalTokens: componentTokens,
+                truncatedTokens: actualTokens,
+                userTokenLimit: this.config.maxUserMessagesTokens
+              });
+            }
+          }
+          // Skip user messages that don't fit in the 20k limit
+        });
+    
+        // Step 3: Add assistant responses if we have room
+        assistantComponents.forEach(component => {
+          const componentTokens = this.estimateTokens(component.content);
+          if (tokensUsed + componentTokens <= this.config.maxTotalTokens - targetTokenReduction) {
+            truncatedComponents.push({ ...component });
+            tokensUsed += componentTokens;
+          }
+          // Skip assistant messages if no room
+        });
+    
+        // Step 4: Add tool responses with truncation if needed
+        const remainingTokenBudget = this.config.maxTotalTokens - tokensUsed;
+        let toolBudgetUsed = 0;
+    
+        toolComponents.forEach(component => {
+          const componentTokens = this.estimateTokens(component.content);
+          
+          if (toolBudgetUsed + componentTokens <= remainingTokenBudget) {
+            // Tool response fits fully
+            truncatedComponents.push({ ...component });
+            tokensUsed += componentTokens;
+            toolBudgetUsed += componentTokens;
+          } else if (toolBudgetUsed < remainingTokenBudget) {
+            // Partial truncation of tool response
+            const allowedTokens = remainingTokenBudget - toolBudgetUsed;
+            const allowedChars = Math.floor(allowedTokens * 4);
+            
+            const result = this.truncateText(component.content, allowedChars, component.source || 'tool_result');
+            truncatedComponents.push({
+              ...component,
+              content: result.text,
+              truncated: result.truncated,
+              originalContent: result.originalContent,
+              truncatedAt: result.truncatedAt,
+              truncationReason: `Tool response truncated to fit within ${this.config.maxTotalTokens} token total limit`
+            });
+            
+            const actualTokens = this.estimateTokens(result.text);
+            tokensUsed += actualTokens;
+            toolBudgetUsed += actualTokens;
+            tokensReduced += componentTokens - actualTokens;
+            
+            if (result.truncated) {
+              this.logger.warn("Tool response truncated", {
+                toolSource: component.source,
+                originalTokens: componentTokens,
+                truncatedTokens: actualTokens,
+                originalLength: component.content.length,
+                truncatedLength: result.text.length,
+                truncationMethod: result.truncationMethod,
+                truncatedAt: result.truncatedAt
+              });
+            }
+          }
+          // Skip tool responses that don't fit
+        });
+    
+        // Step 5: Handle unknown component types
+        otherComponents.forEach(component => {
+          this.logger.warn("Unknown component type in prompt", {
+            type: component.type,
+            source: component.source,
+            length: component.content.length,
+            tokens: this.estimateTokens(component.content),
+            note: "Added to debug page for analysis"
+          });
+          
+          // Add to debug but don't include in prompt for now
+          truncatedComponents.push({
+            ...component,
+            truncationReason: `Unknown component type '${component.type}' - review on debug page`
+          });
+        });
+    
+        const finalTokens = this.estimateTokens(truncatedComponents.map(c => c.content).join(''));
+        
+        return {
+          totalCharacters: truncatedComponents.reduce((sum, c) => sum + c.content.length, 0),
+          estimatedTokens: finalTokens,
+          components: truncatedComponents,
+          truncationApplied: tokensReduced > 0,
+          warnings: [
+            ...analysis.warnings,
+            `Applied Claude 4 smart truncation: reduced by ${tokensReduced} tokens (${Math.round(tokensReduced / analysis.estimatedTokens * 100)}%)`,
+            `Preservation strategy: System (100%) → User (up to 20k tokens) → Assistant → Tools`,
+            `Final prompt: ${finalTokens.toLocaleString()} tokens (limit: ${this.config.maxTotalTokens.toLocaleString()})`
+          ],
+        };
+        */ // END OF COMMENTED OUT TRUNCATION LOGIC
+    }
+    /**
+     * Check if a provider-specific error indicates prompt too long
+     */
+    isPromptTooLongError(error, provider) {
+        const errorMessage = error.message.toLowerCase();
+        if (provider === 'anthropic') {
+            return errorMessage.includes('prompt too long') ||
+                errorMessage.includes('maximum context length') ||
+                errorMessage.includes('context_length_exceeded') ||
+                errorMessage.includes('token limit exceeded');
+        }
+        if (provider === 'openai') {
+            return errorMessage.includes('maximum context length') ||
+                errorMessage.includes('context_length_exceeded') ||
+                errorMessage.includes('token limit exceeded') ||
+                errorMessage.includes('reduce the length');
+        }
+        return false;
+    }
+    /**
+     * Log comprehensive debug information about prompt structure
+     */
+    logPromptDebugInfo(analysis, provider, botId) {
+        const debugData = {
+            provider,
+            botId,
+            summary: {
+                totalCharacters: analysis.totalCharacters,
+                estimatedTokens: analysis.estimatedTokens,
+                componentCount: analysis.components.length,
+                truncationApplied: analysis.truncationApplied,
+                warningCount: analysis.warnings.length,
+            },
+            breakdown: analysis.components.map(comp => ({
+                type: comp.type,
+                source: comp.source,
+                currentLength: comp.content.length,
+                originalLength: comp.originalLength || comp.content.length,
+                truncated: comp.truncated,
+                reductionPercent: comp.originalLength ?
+                    Math.round((1 - comp.content.length / comp.originalLength) * 100) : 0,
+                estimatedTokens: this.estimateTokens(comp.content),
+                // First 100 chars as preview (for debugging)
+                preview: comp.content.substring(0, 100) + (comp.content.length > 100 ? '...' : ''),
+            })),
+            warnings: analysis.warnings,
+        };
+        this.logger.info("Prompt debug analysis", debugData);
+        // Enhanced truncation logging
+        const truncatedComponents = analysis.components.filter(c => c.truncated);
+        if (truncatedComponents.length > 0) {
+            this.logger.warn("Component truncation summary", {
+                truncatedCount: truncatedComponents.length,
+                totalComponents: analysis.components.length,
+                truncations: truncatedComponents.map(comp => ({
+                    type: comp.type,
+                    source: comp.source,
+                    originalChars: comp.originalLength,
+                    truncatedChars: comp.content.length,
+                    savedChars: (comp.originalLength || comp.content.length) - comp.content.length,
+                    reductionPercent: comp.originalLength ?
+                        Math.round((1 - comp.content.length / comp.originalLength) * 100) : 0,
+                }))
+            });
+        }
+        // Log full prompt to separate file if it was truncated or has warnings
+        if (analysis.truncationApplied || analysis.warnings.length > 0) {
+            this.logger.warn("Prompt required attention", {
+                reason: analysis.truncationApplied ? 'truncation' : 'warnings',
+                fullPrompt: analysis.components.map(c => `=== ${c.type.toUpperCase()} (${c.source || 'unknown'}) ===\n${c.content}`).join('\n\n'),
+            });
+        }
+    }
+    /**
+     * Generate a quick truncation summary for debugging
+     */
+    generateTruncationSummary(analysis) {
+        const totalOriginal = analysis.components.reduce((sum, comp) => sum + (comp.originalLength || comp.content.length), 0);
+        const totalCurrent = analysis.totalCharacters;
+        const totalSaved = totalOriginal - totalCurrent;
+        const overallReduction = totalOriginal > 0 ? Math.round((totalSaved / totalOriginal) * 100) : 0;
+        const truncatedComponents = analysis.components.filter(c => c.truncated);
+        let summary = `Prompt Summary: ${totalCurrent.toLocaleString()} chars (${analysis.estimatedTokens.toLocaleString()} tokens)`;
+        if (totalSaved > 0) {
+            summary += `\nTruncation Applied: Saved ${totalSaved.toLocaleString()} chars (${overallReduction}% reduction)`;
+            summary += `\nTruncated Components: ${truncatedComponents.length}/${analysis.components.length}`;
+            if (truncatedComponents.length > 0) {
+                summary += `\nBreakdown:`;
+                truncatedComponents.forEach(comp => {
+                    const saved = (comp.originalLength || comp.content.length) - comp.content.length;
+                    const percent = comp.originalLength ? Math.round((saved / comp.originalLength) * 100) : 0;
+                    summary += `\n  - ${comp.type} (${comp.source}): ${saved.toLocaleString()} chars saved (${percent}%)`;
+                });
+            }
+        }
+        else {
+            summary += `\nNo truncation applied`;
+        }
+        return summary;
+    }
+}
+exports.PromptLengthManager = PromptLengthManager;
+// Export a default instance
+exports.promptLengthManager = new PromptLengthManager();
+//# sourceMappingURL=prompt-length-manager.js.map

package/dist/lib/terminal-prompt.d.ts

@@ -0,0 +1,9 @@
+export interface TerminalPrompts {
+    email: string;
+    password: string;
+}
+/**
+ * Prompts user for email and password in terminal
+ */
+export declare function promptForCredentials(): Promise<TerminalPrompts>;
+//# sourceMappingURL=terminal-prompt.d.ts.map

package/dist/lib/terminal-prompt.js

@@ -0,0 +1,108 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptForCredentials = promptForCredentials;
+const readline = __importStar(require("readline"));
+const logger_1 = require("./logger");
+const logger = (0, logger_1.createLogger)({ component: 'terminal-prompt' });
+/**
+ * Prompts user for email and password in terminal
+ */
+function promptForCredentials() {
+    return new Promise((resolve, reject) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        logger.info('Prompting for Hailer credentials in Claude Code mode');
+        console.log(`\n🔐 Please enter bot's or your own Hailer credentials. The Claude Code will use the account to access production data on Hailer.`);
+        rl.question('Email: ', (email) => {
+            if (!email.trim()) {
+                logger.error('Email validation failed: empty email provided');
+                console.log('❌ Email cannot be empty');
+                rl.close();
+                reject(new Error('Email cannot be empty'));
+                return;
+            }
+            // Use a simple approach - just hide the password completely during input
+            rl.close();
+            process.stdout.write('Password: ');
+            // Disable echo temporarily
+            if (process.stdin.setRawMode) {
+                process.stdin.setRawMode(true);
+            }
+            process.stdin.resume();
+            process.stdin.setEncoding('utf8');
+            let password = '';
+            const cleanup = () => {
+                if (process.stdin.setRawMode) {
+                    process.stdin.setRawMode(false);
+                }
+                process.stdin.pause();
+            };
+            process.stdin.on('data', function onData(char) {
+                const byte = char.charCodeAt(0);
+                if (byte === 3) { // Ctrl-C
+                    cleanup();
+                    process.stdin.removeListener('data', onData);
+                    reject(new Error('Password input cancelled'));
+                    return;
+                }
+                if (byte === 13 || byte === 10) { // Enter
+                    cleanup();
+                    process.stdin.removeListener('data', onData);
+                    resolve({
+                        email: email.trim(),
+                        password: password.trim()
+                    });
+                    return;
+                }
+                if (byte === 127 || byte === 8) { // Backspace
+                    if (password.length > 0) {
+                        password = password.slice(0, -1);
+                        process.stdout.write('\b \b'); // Move back, write space, move back again
+                    }
+                    return;
+                }
+                // Add character to password and show asterisk
+                if (byte >= 32) {
+                    password += char;
+                    process.stdout.write('*');
+                }
+            });
+        });
+    });
+}
+//# sourceMappingURL=terminal-prompt.js.map

package/dist/mcp/UserContextCache.d.ts

@@ -0,0 +1,56 @@
+import { HailerClient } from './hailer-clients';
+import { WorkspaceCache } from './workspace-cache';
+import { HailerV2CoreInitResponse, HailerApiClient } from './utils/index';
+export interface UserContext {
+    client: HailerClient;
+    hailer: HailerApiClient;
+    init: HailerV2CoreInitResponse;
+    workspaceCache: WorkspaceCache;
+    apiKey: string;
+    createdAt: number;
+}
+/**
+ * Cache for user-specific data (client connections, init data, workspace cache)
+ *
+ * Replaces per-user ClassBasedToolManager instances with efficient caching:
+ * - Reuses shared connection pool from hailer-clients.ts
+ * - Caches user-specific data (init, workspaceCache) separately from tool logic
+ * - Used by both MCP Server and Client for consistent user context
+ */
+export declare class UserContextCache {
+    private static cache;
+    /** Life of each cache unit. */
+    private static readonly DEFAULT_TTL_MS;
+    /**
+     * Get or create user context (client, init, workspaceCache) for an API key
+     * This data is user-specific and should be cached per user
+     *
+     * @param apiKey - Hailer API key for authentication
+     * @param forceRefresh - If true, bypasses cache and creates fresh context (useful for testing or after permission changes)
+     * @param ttlMs - Custom TTL in milliseconds, defaults to 15 minutes
+     */
+    static getContext(apiKey: string, forceRefresh?: boolean, ttlMs?: number): Promise<UserContext>;
+    /**
+     * Clear cache entry for specific API key (for cleanup/testing)
+     */
+    static clearContext(apiKey: string): void;
+    /**
+     * Clear all cached contexts (for cleanup/testing)
+     */
+    static clearAll(): void;
+    /**
+     * Get cache statistics (for monitoring and debugging)
+     *
+     * @returns Cache stats including size, API keys, and age information
+     */
+    static getCacheStats(): {
+        size: number;
+        apiKeys: string[];
+        entries: Array<{
+            apiKey: string;
+            ageMinutes: number;
+            isExpired: boolean;
+        }>;
+    };
+}
+//# sourceMappingURL=UserContextCache.d.ts.map