@hailer/mcp 0.1.16 → 0.2.1

package/dist/agents/shared/services/conversation-manager.js

@@ -1,136 +0,0 @@
-"use strict";
-/**
- * Conversation Manager Service
- *
- * Manages per-discussion conversation state:
- * - LRU cache of conversation histories
- * - Context size management with summarization
- * - Conversation state access
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConversationManager = void 0;
-class ConversationManager {
-    maxConversations;
-    maxContextMessages;
-    anthropicClient;
-    logger;
-    conversationsByDiscussion = new Map();
-    constructor(maxConversations, maxContextMessages, anthropicClient, logger) {
-        this.maxConversations = maxConversations;
-        this.maxContextMessages = maxContextMessages;
-        this.anthropicClient = anthropicClient;
-        this.logger = logger;
-    }
-    /**
-     * Get or create conversation history for a specific discussion
-     * Each discussion has its own isolated context to prevent bloat
-     * Uses LRU eviction when map exceeds maxConversations
-     */
-    getConversation(discussionId) {
-        let conversation = this.conversationsByDiscussion.get(discussionId);
-        if (conversation) {
-            // Move to end for LRU (delete and re-add to update insertion order)
-            this.conversationsByDiscussion.delete(discussionId);
-            this.conversationsByDiscussion.set(discussionId, conversation);
-            return conversation;
-        }
-        // Evict oldest conversations if at capacity
-        if (this.conversationsByDiscussion.size >= this.maxConversations) {
-            const toEvict = this.conversationsByDiscussion.size - this.maxConversations + 1;
-            const keys = [...this.conversationsByDiscussion.keys()].slice(0, toEvict);
-            for (const key of keys) {
-                this.conversationsByDiscussion.delete(key);
-            }
-            this.logger.debug("Evicted old conversations", { evicted: toEvict, remaining: this.conversationsByDiscussion.size });
-        }
-        conversation = [];
-        this.conversationsByDiscussion.set(discussionId, conversation);
-        this.logger.debug("Created new conversation context", { discussionId });
-        return conversation;
-    }
-    /**
-     * Add a message to a conversation
-     */
-    addMessage(discussionId, message) {
-        const conversation = this.getConversation(discussionId);
-        conversation.push(message);
-    }
-    /**
-     * Manage conversation context size - summarize if too large
-     */
-    async manageContextSize(discussionId) {
-        const conversation = this.getConversation(discussionId);
-        if (conversation.length > this.maxContextMessages) {
-            this.logger.info("Context size limit reached, summarizing", {
-                discussionId,
-                messageCount: conversation.length,
-            });
-            // Keep last 10 messages, summarize the rest
-            const toSummarize = conversation.slice(0, -10);
-            const toKeep = conversation.slice(-10);
-            // Create summary using LLM with structured content to mitigate prompt injection
-            const summaryResponse = await this.anthropicClient.messages.create({
-                model: "claude-haiku-4-5-20251001",
-                max_tokens: 1000,
-                messages: [
-                    {
-                        role: "user",
-                        content: [
-                            { type: "text", text: "Summarize this conversation context concisely, preserving key information. The conversation data follows in JSON format:" },
-                            { type: "text", text: JSON.stringify(toSummarize) },
-                        ],
-                    },
-                ],
-            });
-            const summary = summaryResponse.content
-                .filter((b) => b.type === "text")
-                .map(b => b.text)
-                .join("\n");
-            // Replace conversation with summary + recent messages
-            const newConversation = [
-                {
-                    role: "user",
-                    content: `<context_summary>${summary}</context_summary>`,
-                },
-                ...toKeep,
-            ];
-            this.conversationsByDiscussion.set(discussionId, newConversation);
-            this.logger.info("Context summarized", {
-                discussionId,
-                originalCount: toSummarize.length + toKeep.length,
-                newCount: newConversation.length,
-            });
-        }
-    }
-    /**
-     * Get conversation state for debugging
-     */
-    getState(currentDiscussionId) {
-        const currentConvo = currentDiscussionId
-            ? this.conversationsByDiscussion.get(currentDiscussionId)
-            : null;
-        return {
-            discussionCount: this.conversationsByDiscussion.size,
-            currentMessageCount: currentConvo?.length ?? 0,
-        };
-    }
-    /**
-     * Get full conversation for a discussion (for debugging)
-     */
-    getFullConversation(discussionId) {
-        if (!discussionId) {
-            // Return first conversation if no ID specified
-            const first = this.conversationsByDiscussion.values().next().value;
-            return first || [];
-        }
-        return this.conversationsByDiscussion.get(discussionId) || [];
-    }
-    /**
-     * Clear all conversations
-     */
-    clear() {
-        this.conversationsByDiscussion.clear();
-    }
-}
-exports.ConversationManager = ConversationManager;
-//# sourceMappingURL=conversation-manager.js.map

