@hailer/mcp 0.0.1

package/dist/client/mcp-client.js

@@ -0,0 +1,532 @@
+"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 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 "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
+                const confirmationMessage = await provider.generateConfirmationMessage(message);
+                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

@@ -0,0 +1,35 @@
+/**
+ * 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