@hailer/mcp 1.0.29 → 1.1.2

package/dist/bot/operation-logger.d.ts

@@ -0,0 +1,28 @@
+/**
+ * OperationLogger - Centralized inline logging for bot operations.
+ *
+ * Produces structured single-line log entries for message flow,
+ * balance checks, routing, LLM calls, tool calls, and responses.
+ */
+export declare class OperationLogger {
+    messageIn(discussionId: string, from: string, content: string): void;
+    balanceCheck(discussionId: string, workspaceId: string, balance: number, status: string): void;
+    route(discussionId: string, classification: string, model: string, content: string): void;
+    llmCall(discussionId: string, model: string, inTokens: number, outTokens: number, cacheHitPct: number, durationSec: number): void;
+    toolCall(discussionId: string, toolName: string, summary: string, durationSec: number, status: 'OK' | 'FAIL', errorPreview?: string): void;
+    permDenied(discussionId: string, toolName: string, workflowId: string, userId: string): void;
+    permFiltered(discussionId: string, toolName: string, before: number, after: number): void;
+    messageOut(discussionId: string, charCount: number, tagCount: number): void;
+    engage(discussionId: string, trigger: string): void;
+    disengage(discussionId: string, nonResponses: number): void;
+    coalesce(discussionId: string, count: number): void;
+    interrupt(discussionId: string, reason: string): void;
+    contextInject(discussionId: string, count: number): void;
+    progress(discussionId: string): void;
+}
+/**
+ * Generate a human-readable summary from a tool result.
+ * Used by bot.ts executeTools() to produce concise TOOL CALL log summaries.
+ */
+export declare function summarizeToolResult(toolName: string, resultText: string): string;
+//# sourceMappingURL=operation-logger.d.ts.map

package/dist/bot/operation-logger.js

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * OperationLogger - Centralized inline logging for bot operations.
+ *
+ * Produces structured single-line log entries for message flow,
+ * balance checks, routing, LLM calls, tool calls, and responses.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationLogger = void 0;
+exports.summarizeToolResult = summarizeToolResult;
+const logger_1 = require("../lib/logger");
+const logger = (0, logger_1.createLogger)({ component: 'ops' });
+/** Shorten discussion ID to first 8 chars */
+function did(discussionId) {
+    return `d:${discussionId.slice(0, 8)}..`;
+}
+/** Shorten model name for log readability */
+function shortModel(model) {
+    if (model.includes('sonnet-4-5'))
+        return 'sonnet-4.5';
+    if (model.includes('haiku-4-5'))
+        return 'haiku-4.5';
+    if (model.includes('sonnet'))
+        return 'sonnet';
+    if (model.includes('haiku'))
+        return 'haiku';
+    return model;
+}
+/** Truncate string to maxLen chars, collapsing newlines */
+function trunc(s, maxLen = 80) {
+    const clean = s.replace(/\n/g, ' ').trim();
+    return clean.length > maxLen ? clean.slice(0, maxLen) + '...' : clean;
+}
+class OperationLogger {
+    messageIn(discussionId, from, content) {
+        logger.info(`MSG IN    | ${did(discussionId)} | from:${from} | "${trunc(content, 60)}"`);
+    }
+    balanceCheck(discussionId, workspaceId, balance, status) {
+        logger.info(`BALANCE   | ${did(discussionId)} | ws:${workspaceId.slice(0, 8)}.. | ${balance} tokens | ${status}`);
+    }
+    route(discussionId, classification, model, content) {
+        logger.info(`ROUTE     | ${did(discussionId)} | ${classification} -> ${shortModel(model)} | "${trunc(content, 60)}"`);
+    }
+    llmCall(discussionId, model, inTokens, outTokens, cacheHitPct, durationSec) {
+        logger.info(`LLM CALL  | ${did(discussionId)} | ${shortModel(model)} | ${inTokens} in / ${outTokens} out | cache: ${cacheHitPct}% | ${durationSec.toFixed(1)}s`);
+    }
+    toolCall(discussionId, toolName, summary, durationSec, status, errorPreview) {
+        let line = `TOOL CALL | ${did(discussionId)} | ${toolName} | ${summary} | ${durationSec.toFixed(1)}s | ${status}`;
+        if (errorPreview)
+            line += ` | "${trunc(errorPreview)}"`;
+        logger.info(line);
+    }
+    permDenied(discussionId, toolName, workflowId, userId) {
+        logger.warn(`PERM DENY | ${did(discussionId)} | ${toolName} | wf:${workflowId.slice(0, 8)}.. | user:${userId.slice(0, 8)}..`);
+    }
+    permFiltered(discussionId, toolName, before, after) {
+        logger.info(`PERM FILT | ${did(discussionId)} | ${toolName} | ${before} -> ${after} workflows`);
+    }
+    messageOut(discussionId, charCount, tagCount) {
+        logger.info(`MSG OUT   | ${did(discussionId)} | ${charCount} chars | ${tagCount} tags`);
+    }
+    engage(discussionId, trigger) {
+        logger.info(`ENGAGE    | ${did(discussionId)} | ${trigger}`);
+    }
+    disengage(discussionId, nonResponses) {
+        logger.info(`DISENGAGE | ${did(discussionId)} | ${nonResponses} non-responses`);
+    }
+    coalesce(discussionId, count) {
+        logger.info(`COALESCE  | ${did(discussionId)} | ${count} messages`);
+    }
+    interrupt(discussionId, reason) {
+        logger.info(`INTERRUPT | ${did(discussionId)} | ${reason}`);
+    }
+    contextInject(discussionId, count) {
+        logger.info(`CTX INJ   | ${did(discussionId)} | ${count} messages`);
+    }
+    progress(discussionId) {
+        logger.info(`PROGRESS  | ${did(discussionId)}`);
+    }
+}
+exports.OperationLogger = OperationLogger;
+/**
+ * Generate a human-readable summary from a tool result.
+ * Used by bot.ts executeTools() to produce concise TOOL CALL log summaries.
+ */
+function summarizeToolResult(toolName, resultText) {
+    try {
+        const json = JSON.parse(resultText);
+        // create_activity
+        if (toolName === 'create_activity') {
+            if (json.created_ids)
+                return `${json.created_ids.length} activit${json.created_ids.length === 1 ? 'y' : 'ies'}`;
+            if (json.name)
+                return `1 activity: ${trunc(json.name, 40)}`;
+        }
+        // list_activities
+        if (toolName === 'list_activities') {
+            const count = json.stats?.total ?? json.activities?.length ?? json.length;
+            if (count !== undefined)
+                return `${count} results`;
+        }
+        // list_workflows / list_workflows_minimal
+        if (toolName.includes('list_workflows')) {
+            const count = json.workflows?.length ?? json.length;
+            if (count !== undefined)
+                return `${count} workflows`;
+        }
+        // get_workflow_schema
+        if (toolName === 'get_workflow_schema') {
+            const count = json.fields?.length ?? Object.keys(json.fields || {}).length;
+            if (count)
+                return `${count} fields`;
+        }
+        // count_activities
+        if (toolName === 'count_activities') {
+            if (json.total !== undefined)
+                return `${json.total} activities`;
+        }
+        // search_workspace_users
+        if (toolName === 'search_workspace_users') {
+            const count = json.users?.length ?? json.length;
+            if (count !== undefined)
+                return `${count} users`;
+        }
+    }
+    catch {
+        // Not JSON, fall through
+    }
+    // Fallback: first 80 chars of result text
+    return trunc(resultText);
+}
+//# sourceMappingURL=operation-logger.js.map