package/dist/agents/shared/services/mcp-client.d.ts

@@ -1,56 +0,0 @@
-/**
- * MCP Client Service
- *
- * Handles all communication with the MCP server:
- * - Tool schema loading
- * - Tool execution
- * - Response parsing
- */
-import { Logger } from "../../../lib/logger";
-import { ToolInput, McpToolResult } from "../../shared/types";
-/** MCP tool schema definition */
-export interface McpToolSchema {
-    name: string;
-    description?: string;
-    inputSchema?: {
-        type: string;
-        properties?: Record<string, unknown>;
-        required?: string[];
-    };
-}
-export declare class McpClientService {
-    private mcpServerUrl;
-    private mcpServerApiKey;
-    private loadedToolSchemas;
-    private logger;
-    constructor(mcpServerUrl: string, mcpServerApiKey: string, logger: Logger);
-    /**
-     * Mask sensitive data for safe logging
-     */
-    private maskApiKey;
-    /**
-     * Create safe error without exposing API key
-     */
-    private createSafeError;
-    /**
-     * Fetch tool schema from MCP server
-     */
-    fetchToolSchema(toolName: string): Promise<any>;
-    /**
-     * Call MCP tool
-     */
-    callMcpTool(name: string, args: ToolInput): Promise<McpToolResult>;
-    /**
-     * Load tool schema if not already loaded
-     */
-    loadToolSchemaIfNeeded(toolName: string): Promise<McpToolSchema | undefined>;
-    /**
-     * Get cached tool schema
-     */
-    getCachedToolSchema(toolName: string): McpToolSchema | undefined;
-    /**
-     * Clear tool schema cache
-     */
-    clearSchemaCache(): void;
-}
-//# sourceMappingURL=mcp-client.d.ts.map

package/dist/agents/shared/services/mcp-client.js

@@ -1,124 +0,0 @@
-"use strict";
-/**
- * MCP Client Service
- *
- * Handles all communication with the MCP server:
- * - Tool schema loading
- * - Tool execution
- * - Response parsing
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.McpClientService = void 0;
-class McpClientService {
-    mcpServerUrl;
-    mcpServerApiKey;
-    loadedToolSchemas = new Map();
-    logger;
-    constructor(mcpServerUrl, mcpServerApiKey, logger) {
-        this.mcpServerUrl = mcpServerUrl;
-        this.mcpServerApiKey = mcpServerApiKey;
-        this.logger = logger;
-    }
-    /**
-     * Mask sensitive data for safe logging
-     */
-    maskApiKey(key) {
-        if (!key || key.length < 8)
-            return '***';
-        return `${key.slice(0, 4)}...${key.slice(-4)}`;
-    }
-    /**
-     * Create safe error without exposing API key
-     */
-    createSafeError(message, originalError) {
-        const safeMessage = message.replace(this.mcpServerApiKey, this.maskApiKey(this.mcpServerApiKey));
-        const error = new Error(safeMessage);
-        if (originalError instanceof Error) {
-            error.stack = originalError.stack?.replace(this.mcpServerApiKey, this.maskApiKey(this.mcpServerApiKey));
-        }
-        return error;
-    }
-    /**
-     * Fetch tool schema from MCP server
-     */
-    async fetchToolSchema(toolName) {
-        const url = `${this.mcpServerUrl}?apiKey=${this.mcpServerApiKey}`;
-        const response = await fetch(url, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-                jsonrpc: "2.0",
-                id: Math.random().toString(36).substring(2),
-                method: "tools/get_schema",
-                params: { name: toolName },
-            }),
-        });
-        const text = await response.text();
-        const lines = text.split("\n");
-        for (const line of lines) {
-            if (line.startsWith("data: ")) {
-                const data = JSON.parse(line.substring(6));
-                if (data.result) {
-                    return {
-                        name: data.result.name,
-                        description: data.result.description,
-                        input_schema: data.result.inputSchema,
-                    };
-                }
-            }
-        }
-        throw this.createSafeError(`Failed to load schema for ${toolName}`);
-    }
-    /**
-     * Call MCP tool
-     */
-    async callMcpTool(name, args) {
-        const url = `${this.mcpServerUrl}?apiKey=${this.mcpServerApiKey}`;
-        const response = await fetch(url, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-                jsonrpc: "2.0",
-                id: Math.random().toString(36).substring(2),
-                method: "tools/call",
-                params: { name, arguments: args },
-            }),
-        });
-        const text = await response.text();
-        const lines = text.split("\n");
-        for (const line of lines) {
-            if (line.startsWith("data: ")) {
-                const data = JSON.parse(line.substring(6));
-                if (data.error) {
-                    throw this.createSafeError(data.error.message || String(data.error));
-                }
-                return data.result;
-            }
-        }
-        throw this.createSafeError("Failed to parse MCP response");
-    }
-    /**
-     * Load tool schema if not already loaded
-     */
-    async loadToolSchemaIfNeeded(toolName) {
-        if (!this.loadedToolSchemas.has(toolName)) {
-            const schema = await this.fetchToolSchema(toolName);
-            this.loadedToolSchemas.set(toolName, schema);
-        }
-        return this.loadedToolSchemas.get(toolName);
-    }
-    /**
-     * Get cached tool schema
-     */
-    getCachedToolSchema(toolName) {
-        return this.loadedToolSchemas.get(toolName);
-    }
-    /**
-     * Clear tool schema cache
-     */
-    clearSchemaCache() {
-        this.loadedToolSchemas.clear();
-    }
-}
-exports.McpClientService = McpClientService;
-//# sourceMappingURL=mcp-client.js.map

