@hailer/mcp 0.1.8 → 0.1.9

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

@@ -1,645 +0,0 @@
-"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`,
-                };
-            }
-            // Enable structured outputs with strict mode for schema validation
-            const strictTools = minimalTools.map(tool => ({
-                ...tool,
-                strict: true
-            }));
-            let response = await this.client.beta.messages.create({
-                model: this.config.model || "claude-sonnet-4-20250514",
-                max_tokens: this.config.maxTokens || 2000,
-                temperature: this.config.temperature || 0.7,
-                betas: ['structured-outputs-2025-11-13'],
-                system: [
-                    {
-                        type: "text",
-                        text: finalSystemPrompt,
-                        cache_control: { type: "ephemeral" }
-                    }
-                ],
-                messages: [
-                    {
-                        role: "user",
-                        content: finalUserContent,
-                    },
-                ],
-                tools: strictTools,
-            });
-            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
-                    // Add strict mode for structured outputs
-                    const strictOptimizedTools = optimizedTools.map(tool => ({
-                        ...tool,
-                        strict: true
-                    }));
-                    response = await this.client.beta.messages.create({
-                        model: this.config.model || "claude-sonnet-4-20250514",
-                        max_tokens: this.config.maxTokens || 2000,
-                        temperature: this.config.temperature || 0.7,
-                        betas: ['structured-outputs-2025-11-13'],
-                        system: [
-                            {
-                                type: "text",
-                                text: finalSystemPrompt,
-                                cache_control: { type: "ephemeral" }
-                            }
-                        ],
-                        messages: messagesToSend,
-                        tools: strictOptimizedTools,
-                    });
-                    // 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 (no strict mode needed - no tools)
-                response = await this.client.beta.messages.create({
-                    model: this.config.model || "claude-sonnet-4-20250514",
-                    max_tokens: this.config.maxTokens || 2000,
-                    temperature: this.config.temperature || 0.7,
-                    betas: ['structured-outputs-2025-11-13'],
-                    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 with strict mode
-        const toolSchema = {
-            name: jsonData.result.name,
-            description: jsonData.result.description || `Tool: ${jsonData.result.name}`,
-            input_schema: jsonData.result.inputSchema || {
-                type: "object",
-                properties: {},
-                required: [],
-            },
-            strict: true, // Enable structured outputs validation
-        };
-        // 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/assistant-provider.d.ts

@@ -1,17 +0,0 @@
-/**
- * Assistant Provider
- *
- * Pure pass-through chatbot. No tools, no local system prompt.
- * System prompt is loaded on AI PC side via llama-server.
- */
-import { ChatMessage, McpResponse } from "../types";
-import { LlmProvider } from "./llm-provider";
-import { LlmProviderConfig } from "../types";
-export declare class AssistantProvider extends LlmProvider {
-    private assistant;
-    constructor(config: LlmProviderConfig);
-    generateConfirmationMessage(_userMessage: ChatMessage): Promise<string>;
-    processMessage(userMessage: ChatMessage, _mcpServerUrl: string, _botMcpApiKey: string, _botEmail: string): Promise<McpResponse>;
-    protected callMcpTool(): Promise<any>;
-}
-//# sourceMappingURL=assistant-provider.d.ts.map