package/dist/bot/services/conversation-manager.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Conversation Manager Service
+ *
+ * Manages per-discussion conversation state:
+ * - LRU cache of conversation histories
+ * - Context size management with summarization
+ * - Conversation state access
+ */
+import Anthropic from "@anthropic-ai/sdk";
+import { Logger } from "../../lib/logger";
+/** Conversation message using Anthropic's MessageParam type */
+export type ConversationMessage = Anthropic.MessageParam;
+export declare class ConversationManager {
+    private maxConversations;
+    private maxContextMessages;
+    private logger;
+    private conversationsByDiscussion;
+    constructor(maxConversations: number, maxContextMessages: number, 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: string): ConversationMessage[];
+    /**
+     * Add a message to a conversation
+     */
+    addMessage(discussionId: string, message: ConversationMessage): void;
+    /**
+     * Manage conversation context size - truncate if too large
+     * Generates a programmatic summary of dropped messages before truncating
+     */
+    manageContextSize(discussionId: string): void;
+    /**
+     * Build a compact programmatic summary of dropped messages (no LLM call)
+     */
+    private summarizeDroppedMessages;
+    /**
+     * Get conversation state for debugging
+     */
+    getState(currentDiscussionId?: string): {
+        discussionCount: number;
+        currentMessageCount: number;
+    };
+    /**
+     * Get full conversation for a discussion (for debugging)
+     */
+    getFullConversation(discussionId?: string): ConversationMessage[];
+    /**
+     * Clear all conversations
+     */
+    clear(): void;
+    /**
+     * Prepare conversation for API call with Anthropic prompt caching
+     * Adds cache_control to the last assistant message to cache conversation history
+     * Returns a COPY - does not modify the original conversation
+     */
+    prepareForCaching(conversation: ConversationMessage[]): ConversationMessage[];
+}
+//# sourceMappingURL=conversation-manager.d.ts.map

