@hailer/mcp 0.0.1

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

@@ -0,0 +1,621 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIProvider = void 0;
+const openai_1 = __importDefault(require("openai"));
+const llm_provider_1 = require("./llm-provider");
+const context_manager_1 = require("../../lib/context-manager");
+const token_pricing_1 = require("../token-pricing");
+const tool_schema_loader_1 = require("../tool-schema-loader");
+const tool_executor_1 = require("../tool-executor");
+const tool_registry_1 = require("../../mcp/tool-registry");
+class OpenAIProvider extends llm_provider_1.LlmProvider {
+    client;
+    contextManager;
+    toolSchemaLoader = new tool_schema_loader_1.ToolSchemaLoader();
+    toolExecutor = new tool_executor_1.ToolExecutor();
+    constructor(config) {
+        super(config);
+        this.client = new openai_1.default({
+            apiKey: config.apiKey,
+        });
+        this.contextManager = (0, context_manager_1.getContextManager)({
+            openaiApiKey: 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.chat.completions.create({
+                model: this.config.model || "gpt-4o",
+                max_tokens: 100,
+                temperature: 0.7,
+                messages: [
+                    {
+                        role: "user",
+                        content: confirmationPrompt,
+                    },
+                ],
+            });
+            const confirmationText = response.choices[0]?.message?.content?.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("OpenAI provider is not enabled or missing API key");
+            return {
+                success: false,
+                error: "OpenAI provider is not enabled or missing API key",
+            };
+        }
+        try {
+            const systemPrompt = await this.createSystemPrompt({
+                userMessage,
+                mcpServerUrl,
+                mcpServerApiKey: botMcpApiKey,
+                botEmail,
+            });
+            const startTime = Date.now();
+            // Load 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
+            });
+            if (!toolIndex || toolIndex.length === 0) {
+                this.logger.warn("No MCP tools available");
+                return await this.handleDirectResponse(this.removeMentions(userMessage), systemPrompt);
+            }
+            // Convert to OpenAI tool format - minimal stubs initially (on-demand schema loading)
+            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 for OpenAI
+            const finalSystemPrompt = systemPrompt;
+            const finalUserContent = this.removeMentions(userMessage);
+            // Check token count before initial API call (with minimal tools)
+            const initialMessages = [
+                { role: "system", content: finalSystemPrompt },
+                { role: "user", content: finalUserContent }
+            ];
+            // Convert minimal tools to OpenAI format
+            const openaiTools = await this.convertToolIndexToOpenAIFormat(mcpServerUrl, botMcpApiKey, minimalTools);
+            const initialTokenCount = this.contextManager.countTokens(finalSystemPrompt, initialMessages, openaiTools, 'openai');
+            this.logger.info("Initial prompt token count", {
+                totalTokens: initialTokenCount.totalTokens,
+                systemPromptTokens: initialTokenCount.systemPromptTokens,
+                messagesTokens: initialTokenCount.messagesTokens,
+                toolsTokens: initialTokenCount.toolsTokens,
+                safeLimit: initialTokenCount.limit.safeTokens,
+                exceedsLimit: initialTokenCount.exceedsLimit,
+            });
+            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`,
+                };
+            }
+            // Initial request to OpenAI with tools
+            let response = await this.client.chat.completions.create({
+                model: this.config.model || "gpt-4o",
+                max_tokens: this.config.maxTokens || 2000,
+                temperature: this.config.temperature || 0.7,
+                messages: [
+                    {
+                        role: "system",
+                        content: finalSystemPrompt,
+                    },
+                    {
+                        role: "user",
+                        content: finalUserContent,
+                    },
+                ],
+                tools: openaiTools,
+                tool_choice: "auto",
+            });
+            const toolCalls = [];
+            // No conversation history - process each message independently
+            const conversationMessages = [
+                { role: "system", content: finalSystemPrompt },
+                { role: "user", content: finalUserContent },
+            ];
+            // Track token usage across all API calls
+            let totalInputTokens = 0;
+            let totalOutputTokens = 0;
+            // Accumulate tokens from initial response
+            if (response.usage) {
+                totalInputTokens += response.usage.prompt_tokens || 0;
+                totalOutputTokens += response.usage.completion_tokens || 0;
+            }
+            // Handle tool use requests
+            let maxIterations = 25; // Prevent infinite loops
+            while (maxIterations > 0 && response.choices[0]?.message?.tool_calls) {
+                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
+                }
+                const assistantMessage = response.choices[0].message;
+                const toolCalls_list = assistantMessage.tool_calls;
+                if (!toolCalls_list)
+                    break;
+                // Add assistant's response to conversation
+                conversationMessages.push({
+                    role: "assistant",
+                    content: assistantMessage.content || null,
+                    tool_calls: toolCalls_list,
+                });
+                // Build optimized tool set: full schemas for loaded tools, minimal stubs for others
+                const optimizedTools = this.buildOptimizedTools(minimalTools, loadedToolSchemas);
+                const toolResults = [];
+                const schemasJustLoaded = [];
+                // First pass: Check if any tools need schema loading
+                for (const toolCall of toolCalls_list) {
+                    const funcCall = toolCall.function;
+                    const toolName = funcCall?.name;
+                    if (!loadedToolSchemas.has(toolName)) {
+                        this.logger.info("Tool schema needed - loading before execution", { toolName });
+                        const fullSchema = await this.toolSchemaLoader.loadToolSchema(mcpServerUrl, botMcpApiKey, toolName);
+                        loadedToolSchemas.set(toolName, fullSchema);
+                        schemasJustLoaded.push(toolName);
+                        this.logger.debug("Tool schema loaded and will be sent to GPT", {
+                            toolName,
+                            totalLoaded: loadedToolSchemas.size
+                        });
+                    }
+                }
+                // If we just loaded schemas, don't execute yet - let GPT see them first
+                if (schemasJustLoaded.length > 0) {
+                    this.logger.info("Loaded new tool schemas - giving GPT another iteration to see parameters", {
+                        schemasLoaded: schemasJustLoaded,
+                        tokensAdded: schemasJustLoaded.length * 200
+                    });
+                    // IMPORTANT: OpenAI expects tool results for every tool call
+                    // Add stub results telling GPT to retry with full schemas
+                    const stubResults = toolCalls_list.map(toolCall => ({
+                        role: "tool",
+                        tool_call_id: toolCall.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(...stubResults);
+                    // Continue to next iteration - GPT will now see full schemas in optimizedTools
+                    continue;
+                }
+                // Second pass: Execute tools (schemas are already loaded)
+                for (const toolCall of toolCalls_list) {
+                    const toolCallStart = Date.now();
+                    try {
+                        const funcCall = toolCall.function;
+                        this.logToolCall(funcCall?.name, JSON.parse(funcCall?.arguments || "{}"));
+                        const args = JSON.parse(funcCall?.arguments || "{}");
+                        const result = await this.callMcpTool(mcpServerUrl, botMcpApiKey, {
+                            name: funcCall?.name,
+                            arguments: args,
+                        });
+                        const toolCallDuration = Date.now() - toolCallStart;
+                        toolCalls.push({
+                            toolName: funcCall?.name,
+                            args: args,
+                            result: result?.content,
+                            duration: toolCallDuration,
+                        });
+                        // Note: Individual tool truncation removed - now handled at prompt level
+                        const resultContent = JSON.stringify(result?.content || {});
+                        toolResults.push({
+                            role: "tool",
+                            tool_call_id: toolCall.id,
+                            content: resultContent,
+                        });
+                        this.logToolCall(funcCall?.name, args, toolCallDuration);
+                        // Log detailed tool call to activity logger
+                        this.agentTracker.logToolCall({
+                            toolName: funcCall?.name,
+                            provider: "OpenAI",
+                            request: {
+                                arguments: args,
+                                endpoint: mcpServerUrl,
+                                method: "POST",
+                            },
+                            response: {
+                                success: true,
+                                data: result?.content,
+                            },
+                            duration: toolCallDuration,
+                            botId: userMessage.mentionedOrDirectMessagedBotId,
+                            discussionId: userMessage.discussionId,
+                            workspaceId: userMessage.workspaceId,
+                        });
+                    }
+                    catch (error) {
+                        const funcCall = toolCall.function;
+                        const toolCallDuration = Date.now() - toolCallStart;
+                        this.logger.toolError(funcCall?.name, this.name, error, toolCallDuration);
+                        toolCalls.push({
+                            toolName: funcCall?.name,
+                            args: JSON.parse(funcCall?.arguments || "{}"),
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                        toolResults.push({
+                            role: "tool",
+                            tool_call_id: toolCall.id,
+                            content: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                        });
+                        // Log failed tool call to activity logger
+                        this.agentTracker.logToolCall({
+                            toolName: funcCall?.name,
+                            provider: "OpenAI",
+                            request: {
+                                arguments: JSON.parse(funcCall?.arguments || "{}"),
+                                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,
+                        });
+                    }
+                }
+                // Add tool results to conversation
+                if (toolResults.length > 0) {
+                    conversationMessages.push(...toolResults);
+                    // Check token count before API call with tool results
+                    const tokenCount = this.contextManager.countTokens(finalSystemPrompt, conversationMessages, optimizedTools, 'openai');
+                    this.logger.info("Token count after tool results", {
+                        totalTokens: tokenCount.totalTokens,
+                        messagesTokens: tokenCount.messagesTokens,
+                        safeLimit: tokenCount.limit.safeTokens,
+                        exceedsLimit: tokenCount.exceedsLimit,
+                        messageCount: conversationMessages.length,
+                    });
+                    // Check if approaching limit (80%)
+                    if (this.contextManager.approachingLimit(tokenCount.totalTokens, 'openai')) {
+                        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 {
+                            // Extract system prompt from messages for summarization
+                            const messagesWithoutSystem = conversationMessages.filter(m => m.role !== 'system');
+                            const systemMsg = conversationMessages.find(m => m.role === 'system');
+                            const summarizationResult = await this.contextManager.summarizeContext(systemMsg?.content || finalSystemPrompt, messagesWithoutSystem, 'openai', 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 system prompt, first user message, add summarized results
+                            messagesToSend = [
+                                { role: "system", content: finalSystemPrompt },
+                                conversationMessages.find(m => m.role === 'user'),
+                                ...summarizationResult.summarizedMessages,
+                            ];
+                            // Verify summarized context is within limits
+                            const summarizedTokenCount = this.contextManager.countTokens(finalSystemPrompt, messagesToSend, optimizedTools, 'openai');
+                            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)}`,
+                            };
+                        }
+                    }
+                    // Get OpenAI's response to the tool results (potentially summarized)
+                    response = await this.client.chat.completions.create({
+                        model: this.config.model || "gpt-4o",
+                        max_tokens: this.config.maxTokens || 2000,
+                        temperature: this.config.temperature || 0.7,
+                        messages: messagesToSend,
+                        tools: optimizedTools,
+                        tool_choice: "auto",
+                    });
+                    // Accumulate tokens from this API call
+                    if (response.usage) {
+                        totalInputTokens += response.usage.prompt_tokens || 0;
+                        totalOutputTokens += response.usage.completion_tokens || 0;
+                    }
+                }
+            }
+            // If we hit the iteration limit, force a final response without tool calls
+            if (maxIterations === 0 && response.choices[0]?.message?.tool_calls) {
+                this.logger.info("Forcing final response without tool calls after hitting iteration limit", {
+                    botId: userMessage.mentionedOrDirectMessagedBotId,
+                });
+                // Add final instruction
+                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
+                'openai');
+                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 {
+                        // Extract messages without system for summarization
+                        const messagesWithoutSystem = conversationMessages.filter(m => m.role !== 'system');
+                        const systemMsg = conversationMessages.find(m => m.role === 'system');
+                        const summarizationResult = await this.contextManager.summarizeContext(systemMsg?.content || finalSystemPrompt, messagesWithoutSystem, 'openai', finalUserContent);
+                        finalMessagesToSend = [
+                            { role: "system", content: finalSystemPrompt },
+                            conversationMessages.find(m => m.role === 'user'),
+                            ...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.chat.completions.create({
+                    model: this.config.model || "gpt-4o",
+                    max_tokens: this.config.maxTokens || 2000,
+                    temperature: this.config.temperature || 0.7,
+                    messages: finalMessagesToSend,
+                    // No tools - force text response only
+                });
+                // Accumulate tokens from final API call
+                if (response.usage) {
+                    totalInputTokens += response.usage.prompt_tokens || 0;
+                    totalOutputTokens += response.usage.completion_tokens || 0;
+                }
+            }
+            // No cleanup needed for HTTP-based MCP calls
+            const duration = Date.now() - startTime;
+            const responseText = response.choices[0]?.message?.content?.trim() ||
+                "Task completed successfully.";
+            // Calculate total cost (OpenAI doesn't have cache tokens)
+            const model = this.config.model || "gpt-4o";
+            const cost = (0, token_pricing_1.calculateTokenCost)({
+                input_tokens: totalInputTokens,
+                output_tokens: totalOutputTokens,
+            }, model);
+            this.logger.info("Processed request", {
+                duration,
+                toolCallCount: toolCalls.length,
+                maxIterationsReached: maxIterations === 0,
+                tokens: {
+                    input: totalInputTokens,
+                    output: totalOutputTokens,
+                    total: totalInputTokens + totalOutputTokens,
+                    cost: cost,
+                }
+            });
+            return {
+                success: true,
+                toolCalls,
+                response: responseText,
+                tokens: {
+                    input: totalInputTokens,
+                    output: totalOutputTokens,
+                    total: totalInputTokens + totalOutputTokens,
+                    cost: cost,
+                },
+            };
+        }
+        catch (error) {
+            this.logError(error, "processMessage");
+            return {
+                success: false,
+                error: `OpenAI processing failed: ${error.message || error}`,
+            };
+        }
+    }
+    /**
+     * Convert tool index to OpenAI tool format
+     * Loads full schemas for all tools (for now - could optimize with on-demand loading later)
+     */
+    async convertToolIndexToOpenAIFormat(mcpServerUrl, mcpServerApiKey, toolIndex) {
+        const tools = [];
+        for (const tool of toolIndex) {
+            try {
+                // Load full schema for each tool
+                const schema = await this.toolSchemaLoader.loadToolSchema(mcpServerUrl, mcpServerApiKey, tool.name);
+                // Convert to OpenAI format
+                tools.push({
+                    type: "function",
+                    function: {
+                        name: schema.name,
+                        description: schema.description,
+                        parameters: schema.inputSchema || schema.input_schema,
+                    },
+                });
+            }
+            catch (error) {
+                this.logger.error(`Failed to load schema for tool ${tool.name}`, error);
+                // Skip this tool and continue
+            }
+        }
+        return tools;
+    }
+    /**
+     * Build optimized tools list: full schemas for loaded tools, minimal stubs for others
+     */
+    buildOptimizedTools(minimalTools, loadedToolSchemas) {
+        const optimizedTools = [];
+        for (const tool of minimalTools) {
+            if (loadedToolSchemas.has(tool.name)) {
+                // Use full schema from loaded schemas
+                const fullSchema = loadedToolSchemas.get(tool.name);
+                optimizedTools.push({
+                    type: "function",
+                    function: {
+                        name: fullSchema.name,
+                        description: fullSchema.description,
+                        parameters: fullSchema.input_schema || fullSchema.inputSchema,
+                    },
+                });
+            }
+            else {
+                // Use minimal stub (empty parameters)
+                optimizedTools.push({
+                    type: "function",
+                    function: {
+                        name: tool.name,
+                        description: tool.description,
+                        parameters: {
+                            type: "object",
+                            properties: {},
+                            required: [],
+                        },
+                    },
+                });
+            }
+        }
+        return optimizedTools;
+    }
+    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;
+    }
+    async handleDirectResponse(userMessage, systemPrompt) {
+        try {
+            const response = await this.client.chat.completions.create({
+                model: this.config.model || "gpt-4o",
+                max_tokens: this.config.maxTokens || 2000,
+                temperature: this.config.temperature || 0.7,
+                messages: [
+                    {
+                        role: "system",
+                        content: systemPrompt,
+                    },
+                    {
+                        role: "user",
+                        content: userMessage,
+                    },
+                ],
+            });
+            const responseText = response.choices[0]?.message?.content?.trim() ||
+                "No response generated";
+            return {
+                success: true,
+                response: responseText,
+                toolCalls: [],
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Direct response failed: ${error.message || error}`,
+            };
+        }
+    }
+}
+exports.OpenAIProvider = OpenAIProvider;
+//# sourceMappingURL=openai-provider.js.map

package/dist/client/simple-llm-caller.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Simple LLM Caller for Adaptive Documentation Bot
+ *
+ * Provides basic LLM API calls without the full MCP provider infrastructure.
+ * Used for analyzing errors and generating improvements.
+ */
+export declare class SimpleLLMCaller {
+    private apiKey;
+    private model;
+    private provider;
+    constructor(provider: 'anthropic' | 'openai', apiKey: string, model?: string);
+    /**
+     * Simple LLM call for text generation
+     */
+    generate(prompt: string, systemPrompt?: string): Promise<string>;
+    private callAnthropic;
+    private callOpenAI;
+}
+//# sourceMappingURL=simple-llm-caller.d.ts.map