@hailer/mcp 0.1.6 → 0.1.9

package/dist/client/message-processor.js

@@ -1,357 +0,0 @@
-"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;
-            // Validate required fields
-            if (!uid || !discussion) {
-                console.warn("❌ MCP Client: Missing uid or discussion in messenger.new signal");
-                return [];
-            }
-            // 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/providers/anthropic-provider.d.ts

@@ -1,19 +0,0 @@
-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