package/dist/bot/services/conversation-manager.js

@@ -0,0 +1,246 @@
+"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;
+    logger;
+    conversationsByDiscussion = new Map();
+    constructor(maxConversations, maxContextMessages, logger) {
+        this.maxConversations = maxConversations;
+        this.maxContextMessages = maxContextMessages;
+        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 - truncate if too large
+     * Generates a programmatic summary of dropped messages before truncating
+     */
+    manageContextSize(discussionId) {
+        const conversation = this.getConversation(discussionId);
+        if (conversation.length > this.maxContextMessages) {
+            const originalCount = conversation.length;
+            const keepCount = Math.floor(this.maxContextMessages * 0.6);
+            const dropped = conversation.slice(0, -keepCount);
+            const toKeep = conversation.slice(-keepCount);
+            // Build summary of what's being dropped
+            const summary = this.summarizeDroppedMessages(dropped);
+            // Merge or prepend summary to preserve user/assistant alternation
+            let result;
+            if (toKeep.length > 0 && toKeep[0].role === "user") {
+                // First kept message is user — merge summary into it to avoid consecutive user messages
+                const first = toKeep[0];
+                if (typeof first.content === "string") {
+                    toKeep[0] = { role: "user", content: `${summary}\n\n${first.content}` };
+                }
+                else if (Array.isArray(first.content)) {
+                    toKeep[0] = {
+                        role: "user",
+                        content: [{ type: "text", text: summary }, ...first.content],
+                    };
+                }
+                result = toKeep;
+            }
+            else {
+                // First kept message is assistant — safe to prepend user summary
+                result = [{ role: "user", content: summary }, ...toKeep];
+            }
+            this.conversationsByDiscussion.set(discussionId, result);
+            this.logger.debug("Context truncated with summary", {
+                discussionId,
+                originalCount,
+                newCount: result.length,
+                dropped: dropped.length,
+            });
+        }
+    }
+    /**
+     * Build a compact programmatic summary of dropped messages (no LLM call)
+     */
+    summarizeDroppedMessages(dropped) {
+        const senders = new Set();
+        const tools = new Set();
+        const userSnippets = [];
+        for (const msg of dropped) {
+            if (msg.role === "user") {
+                const content = typeof msg.content === "string"
+                    ? msg.content
+                    : Array.isArray(msg.content)
+                        ? msg.content
+                            .filter((b) => b.type === "text")
+                            .map((b) => b.text)
+                            .join(" ")
+                        : "";
+                // Extract sender from <incoming from="Name">
+                const fromMatch = content.match(/from="([^"]+)"/);
+                if (fromMatch)
+                    senders.add(fromMatch[1]);
+                if (content && !content.startsWith("<context")) {
+                    userSnippets.push(content.slice(0, 100));
+                }
+            }
+            else if (msg.role === "assistant" && Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    if (block.type === "tool_use") {
+                        tools.add(block.name);
+                    }
+                }
+            }
+        }
+        const parts = [
+            `Prior conversation (${dropped.length} messages truncated):`,
+        ];
+        if (senders.size > 0)
+            parts.push(`- Participants: ${[...senders].join(", ")}`);
+        if (tools.size > 0)
+            parts.push(`- Tools used: ${[...tools].join(", ")}`);
+        if (userSnippets.length > 0) {
+            parts.push(`- First topic: ${userSnippets[0]}...`);
+            if (userSnippets.length > 1) {
+                parts.push(`- Last topic: ${userSnippets[userSnippets.length - 1]}...`);
+            }
+        }
+        return `<context type="truncated-history">\n${parts.join("\n")}\n</context>`;
+    }
+    /**
+     * 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();
+    }
+    /**
+     * Prepare conversation for API call with Anthropic prompt caching
+     * Adds cache_control to the last assistant message to cache conversation history
+     * Returns a COPY - does not modify the original conversation
+     */
+    prepareForCaching(conversation) {
+        // Sanitize: remove any messages with empty content (prevents API 400 errors)
+        for (let i = conversation.length - 1; i >= 0; i--) {
+            const msg = conversation[i];
+            const content = msg.content;
+            const isEmpty = !content || (Array.isArray(content) && content.length === 0) ||
+                (typeof content === 'string' && content.trim() === '');
+            if (isEmpty) {
+                this.logger.warn('Removed empty content message from conversation', {
+                    index: i, role: msg.role, contentType: typeof content,
+                });
+                conversation.splice(i, 1);
+            }
+        }
+        if (conversation.length < 2) {
+            // Need at least one exchange to cache
+            return conversation;
+        }
+        // Find the last assistant message (should be second-to-last, before new user message)
+        let lastAssistantIndex = -1;
+        for (let i = conversation.length - 1; i >= 0; i--) {
+            if (conversation[i].role === "assistant") {
+                lastAssistantIndex = i;
+                break;
+            }
+        }
+        if (lastAssistantIndex === -1) {
+            // No assistant message found
+            return conversation;
+        }
+        // Shallow copy with targeted cache_control modification
+        const cached = conversation.map((msg, index) => {
+            if (index !== lastAssistantIndex) {
+                return msg;
+            }
+            // This is the last assistant message - add cache_control
+            const content = msg.content;
+            if (typeof content === "string") {
+                // Convert string to block format with cache_control
+                return {
+                    role: msg.role,
+                    content: [
+                        {
+                            type: "text",
+                            text: content,
+                            cache_control: { type: "ephemeral" },
+                        },
+                    ],
+                };
+            }
+            if (Array.isArray(content) && content.length > 0) {
+                // Add cache_control to the last block
+                const newContent = content.map((block, blockIndex) => {
+                    if (blockIndex === content.length - 1) {
+                        return { ...block, cache_control: { type: "ephemeral" } };
+                    }
+                    return block;
+                });
+                return { role: msg.role, content: newContent };
+            }
+            return msg;
+        });
+        return cached;
+    }
+}
+exports.ConversationManager = ConversationManager;
+//# sourceMappingURL=conversation-manager.js.map