package/dist/agents/shared/services/message-classifier.d.ts

@@ -1,37 +0,0 @@
-/**
- * Message Classifier Service
- *
- * Handles incoming message extraction and classification:
- * - Extracts message content from Hailer signals
- * - Classifies message priority (high/normal)
- * - Detects mentions, replies, and DMs
- */
-import { Logger } from "../../../lib/logger";
-import { BotClient } from "../../bot-manager";
-import { HailerSignal } from "../../../mcp/signal-handler";
-import { IncomingMessage } from "../../shared/types";
-export declare class MessageClassifier {
-    private botUserId;
-    private botClient;
-    private logger;
-    private mentionPattern;
-    constructor(botUserId: string, botClient: BotClient, logger: Logger);
-    /**
-     * Extract and classify incoming message from signal
-     */
-    extractIncomingMessage(signal: HailerSignal): Promise<IncomingMessage | null>;
-    /**
-     * Check if message mentions this bot
-     * Uses pre-compiled regex pattern for performance
-     */
-    checkMention(content: string): boolean;
-    /**
-     * Check if message is a reply to one of our messages
-     */
-    checkReplyToBot(discussionId: string, messageId: string): Promise<boolean>;
-    /**
-     * Check if this is a 1:1 DM with the bot
-     */
-    checkDirectMessage(discussionId: string, senderId: string): Promise<boolean>;
-}
-//# sourceMappingURL=message-classifier.d.ts.map

package/dist/agents/shared/services/message-classifier.js

