@hailer/mcp 0.1.16 → 0.2.1

package/dist/agents/shared/base.js

@@ -1,846 +0,0 @@
-"use strict";
-/**
- * Chat Agent Daemon
- *
- * A persistent LLM conversation that monitors all workspace chats.
- * The LLM maintains context across messages and decides what to respond to.
- *
- * Architecture:
- * - One daemon per bot client
- * - Subscribes to ALL messenger.new signals (not filtered)
- * - LLM sees every message with priority markers
- * - LLM decides: RESPOND / IGNORE / ACTION
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChatAgentDaemon = void 0;
-const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
-const hailer_clients_1 = require("../../mcp/hailer-clients");
-const logger_1 = require("../../lib/logger");
-const tool_schema_loader_1 = require("./tool-schema-loader");
-const tool_registry_1 = require("../../mcp/tool-registry");
-const agent_registry_1 = require("./services/agent-registry");
-const conversation_manager_1 = require("./services/conversation-manager");
-const mcp_client_1 = require("./services/mcp-client");
-const message_formatter_1 = require("./services/message-formatter");
-const message_classifier_1 = require("./services/message-classifier");
-const session_logger_1 = require("./services/session-logger");
-const tool_executor_1 = require("./services/tool-executor");
-const workspace_schema_cache_1 = require("./services/workspace-schema-cache");
-const bot_config_1 = require("../../mcp/tools/bot-config");
-const config_1 = require("../../config");
-class ChatAgentDaemon {
-    logger;
-    client;
-    botClient;
-    config;
-    toolSchemaLoader = new tool_schema_loader_1.ToolSchemaLoader();
-    // Processing state
-    isProcessing = false;
-    messageQueue = [];
-    processedMessageIds = new Set();
-    // Typing indicator state
-    typingInterval = null;
-    typingDiscussionId = null;
-    static TYPING_REFRESH_MS = 3000; // Refresh typing every 3 seconds
-    // Tool schemas (loaded once)
-    toolIndex = [];
-    minimalTools = [];
-    // ===== SERVICES =====
-    /** Message classifier - handles message extraction and priority classification */
-    messageClassifier = null;
-    /** Conversation manager - handles per-discussion context and LRU cache */
-    conversationManager = null;
-    /** MCP client service - handles tool schema loading and execution */
-    mcpClient = null;
-    /** Tool executor - handles tool execution and write tracking */
-    toolExecutor = null;
-    /** Agent registration service - handles Agent Directory, Position, Team, etc. */
-    registryService = null;
-    /** Message formatting service - handles tag resolution and formatting */
-    messageFormatter = null;
-    /** Session logging service - handles activity session tracking */
-    sessionLogger = null;
-    /** Workspace schema cache - dynamic workflow/field ID lookup */
-    schemaCache = null;
-    /** Current discussion context for tracking */
-    currentDiscussionId = null;
-    currentLinkedActivityId = null;
-    /** Unsubscribe function for messenger.new signals */
-    messengerUnsubscribe = null;
-    /** Original API key for cleanup - stored at init because botClient.config may change */
-    originalApiKey = null;
-    constructor(config) {
-        this.config = config;
-        this.botClient = config.botClient;
-        this.logger = (0, logger_1.createLogger)({
-            component: "ChatAgentDaemon",
-            botId: config.botClient.userId
-        });
-        this.client = new sdk_1.default({
-            apiKey: config.anthropicApiKey,
-        });
-    }
-    /**
-     * Initialize the daemon - load tools and subscribe to signals
-     */
-    async initialize() {
-        this.logger.info("Initializing Chat Agent Daemon", {
-            botId: this.botClient.userId,
-            email: (0, config_1.maskEmail)(this.botClient.config.email),
-        });
-        // Load tool index once
-        const allowedGroups = [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE];
-        let tools = await this.toolSchemaLoader.loadToolIndex({
-            mcpServerUrl: this.config.mcpServerUrl,
-            mcpServerApiKey: this.botClient.config.mcpServerApiKey,
-            allowedGroups,
-        });
-        // Filter by whitelist if agent specifies one
-        const whitelist = this.getToolWhitelist();
-        if (whitelist) {
-            tools = tools.filter((t) => whitelist.includes(t.name));
-            this.logger.debug("Tools filtered by whitelist", {
-                total: tools.length,
-                whitelist: whitelist.length
-            });
-        }
-        this.toolIndex = tools;
-        this.minimalTools = this.toolSchemaLoader.toMinimalToolDefinitions(this.toolIndex);
-        this.logger.debug("Tools loaded", { toolCount: this.toolIndex.length });
-        // Initialize MCP client service (must be first - other services depend on it)
-        this.mcpClient = new mcp_client_1.McpClientService(this.config.mcpServerUrl, this.botClient.config.mcpServerApiKey, this.logger);
-        // Get workspace ID early - needed for schema cache and registration
-        const workspaceId = this.botClient.workspaceCache?.currentWorkspace?._id || "";
-        // Initialize workspace schema cache FIRST (discovers workflows dynamically)
-        // This MUST happen before agent registration so we have dynamic workflow IDs
-        this.schemaCache = new workspace_schema_cache_1.WorkspaceSchemaCacheService(this.logger, this.mcpClient.callMcpTool.bind(this.mcpClient));
-        // Initialize schema for current workspace (may install template if missing)
-        if (workspaceId) {
-            await this.schemaCache.initializeForWorkspace(workspaceId);
-        }
-        // Initialize conversation manager
-        this.conversationManager = new conversation_manager_1.ConversationManager(100, // maxConversations
-        this.config.maxContextMessages || 50, this.client, this.logger);
-        // Initialize tool executor
-        this.toolExecutor = new tool_executor_1.ToolExecutor(this.mcpClient, this.logger);
-        // Initialize message classifier
-        this.messageClassifier = new message_classifier_1.MessageClassifier(this.botClient.userId, this.botClient, this.logger);
-        // Create agent registry service WITH schema cache for dynamic ID lookup
-        this.registryService = new agent_registry_1.AgentRegistryService(this.schemaCache, this.logger, this.mcpClient.callMcpTool.bind(this.mcpClient), this.getDefaultTeamId.bind(this));
-        // Initialize message formatter service
-        this.messageFormatter = new message_formatter_1.MessageFormatterService(this.botClient, this.logger, this.mcpClient.callMcpTool.bind(this.mcpClient));
-        // Build agent info from config and abstract methods
-        const { firstName, lastName } = this.getAgentName();
-        const agentInfo = {
-            firstName,
-            lastName,
-            description: this.getAgentDescription(),
-            email: this.botClient.config.email,
-            userId: this.botClient.userId,
-        };
-        // Try to load from cache first (workspace-scoped, 1 API call to verify)
-        const cacheLoaded = await this.registryService.loadFromCache(this.botClient.userId, workspaceId);
-        if (!cacheLoaded) {
-            // Cache miss or invalid - do full registration using dynamic schema lookup
-            this.logger.info("Starting full agent registration", { workspaceId });
-            await this.registryService.registerAllAgentData(agentInfo, this.getPositionDetails(), this.config.mcpServerUrl, this.toolIndex, workspaceId);
-        }
-        // Store the API key at initialization for cleanup
-        // This is critical because botClient.config.mcpServerApiKey may change during daemon restart
-        this.originalApiKey = this.botClient.config.mcpServerApiKey;
-        // Subscribe to messenger.new signals using the working signal system (same as BugMonitor)
-        this.messengerUnsubscribe = (0, hailer_clients_1.subscribeToSignal)(this.botClient.config.mcpServerApiKey, 'messenger.new', (eventData) => {
-            // Convert raw event data to HailerSignal format expected by handleSignal
-            const signal = {
-                type: 'messenger.new',
-                data: eventData,
-                timestamp: Date.now(),
-                workspaceId: eventData.sid,
-            };
-            this.handleSignal(signal);
-        });
-        if (this.messengerUnsubscribe) {
-            this.logger.info("Subscribed to messenger.new signals via HailerClientManager");
-        }
-        else {
-            this.logger.warn("Failed to subscribe to messenger.new signals - no client manager found");
-        }
-        // Initialize session logger service (after registration so we have agentDirectoryId)
-        this.sessionLogger = new session_logger_1.SessionLoggerService(this.registryService?.getAgentDirectoryId() ?? null, this.logger, this.mcpClient.callMcpTool.bind(this.mcpClient), this.getDefaultTeamId.bind(this));
-        // Pass Anthropic client for conversation summary generation
-        this.sessionLogger.setAnthropicClient(this.client);
-        // Pass schema cache for dynamic workflow ID lookup
-        if (workspaceId && this.schemaCache) {
-            this.sessionLogger.setSchemaCache(this.schemaCache, workspaceId);
-        }
-        // Start idle session check timer (every 30 seconds)
-        this.sessionLogger.startIdleCheckTimer(30_000);
-        // Load existing discussions the bot is already a member of
-        await this.loadExistingDiscussions();
-        this.logger.info("Chat Agent Daemon initialized and listening", {
-            workspaceId,
-            agentDirectoryId: this.registryService.getAgentDirectoryId(),
-            positionId: this.registryService.getPositionId(),
-            teamId: this.registryService.getTeamId(),
-        });
-    }
-    /**
-     * Load existing discussions the bot is already a member of
-     * This ensures the bot can respond to messages in discussions it was added to before startup
-     */
-    async loadExistingDiscussions() {
-        if (!this.conversationManager) {
-            this.logger.warn("Cannot load existing discussions - conversationManager not initialized");
-            return;
-        }
-        try {
-            // Use bot's hailer connection directly to get discussions
-            const hailerClient = this.botClient.client;
-            if (!hailerClient) {
-                this.logger.warn("Cannot load existing discussions - hailer client not available");
-                return;
-            }
-            // Call discussion sync API directly via socket
-            const syncResponse = await hailerClient.socket.request('v2.discussion.sync', [{ timestamp: 0 }]);
-            const discussions = syncResponse?.discussions || [];
-            if (discussions.length === 0) {
-                this.logger.debug("Bot is not a member of any discussions");
-                return;
-            }
-            this.logger.info("Loading existing discussions", { count: discussions.length });
-            // Pre-populate ConversationManager with each discussion
-            for (const discussion of discussions) {
-                // Create an empty conversation entry - messages will come via signals
-                this.conversationManager.getConversation(discussion._id);
-                this.logger.debug("Registered existing discussion", {
-                    discussionId: discussion._id,
-                    name: discussion.name || "Untitled"
-                });
-            }
-            this.logger.info("Existing discussions loaded", {
-                loaded: discussions.length,
-                totalTracked: this.conversationManager.getState().discussionCount
-            });
-        }
-        catch (error) {
-            this.logger.warn("Failed to load existing discussions", { error });
-            // Non-fatal - bot will still work for new messages
-        }
-    }
-    /**
-     * Extract and classify incoming message from signal
-     * Can be overridden in subclasses to customize filtering
-     */
-    async extractIncomingMessage(signal) {
-        return this.messageClassifier.extractIncomingMessage(signal);
-    }
-    /**
-     * Handle incoming signal from Hailer
-     */
-    async handleSignal(signal) {
-        try {
-            // EARLY dedup check using raw signal data (before async operation)
-            // This prevents race condition where two signals arrive simultaneously
-            const signalData = signal.data;
-            const rawMsgId = signalData.msg_id;
-            if (rawMsgId) {
-                if (this.processedMessageIds.has(rawMsgId)) {
-                    this.logger.debug("Early dedup: skipping duplicate signal", { rawMsgId });
-                    return;
-                }
-                // Add immediately to prevent race condition
-                this.processedMessageIds.add(rawMsgId);
-            }
-            const message = await this.extractIncomingMessage(signal);
-            if (!message) {
-                // Remove from set if extraction failed (message was invalid)
-                if (rawMsgId)
-                    this.processedMessageIds.delete(rawMsgId);
-                return;
-            }
-            // Clean up old IDs (keep last 500)
-            if (this.processedMessageIds.size > 500) {
-                const ids = Array.from(this.processedMessageIds);
-                this.processedMessageIds = new Set(ids.slice(-250));
-            }
-            this.logger.info("Incoming message", {
-                from: message.senderName,
-                discussion: message.discussionId,
-                priority: message.priority,
-                reason: message.priorityReason,
-                preview: message.content.substring(0, 50),
-            });
-            // Queue the message
-            this.messageQueue.push(message);
-            // Process if not already processing
-            if (!this.isProcessing) {
-                await this.processQueue();
-            }
-        }
-        catch (error) {
-            this.logger.error("Failed to handle signal", error);
-        }
-    }
-    /**
-     * Process queued messages through the LLM
-     * Note: Uses flag-first pattern to prevent race conditions
-     */
-    async processQueue() {
-        // Set flag FIRST to prevent race condition (multiple async calls)
-        if (this.isProcessing)
-            return;
-        this.isProcessing = true;
-        // Now check queue (after claiming the lock)
-        if (this.messageQueue.length === 0) {
-            this.isProcessing = false;
-            return;
-        }
-        try {
-            // Sort by priority (high first) then by timestamp
-            this.messageQueue.sort((a, b) => {
-                const priorityOrder = { high: 0, normal: 1, low: 2 };
-                if (priorityOrder[a.priority] !== priorityOrder[b.priority]) {
-                    return priorityOrder[a.priority] - priorityOrder[b.priority];
-                }
-                return a.timestamp - b.timestamp;
-            });
-            // Process one message at a time for now
-            while (this.messageQueue.length > 0) {
-                const message = this.messageQueue.shift();
-                await this.processMessage(message);
-            }
-        }
-        finally {
-            this.isProcessing = false;
-        }
-    }
-    /**
-     * Process a single message through the persistent LLM conversation
-     */
-    async processMessage(message) {
-        // Check if bot is still enabled (may have been disabled via AI Hub)
-        const botState = (0, bot_config_1.getBotState)();
-        if (!botState[this.config.botClient.userId]) {
-            this.logger.info("Bot disabled, skipping message", {
-                discussion: message.discussionId,
-                from: message.senderName,
-            });
-            return;
-        }
-        const startTime = Date.now();
-        // Update current context for session tracking
-        this.currentDiscussionId = message.discussionId;
-        this.currentLinkedActivityId = message.linkedActivityId || null;
-        // Multi-tenant: Initialize schema cache for this workspace on-demand
-        // Each workspace has its own workflow IDs - must be cached before processing
-        if (this.schemaCache && message.workspaceId) {
-            const schemas = this.schemaCache.getSchemas(message.workspaceId);
-            if (!schemas?.initialized) {
-                this.logger.info("Initializing schema cache for workspace", { workspaceId: message.workspaceId });
-                await this.schemaCache.initializeForWorkspace(message.workspaceId);
-                // Update session logger with workspace-specific schema
-                if (this.sessionLogger) {
-                    this.sessionLogger.setSchemaCache(this.schemaCache, message.workspaceId);
-                }
-            }
-        }
-        // Start typing indicator with auto-refresh
-        this.startTypingIndicator(message.discussionId);
-        // Get or create activity session
-        const session = this.sessionLogger.getOrCreateActivitySession(message);
-        session.lastActivityTime = Date.now();
-        session.metrics.messagesProcessed++;
-        // Add user message to conversation log (compact version)
-        const userSnippet = message.content.length > 100
-            ? message.content.substring(0, 100) + "..."
-            : message.content;
-        session.conversation.push(`${message.senderName}: ${userSnippet}`);
-        // Format incoming message for LLM
-        const incomingContent = this.formatIncomingMessage(message);
-        // Get conversation for THIS discussion (isolated context)
-        const conversation = this.conversationManager.getConversation(message.discussionId);
-        // Load memory from Hailer if this is a new conversation for an activity
-        if (conversation.length === 0 && message.linkedActivityId) {
-            await this.injectMemoryForActivity(conversation, message.linkedActivityId, message.workspaceId);
-        }
-        // Append to conversation
-        conversation.push({
-            role: "user",
-            content: incomingContent,
-        });
-        // Check context size and summarize if needed
-        await this.conversationManager.manageContextSize(message.discussionId);
-        try {
-            // Call LLM with this discussion's conversation
-            const response = await this.client.messages.create({
-                model: this.config.model || "claude-haiku-4-5-20251001",
-                max_tokens: 2000,
-                system: this.getSystemPrompt(),
-                messages: conversation,
-                tools: this.getTools(),
-            });
-            // Track token usage in the activity session
-            if (response.usage) {
-                session.metrics.inputTokens += response.usage.input_tokens;
-                session.metrics.outputTokens += response.usage.output_tokens;
-            }
-            // Handle response
-            await this.handleLlmResponse(response, message);
-            const duration = Date.now() - startTime;
-            this.logger.info("Message processed", {
-                discussion: message.discussionId,
-                duration,
-                stopReason: response.stop_reason,
-                sessionActivity: session.activityName,
-            });
-            // Update last activity time (idle checker will flush when needed)
-            session.lastActivityTime = Date.now();
-        }
-        catch (error) {
-            this.logger.error("LLM processing failed", error);
-            // Stop typing indicator on error
-            this.stopTypingIndicator();
-            // On error, remove the message from conversation to avoid poisoning context
-            if (conversation.length > 0) {
-                conversation.pop();
-            }
-        }
-    }
-    /**
-     * Format incoming message for LLM consumption
-     */
-    formatIncomingMessage(message) {
-        const priorityTag = message.priority === "high" ? " priority=\"high\"" : "";
-        const reasonAttr = message.priority === "high" ? ` reason="${message.priorityReason}"` : "";
-        const activityAttr = message.linkedActivityId ? ` activity_id="${message.linkedActivityId}"` : "";
-        return `<incoming discussion="${message.discussionId}"${activityAttr} from="${message.senderName}" user_id="${message.senderId}" timestamp="${new Date(message.timestamp).toISOString()}"${priorityTag}${reasonAttr}>
-${message.content}
-</incoming>`;
-    }
-    /**
-     * Load and inject memory for an activity into conversation context
-     * Called when entering a new discussion that's linked to an activity
-     */
-    async injectMemoryForActivity(conversation, activityId, workspaceId) {
-        try {
-            const memoryEntries = await this.sessionLogger.loadMemoryForActivity(activityId, workspaceId, 5);
-            if (memoryEntries.length > 0) {
-                const memoryContext = this.sessionLogger.formatMemoryForContext(memoryEntries);
-                // Inject memory as a system-like user message at the start
-                conversation.push({
-                    role: "user",
-                    content: memoryContext,
-                });
-                // Add acknowledgment to keep conversation valid (assistant must respond)
-                conversation.push({
-                    role: "assistant",
-                    content: "I've loaded context from previous interactions with this activity. I'll use this to provide better continuity.",
-                });
-                this.logger.info("Injected memory into conversation", {
-                    activityId,
-                    memoryCount: memoryEntries.length,
-                });
-            }
-        }
-        catch (error) {
-            this.logger.warn("Failed to inject memory", {
-                activityId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            // Continue without memory - not critical
-        }
-    }
-    /**
-     * Execute tool calls and continue the conversation
-     * Simple passthrough - just execute tools and return results to LLM
-     */
-    async executeToolsAndContinue(toolUseBlocks, originalMessage) {
-        // Get current activity session
-        const sessionKey = this.currentLinkedActivityId || this.currentDiscussionId || "default";
-        const session = this.sessionLogger.getSession(sessionKey);
-        // Store the user's request that triggered these tool calls (for context)
-        if (session && !session.triggerRequest) {
-            session.triggerRequest = originalMessage.content.substring(0, 500);
-            session.requestedBy = originalMessage.senderName;
-            session.requestedById = originalMessage.senderId;
-        }
-        // Execute tools using the tool executor service
-        const toolResults = await this.toolExecutor.executeTools(toolUseBlocks, {
-            session,
-            preprocessToolInput: this.preprocessToolInput.bind(this),
-        });
-        // Get conversation for this discussion
-        const conversation = this.conversationManager.getConversation(originalMessage.discussionId);
-        // Add tool results to conversation
-        conversation.push({
-            role: "user",
-            content: toolResults,
-        });
-        // Continue with LLM
-        const response = await this.client.messages.create({
-            model: this.config.model || "claude-haiku-4-5-20251001",
-            max_tokens: 2000,
-            system: this.getSystemPrompt(),
-            messages: conversation,
-            tools: this.getTools(),
-        });
-        // Track token usage in session
-        if (session && response.usage) {
-            session.metrics.inputTokens += response.usage.input_tokens;
-            session.metrics.outputTokens += response.usage.output_tokens;
-            session.lastActivityTime = Date.now();
-        }
-        // Recursively handle (might need more tools or finally respond)
-        await this.handleLlmResponse(response, originalMessage);
-    }
-    /**
-     * Handle LLM response
-     * Override in subclasses to customize response handling
-     */
-    async handleLlmResponse(response, originalMessage) {
-        // Get conversation for this discussion
-        const conversation = this.conversationManager.getConversation(originalMessage.discussionId);
-        // Add assistant response to conversation
-        // Cast response content to MessageParam content type (ContentBlock[] → ContentBlockParam[])
-        conversation.push({
-            role: "assistant",
-            content: response.content,
-        });
-        // Check for tool calls
-        const toolUseBlocks = response.content.filter((block) => block.type === "tool_use");
-        if (toolUseBlocks.length > 0) {
-            // Execute tools and continue conversation
-            await this.executeToolsAndContinue(toolUseBlocks, originalMessage);
-            return;
-        }
-        // Check for text response
-        const textBlocks = response.content.filter((block) => block.type === "text");
-        if (textBlocks.length > 0) {
-            const responseText = textBlocks.map(b => b.text).join("\n").trim();
-            // Log metadata only - avoid logging user content (PII risk)
-            this.logger.info("LLM response received", {
-                discussion: originalMessage.discussionId,
-                priority: originalMessage.priority,
-                responseLength: responseText.length,
-                hasIgnoreTag: responseText.includes("<ignore"),
-                hasRespondTag: responseText.includes("<respond"),
-            });
-            // Check for IGNORE decision
-            if (responseText.includes("<decision>IGNORE</decision>") ||
-                responseText.includes("<ignore")) {
-                this.logger.debug("LLM decided to ignore message - removing from context", {
-                    discussion: originalMessage.discussionId,
-                });
-                // Stop typing indicator
-                this.stopTypingIndicator();
-                // Remove both the assistant's ignore response AND the original incoming message
-                // to keep the context clean from irrelevant chatter
-                conversation.pop(); // Remove assistant response we just added
-                conversation.pop(); // Remove the incoming message
-                return;
-            }
-            // Check for explicit response directive
-            const responseMatch = responseText.match(/<respond discussion="([^"]+)">([\s\S]*?)<\/respond>/);
-            if (responseMatch) {
-                const targetDiscussion = responseMatch[1];
-                const content = responseMatch[2].trim();
-                await this.postResponse(targetDiscussion, content);
-                return;
-            }
-            // For high priority messages, always send substantive responses
-            if (originalMessage.priority === "high" && responseText &&
-                !responseText.includes("<thinking>") &&
-                !responseText.startsWith("I'll") &&
-                responseText.length > 10) {
-                await this.postResponse(originalMessage.discussionId, responseText);
-                return;
-            }
-            // For normal priority, ONLY respond if LLM used explicit <respond> tag
-            // This was already handled above - if we reach here, don't post
-            // (LLM should use <respond> or <ignore> for normal priority messages)
-            if (originalMessage.priority === "normal") {
-                this.logger.debug("Normal priority without <respond> tag - removing from context", {
-                    discussion: originalMessage.discussionId,
-                    responsePreview: responseText.substring(0, 100),
-                });
-                // Stop typing indicator
-                this.stopTypingIndicator();
-                // Remove from context - we didn't respond so don't need this in history
-                conversation.pop(); // Remove assistant response
-                conversation.pop(); // Remove incoming message
-            }
-        }
-    }
-    /**
-     * Start typing indicator with auto-refresh interval
-     * Keeps refreshing every 3 seconds until stopTypingIndicator is called
-     */
-    startTypingIndicator(discussionId) {
-        // Stop any existing typing interval
-        this.stopTypingIndicator();
-        this.typingDiscussionId = discussionId;
-        // Send initial typing signal
-        this.sendTypingSignal(discussionId, true);
-        // Set up interval to refresh typing (prevents server-side timeout)
-        this.typingInterval = setInterval(() => {
-            if (this.typingDiscussionId) {
-                this.sendTypingSignal(this.typingDiscussionId, true);
-            }
-        }, ChatAgentDaemon.TYPING_REFRESH_MS);
-    }
-    /**
-     * Stop typing indicator and clear refresh interval
-     */
-    stopTypingIndicator() {
-        if (this.typingInterval) {
-            clearInterval(this.typingInterval);
-            this.typingInterval = null;
-        }
-        if (this.typingDiscussionId) {
-            this.sendTypingSignal(this.typingDiscussionId, false);
-            this.typingDiscussionId = null;
-        }
-    }
-    /**
-     * Send typing signal to Hailer API
-     * API: messenger.set_discussion_typing_state(discussionId, typingState)
-     */
-    sendTypingSignal(discussionId, isTyping) {
-        this.botClient.client.socket.request("messenger.set_discussion_typing_state", [
-            discussionId,
-            isTyping
-        ]).catch((error) => {
-            // Silently ignore - typing indicator is not critical
-            this.logger.debug("Typing indicator failed", { discussionId, isTyping, error: error?.message });
-        });
-    }
-    /**
-     * Post a response to a discussion
-     * Automatically converts @mentions and #activity tags to Hailer tags
-     * Includes links metadata required for tags to work
-     */
-    async postResponse(discussionId, content) {
-        // Stop typing indicator before posting
-        this.stopTypingIndicator();
-        try {
-            // Resolve tags that need API lookup
-            let formattedContent = await this.messageFormatter.resolveUserTags(content); // @userId → [hailerTag|Name](id)
-            formattedContent = await this.messageFormatter.resolveActivityTags(formattedContent); // #activityId → [hailerTag|Name](id)
-            formattedContent = await this.messageFormatter.resolveHailerUrls(formattedContent); // URLs → [hailerTag|Name](id)
-            // Then convert any remaining @mentions from cache (fallback)
-            formattedContent = this.messageFormatter.convertMentionsToTags(formattedContent);
-            // Remove redundant "(Name)" after tags - LLM sometimes adds these
-            formattedContent = formattedContent.replace(/(\[hailerTag\|[^\]]+\]\([a-f0-9]{24}\)\uFEFF?)\s*\([^)]+\)/gi, '$1');
-            // Extract link metadata for any tags in the content
-            const links = this.messageFormatter.extractTagLinks(formattedContent);
-            // Build message object with links if we have any
-            const messageData = {
-                msg: formattedContent
-            };
-            if (links.length > 0) {
-                messageData.links = links;
-            }
-            await this.botClient.client.socket.request("messenger.send", [
-                messageData,
-                discussionId,
-            ]);
-            // Track response in activity session
-            const sessionKey = this.currentLinkedActivityId || this.currentDiscussionId || "default";
-            const session = this.sessionLogger.getSession(sessionKey);
-            if (session) {
-                session.metrics.responsesPosted++;
-                session.actions.push(`Responded in discussion`);
-                session.lastActivityTime = Date.now();
-                // Add bot response to conversation log (compact version)
-                const botSnippet = content.length > 100 ? content.substring(0, 100) + "..." : content;
-                session.conversation.push(`Bot: ${botSnippet}`);
-            }
-            this.logger.info("Response posted", {
-                discussion: discussionId,
-                length: formattedContent.length,
-                hadTags: formattedContent !== content,
-                linkCount: links.length,
-            });
-        }
-        catch (error) {
-            this.logger.error("Failed to post response", error);
-        }
-    }
-    /**
-     * Get the system prompt for the daemon
-     * MUST be overridden in subclasses
-     */
-    getSystemPrompt() {
-        throw new Error("getSystemPrompt() must be implemented by subclass");
-    }
-    /**
-     * Get tools for LLM calls
-     * Override in subclass to add custom tools (like trigger_giuseppe_retry)
-     */
-    getTools() {
-        return this.minimalTools;
-    }
-    /**
-     * Get tool whitelist for this agent
-     * Override in subclass to limit which tools are available
-     * Return null for all tools, or array of tool names
-     */
-    getToolWhitelist() {
-        return null; // Default: all tools
-    }
-    /**
-     * Preprocess tool input before execution
-     * Override in subclass to inject context (e.g., sourceActivityId)
-     * @param toolName - Name of the tool being called
-     * @param input - Original tool input from LLM
-     * @returns Processed input (may be modified)
-     */
-    preprocessToolInput(toolName, input) {
-        return input; // Default: no preprocessing
-    }
-    /**
-     * Call MCP tool (delegates to McpClientService)
-     * Protected for subclass access
-     */
-    async callMcpTool(name, args) {
-        return this.mcpClient.callMcpTool(name, args);
-    }
-    /**
-     * Stop the daemon
-     * Flushes all pending activity sessions before stopping
-     */
-    async stop() {
-        // Stop idle check timer and flush all pending sessions
-        this.sessionLogger?.stopIdleCheckTimer();
-        await this.sessionLogger?.flushAllSessions();
-        // Unsubscribe from messenger.new signals
-        if (this.messengerUnsubscribe) {
-            this.messengerUnsubscribe();
-            this.messengerUnsubscribe = null;
-        }
-        // Disconnect the Hailer client connection using the ORIGINAL API key
-        // This is critical: botClient.config.mcpServerApiKey may have been updated to a new value
-        // before stop() is called during restart, so we must use the stored originalApiKey
-        if (this.originalApiKey) {
-            (0, hailer_clients_1.disconnectHailerClientByApiKey)(this.originalApiKey);
-            this.originalApiKey = null;
-        }
-        this.botClient.signalHandler.unsubscribe(`daemon-${this.botClient.userId}`);
-        this.logger.info("Chat Agent Daemon stopped", {
-            agentDirectoryId: this.registryService?.getAgentDirectoryId(),
-            activeSessions: this.sessionLogger?.getActiveSessions().size ?? 0,
-        });
-    }
-    /**
-     * Get current conversation state (for debugging)
-     */
-    getConversationState() {
-        // Get current discussion's conversation
-        const currentConversation = this.currentDiscussionId
-            ? this.conversationManager.getConversation(this.currentDiscussionId)
-            : [];
-        // Get last 5 messages with preview
-        const lastMessages = currentConversation.slice(-5).map(msg => {
-            let preview = "";
-            if (typeof msg.content === "string") {
-                preview = msg.content.substring(0, 100);
-            }
-            else if (Array.isArray(msg.content)) {
-                const textBlock = msg.content.find((b) => b.type === "text");
-                preview = textBlock?.text?.substring(0, 100) || "[tool call/result]";
-            }
-            return {
-                role: msg.role,
-                preview: preview + (preview.length >= 100 ? "..." : ""),
-            };
-        });
-        const state = this.conversationManager.getState(this.currentDiscussionId ?? undefined);
-        return {
-            discussionCount: state.discussionCount,
-            currentDiscussion: this.currentDiscussionId,
-            currentMessageCount: currentConversation.length,
-            queueLength: this.messageQueue.length,
-            lastMessages,
-            isProcessing: this.isProcessing,
-        };
-    }
-    /**
-     * Get full conversation for a specific discussion (for debugging)
-     */
-    getFullConversation(discussionId) {
-        const targetDiscussion = discussionId || this.currentDiscussionId;
-        if (!targetDiscussion)
-            return [];
-        return [...this.conversationManager.getFullConversation(targetDiscussion)];
-    }
-    // ===== AGENT REGISTRY & SESSION LOGGING METHODS =====
-    /**
-     * Get agent's display name (override in subclass for custom names)
-     * Default implementation uses the actual Hailer user name from BotClient
-     */
-    getAgentName() {
-        // Use actual Hailer user name from BotClient (populated from workspace cache)
-        return {
-            firstName: this.botClient.firstName,
-            lastName: this.botClient.lastName,
-        };
-    }
-    /**
-     * Get agent's description/system prompt (override in subclass)
-     */
-    getAgentDescription() {
-        return "Chat Agent Daemon - handles general workspace conversations";
-    }
-    /**
-     * Get default team ID from workspace cache
-     * Returns the first available team, or undefined if no teams exist
-     *
-     * Teams structure in init is: { teams: { workspaceId: { teamId: teamData, ... } } }
-     */
-    getDefaultTeamId() {
-        const rawInit = this.botClient.workspaceCache?.rawInit;
-        if (!rawInit?.teams) {
-            this.logger.debug("No teams in workspace cache");
-            return undefined;
-        }
-        // Teams are nested under workspace ID
-        // Structure: { workspaceId: { teamId1: {...}, teamId2: {...} } }
-        const workspaceTeams = Object.values(rawInit.teams)[0];
-        if (!workspaceTeams || typeof workspaceTeams !== 'object') {
-            this.logger.debug("No workspace teams found");
-            return undefined;
-        }
-        const teamIds = Object.keys(workspaceTeams);
-        if (teamIds.length === 0) {
-            this.logger.debug("No teams available in workspace");
-            return undefined;
-        }
-        const defaultTeamId = teamIds[0];
-        const teamName = workspaceTeams[defaultTeamId]?.name || 'unknown';
-        this.logger.debug("Using default team", { teamId: defaultTeamId, teamName, teamCount: teamIds.length });
-        return defaultTeamId;
-    }
-    /**
-     * Get agent's Position details (override in subclass for custom positions)
-     */
-    getPositionDetails() {
-        return {
-            name: "Chat Agent",
-            purpose: "General workspace assistant that monitors discussions and responds to user queries.",
-            personaTone: "Professional, helpful, and concise. Responds directly without unnecessary filler.",
-            coreCapabilities: "- Monitor workspace discussions\n- Answer questions about workflows and activities\n- Execute MCP tools to read/write data\n- Tag users and link activities",
-            boundaries: "- Never fabricate data - always use tools\n- Don't respond to off-topic messages\n- Don't share sensitive credentials",
-        };
-    }
-    /**
-     * Get agent directory ID
-     */
-    getAgentDirectoryId() {
-        return this.registryService?.getAgentDirectoryId() || null;
-    }
-}
-exports.ChatAgentDaemon = ChatAgentDaemon;
-//# sourceMappingURL=base.js.map