@hailer/mcp 0.0.1

package/dist/client/message-processor.js

@@ -0,0 +1,352 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HailerMessageProcessor = void 0;
+class HailerMessageProcessor {
+    multiBotManager;
+    mcpAgentIds;
+    enableDirectMessages;
+    constructor(multiBotManager, mcpAgentIds = [], enableDirectMessages = false) {
+        this.multiBotManager = multiBotManager;
+        this.mcpAgentIds = mcpAgentIds;
+        this.enableDirectMessages = enableDirectMessages;
+    }
+    shouldProcess(signal) {
+        // Only process discussion.message and messenger.new signals
+        if (signal.type !== "discussion.message" &&
+            signal.type !== "messenger.new") {
+            return false;
+        }
+        // For messenger.new signals, we'll check both hailerTag mentions and direct messages in extractMessage
+        if (signal.type === "messenger.new") {
+            return true; // Let extractMessage handle all the logic
+        }
+        // For discussion.message signals, check here
+        const messageContent = signal.data?.message?.content || "";
+        return this.containsMcpAgentMention(messageContent).found;
+    }
+    containsMcpAgentMention(content) {
+        if (this.mcpAgentIds.length === 0) {
+            // Fallback to old @mcp-agent detection if no agent IDs configured
+            return {
+                found: content.toLowerCase().includes("@mcp-agent"),
+                mentionedBotIds: [],
+            };
+        }
+        // Check for hailerTag mentions of our MCP agents
+        // Pattern: [hailerTag|Agent Name](agentUserId)
+        const hailerTagPattern = /\[hailerTag\|[^\]]+\]\(([^)]+)\)/g;
+        let match;
+        const mentionedBotIds = [];
+        while ((match = hailerTagPattern.exec(content)) !== null) {
+            const mentionedUserId = match[1];
+            if (this.mcpAgentIds.includes(mentionedUserId)) {
+                mentionedBotIds.push(mentionedUserId);
+                console.log(`✅ MCP Client: Found mention of bot: ${mentionedUserId}`);
+            }
+        }
+        return { found: mentionedBotIds.length > 0, mentionedBotIds };
+    }
+    /**
+     * Fetch discussion participants to determine if it's a one-on-one conversation
+     * Uses messenger.load_discussions API to get actual member count
+     */
+    async fetchDiscussionParticipants(discussionId, botClient) {
+        try {
+            // Try messenger.load_discussions - it expects an array of discussion IDs
+            const response = await botClient.client.socket.request("messenger.load_discussions", [[discussionId]]);
+            // Response is an object with discussionId as key
+            if (response && response[discussionId]) {
+                const discussion = response[discussionId];
+                // First try: Use the 'participants' array which has plain user IDs
+                if (discussion.participants && Array.isArray(discussion.participants)) {
+                    console.log(`📊 MCP Client: Discussion has ${discussion.participants.length} participant(s)`);
+                    return discussion.participants;
+                }
+                // Fallback: Use 'members' array and extract IDs
+                if (discussion.members && Array.isArray(discussion.members)) {
+                    const memberIds = [];
+                    for (const member of discussion.members) {
+                        // Members have format: { id: "user_USERID", ... }
+                        if (member && member.id && typeof member.id === "string") {
+                            // Extract the actual user ID from "user_USERID" format
+                            const userId = member.id.replace(/^user_/, "");
+                            memberIds.push(userId);
+                        }
+                        else if (typeof member === "string") {
+                            memberIds.push(member);
+                        }
+                        else if (member && member._id) {
+                            memberIds.push(member._id);
+                        }
+                    }
+                    console.log(`📊 MCP Client: Discussion has ${memberIds.length} member(s)`);
+                    return memberIds;
+                }
+            }
+            const messagesResponse = await botClient.client.socket.request("v3.discussion.message.latest", [discussionId]);
+            const messages = messagesResponse?.messages || [];
+            const participantIds = new Set();
+            // Extract unique participant IDs from messages
+            for (const message of messages) {
+                if (message.uid) {
+                    participantIds.add(message.uid);
+                }
+            }
+            // Add the bot itself as a participant
+            participantIds.add(botClient.userId);
+            const participants = Array.from(participantIds);
+            console.log(`📊 MCP Client: Discussion has ${participants.length} participant(s) (message-based fallback)`);
+            return participants;
+        }
+        catch (error) {
+            console.error(`❌ MCP Client: Failed to fetch discussion participants:`, error);
+            // On error, also try fallback
+            try {
+                const messagesResponse = await botClient.client.socket.request("v3.discussion.message.latest", [discussionId]);
+                const messages = messagesResponse?.messages || [];
+                const participantIds = new Set();
+                for (const message of messages) {
+                    if (message.uid) {
+                        participantIds.add(message.uid);
+                    }
+                }
+                participantIds.add(botClient.userId);
+                const participants = Array.from(participantIds);
+                console.log(`📊 MCP Client: Discussion has ${participants.length} participant(s) (error recovery)`);
+                return participants;
+            }
+            catch (fallbackError) {
+                console.error(`❌ MCP Client: All participant detection methods failed`);
+                return [];
+            }
+        }
+    }
+    /**
+     * 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
+     */
+    async isDirectMessageToBot(discussionId, senderId, botIdToCheck) {
+        // Get the bot client for the specific bot we're checking
+        const botClient = this.multiBotManager.getBotClient(botIdToCheck);
+        if (!botClient) {
+            console.warn(`⚠️ MCP Client: No bot client found for bot ID: ${botIdToCheck}`);
+            return null;
+        }
+        const participants = await this.fetchDiscussionParticipants(discussionId, botClient);
+        // For a one-on-one conversation, we expect exactly 2 participants
+        if (participants.length !== 2) {
+            return null;
+        }
+        // Check if the two participants are the sender and the bot we're checking for
+        const includesSender = participants.includes(senderId);
+        const includesBot = participants.includes(botIdToCheck);
+        if (includesSender && includesBot) {
+            console.log(`✅ MCP Client: 1:1 chat detected - will respond without tag`);
+            return botIdToCheck;
+        }
+        return null;
+    }
+    async extractMessage(signal) {
+        try {
+            if (!this.shouldProcess(signal)) {
+                return [];
+            }
+            if (signal.type === "messenger.new") {
+                return await this.extractFromMessengerNew(signal);
+            }
+            else {
+                // For discussion.message signals
+                const messageData = signal.data?.message;
+                if (!messageData) {
+                    console.warn("❌ MCP Client: No message data in signal");
+                    return [];
+                }
+                const messageContent = messageData.content || "";
+                const mentionResult = this.containsMcpAgentMention(messageContent);
+                if (!mentionResult.found) {
+                    return [];
+                }
+                // Create a message for each mentioned bot
+                const messages = [];
+                for (const botId of mentionResult.mentionedBotIds) {
+                    const extractedMessage = {
+                        id: messageData._id || `msg-${Date.now()}`,
+                        content: messageContent,
+                        timestamp: signal.timestamp,
+                        discussionId: messageData.discussion || "",
+                        userId: messageData.user || "",
+                        userName: messageData.userName || "Unknown User",
+                        workspaceId: signal.workspaceId,
+                        mentionedOrDirectMessagedBotId: botId,
+                    };
+                    messages.push(extractedMessage);
+                }
+                console.log(`🤖 MCP Client: Processing message from ${messages[0]?.userName} for ${messages.length} bot(s)`);
+                return messages;
+            }
+        }
+        catch (error) {
+            console.error("❌ MCP Client: Failed to extract message from signal:", error);
+            return [];
+        }
+    }
+    async extractFromMessengerNew(signal) {
+        try {
+            const { discussion, msg_id, uid } = signal.data;
+            // IMPORTANT: Ignore messages from our own bots to prevent loops
+            if (this.mcpAgentIds.includes(uid)) {
+                console.log(`🔇 MCP Client: Ignoring message from bot ${uid} (preventing self-trigger loop)`);
+                return [];
+            }
+            // Try to fetch the message with the first available bot client to check mentions
+            const botClients = this.multiBotManager.getAllBotClients();
+            let targetMessage = null;
+            let messageContent = "";
+            let workingBotClient = null;
+            // Try each bot client until we find the message
+            for (const botClient of botClients) {
+                try {
+                    // Fetch the message content using the discussion message API
+                    const response = await botClient.client.socket.request("v3.discussion.message.latest", [discussion]);
+                    // Extract messages from the response object
+                    const messages = response?.messages || [];
+                    // Find the specific message by ID
+                    targetMessage = messages.find((msg) => msg._id === msg_id);
+                    if (targetMessage) {
+                        messageContent = targetMessage.msg || targetMessage.content || "";
+                        workingBotClient = botClient;
+                        break; // Found the message, no need to try other bots
+                    }
+                }
+                catch (error) {
+                    // Continue with next bot client if this one fails
+                    continue;
+                }
+            }
+            if (!targetMessage || !workingBotClient) {
+                console.warn(`❌ MCP Client: Could not find message ${msg_id} in discussion ${discussion} with any bot client`);
+                return [];
+            }
+            // Filter out system messages (like "Hi, I created this group!" or user invites)
+            const msgType = targetMessage.type;
+            if (msgType && msgType !== "user") {
+                console.log(`🔇 MCP Client: Ignoring system message type "${msgType}" (discussion: ${discussion})`);
+                return [];
+            }
+            // Also check for common system message patterns
+            const systemMessagePatterns = [
+                /^Hi, I created this group!$/i,
+                /^I invited .+ to this group\.?$/i,
+                /^.+ was invited to this group\.?$/i,
+                /^.+ joined the group\.?$/i,
+                /^.+ left the group\.?$/i,
+            ];
+            for (const pattern of systemMessagePatterns) {
+                if (pattern.test(messageContent.trim())) {
+                    console.log(`🔇 MCP Client: Ignoring system message pattern: "${messageContent}" (discussion: ${discussion})`);
+                    return [];
+                }
+            }
+            // First, check if the message contains an explicit mention of one of our MCP agents
+            const mentionResult = this.containsMcpAgentMention(messageContent);
+            let handlingBotIds = mentionResult.mentionedBotIds;
+            // If no explicit mention found, check if this is a direct message to one of our bots (if enabled)
+            if (handlingBotIds.length === 0 && this.enableDirectMessages) {
+                // Check each bot to see if this is a 1:1 conversation with that specific bot
+                for (const botId of this.mcpAgentIds) {
+                    const directMessageBotId = await this.isDirectMessageToBot(discussion, uid, botId);
+                    if (directMessageBotId) {
+                        handlingBotIds = [directMessageBotId];
+                        break; // Found a 1:1 conversation, no need to check other bots
+                    }
+                }
+            }
+            if (handlingBotIds.length === 0) {
+                return []; // No mention and not a direct message to our bot
+            }
+            // Validate that all bot clients exist
+            const validBotIds = [];
+            for (const botId of handlingBotIds) {
+                const botClient = this.multiBotManager.getBotClient(botId);
+                if (botClient) {
+                    validBotIds.push(botId);
+                }
+                else {
+                    console.warn(`❌ MCP Client: No bot client found for bot ID: ${botId}`);
+                }
+            }
+            if (validBotIds.length === 0) {
+                console.warn(`❌ MCP Client: No valid bot clients found for processing`);
+                return [];
+            }
+            // Fetch user info if needed
+            const userName = targetMessage.userName || "Unknown User";
+            // Create messages for each mentioned bot
+            const messages = [];
+            for (const botId of validBotIds) {
+                const extractedMessage = {
+                    id: targetMessage._id,
+                    content: messageContent,
+                    timestamp: signal.timestamp,
+                    discussionId: discussion,
+                    userId: uid,
+                    userName: userName,
+                    workspaceId: signal.workspaceId,
+                    mentionedOrDirectMessagedBotId: botId,
+                };
+                messages.push(extractedMessage);
+            }
+            // Clean content for logging (remove hailerTag mentions)
+            const cleanContent = messageContent
+                .replace(/\[hailerTag\|[^\]]+\]\([^)]+\)/g, "")
+                .trim();
+            const messageType = mentionResult.found ? "mentioned" : "direct message";
+            console.log(`🤖 MCP Client: Processing ${messageType} from ${messages[0]?.userName} for ${messages.length} bot(s): "${cleanContent}"`);
+            return messages;
+        }
+        catch (error) {
+            console.error("❌ MCP Client: Failed to extract messenger.new message:", error);
+            return [];
+        }
+    }
+    async postMessage(discussionId, content, workspaceId, botId) {
+        try {
+            // Use the specified bot or fall back to the first available bot
+            const botClient = botId
+                ? this.multiBotManager.getBotClient(botId)
+                : this.multiBotManager.getAllBotClients()[0];
+            if (!botClient) {
+                console.error(`❌ MCP Client: No bot client available for posting message (botId: ${botId})`);
+                return false;
+            }
+            // Use the bot's socket client to post the message
+            const result = await botClient.client.socket.request("messenger.send", [
+                { msg: content },
+                discussionId,
+            ]);
+            return true;
+        }
+        catch (error) {
+            console.error("❌ MCP Client: Failed to post message via socket:", error);
+            return false;
+        }
+    }
+    async postInfoMessage(discussionId, toolName, args, workspaceId, botId) {
+        const infoContent = `🔧 Using tool: **${toolName}**\n\`\`\`json\n${JSON.stringify(args, null, 2)}\n\`\`\``;
+        return this.postMessage(discussionId, infoContent, workspaceId, botId);
+    }
+    async postErrorMessage(discussionId, error, workspaceId, botId) {
+        const errorContent = `❌ Error: ${error}`;
+        return this.postMessage(discussionId, errorContent, workspaceId, botId);
+    }
+}
+exports.HailerMessageProcessor = HailerMessageProcessor;
+//# sourceMappingURL=message-processor.js.map

