@hailer/mcp 1.1.15 → 1.1.16

package/dist/agents/shared/base.js

@@ -0,0 +1,1122 @@
+"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 typing_indicator_1 = require("./services/typing-indicator");
+const token_billing_1 = require("./services/token-billing");
+const structured_output_executor_1 = require("./services/structured-output-executor");
+const action_schema_1 = require("./schemas/action-schema");
+const hailer_api_client_1 = require("../../mcp/utils/hailer-api-client");
+const config_1 = require("../../config");
+const bot_config_1 = require("../../bot-config");
+const config_2 = require("../../config");
+class ChatAgentDaemon {
+    logger;
+    client;
+    botClient;
+    config;
+    toolSchemaLoader = new tool_schema_loader_1.ToolSchemaLoader();
+    // Processing state
+    isProcessing = false;
+    messageQueue = [];
+    processedMessageIds = new Set();
+    // 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;
+    /** Typing indicator service - handles typing state with auto-refresh */
+    typingIndicator = null;
+    /** Token billing service - handles real-time token burning per workspace */
+    tokenBilling = null;
+    /** Structured output executor - handles action-based output instead of native tools */
+    structuredOutputExecutor = 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,
+        });
+    }
+    /**
+     * Get the workspace schema cache for dynamic workflow/field ID lookup
+     * Exposed for modules that need to share schema discovery (e.g., Bug Fixer)
+     */
+    getSchemaCache() {
+        return this.schemaCache;
+    }
+    /**
+     * 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_2.maskEmail)(this.botClient.config.email),
+        });
+        // Load tool index once
+        const allowedGroups = this.getToolGroups();
+        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.toFullToolDefinitions(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 (with token billing for cache invalidation)
+        this.toolExecutor = new tool_executor_1.ToolExecutor(this.mcpClient, this.logger, this.tokenBilling || undefined);
+        // Initialize structured output executor (if enabled)
+        if (this.config.useStructuredOutputs) {
+            this.structuredOutputExecutor = new structured_output_executor_1.StructuredOutputExecutor(this.mcpClient, this.toolExecutor, this.logger);
+            this.logger.info("Structured outputs enabled - saving ~100K tokens per request");
+        }
+        // Initialize message classifier
+        this.messageClassifier = new message_classifier_1.MessageClassifier(this.botClient.userId, this.botClient, this.logger);
+        // Initialize typing indicator service
+        this.typingIndicator = new typing_indicator_1.TypingIndicatorService(this.botClient, this.logger);
+        // Initialize token billing service (if enabled)
+        const appConfig = (0, config_1.createApplicationConfig)();
+        if (appConfig.tokenBilling.enabled) {
+            // Create HailerApiClient from botClient
+            const hailerApiClient = this.botClient?.client
+                ? new hailer_api_client_1.HailerApiClient(this.botClient.client)
+                : null;
+            this.tokenBilling = new token_billing_1.TokenBillingService(this.logger, hailerApiClient || undefined);
+            this.logger.info("Token billing service initialized", {
+                hasHailerClient: !!hailerApiClient,
+            });
+        }
+        // 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,
+        };
+        // Register agent in workspace (handles deduplication internally)
+        this.logger.info("Starting 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);
+        this.logger.info("Chat Agent Daemon initialized and listening", {
+            workspaceId,
+            agentDirectoryId: this.registryService.getAgentDirectoryId(),
+            positionId: this.registryService.getPositionId(),
+            teamId: this.registryService.getTeamId(),
+        });
+    }
+    /**
+     * 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.typingIndicator?.start(message.discussionId);
+        // Get or create activity session
+        const session = this.sessionLogger.getOrCreateActivitySession(message);
+        session.lastActivityTime = Date.now();
+        session.metrics.messagesProcessed++;
+        // Check balance before every message (caching prevents API spam)
+        if (this.tokenBilling && message.workspaceId) {
+            const balance = await this.tokenBilling.checkBalance(message.workspaceId);
+            if (!balance.hasBalance) {
+                this.logger.info("Session rejected - no token balance", {
+                    workspaceId: message.workspaceId,
+                    balance: balance.balance,
+                    discussion: message.discussionId,
+                });
+                this.typingIndicator?.stop();
+                await this.sendInsufficientBalanceMessage(message.discussionId);
+                return;
+            }
+        }
+        // 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
+        let incomingContent = this.formatIncomingMessage(message);
+        // Get conversation for THIS discussion (isolated context)
+        const conversation = this.conversationManager.getConversation(message.discussionId);
+        // Track conversation length BEFORE this message for proper cleanup on IGNORE
+        const conversationLengthBeforeMessage = conversation.length;
+        // COLD START: If conversation is empty, try to load memory context from Hailer
+        if (conversation.length === 0) {
+            const memoryContext = await this.loadMemoryContext(message.discussionId, message.workspaceId);
+            if (memoryContext) {
+                // Prepend memory context to the user message
+                incomingContent = `${memoryContext}\n\n[Current message]\n${incomingContent}`;
+                this.logger.debug("Injected memory context on cold start", {
+                    discussion: message.discussionId.substring(0, 8),
+                });
+            }
+        }
+        // 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 (with caching enabled)
+            const cachedConversation = this.conversationManager.prepareForCaching(conversation);
+            // Use structured outputs if enabled (saves ~100K tokens per request)
+            let response;
+            if (this.config.useStructuredOutputs) {
+                response = await this.callLlmWithStructuredOutputs(cachedConversation);
+            }
+            else {
+                // Log sizing for comparison with structured outputs
+                const systemPrompt = this.getCachedSystemPrompt();
+                const tools = this.getTools();
+                const systemCharCount = systemPrompt.reduce((acc, block) => acc + (block.text?.length || 0), 0);
+                const toolsCharCount = JSON.stringify(tools).length;
+                const messagesCharCount = JSON.stringify(cachedConversation).length;
+                this.logger.info("Native tools request sizing", {
+                    systemCharCount,
+                    toolsCharCount,
+                    messagesCharCount,
+                    estimatedTokens: Math.round((systemCharCount + toolsCharCount + messagesCharCount) / 4),
+                    toolCount: tools.length,
+                });
+                response = await this.client.messages.create({
+                    model: this.config.model || "claude-haiku-4-5-20251001",
+                    max_tokens: 2000,
+                    system: systemPrompt,
+                    messages: cachedConversation,
+                    tools,
+                });
+                // Log actual usage
+                if (response.usage) {
+                    const usage = response.usage;
+                    this.logger.info("Native tools response usage", {
+                        inputTokens: usage.input_tokens,
+                        outputTokens: usage.output_tokens,
+                        cacheCreationTokens: usage.cache_creation_input_tokens || 0,
+                        cacheReadTokens: usage.cache_read_input_tokens || 0,
+                    });
+                }
+            }
+            // Track token usage in the activity session (including cache stats for billing)
+            if (response.usage) {
+                const inputTokens = response.usage.input_tokens;
+                const outputTokens = response.usage.output_tokens;
+                const cacheCreationTokens = response.usage.cache_creation_input_tokens || 0;
+                const cacheReadTokens = response.usage.cache_read_input_tokens || 0;
+                session.metrics.inputTokens += inputTokens;
+                session.metrics.outputTokens += outputTokens;
+                session.metrics.cacheCreationTokens += cacheCreationTokens;
+                session.metrics.cacheReadTokens += cacheReadTokens;
+                session.metrics.apiCalls += 1;
+                // Burn tokens real-time (fire-and-forget)
+                if (this.tokenBilling && session.workspaceId) {
+                    const cost = this.tokenBilling.calculateCost(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens);
+                    this.tokenBilling.burnTokens({
+                        workspaceId: session.workspaceId,
+                        inputTokens,
+                        outputTokens,
+                        cacheCreationTokens,
+                        cacheReadTokens,
+                        costUsd: cost,
+                        sessionId: session.discussionId,
+                        activityId: session.activityId,
+                    });
+                }
+            }
+            // Handle response (pass original length for proper cleanup on IGNORE)
+            if (this.config.useStructuredOutputs) {
+                await this.handleStructuredResponse(response, message, conversationLengthBeforeMessage);
+            }
+            else {
+                await this.handleLlmResponse(response, message, conversationLengthBeforeMessage);
+            }
+            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.typingIndicator?.stop();
+            // 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}"` : "";
+        // Build file attachment info if present
+        let fileInfo = "";
+        if (message.fileAttachments && message.fileAttachments.length > 0) {
+            const fileList = message.fileAttachments.map(f => `  - ${f.filename} (ID: ${f.fileId}${f.size ? `, ${Math.round(f.size / 1024)}KB` : ""}${f.mime ? `, ${f.mime}` : ""})`).join("\n");
+            fileInfo = `\n[File attached: ${message.fileAttachments.length} file(s) - IDs: ${message.fileAttachments.map(f => f.fileId).join(", ")}]\n${fileList}\n\nUse download_file tool with fileId to read file contents.`;
+        }
+        return `<incoming discussion="${message.discussionId}"${activityAttr} from="${message.senderName}" user_id="${message.senderId}" timestamp="${new Date(message.timestamp).toISOString()}"${priorityTag}${reasonAttr}>
+${message.content}${fileInfo}
+</incoming>`;
+    }
+    /**
+     * Load memory context on cold start
+     * Uses discussion message history (FREE) instead of SESSION_LOG (costs tokens)
+     */
+    async loadMemoryContext(discussionId, _workspaceId) {
+        if (!this.mcpClient) {
+            return null;
+        }
+        try {
+            // Fetch last 15 messages from discussion (FREE - read operation)
+            const result = await this.mcpClient.callMcpTool("fetch_discussion_messages", {
+                discussionId,
+                limit: 15,
+            });
+            const text = result?.content?.[0]?.text;
+            if (!text || text.includes("No messages found")) {
+                return null;
+            }
+            // Extract just the message content, skip the header/metadata
+            const messagesMatch = text.match(/📨 \*\*MESSAGES\*\*[\s\S]*/);
+            if (!messagesMatch) {
+                return null;
+            }
+            return `[Previous conversation in this discussion]\n${messagesMatch[0]}`;
+        }
+        catch (error) {
+            this.logger.debug("Failed to load memory context from discussion", {
+                discussion: discussionId.substring(0, 8),
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+    /**
+     * Execute tool calls and continue the conversation
+     * Simple passthrough - just execute tools and return results to LLM
+     * @param conversationLengthBeforeMessage - passed through for proper IGNORE cleanup
+     */
+    async executeToolsAndContinue(toolUseBlocks, originalMessage, conversationLengthBeforeMessage) {
+        // 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 (with caching enabled)
+        const cachedConversation = this.conversationManager.prepareForCaching(conversation);
+        const response = await this.client.messages.create({
+            model: this.config.model || "claude-haiku-4-5-20251001",
+            max_tokens: 2000,
+            system: this.getCachedSystemPrompt(),
+            messages: cachedConversation,
+            tools: this.getTools(),
+        });
+        // Track token usage in session (including cache stats for billing)
+        if (session && response.usage) {
+            const inputTokens = response.usage.input_tokens;
+            const outputTokens = response.usage.output_tokens;
+            const cacheCreationTokens = response.usage.cache_creation_input_tokens || 0;
+            const cacheReadTokens = response.usage.cache_read_input_tokens || 0;
+            session.metrics.inputTokens += inputTokens;
+            session.metrics.outputTokens += outputTokens;
+            session.metrics.cacheCreationTokens += cacheCreationTokens;
+            session.metrics.cacheReadTokens += cacheReadTokens;
+            session.metrics.apiCalls += 1;
+            session.lastActivityTime = Date.now();
+            // Burn tokens real-time (fire-and-forget)
+            if (this.tokenBilling && session.workspaceId) {
+                const cost = this.tokenBilling.calculateCost(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens);
+                this.tokenBilling.burnTokens({
+                    workspaceId: session.workspaceId,
+                    inputTokens,
+                    outputTokens,
+                    cacheCreationTokens,
+                    cacheReadTokens,
+                    costUsd: cost,
+                    sessionId: session.discussionId,
+                    activityId: session.activityId,
+                });
+            }
+        }
+        // Recursively handle (might need more tools or finally respond)
+        await this.handleLlmResponse(response, originalMessage, conversationLengthBeforeMessage);
+    }
+    /**
+     * Handle LLM response
+     * Override in subclasses to customize response handling
+     * @param conversationLengthBeforeMessage - length to truncate to on IGNORE (cleans up entire tool loop)
+     */
+    async handleLlmResponse(response, originalMessage, conversationLengthBeforeMessage) {
+        const conversation = this.conversationManager.getConversation(originalMessage.discussionId);
+        // Add assistant response to conversation
+        conversation.push({
+            role: "assistant",
+            content: response.content,
+        });
+        // Check for tool calls - execute and continue
+        const toolUseBlocks = response.content.filter((block) => block.type === "tool_use");
+        if (toolUseBlocks.length > 0) {
+            await this.executeToolsAndContinue(toolUseBlocks, originalMessage, conversationLengthBeforeMessage);
+            return;
+        }
+        // Extract text response
+        const textBlocks = response.content.filter((block) => block.type === "text");
+        if (textBlocks.length === 0)
+            return;
+        const responseText = textBlocks.map(b => b.text).join("\n").trim();
+        this.logger.info("LLM response received", {
+            discussion: originalMessage.discussionId,
+            responseLength: responseText.length,
+        });
+        // IGNORE/COMPLETE decision - clean up context (entire tool loop if any)
+        // LLM may use IGNORE (don't respond) or COMPLETE (already posted via tool)
+        if (responseText.includes("<decision>IGNORE</decision>") ||
+            responseText.includes("<decision>COMPLETE</decision>") ||
+            responseText.includes("<ignore")) {
+            this.logger.debug("LLM decided to ignore", { discussion: originalMessage.discussionId });
+            this.typingIndicator?.stop();
+            // If we have the original conversation length, truncate to it (cleans up entire tool loop)
+            if (conversationLengthBeforeMessage !== undefined) {
+                conversation.length = Math.min(conversationLengthBeforeMessage, conversation.length);
+                this.logger.debug("Truncated conversation to pre-message state", {
+                    discussion: originalMessage.discussionId,
+                    newLength: conversation.length
+                });
+            }
+            else {
+                // Fallback: just remove assistant response and user message
+                conversation.pop(); // Remove assistant response
+                conversation.pop(); // Remove incoming message
+            }
+            return;
+        }
+        // Explicit <respond> tag
+        const responseMatch = responseText.match(/<respond discussion="([^"]+)">([\s\S]*?)<\/respond>/);
+        if (responseMatch) {
+            await this.postResponse(responseMatch[1], responseMatch[2].trim());
+            return;
+        }
+        // High priority: always respond if substantive
+        if (originalMessage.priority === "high" && responseText.length > 10 &&
+            !responseText.includes("<thinking>") && !responseText.startsWith("I'll")) {
+            await this.postResponse(originalMessage.discussionId, responseText);
+            return;
+        }
+        // Normal priority without <respond> tag - clean up context
+        if (originalMessage.priority === "normal") {
+            this.logger.debug("Normal priority without <respond> - removing from context");
+            this.typingIndicator?.stop();
+            if (conversationLengthBeforeMessage !== undefined) {
+                conversation.length = Math.min(conversationLengthBeforeMessage, conversation.length);
+            }
+            else {
+                conversation.pop();
+                conversation.pop();
+            }
+        }
+    }
+    // ===== STRUCTURED OUTPUTS SUPPORT =====
+    /**
+     * Call LLM with structured outputs instead of native tools
+     * Saves ~100K tokens per request by not sending tool schemas
+     */
+    async callLlmWithStructuredOutputs(messages) {
+        // Build system prompt with action reference
+        const systemPrompt = this.getCachedSystemPrompt();
+        const actionPrompt = this.structuredOutputExecutor.generateActionPrompt(this.getAllowedActions());
+        // Combine system prompt with action reference
+        // ARCHITECTURE for caching:
+        //   1. Static blocks (all except last) - stripped of cache_control
+        //   2. Action prompt - WITH cache_control (this is the cache breakpoint)
+        //   3. Dynamic block (last) - NO cache_control, comes AFTER breakpoint
+        // This way only static + action are cached, dynamic content is fresh each call
+        const systemBlocks = Array.isArray(systemPrompt) ? systemPrompt : [{ type: "text", text: systemPrompt }];
+        // Separate static (all but last) from dynamic (last)
+        const staticBlocks = systemBlocks.slice(0, -1);
+        const dynamicBlock = systemBlocks.length > 1 ? systemBlocks[systemBlocks.length - 1] : null;
+        const combinedSystem = [
+            // Static blocks (stripped of cache_control)
+            ...staticBlocks.map(block => ({
+                type: "text",
+                text: block.text || "",
+            })),
+            // Action prompt WITH cache_control (cache breakpoint)
+            {
+                type: "text",
+                text: actionPrompt,
+                cache_control: { type: "ephemeral" },
+            },
+            // Dynamic block AFTER breakpoint (not cached)
+            ...(dynamicBlock ? [{
+                    type: "text",
+                    text: dynamicBlock.text || "",
+                }] : []),
+        ];
+        // DEBUG: Log what we're sending to API
+        const systemCharCount = combinedSystem.reduce((acc, block) => acc + (block.text?.length || 0), 0);
+        const messagesCharCount = JSON.stringify(messages).length;
+        const outputFormat = this.structuredOutputExecutor.getOutputFormat();
+        const schemaCharCount = JSON.stringify(outputFormat).length;
+        this.logger.info("Structured outputs request sizing", {
+            systemCharCount,
+            messagesCharCount,
+            schemaCharCount,
+            estimatedTokens: Math.round((systemCharCount + messagesCharCount) / 4),
+            messagesCount: messages.length,
+        });
+        // Call with structured outputs beta
+        // Note: Prompt caching is now GA (no beta header needed)
+        // Note: output_format is a beta feature not yet in SDK types
+        const params = {
+            model: this.config.model || "claude-haiku-4-5-20251001",
+            max_tokens: 2000,
+            betas: [structured_output_executor_1.STRUCTURED_OUTPUTS_BETA],
+            system: combinedSystem,
+            messages,
+            output_format: outputFormat,
+        };
+        const response = await this.client.beta.messages.create(params);
+        // DEBUG: Log actual usage from API
+        if (response.usage) {
+            const usage = response.usage;
+            this.logger.info("Structured outputs response usage", {
+                inputTokens: usage.input_tokens,
+                outputTokens: usage.output_tokens,
+                cacheCreationTokens: usage.cache_creation_input_tokens || 0,
+                cacheReadTokens: usage.cache_read_input_tokens || 0,
+                estimatedVsActual: `${Math.round((systemCharCount + messagesCharCount) / 4)} vs ${usage.input_tokens + (usage.cache_creation_input_tokens || 0)}`,
+            });
+        }
+        return response;
+    }
+    /**
+     * Handle structured output response
+     * Parses JSON action and executes it
+     */
+    async handleStructuredResponse(response, originalMessage, conversationLengthBeforeMessage) {
+        const conversation = this.conversationManager.getConversation(originalMessage.discussionId);
+        // Add assistant response to conversation
+        conversation.push({
+            role: "assistant",
+            content: response.content,
+        });
+        // Parse the action from response
+        const action = this.structuredOutputExecutor.parseResponse(response);
+        if (!action) {
+            this.logger.warn("Failed to parse action from response");
+            this.typingIndicator?.stop();
+            // Remove failed response from context
+            conversation.pop();
+            return;
+        }
+        this.logger.debug("Parsed action", {
+            action: action.action,
+            thinking: action.thinking?.substring(0, 50),
+        });
+        // Get session for tracking
+        const sessionKey = this.currentLinkedActivityId || this.currentDiscussionId || "default";
+        const session = this.sessionLogger.getSession(sessionKey);
+        // Execute the action
+        const result = await this.structuredOutputExecutor.executeAction(action, {
+            session,
+            preprocessToolInput: this.preprocessToolInput.bind(this),
+        });
+        // Handle terminal actions
+        if (result.isTerminal) {
+            if (result.action === "respond" && result.responseText) {
+                await this.postResponse(originalMessage.discussionId, result.responseText);
+            }
+            else if (result.action === "ignore") {
+                this.logger.debug("Action: ignore", { discussion: originalMessage.discussionId });
+                this.typingIndicator?.stop();
+                // Clean up context on ignore
+                if (conversationLengthBeforeMessage !== undefined) {
+                    conversation.length = Math.min(conversationLengthBeforeMessage, conversation.length);
+                }
+                else {
+                    conversation.pop();
+                    conversation.pop();
+                }
+            }
+            else if (result.action === "invite_specialist" && result.specialist) {
+                // Handle specialist invitation (override in subclass)
+                await this.handleSpecialistInvite(result.specialist.key, result.specialist.context, originalMessage);
+            }
+            return;
+        }
+        // Non-terminal action: add result and continue
+        if (result.error || result.toolResult) {
+            const resultMessage = this.structuredOutputExecutor.formatResultForConversation(result);
+            conversation.push(resultMessage);
+            // Continue the loop with another LLM call
+            await this.executeStructuredActionLoop(originalMessage, conversationLengthBeforeMessage);
+        }
+    }
+    /**
+     * Continue executing actions until a terminal action
+     */
+    async executeStructuredActionLoop(originalMessage, conversationLengthBeforeMessage) {
+        const conversation = this.conversationManager.getConversation(originalMessage.discussionId);
+        const sessionKey = this.currentLinkedActivityId || this.currentDiscussionId || "default";
+        const session = this.sessionLogger.getSession(sessionKey);
+        // Call LLM again with structured outputs
+        const cachedConversation = this.conversationManager.prepareForCaching(conversation);
+        const response = await this.callLlmWithStructuredOutputs(cachedConversation);
+        // Track token usage
+        if (session && response.usage) {
+            const inputTokens = response.usage.input_tokens;
+            const outputTokens = response.usage.output_tokens;
+            const cacheCreationTokens = response.usage.cache_creation_input_tokens || 0;
+            const cacheReadTokens = response.usage.cache_read_input_tokens || 0;
+            session.metrics.inputTokens += inputTokens;
+            session.metrics.outputTokens += outputTokens;
+            session.metrics.cacheCreationTokens += cacheCreationTokens;
+            session.metrics.cacheReadTokens += cacheReadTokens;
+            session.metrics.apiCalls += 1;
+            session.lastActivityTime = Date.now();
+            // Burn tokens real-time
+            if (this.tokenBilling && session.workspaceId) {
+                const cost = this.tokenBilling.calculateCost(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens);
+                this.tokenBilling.burnTokens({
+                    workspaceId: session.workspaceId,
+                    inputTokens,
+                    outputTokens,
+                    cacheCreationTokens,
+                    cacheReadTokens,
+                    costUsd: cost,
+                    sessionId: session.discussionId,
+                    activityId: session.activityId,
+                });
+            }
+        }
+        // Handle the response (recursive)
+        await this.handleStructuredResponse(response, originalMessage, conversationLengthBeforeMessage);
+    }
+    /**
+     * Get allowed actions for this agent
+     * Override in subclass to customize available actions
+     */
+    getAllowedActions() {
+        // Default: all actions except meta actions (handled separately)
+        return action_schema_1.BOT_ACTIONS.filter((a) => a !== "respond" && a !== "ignore" && a !== "invite_specialist");
+    }
+    /**
+     * Handle specialist invitation
+     * Override in subclass (e.g., HAL daemon) to implement specialist logic
+     */
+    async handleSpecialistInvite(specialistKey, context, originalMessage) {
+        this.logger.warn("Specialist invite not implemented in base class", {
+            specialist: specialistKey,
+        });
+    }
+    /**
+     * 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.typingIndicator?.stop();
+        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);
+        }
+    }
+    /**
+     * Send insufficient balance message to user
+     * Can be overridden in subclasses to customize the message
+     */
+    async sendInsufficientBalanceMessage(discussionId) {
+        try {
+            await this.botClient.client.socket.request("messenger.send", [
+                { msg: "Insufficient balance. Please top up your workspace AI credits to continue." },
+                discussionId,
+            ]);
+        }
+        catch (error) {
+            this.logger.error("Failed to send insufficient balance message", error);
+        }
+    }
+    /**
+     * Get the system prompt for the daemon
+     * MUST be overridden in subclasses
+     */
+    getSystemPrompt() {
+        throw new Error("getSystemPrompt() must be implemented by subclass");
+    }
+    /**
+     * Get the system prompt wrapped with Anthropic prompt caching
+     * This enables 50% cost reduction on cached tokens after first use
+     */
+    getCachedSystemPrompt() {
+        return [
+            {
+                type: "text",
+                text: this.getSystemPrompt(),
+                cache_control: { type: "ephemeral" },
+            },
+        ];
+    }
+    /**
+     * Get tools for LLM calls
+     * Override in subclass to add custom tools (like trigger_giuseppe_retry)
+     */
+    getTools() {
+        return this.minimalTools;
+    }
+    /**
+     * Get tool groups to load for this agent
+     * Override in subclass to include additional groups (e.g., BOT_INTERNAL)
+     */
+    getToolGroups() {
+        return [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE];
+    }
+    /**
+     * 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) {
+        // Auto-inject discussionId for leave_discussion if not provided
+        if (toolName === "leave_discussion" && !input.discussionId && !input.activityId) {
+            if (this.currentDiscussionId) {
+                this.logger.debug("Auto-injected discussionId for leave_discussion", {
+                    discussionId: this.currentDiscussionId,
+                });
+                return { ...input, discussionId: this.currentDiscussionId };
+            }
+        }
+        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,
+        };
+    }
+    // ===== 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