@hailer/mcp 0.0.1

package/dist/client/providers/anthropic-provider.js

@@ -0,0 +1,631 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicProvider = void 0;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const llm_provider_1 = require("./llm-provider");
+const context_manager_1 = require("../../lib/context-manager");
+const token_pricing_1 = require("../token-pricing");
+const tool_registry_1 = require("../../mcp/tool-registry");
+const tool_schema_loader_1 = require("../tool-schema-loader");
+const tool_executor_1 = require("../tool-executor");
+class AnthropicProvider extends llm_provider_1.LlmProvider {
+    client;
+    contextManager;
+    toolSchemaLoader = new tool_schema_loader_1.ToolSchemaLoader();
+    toolExecutor = new tool_executor_1.ToolExecutor();
+    // Deprecated - kept for backwards compatibility during migration
+    toolSchemaCache = new Map();
+    constructor(config) {
+        super(config);
+        this.client = new sdk_1.default({
+            apiKey: config.apiKey,
+        });
+        this.contextManager = (0, context_manager_1.getContextManager)({
+            anthropicApiKey: config.apiKey,
+            safetyMarginPercent: 25,
+            enableAutoSummarization: true,
+            maxSummarizationChunks: 10,
+        });
+    }
+    async generateConfirmationMessage(userMessage) {
+        if (!this.isEnabled()) {
+            return `🤖 Processing your request with ${this.name}...`;
+        }
+        try {
+            const confirmationPrompt = this.getConfirmationPrompt(userMessage);
+            const response = await this.client.messages.create({
+                model: this.config.model || "claude-sonnet-4-20250514",
+                max_tokens: 100,
+                temperature: 0.7,
+                messages: [
+                    {
+                        role: "user",
+                        content: confirmationPrompt,
+                    },
+                ],
+            });
+            const confirmationText = response.content
+                .filter((content) => content.type === "text")
+                .map((content) => content.text)
+                .join("\n")
+                .trim() ||
+                `🤖 Processing your request with ${this.name}...`;
+            return confirmationText;
+        }
+        catch (error) {
+            this.logError(error, "generateConfirmationMessage");
+            return `🤖 Processing your request with ${this.name}...`;
+        }
+    }
+    async processMessage(userMessage, mcpServerUrl, botMcpApiKey, botEmail) {
+        if (!this.isEnabled()) {
+            this.logger.error("Anthropic provider is not enabled or missing API key");
+            return {
+                success: false,
+                error: "Anthropic provider is not enabled or missing API key",
+            };
+        }
+        try {
+            const systemPrompt = await this.createSystemPrompt({
+                userMessage,
+                mcpServerUrl,
+                mcpServerApiKey: botMcpApiKey,
+                botEmail,
+            });
+            const startTime = Date.now();
+            // Load lightweight tool index with automatic filtering
+            // Chat bot only gets READ + WRITE tools (no PLAYGROUND tools)
+            const allowedGroups = [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE];
+            const toolIndex = await this.toolSchemaLoader.loadToolIndex({
+                mcpServerUrl,
+                mcpServerApiKey: botMcpApiKey,
+                allowedGroups
+            });
+            // Convert to minimal tool stubs (full schemas loaded on-demand)
+            const minimalTools = this.toolSchemaLoader.toMinimalToolDefinitions(toolIndex);
+            // Track which tools have been loaded with full schemas
+            const loadedToolSchemas = new Map();
+            this.logger.info("Connected to MCP server (on-demand mode)", {
+                toolsForChatBot: toolIndex.length,
+                allowedGroups: allowedGroups.join(', '),
+                initialTokensSaved: "~28,000 tokens (95% reduction)"
+            });
+            // Initial prompt is simple and unlikely to need truncation, let Claude 4 handle it
+            const finalSystemPrompt = systemPrompt;
+            const finalUserContent = this.removeMentions(userMessage);
+            // Check token count before initial API call (with minimal tools)
+            const initialMessages = [{ role: "user", content: finalUserContent }];
+            const initialTokenCount = this.contextManager.countTokens(finalSystemPrompt, initialMessages, minimalTools, 'anthropic');
+            this.logger.info("Initial prompt token count (on-demand mode)", {
+                totalTokens: initialTokenCount.totalTokens,
+                systemPromptTokens: initialTokenCount.systemPromptTokens,
+                messagesTokens: initialTokenCount.messagesTokens,
+                toolsTokens: initialTokenCount.toolsTokens,
+                safeLimit: initialTokenCount.limit.safeTokens,
+                exceedsLimit: initialTokenCount.exceedsLimit,
+                note: "Using minimal tool stubs - full schemas loaded on-demand"
+            });
+            if (initialTokenCount.exceedsLimit) {
+                this.logger.error("Initial prompt exceeds token limit", {
+                    totalTokens: initialTokenCount.totalTokens,
+                    safeLimit: initialTokenCount.limit.safeTokens,
+                });
+                return {
+                    success: false,
+                    error: `Initial prompt too long: ${initialTokenCount.totalTokens} tokens exceeds safe limit of ${initialTokenCount.limit.safeTokens} tokens`,
+                };
+            }
+            let response = await this.client.messages.create({
+                model: this.config.model || "claude-sonnet-4-20250514",
+                max_tokens: this.config.maxTokens || 2000,
+                temperature: this.config.temperature || 0.7,
+                system: [
+                    {
+                        type: "text",
+                        text: finalSystemPrompt,
+                        cache_control: { type: "ephemeral" }
+                    }
+                ],
+                messages: [
+                    {
+                        role: "user",
+                        content: finalUserContent,
+                    },
+                ],
+                tools: minimalTools,
+            });
+            const toolCalls = [];
+            // No conversation history - process each message independently
+            const currentUserContent = this.removeMentions(userMessage);
+            const conversationMessages = [{
+                    role: "user",
+                    content: currentUserContent,
+                }];
+            // Track token usage across all API calls
+            let totalInputTokens = 0;
+            let totalOutputTokens = 0;
+            let totalCacheCreation = 0;
+            let totalCacheRead = 0;
+            // Accumulate tokens from initial response
+            if (response.usage) {
+                totalInputTokens += response.usage.input_tokens;
+                totalOutputTokens += response.usage.output_tokens;
+                totalCacheCreation += response.usage.cache_creation_input_tokens || 0;
+                totalCacheRead += response.usage.cache_read_input_tokens || 0;
+            }
+            let maxIterations = 25;
+            while (maxIterations > 0 &&
+                response.content.some((content) => content.type === "tool_use")) {
+                maxIterations--;
+                if (maxIterations === 0) {
+                    this.logger.warn("Max iteration limit reached, generating final response with current tool results", {
+                        botId: userMessage.mentionedOrDirectMessagedBotId,
+                        totalIterations: 25,
+                    });
+                    break; // Exit the loop but continue to generate response
+                }
+                // Add assistant's response to conversation
+                conversationMessages.push({
+                    role: "assistant",
+                    content: response.content,
+                });
+                // Build optimized tool set: full schemas for used tools, minimal stubs for others
+                const optimizedTools = minimalTools.map((tool, index) => {
+                    let toolDef = tool;
+                    if (loadedToolSchemas.has(tool.name)) {
+                        toolDef = loadedToolSchemas.get(tool.name);
+                    }
+                    // Add cache control to last tool in array for maximum caching
+                    if (index === minimalTools.length - 1) {
+                        toolDef = { ...toolDef, cache_control: { type: "ephemeral" } };
+                    }
+                    return toolDef;
+                });
+                const toolResults = [];
+                const schemasJustLoaded = [];
+                // First pass: Check if any tools need schema loading
+                for (const content of response.content) {
+                    if (content.type === "tool_use") {
+                        if (!loadedToolSchemas.has(content.name)) {
+                            this.logger.info("Tool schema needed - loading before execution", { toolName: content.name });
+                            const fullSchema = await this.fetchMcpToolSchema(mcpServerUrl, botMcpApiKey, content.name);
+                            loadedToolSchemas.set(content.name, fullSchema);
+                            schemasJustLoaded.push(content.name);
+                            this.logger.debug("Tool schema loaded and will be sent to Claude", {
+                                toolName: content.name,
+                                totalLoaded: loadedToolSchemas.size
+                            });
+                        }
+                    }
+                }
+                // If we just loaded schemas, don't execute yet - let Claude see them first
+                if (schemasJustLoaded.length > 0) {
+                    this.logger.info("Loaded new tool schemas - giving Claude another iteration to see parameters", {
+                        schemasLoaded: schemasJustLoaded,
+                        tokensAdded: schemasJustLoaded.length * 200
+                    });
+                    // IMPORTANT: Anthropic requires tool_result for every tool_use
+                    // Add stub results telling Claude to retry with full schemas
+                    const stubResults = response.content
+                        .filter(content => content.type === "tool_use")
+                        .map(content => ({
+                        type: "tool_result",
+                        tool_use_id: content.id,
+                        content: `Schema loaded. Full parameter details are now available. Please retry this tool call with the correct parameters based on the schema.`
+                    }));
+                    conversationMessages.push({
+                        role: "user",
+                        content: stubResults,
+                    });
+                    // Continue to next iteration - Claude will now see full schemas in optimizedTools
+                    continue;
+                }
+                // Second pass: Execute tools (schemas are already loaded)
+                for (const content of response.content) {
+                    if (content.type === "tool_use") {
+                        const toolCallStart = Date.now();
+                        try {
+                            this.logToolCall(content.name, content.input);
+                            const result = await this.callMcpTool(mcpServerUrl, botMcpApiKey, {
+                                name: content.name,
+                                arguments: content.input ?? undefined,
+                            });
+                            const toolCallDuration = Date.now() - toolCallStart;
+                            toolCalls.push({
+                                toolName: content.name,
+                                args: content.input,
+                                result: result?.content,
+                                duration: toolCallDuration,
+                            });
+                            // Note: Individual tool truncation removed - now handled at prompt level
+                            const resultContent = JSON.stringify(result?.content || {});
+                            toolResults.push({
+                                type: "tool_result",
+                                tool_use_id: content.id,
+                                content: resultContent,
+                            });
+                            this.logToolCall(content.name, content.input, toolCallDuration);
+                            // Log detailed tool call to activity logger
+                            this.agentTracker.logToolCall({
+                                toolName: content.name,
+                                provider: "Anthropic",
+                                request: {
+                                    arguments: content.input,
+                                    endpoint: mcpServerUrl,
+                                    method: "POST",
+                                },
+                                response: {
+                                    success: true,
+                                    data: result?.content,
+                                },
+                                duration: toolCallDuration,
+                                botId: userMessage.mentionedOrDirectMessagedBotId,
+                                discussionId: userMessage.discussionId,
+                                workspaceId: userMessage.workspaceId,
+                            });
+                        }
+                        catch (error) {
+                            const toolCallDuration = Date.now() - toolCallStart;
+                            this.logger.toolError(content.name, this.name, error, toolCallDuration);
+                            toolCalls.push({
+                                toolName: content.name,
+                                args: content.input,
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                            toolResults.push({
+                                type: "tool_result",
+                                tool_use_id: content.id,
+                                content: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                                is_error: true,
+                            });
+                            // Log failed tool call to activity logger
+                            this.agentTracker.logToolCall({
+                                toolName: content.name,
+                                provider: "Anthropic",
+                                request: {
+                                    arguments: content.input,
+                                    endpoint: mcpServerUrl,
+                                    method: "POST",
+                                },
+                                response: {
+                                    success: false,
+                                    error: error instanceof Error ? error.message : String(error),
+                                },
+                                duration: toolCallDuration,
+                                botId: userMessage.mentionedOrDirectMessagedBotId,
+                                discussionId: userMessage.discussionId,
+                                workspaceId: userMessage.workspaceId,
+                            });
+                        }
+                    }
+                }
+                if (toolResults.length > 0) {
+                    conversationMessages.push({
+                        role: "user",
+                        content: toolResults,
+                    });
+                    // Check token count before API call with tool results
+                    const tokenCount = this.contextManager.countTokens(finalSystemPrompt, conversationMessages, optimizedTools, 'anthropic');
+                    this.logger.info("Token count after tool results (on-demand mode)", {
+                        totalTokens: tokenCount.totalTokens,
+                        messagesTokens: tokenCount.messagesTokens,
+                        toolsTokens: tokenCount.toolsTokens,
+                        safeLimit: tokenCount.limit.safeTokens,
+                        exceedsLimit: tokenCount.exceedsLimit,
+                        messageCount: conversationMessages.length,
+                        loadedSchemas: loadedToolSchemas.size,
+                        note: `${loadedToolSchemas.size} tools with full schemas, ${minimalTools.length - loadedToolSchemas.size} minimal stubs`
+                    });
+                    // Check if approaching limit (80%)
+                    if (this.contextManager.approachingLimit(tokenCount.totalTokens, 'anthropic')) {
+                        this.logger.warn("Approaching token limit", {
+                            totalTokens: tokenCount.totalTokens,
+                            safeLimit: tokenCount.limit.safeTokens,
+                            percentUsed: Math.round((tokenCount.totalTokens / tokenCount.limit.safeTokens) * 100),
+                        });
+                    }
+                    // If exceeds limit, summarize context
+                    let messagesToSend = conversationMessages;
+                    if (tokenCount.exceedsLimit) {
+                        this.logger.warn("Context exceeds token limit, starting summarization", {
+                            totalTokens: tokenCount.totalTokens,
+                            safeLimit: tokenCount.limit.safeTokens,
+                            messageCount: conversationMessages.length,
+                        });
+                        try {
+                            const summarizationResult = await this.contextManager.summarizeContext(finalSystemPrompt, conversationMessages, 'anthropic', finalUserContent);
+                            this.logger.info("Context summarization successful", {
+                                originalTokens: summarizationResult.originalTokens,
+                                summarizedTokens: summarizationResult.summarizedTokens,
+                                reductionPercent: summarizationResult.reductionPercent,
+                                chunksProcessed: summarizationResult.chunksProcessed,
+                                originalMessages: conversationMessages.length,
+                                summarizedMessages: summarizationResult.summarizedMessages.length,
+                            });
+                            // Replace conversation messages with summarized version
+                            // Keep first user message, add summarized results
+                            messagesToSend = [
+                                conversationMessages[0], // Original user query
+                                ...summarizationResult.summarizedMessages,
+                            ];
+                            // Verify summarized context is within limits
+                            const summarizedTokenCount = this.contextManager.countTokens(finalSystemPrompt, messagesToSend, optimizedTools, 'anthropic');
+                            if (summarizedTokenCount.exceedsLimit) {
+                                this.logger.error("Summarized context still exceeds limit", {
+                                    summarizedTokens: summarizedTokenCount.totalTokens,
+                                    safeLimit: summarizedTokenCount.limit.safeTokens,
+                                });
+                                return {
+                                    success: false,
+                                    error: `Context too large even after summarization: ${summarizedTokenCount.totalTokens} tokens exceeds safe limit of ${summarizedTokenCount.limit.safeTokens} tokens`,
+                                };
+                            }
+                        }
+                        catch (error) {
+                            this.logger.error("Summarization failed", error, {
+                                originalTokens: tokenCount.totalTokens,
+                                safeLimit: tokenCount.limit.safeTokens,
+                            });
+                            return {
+                                success: false,
+                                error: `Context too large and summarization failed: ${error instanceof Error ? error.message : String(error)}`,
+                            };
+                        }
+                    }
+                    // Make API call with potentially summarized messages and optimized tools
+                    response = await this.client.messages.create({
+                        model: this.config.model || "claude-sonnet-4-20250514",
+                        max_tokens: this.config.maxTokens || 2000,
+                        temperature: this.config.temperature || 0.7,
+                        system: [
+                            {
+                                type: "text",
+                                text: finalSystemPrompt,
+                                cache_control: { type: "ephemeral" }
+                            }
+                        ],
+                        messages: messagesToSend,
+                        tools: optimizedTools,
+                    });
+                    // Accumulate tokens from this API call
+                    if (response.usage) {
+                        totalInputTokens += response.usage.input_tokens;
+                        totalOutputTokens += response.usage.output_tokens;
+                        totalCacheCreation += response.usage.cache_creation_input_tokens || 0;
+                        totalCacheRead += response.usage.cache_read_input_tokens || 0;
+                    }
+                }
+            }
+            // If we hit the iteration limit, force a final response without tool calls
+            if (maxIterations === 0 && response.content.some((content) => content.type === "tool_use")) {
+                this.logger.info("Forcing final response without tool calls after hitting iteration limit", {
+                    botId: userMessage.mentionedOrDirectMessagedBotId,
+                });
+                // Add final instruction (centralized truncation will handle limits)
+                const finalMessages = [...conversationMessages, {
+                        role: "user",
+                        content: "Please provide a summary response based on the information gathered from the tools above. Do not call any more tools."
+                    }];
+                // Check token count before final API call
+                const finalTokenCount = this.contextManager.countTokens(finalSystemPrompt, finalMessages, [], // No tools in final call
+                'anthropic');
+                this.logger.info("Final forced response token count", {
+                    totalTokens: finalTokenCount.totalTokens,
+                    safeLimit: finalTokenCount.limit.safeTokens,
+                    exceedsLimit: finalTokenCount.exceedsLimit,
+                });
+                let finalMessagesToSend = finalMessages;
+                if (finalTokenCount.exceedsLimit) {
+                    this.logger.warn("Final context exceeds limit, summarizing", {
+                        totalTokens: finalTokenCount.totalTokens,
+                        safeLimit: finalTokenCount.limit.safeTokens,
+                    });
+                    try {
+                        const summarizationResult = await this.contextManager.summarizeContext(finalSystemPrompt, conversationMessages, // Summarize conversation before final instruction
+                        'anthropic', finalUserContent);
+                        finalMessagesToSend = [
+                            conversationMessages[0], // Original user query
+                            ...summarizationResult.summarizedMessages,
+                            {
+                                role: "user",
+                                content: "Please provide a summary response based on the information gathered from the tools above. Do not call any more tools."
+                            }
+                        ];
+                        this.logger.info("Final context summarized", {
+                            originalTokens: summarizationResult.originalTokens,
+                            summarizedTokens: summarizationResult.summarizedTokens,
+                            reductionPercent: summarizationResult.reductionPercent,
+                        });
+                    }
+                    catch (error) {
+                        this.logger.error("Final summarization failed", error);
+                        // Continue with truncated messages as fallback
+                    }
+                }
+                // Make final call without tools
+                response = await this.client.messages.create({
+                    model: this.config.model || "claude-sonnet-4-20250514",
+                    max_tokens: this.config.maxTokens || 2000,
+                    temperature: this.config.temperature || 0.7,
+                    system: [
+                        {
+                            type: "text",
+                            text: finalSystemPrompt,
+                            cache_control: { type: "ephemeral" }
+                        }
+                    ],
+                    messages: finalMessagesToSend,
+                    // No tools - force text response only
+                });
+                // Accumulate tokens from final API call
+                if (response.usage) {
+                    totalInputTokens += response.usage.input_tokens;
+                    totalOutputTokens += response.usage.output_tokens;
+                    totalCacheCreation += response.usage.cache_creation_input_tokens || 0;
+                    totalCacheRead += response.usage.cache_read_input_tokens || 0;
+                }
+            }
+            // No cleanup needed for HTTP-based MCP calls
+            const duration = Date.now() - startTime;
+            const responseText = response.content
+                .filter((content) => content.type === "text")
+                .map((content) => content.text)
+                .join("\n")
+                .trim();
+            // Calculate total cost
+            const model = this.config.model || "claude-sonnet-4-20250514";
+            const cost = (0, token_pricing_1.calculateTokenCost)({
+                input_tokens: totalInputTokens,
+                output_tokens: totalOutputTokens,
+                cache_creation_input_tokens: totalCacheCreation,
+                cache_read_input_tokens: totalCacheRead,
+            }, model);
+            this.logger.info("Processed request", {
+                duration,
+                toolCallCount: toolCalls.length,
+                maxIterationsReached: maxIterations === 0,
+                tokens: {
+                    input: totalInputTokens,
+                    output: totalOutputTokens,
+                    total: totalInputTokens + totalOutputTokens,
+                    cacheCreation: totalCacheCreation,
+                    cacheRead: totalCacheRead,
+                    cost: cost,
+                }
+            });
+            return {
+                success: true,
+                toolCalls,
+                response: responseText || "Task completed successfully.",
+                tokens: {
+                    input: totalInputTokens,
+                    output: totalOutputTokens,
+                    total: totalInputTokens + totalOutputTokens,
+                    cacheCreation: totalCacheCreation,
+                    cacheRead: totalCacheRead,
+                    cost: cost,
+                },
+            };
+        }
+        catch (error) {
+            this.logError(error, "processMessage");
+            return {
+                success: false,
+                error: `Anthropic processing failed: ${error.message || error}`,
+            };
+        }
+    }
+    /**
+     * Fetch specific tool schema on-demand
+     * Token-efficient: ~690 tokens per tool vs loading all tools upfront
+     */
+    async fetchMcpToolSchema(mcpServerUrl, mcpServerApiKey, toolName) {
+        // Check cache first
+        const cacheKey = `${mcpServerUrl}:${toolName}`;
+        if (this.toolSchemaCache.has(cacheKey)) {
+            this.logger.debug('Using cached tool schema', { toolName });
+            return this.toolSchemaCache.get(cacheKey);
+        }
+        const url = `${mcpServerUrl}${mcpServerUrl.includes("?") ? "&" : "?"}apiKey=${mcpServerApiKey}`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json, text/event-stream",
+            },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: Math.random().toString(36).substring(2),
+                method: "tools/get_schema",
+                params: { name: toolName },
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`MCP server responded with ${response.status}: ${response.statusText}`);
+        }
+        // Parse SSE response format
+        const responseText = await response.text();
+        const lines = responseText.split("\n");
+        let jsonData = null;
+        for (const line of lines) {
+            if (line.startsWith("data: ")) {
+                try {
+                    jsonData = JSON.parse(line.substring(6));
+                    break;
+                }
+                catch (e) {
+                    // Skip non-JSON lines
+                }
+            }
+        }
+        if (!jsonData) {
+            throw new Error("Failed to parse MCP server response");
+        }
+        if (jsonData.error) {
+            throw new Error(`MCP tool schema error: ${jsonData.error.message || jsonData.error}`);
+        }
+        // Convert MCP tool format to Anthropic tool format
+        const toolSchema = {
+            name: jsonData.result.name,
+            description: jsonData.result.description || `Tool: ${jsonData.result.name}`,
+            input_schema: jsonData.result.inputSchema || {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+        };
+        // Cache the schema
+        this.toolSchemaCache.set(cacheKey, toolSchema);
+        this.logger.debug('Cached tool schema', { toolName });
+        return toolSchema;
+    }
+    async callMcpTool(mcpServerUrl, mcpServerApiKey, request) {
+        const url = `${mcpServerUrl}${mcpServerUrl.includes("?") ? "&" : "?"}apiKey=${mcpServerApiKey}`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json, text/event-stream",
+            },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: Math.random().toString(36).substring(2),
+                method: "tools/call",
+                params: {
+                    name: request.name,
+                    arguments: request.arguments || {},
+                },
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`MCP tool call failed with ${response.status}: ${response.statusText}`);
+        }
+        // Parse SSE response format
+        const responseText = await response.text();
+        const lines = responseText.split("\n");
+        let jsonData = null;
+        for (const line of lines) {
+            if (line.startsWith("data: ")) {
+                try {
+                    jsonData = JSON.parse(line.substring(6));
+                    break;
+                }
+                catch (e) {
+                    // Skip non-JSON lines
+                }
+            }
+        }
+        if (!jsonData) {
+            throw new Error("Failed to parse MCP tool response");
+        }
+        if (jsonData.error) {
+            throw new Error(`MCP tool error: ${jsonData.error.message || jsonData.error}`);
+        }
+        return jsonData.result;
+    }
+}
+exports.AnthropicProvider = AnthropicProvider;
+//# sourceMappingURL=anthropic-provider.js.map