package/dist/client/multi-bot-manager.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Multi-Bot Client Manager
+ * Manages multiple bot clients, each with their own Hailer connection
+ */
+import { HailerClient } from "../mcp/hailer-clients";
+import { SignalHandler } from "../mcp/signal-handler";
+import { BotClientConfig } from "./types";
+export interface BotClient {
+    userId: string;
+    config: BotClientConfig;
+    client: HailerClient;
+    signalHandler: SignalHandler;
+}
+export declare class MultiBotManager {
+    private botConfigs;
+    private botClients;
+    constructor(botConfigs: BotClientConfig[]);
+    initializeAllHailerClientsFromConfig(): Promise<void>;
+    getBotClient(userId: string): BotClient | undefined;
+    getAllBotClients(): BotClient[];
+    getBotIds(): string[];
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=multi-bot-manager.d.ts.map

package/dist/client/multi-bot-manager.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Multi-Bot Client Manager
+ * Manages multiple bot clients, each with their own Hailer connection
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiBotManager = void 0;
+const hailer_clients_1 = require("../mcp/hailer-clients");
+const signal_handler_1 = require("../mcp/signal-handler");
+class MultiBotManager {
+    botConfigs;
+    botClients = new Map();
+    constructor(botConfigs) {
+        this.botConfigs = botConfigs;
+    }
+    // for client we may put initializeAllConfigClients method to do it at once
+    // in case we only use MCP Server:
+    // for MCP Server it may just get a specific client and this class initialize it specifically and even kill it later if not needed
+    async initializeAllHailerClientsFromConfig() {
+        console.log(`🤖 Initializing ${this.botConfigs.length} bot clients...`);
+        for (const config of this.botConfigs) {
+            try {
+                // Use shared connection pool via API key lookup
+                const client = await (0, hailer_clients_1.createHailerClientByApiKey)(config.mcpServerApiKey);
+                // Get user ID automatically from authenticated session
+                const userId = await (0, hailer_clients_1.getCurrentUserId)(client);
+                const signalHandler = new signal_handler_1.SignalHandler(client, undefined);
+                const botClient = {
+                    userId,
+                    config,
+                    client,
+                    signalHandler,
+                };
+                this.botClients.set(userId, botClient);
+                console.log(`✅ Bot client initialized for ${config.email} (${userId}) via API key ${config.mcpServerApiKey.substring(0, 8)}...`);
+            }
+            catch (error) {
+                console.error(`❌ Failed to initialize bot client for ${config.email}:`, error);
+                // Continue with other bots even if one fails
+            }
+        }
+        console.log(`✅ Initialized ${this.botClients.size} bot clients successfully`);
+    }
+    getBotClient(userId) {
+        const botClient = this.botClients.get(userId);
+        if (!botClient) {
+            console.warn(`❌ No bot client found for userId: ${userId}`);
+        }
+        return botClient;
+    }
+    getAllBotClients() {
+        return Array.from(this.botClients.values());
+    }
+    getBotIds() {
+        return Array.from(this.botClients.keys());
+    }
+    async shutdown() {
+        console.log("🤖 Shutting down all bot clients...");
+        for (const [userId, botClient] of this.botClients) {
+            try {
+                // Properly disconnect from shared connection pool
+                (0, hailer_clients_1.disconnectHailerClientByApiKey)(botClient.config.mcpServerApiKey);
+                console.log(`✅ Bot client ${userId} shut down (API key: ${botClient.config.mcpServerApiKey.substring(0, 8)}...)`);
+            }
+            catch (error) {
+                console.error(`❌ Error shutting down bot client ${userId}:`, error);
+            }
+        }
+        this.botClients.clear();
+        console.log("✅ All bot clients shut down");
+    }
+}
+exports.MultiBotManager = MultiBotManager;
+//# sourceMappingURL=multi-bot-manager.js.map

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

@@ -0,0 +1,19 @@
+import { ChatMessage, McpResponse } from "../types";
+import { LlmProvider } from "./llm-provider";
+export declare class AnthropicProvider extends LlmProvider {
+    private client;
+    private contextManager;
+    private toolSchemaLoader;
+    private toolExecutor;
+    private toolSchemaCache;
+    constructor(config: any);
+    generateConfirmationMessage(userMessage: ChatMessage): Promise<string>;
+    processMessage(userMessage: ChatMessage, mcpServerUrl: string, botMcpApiKey: string, botEmail: string): Promise<McpResponse>;
+    /**
+     * Fetch specific tool schema on-demand
+     * Token-efficient: ~690 tokens per tool vs loading all tools upfront
+     */
+    private fetchMcpToolSchema;
+    protected callMcpTool(mcpServerUrl: string, mcpServerApiKey: string, request: any): Promise<any>;
+}
+//# sourceMappingURL=anthropic-provider.d.ts.map