@@ -1,187 +0,0 @@
-"use strict";
-/**
- * Message Classifier Service
- *
- * Handles incoming message extraction and classification:
- * - Extracts message content from Hailer signals
- * - Classifies message priority (high/normal)
- * - Detects mentions, replies, and DMs
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageClassifier = void 0;
-class MessageClassifier {
-    botUserId;
-    botClient;
-    logger;
-    // Pre-compiled mention pattern for performance
-    mentionPattern;
-    constructor(botUserId, botClient, logger) {
-        this.botUserId = botUserId;
-        this.botClient = botClient;
-        this.logger = logger;
-        // Compile mention pattern once
-        this.mentionPattern = new RegExp(`\\[hailerTag\\|[^\\]]+\\]\\(${this.botUserId}\\)`, "i");
-    }
-    /**
-     * Extract and classify incoming message from signal
-     */
-    async extractIncomingMessage(signal) {
-        const { discussion, msg_id, uid } = signal.data;
-        // Skip our own messages
-        if (uid === this.botUserId) {
-            return null;
-        }
-        // Fetch the actual message content
-        let messageContent = "";
-        let senderName = "Unknown";
-        try {
-            const response = await this.botClient.client.socket.request("v3.discussion.message.latest", [discussion]);
-            const messages = response?.messages || [];
-            const targetMessage = messages.find((msg) => msg._id === msg_id);
-            if (!targetMessage) {
-                return null;
-            }
-            messageContent = targetMessage.msg || targetMessage.content || "";
-            // Get sender name: try workspace cache first, then message field
-            const cachedUser = this.botClient.workspaceCache?.usersById[uid];
-            const cachedName = cachedUser?.fullName ?? `${cachedUser?.firstname || ''} ${cachedUser?.lastname || ''}`.trim();
-            senderName = cachedName || targetMessage.userName || "Unknown";
-            // Skip system messages
-            if (targetMessage.type && targetMessage.type !== "user") {
-                return null;
-            }
-        }
-        catch (error) {
-            this.logger.warn("Could not fetch message content", { error });
-            return null;
-        }
-        // Classify priority
-        const isMention = this.checkMention(messageContent);
-        const isReplyToBot = await this.checkReplyToBot(discussion, msg_id);
-        const isDirectMessage = await this.checkDirectMessage(discussion, uid);
-        // Get linked activity ID, name, and workspace ID from discussion metadata
-        let linkedActivityId;
-        let linkedActivityName;
-        let discussionWorkspaceId;
-        try {
-            const discussionResponse = await this.botClient.client.socket.request("messenger.load_discussions", [[discussion]]);
-            if (discussionResponse && discussionResponse[discussion]) {
-                const discData = discussionResponse[discussion];
-                linkedActivityId = discData.linked_activity;
-                linkedActivityName = discData.name; // Discussion name is usually the activity name
-                discussionWorkspaceId = discData.cid; // Workspace ID (cid = company ID in Hailer)
-                this.logger.debug("Discussion metadata loaded", {
-                    discussionId: discussion,
-                    linkedActivityId: linkedActivityId || "none",
-                    linkedActivityName: linkedActivityName || "none",
-                    hasLinkedActivity: !!linkedActivityId,
-                    cid: discussionWorkspaceId || "not in response",
-                    discDataKeys: Object.keys(discData).join(","),
-                });
-            }
-        }
-        catch (error) {
-            this.logger.debug("Failed to load discussion metadata", {
-                discussionId: discussion,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-        let priority = "normal";
-        let priorityReason = "General chat message";
-        if (isDirectMessage) {
-            priority = "high";
-            priorityReason = "Direct message (1:1 conversation)";
-        }
-        else if (isMention) {
-            priority = "high";
-            priorityReason = "Bot mentioned in message";
-        }
-        else if (isReplyToBot) {
-            priority = "high";
-            priorityReason = "Reply to bot's message";
-        }
-        // Extract workspaceId - prefer discussion metadata (accurate), fallback to signal
-        // Discussion metadata contains authoritative workspace ID from Hailer
-        const workspaceId = discussionWorkspaceId || signal.workspaceId;
-        if (!workspaceId) {
-            this.logger.warn("Cannot determine workspace - rejecting message for isolation safety", {
-                discussionId: discussion,
-                messageId: msg_id,
-                discussionWorkspaceId: discussionWorkspaceId || "none",
-                signalWorkspaceId: signal.workspaceId || "none",
-            });
-            return null;
-        }
-        // Debug log workspace context (normal in multi-tenant setup)
-        if (discussionWorkspaceId) {
-            this.logger.debug("Message workspace context", {
-                discussionId: discussion,
-                workspaceId: discussionWorkspaceId,
-            });
-        }
-        return {
-            id: msg_id,
-            discussionId: discussion,
-            workspaceId,
-            linkedActivityId,
-            linkedActivityName,
-            senderId: uid,
-            senderName,
-            content: messageContent,
-            timestamp: signal.timestamp,
-            priority,
-            priorityReason,
-            isReplyToBot,
-            isMention,
-            isDirectMessage,
-        };
-    }
-    /**
-     * Check if message mentions this bot
-     * Uses pre-compiled regex pattern for performance
-     */
-    checkMention(content) {
-        return this.mentionPattern.test(content);
-    }
-    /**
-     * Check if message is a reply to one of our messages
-     */
-    async checkReplyToBot(discussionId, messageId) {
-        try {
-            const response = await this.botClient.client.socket.request("v3.discussion.message.latest", [discussionId]);
-            const messages = response?.messages || [];
-            const targetMessage = messages.find((msg) => msg._id === messageId);
-            if (targetMessage?.replyTo) {
-                const repliedToMessage = messages.find((msg) => msg._id === targetMessage.replyTo);
-                return repliedToMessage?.uid === this.botUserId;
-            }
-        }
-        catch {
-            // Ignore errors
-        }
-        return false;
-    }
-    /**
-     * Check if this is a 1:1 DM with the bot
-     */
-    async checkDirectMessage(discussionId, senderId) {
-        try {
-            const response = await this.botClient.client.socket.request("messenger.load_discussions", [[discussionId]]);
-            if (response && response[discussionId]) {
-                const discussion = response[discussionId];
-                const participants = discussion.participants || [];
-                // 1:1 = exactly 2 participants: sender and bot
-                if (participants.length === 2) {
-                    return participants.includes(this.botUserId) &&
-                        participants.includes(senderId);
-                }
-            }
-        }
-        catch {
-            // Ignore errors
-        }
-        return false;
-    }
-}
-exports.MessageClassifier = MessageClassifier;
-//# sourceMappingURL=message-classifier.js.map

package/dist/agents/shared/services/message-formatter.d.ts

@@ -1,89 +0,0 @@
-/**
- * Message Formatter Service
- *
- * Handles formatting of messages for Hailer:
- * - Converting @mentions and #activity tags to Hailer tags
- * - Resolving user/activity IDs via API
- * - Extracting tag links for messenger.send
- */
-import { BotClient } from "../../bot-manager";
-import { Logger } from "../../../lib/logger";
-import { McpToolCallback } from "../../shared/types";
-export declare class MessageFormatterService {
-    private botClient;
-    private logger;
-    private callMcpTool;
-    constructor(botClient: BotClient, logger: Logger, callMcpTool: McpToolCallback);
-    /**
-     * Sanitize display name to prevent tag injection attacks
-     * Removes/escapes characters that could break the tag format
-     */
-    private sanitizeDisplayName;
-    /**
-     * Validate that targetId is a valid MongoDB ObjectId format
-     */
-    private isValidTargetId;
-    /**
-     * Format a Hailer tag for mentioning a user or activity
-     * Hailer requires ZWNBSP (U+FEFF) around the tag
-     */
-    private formatHailerTag;
-    /**
-     * Look up user by ID and create a Hailer tag
-     */
-    private createUserTagById;
-    /**
-     * Look up user by name and create a Hailer tag
-     */
-    private createUserTagByName;
-    /**
-     * Convert @mentions and #activity tags in response to Hailer tags
-     * Supports:
-     * - @userId (24-char hex MongoDB ID) → user tag
-     * - @"Full Name" (quoted name lookup) → user tag
-     * - @FirstName (single word name lookup) → user tag
-     * - #activityId (24-char hex) → activity tag
-     * - #"Activity Name" (quoted) → activity tag (requires lookup)
-     */
-    convertMentionsToTags(content: string): string;
-    /**
-     * Resolve user tags - look up names for IDs via API when not in cache
-     * Handles @userId (24-char hex) format
-     */
-    resolveUserTags(content: string): Promise<string>;
-    /**
-     * Resolve activity tags - look up names for IDs and IDs for names
-     * Handles both #activityId and #"Activity Name" formats
-     */
-    resolveActivityTags(content: string): Promise<string>;
-    /**
-     * Convert Hailer URLs to Hailer tags
-     * Handles:
-     * - https://app.hailer.com/#/activities/{activityId}
-     * - https://app.hailer.com/#/discussions/{discussionId}
-     */
-    resolveHailerUrls(content: string): Promise<string>;
-    /**
-     * Extract link metadata from hailerTag formatted content
-     * Returns array of links for the messenger.send API
-     */
-    extractTagLinks(content: string): Array<{
-        target: string;
-        targetType: string;
-        type: string;
-    }>;
-    /**
-     * Format incoming message for LLM consumption
-     */
-    formatIncomingMessage(message: {
-        discussionId: string;
-        linkedActivityId?: string;
-        senderName: string;
-        senderId: string;
-        timestamp: number;
-        priority: string;
-        priorityReason: string;
-        content: string;
-    }): string;
-}
-//# sourceMappingURL=message-formatter.d.ts.map