package/dist/client/providers/llm-provider.d.ts

@@ -0,0 +1,47 @@
+import { LlmProviderConfig, ChatMessage, McpResponse } from "../types";
+import { Logger } from "../../lib/logger";
+import { AgentTracker } from "../agent-tracker";
+import { PromptLengthManager } from "../../lib/prompt-length-manager";
+export declare abstract class LlmProvider {
+    readonly name: string;
+    readonly type: string;
+    protected config: LlmProviderConfig;
+    protected logger: Logger;
+    protected agentTracker: AgentTracker;
+    protected promptLengthManager: PromptLengthManager;
+    constructor(config: LlmProviderConfig);
+    isEnabled(): boolean;
+    abstract processMessage(message: ChatMessage, mcpServerUrl: string, botMcpApiKey: string, botEmail: string): Promise<McpResponse>;
+    /**
+     * Generate a personalized confirmation message for the user
+     */
+    abstract generateConfirmationMessage(userMessage: ChatMessage): Promise<string>;
+    /**
+     * Get the confirmation prompt template
+     */
+    protected getConfirmationPrompt(userMessage: ChatMessage): string;
+    /**
+     * Fetch additional context for the bot to better understand the current situation
+     */
+    protected fetchContextualInformation(mcpServerUrl: string, mcpServerApiKey: string, message: ChatMessage): Promise<{
+        workspaceInfo: string;
+        recentMessages: string;
+    }>;
+    protected abstract callMcpTool(mcpServerUrl: string, mcpServerApiKey: string, request: {
+        name: string;
+        arguments: any;
+    }): Promise<any>;
+    protected logToolCall(toolName: string, args: any, duration?: number): void;
+    protected logError(error: any, context: string): void;
+    protected createSystemPrompt(options: {
+        userMessage: ChatMessage;
+        mcpServerUrl: string;
+        mcpServerApiKey: string;
+        botEmail: string;
+    }): Promise<string>;
+    private buildWorkspacesPrompt;
+    private fetchAgentSpecificPrompt;
+    private buildSystemPrompt;
+    protected removeMentions(message: ChatMessage): string;
+}
+//# sourceMappingURL=llm-provider.d.ts.map