package/dist/bot/services/index.d.ts

@@ -0,0 +1,9 @@
+export { ConversationManager } from './conversation-manager';
+export { MessageClassifier } from './message-classifier';
+export { MessageFormatterService } from './message-formatter';
+export { TypingIndicatorService } from './typing-indicator';
+export { TokenBillingService } from './token-billing';
+export { SessionLoggerService } from './session-logger';
+export { WorkspaceSchemaCacheService } from './workspace-schema-cache';
+export type { BotConnection, McpToolCallback } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/bot/services/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceSchemaCacheService = exports.SessionLoggerService = exports.TokenBillingService = exports.TypingIndicatorService = exports.MessageFormatterService = exports.MessageClassifier = exports.ConversationManager = void 0;
+var conversation_manager_1 = require("./conversation-manager");
+Object.defineProperty(exports, "ConversationManager", { enumerable: true, get: function () { return conversation_manager_1.ConversationManager; } });
+var message_classifier_1 = require("./message-classifier");
+Object.defineProperty(exports, "MessageClassifier", { enumerable: true, get: function () { return message_classifier_1.MessageClassifier; } });
+var message_formatter_1 = require("./message-formatter");
+Object.defineProperty(exports, "MessageFormatterService", { enumerable: true, get: function () { return message_formatter_1.MessageFormatterService; } });
+var typing_indicator_1 = require("./typing-indicator");
+Object.defineProperty(exports, "TypingIndicatorService", { enumerable: true, get: function () { return typing_indicator_1.TypingIndicatorService; } });
+var token_billing_1 = require("./token-billing");
+Object.defineProperty(exports, "TokenBillingService", { enumerable: true, get: function () { return token_billing_1.TokenBillingService; } });
+var session_logger_1 = require("./session-logger");
+Object.defineProperty(exports, "SessionLoggerService", { enumerable: true, get: function () { return session_logger_1.SessionLoggerService; } });
+var workspace_schema_cache_1 = require("./workspace-schema-cache");
+Object.defineProperty(exports, "WorkspaceSchemaCacheService", { enumerable: true, get: function () { return workspace_schema_cache_1.WorkspaceSchemaCacheService; } });
+//# sourceMappingURL=index.js.map

package/dist/bot/services/message-classifier.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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 { HailerSignal } from "../../mcp/signal-handler";
+import { BotConnection, IncomingMessage, HailerMessage } from "./types";
+export declare class MessageClassifier {
+    private botUserId;
+    private botConnection;
+    private logger;
+    private mentionPattern;
+    constructor(botUserId: string, botConnection: BotConnection, 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 using pre-fetched messages.
+     * Avoids a redundant API call by reusing the messages already fetched in extractIncomingMessage.
+     */
+    checkReplyInMessages(messages: HailerMessage[], messageId: string): boolean;
+    /**
+     * Check if this is a 1:1 DM with the bot using pre-loaded discussion data.
+     * Avoids a redundant API call by reusing discussion data already fetched in extractIncomingMessage.
+     */
+    checkDirectMessageFromData(discData: any, senderId: string): boolean;
+    /**
+     * Check if this is a 1:1 DM with the bot (fallback - fetches discussion from API)
+     */
+    checkDirectMessage(discussionId: string, senderId: string): Promise<boolean>;
+}
+//# sourceMappingURL=message-classifier.d.ts.map