@hailer/mcp 0.1.8 → 0.1.9

package/dist/client/mcp-client.js

@@ -1,538 +0,0 @@
-"use strict";
-/**
- * Main MCP Client
- * Orchestrates signal handling, message processing, and LLM provider interaction
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.McpClient = void 0;
-const message_processor_1 = require("./message-processor");
-const openai_provider_1 = require("./providers/openai-provider");
-const anthropic_provider_1 = require("./providers/anthropic-provider");
-const assistant_provider_1 = require("./providers/assistant-provider");
-const multi_bot_manager_1 = require("./multi-bot-manager");
-const agent_tracker_1 = require("./agent-tracker");
-const token_tracker_1 = require("./token-tracker");
-const token_usage_bot_1 = require("./token-usage-bot");
-const agent_activity_bot_1 = require("./agent-activity-bot");
-const adaptive_documentation_bot_1 = require("./adaptive-documentation-bot");
-const config_1 = require("../config");
-class McpClient {
-    multiBotManager;
-    messageProcessor;
-    providers = new Map();
-    config;
-    isActive = false;
-    processedMessages = new Set(); // Global message deduplication
-    activeSubscriptions = new Set(); // Track active subscriptions
-    agentTracker = (0, agent_tracker_1.createAgentTracker)();
-    tokenTracker = (0, token_tracker_1.createTokenTracker)();
-    tokenUsageBot;
-    agentActivityBot;
-    adaptiveDocBot;
-    constructor(config) {
-        this.config = config;
-        this.multiBotManager = new multi_bot_manager_1.MultiBotManager(config.botConfigs);
-        this.messageProcessor = new message_processor_1.HailerMessageProcessor(this.multiBotManager, config.mcpAgentIds, config.enableDirectMessages);
-        // Initialize Token Usage Bot
-        this.tokenUsageBot = (0, token_usage_bot_1.createTokenUsageBot)(this.tokenTracker, this.agentTracker, {
-            enabled: config.tokenUsageBotEnabled,
-            postSummaryAfterConversation: config.tokenUsageBotEnabled,
-            minCostThreshold: 0, // Post summary for every conversation
-        });
-        // Initialize Agent Activity Bot
-        this.agentActivityBot = (0, agent_activity_bot_1.createAgentActivityBot)(this.agentTracker, {
-            enabled: config.agentActivityBotEnabled,
-            postSummaryAfterConversation: config.agentActivityBotEnabled,
-            minDurationThreshold: 1000, // Only post if duration > 1s
-        });
-        // Initialize Adaptive Documentation Bot
-        const appConfig = (0, config_1.createApplicationConfig)();
-        if (appConfig.adaptiveDocumentation.enabled && this.config.providers.length > 0) {
-            // Use the first available provider's API key for the adaptive bot
-            const firstProviderConfig = this.config.providers[0];
-            if (firstProviderConfig.apiKey) {
-                this.adaptiveDocBot = new adaptive_documentation_bot_1.AdaptiveDocumentationBot(firstProviderConfig.apiKey, firstProviderConfig.type === 'openai' ? 'openai' : 'anthropic', {
-                    enabled: appConfig.adaptiveDocumentation.enabled,
-                    autoUpdate: appConfig.adaptiveDocumentation.autoUpdate,
-                    updateInterval: appConfig.adaptiveDocumentation.updateInterval,
-                    minErrorCount: appConfig.adaptiveDocumentation.minErrorCount,
-                    skillGeneration: appConfig.adaptiveDocumentation.skillGeneration,
-                });
-                console.log('🔧 Adaptive Documentation Bot initialized');
-            }
-        }
-        // Initialize providers after adaptive bot
-        this.initializeProviders();
-    }
-    async initialize() {
-        await this.multiBotManager.initializeAllHailerClientsFromConfig();
-        // Update agent IDs with the actual user IDs retrieved from authentication
-        const actualAgentIds = this.multiBotManager.getBotIds();
-        if (actualAgentIds.length > 0) {
-            console.log(`🤖 Updated MCP Agent IDs: ${actualAgentIds.join(", ")}`);
-            // Update the message processor with the actual agent IDs
-            this.messageProcessor = new message_processor_1.HailerMessageProcessor(this.multiBotManager, actualAgentIds, this.config.enableDirectMessages);
-            // Log successful initialization
-            this.agentTracker.logSystem({
-                success: true,
-                message: "MCP Client Initialized",
-                details: `Successfully initialized with ${actualAgentIds.length} bot agent(s): ${actualAgentIds.map((id) => id.substring(0, 8)).join(", ")}`,
-            });
-        }
-        else {
-            // Log failed initialization
-            this.agentTracker.logSystem({
-                success: false,
-                message: "MCP Client Initialization Failed",
-                error: "No bot agents configured or authentication failed",
-            });
-        }
-        // Start adaptive documentation monitoring
-        if (this.adaptiveDocBot) {
-            this.adaptiveDocBot.startMonitoring();
-        }
-    }
-    initializeProviders() {
-        for (const providerConfig of this.config.providers) {
-            try {
-                let provider;
-                switch (providerConfig.type) {
-                    case "openai":
-                        provider = new openai_provider_1.OpenAIProvider(providerConfig);
-                        break;
-                    case "anthropic":
-                        provider = new anthropic_provider_1.AnthropicProvider(providerConfig);
-                        break;
-                    case "assistant":
-                        provider = new assistant_provider_1.AssistantProvider(providerConfig);
-                        break;
-                    case "gemini":
-                        // TODO: Implement GeminiProvider
-                        console.warn(`⚠️ Provider type ${providerConfig.type} not yet implemented`);
-                        continue;
-                    default:
-                        console.warn(`⚠️ Unknown provider type: ${providerConfig.type}`);
-                        continue;
-                }
-                if (provider.isEnabled()) {
-                    this.providers.set(providerConfig.name, provider);
-                }
-                else {
-                    console.warn(`⚠️ Provider "${providerConfig.name}" is disabled or missing API key`);
-                }
-            }
-            catch (error) {
-                console.error(`❌ Failed to initialize provider "${providerConfig.name}":`, error);
-            }
-        }
-    }
-    start() {
-        if (this.isActive) {
-            console.log("🤖 MCP Client already active, skipping start");
-            return;
-        }
-        // Subscribe to signals from ALL bot clients since each bot has access to different discussions
-        const botClients = this.multiBotManager.getAllBotClients();
-        if (botClients.length === 0) {
-            console.error("❌ No bot clients available for signal subscription");
-            return;
-        }
-        // Subscribe to signals from each bot client
-        for (const botClient of botClients) {
-            const subscriptionId = `mcp-client-${botClient.userId}`;
-            botClient.signalHandler.subscribe(subscriptionId, ["messenger.new"], this.handleSignal.bind(this));
-            this.activeSubscriptions.add(subscriptionId);
-            console.log(`🤖 Subscribed to signals for bot: ${botClient.config.email} (${botClient.userId})`);
-        }
-        this.isActive = true;
-        console.log(`🤖 MCP Client started with ${botClients.length} bot signal handlers (direct messages: enabled)`);
-    }
-    /**
-     * Get adaptive documentation bot instance (for error reporting)
-     */
-    getAdaptiveBot() {
-        return this.adaptiveDocBot;
-    }
-    stop() {
-        if (!this.isActive) {
-            return;
-        }
-        console.log("🤖 Stopping MCP Client...");
-        // Unsubscribe from all bot signal handlers
-        const botClients = this.multiBotManager.getAllBotClients();
-        for (const botClient of botClients) {
-            const subscriptionId = `mcp-client-${botClient.userId}`;
-            if (this.activeSubscriptions.has(subscriptionId)) {
-                botClient.signalHandler.unsubscribe(subscriptionId);
-                this.activeSubscriptions.delete(subscriptionId);
-                console.log(`🤖 Unsubscribed from signals for bot: ${botClient.config.email}`);
-            }
-        }
-        // Stop adaptive documentation monitoring
-        if (this.adaptiveDocBot) {
-            this.adaptiveDocBot.stopMonitoring();
-        }
-        this.isActive = false;
-        console.log("🤖 MCP Client stopped");
-    }
-    async handleSignal(signal) {
-        let requestId = null;
-        const startTime = Date.now();
-        try {
-            // Early deduplication check - prevent race conditions from multiple bot subscriptions
-            const msgId = signal.data?.msg_id;
-            if (msgId) {
-                if (this.processedMessages.has(msgId)) {
-                    console.log(`🔄 MCP Client: Message ${msgId} already being processed, skipping`);
-                    return;
-                }
-                // Mark as processing immediately to prevent race conditions
-                this.processedMessages.add(msgId);
-                // Clean up old processed message IDs (keep only last 1000)
-                if (this.processedMessages.size > 1000) {
-                    const entries = Array.from(this.processedMessages);
-                    this.processedMessages.clear();
-                    entries.slice(-500).forEach((id) => this.processedMessages.add(id)); // Keep last 500
-                }
-            }
-            const messages = await this.messageProcessor.extractMessage(signal);
-            if (!messages || messages.length === 0) {
-                // If message extraction failed, remove from processed set
-                if (msgId) {
-                    this.processedMessages.delete(msgId);
-                }
-                return; // Signal doesn't contain a valid MCP agent message
-            }
-            // Process each message (one per mentioned bot)
-            const processingPromises = messages.map(async (message) => {
-                // Ensure we have a mentioned bot
-                if (!message.mentionedOrDirectMessagedBotId) {
-                    console.warn(`⚠️ MCP Client: No bot mentioned in message, skipping processing`);
-                    return;
-                }
-                // Double-check that the mentioned bot exists
-                const mentionedBot = this.multiBotManager.getBotClient(message.mentionedOrDirectMessagedBotId);
-                if (!mentionedBot) {
-                    console.error(`❌ MCP Client: Mentioned bot ${message.mentionedOrDirectMessagedBotId} not found`);
-                    return;
-                }
-                // LOG TRIGGER EVENT - Bot was successfully triggered (only for the first message to avoid duplicate logs)
-                let messageRequestId = null;
-                if (!requestId) {
-                    requestId = this.agentTracker.logTrigger({
-                        triggerType: this.determineTriggerType(message.content),
-                        discussionId: message.discussionId,
-                        userId: message.userId,
-                        userName: message.userName,
-                        botId: message.mentionedOrDirectMessagedBotId,
-                        messageContent: message.content,
-                        workspaceId: message.workspaceId,
-                    });
-                    messageRequestId = requestId;
-                }
-                else {
-                    // Log additional triggers for multiple bots
-                    messageRequestId = this.agentTracker.logTrigger({
-                        triggerType: this.determineTriggerType(message.content),
-                        discussionId: message.discussionId,
-                        userId: message.userId,
-                        userName: message.userName,
-                        botId: message.mentionedOrDirectMessagedBotId,
-                        messageContent: message.content,
-                        workspaceId: message.workspaceId,
-                    });
-                }
-                // Process with the first enabled provider (can be enhanced to support multiple or selection)
-                const provider = this.getFirstEnabledProvider();
-                if (!provider) {
-                    console.error(`❌ MCP Client: No LLM providers are available`);
-                    // Log completion failure
-                    if (messageRequestId) {
-                        this.agentTracker.logCompletion({
-                            requestId: messageRequestId,
-                            success: false,
-                            duration: Date.now() - startTime,
-                            error: "No LLM providers are available",
-                        });
-                    }
-                    await this.messageProcessor.postErrorMessage(message.discussionId, "No LLM providers are available", message.workspaceId, message.mentionedOrDirectMessagedBotId);
-                    return;
-                }
-                console.log(`🤖 Processing request from ${message.userName} with ${provider.name} (Bot: ${message.mentionedOrDirectMessagedBotId})`);
-                // Check if Token Bot is mentioned with a token usage query - handle directly without LLM
-                // For other bots (like Manager Bot), they'll use LLM + tools to invite Token Bot
-                const tokenBotUserId = '691c07ad702e78dc33797c97';
-                if (this.config.tokenUsageBotEnabled &&
-                    this.tokenUsageBot.isTokenQuery(message.content) &&
-                    message.mentionedOrDirectMessagedBotId === tokenBotUserId) {
-                    console.log('📊 Token Bot query detected - generating report with direct JSON access');
-                    const detailedReport = this.tokenUsageBot.generateDetailedReport(message.discussionId);
-                    await this.messageProcessor.postMessage(message.discussionId, detailedReport, message.workspaceId, message.mentionedOrDirectMessagedBotId);
-                    // Token Bot leaves the discussion after posting report
-                    const tokenBotClient = this.multiBotManager.getBotClient(message.mentionedOrDirectMessagedBotId);
-                    if (tokenBotClient) {
-                        try {
-                            await tokenBotClient.client.socket.request('messenger.leave_discussion', [message.discussionId]);
-                            console.log('👋 Token Bot left the discussion after posting report');
-                        }
-                        catch (error) {
-                            console.error('❌ Failed to leave discussion:', error);
-                        }
-                    }
-                    // Log completion for token query
-                    if (messageRequestId) {
-                        this.agentTracker.logCompletion({
-                            requestId: messageRequestId,
-                            success: true,
-                            provider: 'token-usage-bot',
-                            toolsCalled: ['generate_detailed_report', 'leave_discussion'],
-                            responseContent: 'Token usage report generated and left discussion',
-                            duration: Date.now() - startTime,
-                        });
-                    }
-                    return; // Skip LLM processing
-                }
-                // Check if this is an agent activity query - handle directly without LLM (only if bot is enabled)
-                if (this.config.agentActivityBotEnabled && this.agentActivityBot.isActivityQuery(message.content)) {
-                    console.log('🤖 Agent activity query detected - generating report');
-                    const detailedReport = this.agentActivityBot.generateDetailedReport(message.discussionId);
-                    await this.messageProcessor.postMessage(message.discussionId, detailedReport, message.workspaceId, message.mentionedOrDirectMessagedBotId);
-                    // Log completion for activity query
-                    if (messageRequestId) {
-                        this.agentTracker.logCompletion({
-                            requestId: messageRequestId,
-                            success: true,
-                            provider: 'agent-activity-bot',
-                            toolsCalled: ['generate_detailed_report'],
-                            responseContent: 'Agent activity report generated',
-                            duration: Date.now() - startTime,
-                        });
-                    }
-                    return; // Skip LLM processing
-                }
-                // Generate and post personalized confirmation message (skip if empty)
-                const confirmationMessage = await provider.generateConfirmationMessage(message);
-                if (confirmationMessage) {
-                    await this.messageProcessor.postMessage(message.discussionId, confirmationMessage, message.workspaceId, message.mentionedOrDirectMessagedBotId);
-                }
-                const response = await this.processMessage(message, provider);
-                await this.handleResponse(message, response);
-                // LOG COMPLETION EVENT - Bot finished processing
-                if (messageRequestId) {
-                    const duration = Date.now() - startTime;
-                    this.agentTracker.logCompletion({
-                        requestId: messageRequestId,
-                        success: response.success,
-                        provider: provider.name,
-                        toolsCalled: response.toolCalls?.map((tc) => tc.toolName) || [],
-                        responseContent: response.response,
-                        duration: duration,
-                        error: response.error,
-                    });
-                    // ANALYZE LOGS - Check for tool call errors after conversation completes
-                    if (this.adaptiveDocBot) {
-                        this.adaptiveDocBot.analyzeAfterConversation().catch(error => {
-                            console.error('❌ Failed to analyze conversation errors:', error);
-                        });
-                    }
-                    // POST AGENT ACTIVITY SUMMARY - Automatically post summary if duration threshold met
-                    if (this.agentActivityBot.shouldPostSummary(message.discussionId, duration)) {
-                        try {
-                            const summary = this.agentActivityBot.generateSummary(messageRequestId, message.discussionId, duration, response.toolCalls?.map((tc) => tc.toolName) || []);
-                            await this.messageProcessor.postMessage(message.discussionId, summary, message.workspaceId, message.mentionedOrDirectMessagedBotId);
-                            this.agentActivityBot.markPosted(message.discussionId);
-                            console.log('🤖 Agent activity summary posted to discussion');
-                        }
-                        catch (error) {
-                            console.error('❌ Failed to post agent activity summary:', error);
-                        }
-                    }
-                    // LOG TOKEN USAGE - Track costs and usage for optimization
-                    if (response.tokens && response.tokens.cost !== undefined && response.success) {
-                        this.tokenTracker.logUsage({
-                            botId: message.mentionedOrDirectMessagedBotId,
-                            botName: mentionedBot.config.email, // Use email as bot name
-                            provider: provider.name,
-                            conversationId: message.discussionId,
-                            toolsCalled: response.toolCalls?.map((tc) => tc.toolName) || [],
-                            tokens: {
-                                input: response.tokens.input,
-                                output: response.tokens.output,
-                                total: response.tokens.total,
-                                cacheCreation: response.tokens.cacheCreation,
-                                cacheRead: response.tokens.cacheRead,
-                                cost: response.tokens.cost,
-                            },
-                            duration: Date.now() - startTime,
-                            success: true,
-                        });
-                        // POST TOKEN USAGE SUMMARY - Automatically post summary if cost threshold met
-                        if (this.tokenUsageBot.shouldPostSummary(message.discussionId, response.tokens.cost)) {
-                            try {
-                                const summary = await this.tokenUsageBot.generateSummary(message.discussionId, response.tokens.cost, response.tokens.total);
-                                await this.messageProcessor.postMessage(message.discussionId, summary, message.workspaceId, message.mentionedOrDirectMessagedBotId);
-                                this.tokenUsageBot.markPosted(message.discussionId);
-                                console.log('💰 Token usage summary posted to discussion');
-                            }
-                            catch (error) {
-                                console.error('❌ Failed to post token usage summary:', error);
-                            }
-                        }
-                    }
-                }
-            });
-            // Wait for all bot processing to complete
-            await Promise.all(processingPromises);
-        }
-        catch (error) {
-            console.error("❌ MCP Client: Error handling signal:", error);
-            // Log completion failure
-            if (requestId) {
-                this.agentTracker.logCompletion({
-                    requestId,
-                    success: false,
-                    duration: Date.now() - startTime,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-            // Remove from processed set on error
-            const msgId = signal.data?.msg_id;
-            if (msgId) {
-                this.processedMessages.delete(msgId);
-            }
-        }
-    }
-    getFirstEnabledProvider() {
-        for (const provider of this.providers.values()) {
-            if (provider.isEnabled()) {
-                return provider;
-            }
-        }
-        return null;
-    }
-    determineTriggerType(messageContent) {
-        // Check if message contains hailerTag mentions
-        const hailerTagPattern = /\[hailerTag\|[^\]]+\]\(([^)]+)\)/g;
-        if (hailerTagPattern.test(messageContent)) {
-            return "mention";
-        }
-        // Check for old @mcp-agent format (fallback)
-        if (messageContent.toLowerCase().includes("@mcp-agent")) {
-            return "mention";
-        }
-        // Otherwise it's a direct message
-        return "direct";
-    }
-    async processMessage(message, provider) {
-        try {
-            const botClient = this.multiBotManager.getBotClient(message.mentionedOrDirectMessagedBotId);
-            if (!botClient) {
-                throw new Error(`Bot client not found for mentionedOrDirectMessagedBotId '${message.mentionedOrDirectMessagedBotId}'`);
-            }
-            const result = await provider.processMessage(message, this.config.mcpServerUrl, botClient.config.mcpServerApiKey, botClient.config.email);
-            return result;
-        }
-        catch (error) {
-            console.error(`❌ MCP Client: Provider "${provider.name}" failed to process message:`, error);
-            return {
-                success: false,
-                error: `Processing failed: ${error instanceof Error ? error.message : String(error)}`,
-            };
-        }
-    }
-    async handleResponse(message, response) {
-        // Build complete message with tool usage info and main response
-        let combinedMessage = "";
-        // Add tool usage information if any tools were called
-        // COMMENTED OUT FOR SALES DEMO - uncomment to re-enable tool logs for developmen/debugging
-        // if (response.toolCalls && response.toolCalls.length > 0) {
-        //   const toolSummary = this.buildToolUsageSummary(response.toolCalls);
-        //   if (toolSummary) {
-        //     combinedMessage += `${toolSummary}\n\n`;
-        //   }
-        // }
-        // Add main response or error
-        if (response.success && response.response) {
-            combinedMessage += response.response;
-            await this.postSuccessResponse(message, combinedMessage.trim());
-        }
-        else if (!response.success && response.error) {
-            combinedMessage += `❌ Error: ${response.error}`;
-            await this.postErrorResponse(message, combinedMessage.trim());
-        }
-        else {
-            console.log(`❌Unhandled case while handling the message, response.success: ${response.success}; response.error: ${response.error}`);
-        }
-    }
-    async postSuccessResponse(message, content) {
-        await this.messageProcessor.postMessage(message.discussionId, content, message.workspaceId, message.mentionedOrDirectMessagedBotId);
-    }
-    buildToolUsageSummary(toolCalls) {
-        if (!toolCalls || toolCalls.length === 0) {
-            return "";
-        }
-        const successfulTools = toolCalls.filter((tc) => !tc.error);
-        const failedTools = toolCalls.filter((tc) => tc.error);
-        let summary = "";
-        if (successfulTools.length > 0) {
-            successfulTools.forEach((tc, index) => {
-                if (index > 0)
-                    summary += "\n\n";
-                summary += `🔧 Using tool: **${tc.toolName}**`;
-                if (tc.args && Object.keys(tc.args).length > 0) {
-                    summary += `\n\`\`\`json\n${JSON.stringify(tc.args, null, 2)}\n\`\`\``;
-                }
-            });
-        }
-        if (failedTools.length > 0) {
-            if (summary)
-                summary += "\n\n";
-            failedTools.forEach((tc, index) => {
-                if (index > 0)
-                    summary += "\n\n";
-                summary += `❌ Tool **${tc.toolName}** failed: ${tc.error}`;
-                if (tc.args && Object.keys(tc.args).length > 0) {
-                    summary += `\nArguments:\n\`\`\`json\n${JSON.stringify(tc.args, null, 2)}\n\`\`\``;
-                }
-            });
-        }
-        return summary;
-    }
-    async postErrorResponse(message, error) {
-        try {
-            await this.messageProcessor.postErrorMessage(message.discussionId, error, message.workspaceId, message.mentionedOrDirectMessagedBotId);
-        }
-        catch (postError) {
-            console.error(`❌ MCP Client: Failed to post error response:`, postError);
-        }
-    }
-    /** Shutdown the dependency: MultiBotManager */
-    async shutdownMultiBotManager() {
-        await this.multiBotManager.shutdown();
-    }
-    /** Shutdown the McpClient and MultiBotManager */
-    async shutdown() {
-        console.log('Shutting down MCP Client');
-        this.stop();
-        await this.shutdownMultiBotManager();
-        console.log('MCP Client shut down successfully');
-    }
-    getStatus() {
-        const enabledProviders = [];
-        for (const [name, provider] of this.providers) {
-            if (provider.isEnabled()) {
-                enabledProviders.push(name);
-            }
-        }
-        return {
-            active: this.isActive,
-            providersCount: this.providers.size,
-            enabledProviders,
-            activeSubscriptions: this.activeSubscriptions.size,
-            botClientsCount: this.multiBotManager.getAllBotClients().length,
-            directMessagesEnabled: this.config.enableDirectMessages,
-        };
-    }
-}
-exports.McpClient = McpClient;
-//# sourceMappingURL=mcp-client.js.map

package/dist/client/message-processor.d.ts

@@ -1,35 +0,0 @@
-/**
- * Message Processor for MCP Client
- * Handles incoming socket.io signals and processes messages that mention MCP agents
- * or are sent directly in one-on-one conversations with MCP agents
- */
-import { HailerSignal } from "../mcp/signal-handler";
-import { ChatMessage, MessageProcessor } from "./types";
-import { MultiBotManager } from "./multi-bot-manager";
-export declare class HailerMessageProcessor implements MessageProcessor {
-    private multiBotManager;
-    private mcpAgentIds;
-    private enableDirectMessages;
-    constructor(multiBotManager: MultiBotManager, mcpAgentIds?: string[], enableDirectMessages?: boolean);
-    shouldProcess(signal: HailerSignal): boolean;
-    private containsMcpAgentMention;
-    /**
-     * Fetch discussion participants to determine if it's a one-on-one conversation
-     * Uses messenger.load_discussions API to get actual member count
-     */
-    private fetchDiscussionParticipants;
-    /**
-     * Check if a discussion is a one-on-one conversation with a specific MCP agent
-     * @param discussionId - The discussion to check
-     * @param senderId - The user who sent the message
-     * @param botIdToCheck - The specific bot ID to check for direct message
-     * @returns The bot ID if it's a 1:1 conversation with that bot, null otherwise
-     */
-    private isDirectMessageToBot;
-    extractMessage(signal: HailerSignal): Promise<ChatMessage[]>;
-    private extractFromMessengerNew;
-    postMessage(discussionId: string, content: string, workspaceId?: string, botId?: string): Promise<boolean>;
-    postInfoMessage(discussionId: string, toolName: string, args: any, workspaceId?: string, botId?: string): Promise<boolean>;
-    postErrorMessage(discussionId: string, error: string, workspaceId?: string, botId?: string): Promise<boolean>;
-}
-//# sourceMappingURL=message-processor.d.ts.map