@hailer/mcp 1.0.28 → 1.1.2

package/dist/bot/bot.js

@@ -0,0 +1,1328 @@
+"use strict";
+/**
+ * Bot - Single class replacing the agents/ hierarchy.
+ *
+ * Connects to Hailer, subscribes to messenger signals,
+ * processes messages through the Anthropic API with tool use,
+ * and posts responses back to discussions.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bot = void 0;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const tool_registry_1 = require("../mcp/tool-registry");
+const hailer_clients_1 = require("../mcp/hailer-clients");
+const hailer_api_client_1 = require("../mcp/utils/hailer-api-client");
+const workspace_cache_1 = require("../mcp/workspace-cache");
+const tool_executor_1 = require("./tool-executor");
+const workspace_overview_1 = require("./workspace-overview");
+const operation_logger_1 = require("./operation-logger");
+const services_1 = require("./services");
+const logger_1 = require("../lib/logger");
+/**
+ * Tools available to the bot. Add/remove tool names here to control what the LLM can use.
+ * The MCP server (Claude Code terminal) is unaffected - it keeps full access to all tools.
+ */
+const BOT_TOOLS = new Set([
+    // Data reading
+    'list_workflows',
+    'list_workflows_minimal',
+    'list_workflow_phases',
+    'get_workflow_schema',
+    'list_activities',
+    'show_activity_by_id',
+    'count_activities',
+    'search_workspace_users',
+    'get_workspace_balance',
+    // Data writing
+    'create_activity',
+    'update_activity',
+    // Workflow management
+    'install_workflow',
+    // Discussions
+    'list_my_discussions',
+    'fetch_discussion_messages',
+    'fetch_previous_discussion_messages',
+    'add_discussion_message',
+    'join_discussion',
+    'leave_discussion',
+    'invite_discussion_members',
+    'get_activity_from_discussion',
+    // Files
+    'upload_files',
+    'download_file',
+    // Insights
+    'list_insights',
+    'get_insight_data',
+    'preview_insight',
+    'create_insight',
+    'update_insight',
+]);
+const WORKFLOW_SCOPED_TOOLS = new Set([
+    'list_activities', 'count_activities',
+    'get_workflow_schema', 'list_workflow_phases',
+    'create_activity', 'update_activity',
+    'install_workflow',
+]);
+/** Tools that bypass the workflowId arg gate and need post-execution permission checks */
+const UNGATED_TOOLS = new Set([
+    'show_activity_by_id',
+    'fetch_discussion_messages',
+    'get_activity_from_discussion',
+]);
+const MODEL_HAIKU = 'claude-haiku-4-5-20251001';
+const MODEL_SONNET = 'claude-sonnet-4-5-20250929';
+const MAX_TOOL_ITERATIONS = 10;
+const RATE_LIMIT_WINDOW = 60_000; // 60 seconds
+const RATE_LIMIT_PER_DISCUSSION = 30; // max signals per discussion per window
+const RATE_LIMIT_GLOBAL = 100; // max signals total per window
+class Bot {
+    logger;
+    clientManager;
+    client = null;
+    anthropic = null;
+    toolExecutor;
+    userContext = null;
+    // Hailer data
+    init = null;
+    workspaceCache = null;
+    workspaceOverview = '';
+    userId = '';
+    _workspaceId;
+    // Services
+    conversationManager = null;
+    messageClassifier = null;
+    messageFormatter = null;
+    typingIndicator = null;
+    tokenBilling = null;
+    sessionLogger = null;
+    opLogger = new operation_logger_1.OperationLogger();
+    // State
+    discussionStates = new Map();
+    processingDiscussions = new Set(); // concurrency guard only
+    static DISENGAGE_THRESHOLD = 5;
+    processedMessageIds = new Set();
+    signalTimestampsPerDiscussion = new Map();
+    globalSignalTimestamps = [];
+    signalHandler = null;
+    processUpdatedHandler = null;
+    workspaceUpdatedHandler = null;
+    cacheInvalidateHandler = null;
+    _connected = false;
+    refreshTimer = null;
+    refreshDirty = false;
+    refreshScope = new Set();
+    isRefreshing = false;
+    refreshQueued = false;
+    permissionIndex = new Map();
+    adminUserIds = new Set();
+    ownerUserIds = new Set();
+    // Config
+    config;
+    constructor(config) {
+        this.config = {
+            ...config,
+            model: config.model || 'claude-haiku-4-5-20251001',
+        };
+        this.logger = (0, logger_1.createLogger)({ component: 'Bot' });
+        this.clientManager = new hailer_clients_1.HailerClientManager(config.apiHost, config.email, config.password);
+        this.toolExecutor = new tool_executor_1.ToolExecutor(config.toolRegistry);
+    }
+    get connected() {
+        return this._connected;
+    }
+    get workspaceId() {
+        return this._workspaceId;
+    }
+    // ===== LIFECYCLE =====
+    async start() {
+        this.logger.debug('Starting bot', { email: this.config.email });
+        // 1. Connect to Hailer
+        this.client = await this.clientManager.connect();
+        // Clear password from memory now that connection is established
+        this.config.password = '';
+        // 2. Get user ID
+        const userInit = await this.client.socket.request('v2.core.init', [['user']]);
+        this.userId = userInit?.user?._id;
+        if (!this.userId)
+            throw new Error('Could not determine bot user ID');
+        // 3. Fetch workspace data
+        this.init = await this.client.socket.request('v2.core.init', [
+            ['processes', 'users', 'network', 'networks', 'teams', 'groups'],
+        ]);
+        this._workspaceId = this.init.network?._id || this.config.workspaceId;
+        this.buildPermissionIndex();
+        // 4. Build workspace cache and overview
+        this.workspaceCache = (0, workspace_cache_1.createWorkspaceCache)(this.init, {
+            excludeTranslations: true,
+            excludeSystemMessages: true,
+            excludeEmptyFields: true,
+            compactUserData: true,
+            includeWorkspaceNamesInTools: false,
+        });
+        this.workspaceOverview = (0, workspace_overview_1.generateWorkspaceOverview)(this.init);
+        // 5. Create Anthropic client
+        this.anthropic = new sdk_1.default({ apiKey: this.config.anthropicApiKey });
+        // 6. Build BotConnection adapter for services
+        const botConnection = {
+            client: this.client,
+            workspaceCache: this.workspaceCache ? {
+                usersById: this.workspaceCache.usersById,
+                users: this.workspaceCache.users,
+                rawInit: this.workspaceCache.rawInit,
+            } : undefined,
+        };
+        // 7. Create services
+        this.conversationManager = new services_1.ConversationManager(100, 50, this.logger);
+        this.messageClassifier = new services_1.MessageClassifier(this.userId, botConnection, this.logger);
+        this.typingIndicator = new services_1.TypingIndicatorService(botConnection, this.logger);
+        // Token billing
+        const hailerApi = new hailer_api_client_1.HailerApiClient(this.client);
+        this.tokenBilling = new services_1.TokenBillingService(this.logger, hailerApi);
+        // Message formatter - wrap ToolExecutor as MCP-style callback
+        const toolCallback = async (name, args) => {
+            return this.toolExecutor.execute(name, args, this.getUserContext());
+        };
+        this.messageFormatter = new services_1.MessageFormatterService(botConnection, this.logger, toolCallback);
+        // Session logger
+        this.sessionLogger = new services_1.SessionLoggerService(null, this.logger, toolCallback, () => this.getDefaultTeamId());
+        this.sessionLogger.setAnthropicClient(this.anthropic);
+        // 8. Build UserContext for tool execution
+        this.userContext = {
+            client: this.client,
+            hailer: hailerApi,
+            init: this.init,
+            workspaceCache: this.workspaceCache,
+            apiKey: '',
+            createdAt: Date.now(),
+            email: this.config.email,
+            password: this.config.password,
+        };
+        // 9. Subscribe to messenger.new signals
+        this.signalHandler = (eventData) => {
+            const signal = {
+                type: 'messenger.new',
+                data: eventData,
+                timestamp: Date.now(),
+                workspaceId: eventData.sid,
+            };
+            this.handleSignal(signal);
+        };
+        this.clientManager.onSignal('messenger.new', this.signalHandler);
+        // 10. Subscribe to workspace change signals for live updates
+        this.processUpdatedHandler = () => this.scheduleRefresh('processes');
+        this.workspaceUpdatedHandler = () => this.scheduleRefresh('network');
+        this.cacheInvalidateHandler = () => this.scheduleRefresh('full');
+        this.clientManager.onSignal('process.updated', this.processUpdatedHandler);
+        this.clientManager.onSignal('workspace.updated', this.workspaceUpdatedHandler);
+        this.clientManager.onSignal('cache.invalidate', this.cacheInvalidateHandler);
+        this._connected = true;
+        this.logger.debug('Bot started', {
+            userId: this.userId,
+            workspaceId: this._workspaceId,
+        });
+    }
+    async stop() {
+        this.logger.debug('Stopping bot');
+        // Clear refresh timer
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+        // Flush sessions
+        this.sessionLogger?.stopIdleCheckTimer();
+        await this.sessionLogger?.flushAllSessions();
+        // Abort all in-flight discussions before clearing state
+        for (const [, state] of this.discussionStates) {
+            state.abortController?.abort();
+        }
+        this.discussionStates.clear();
+        // Clear rate limit tracking
+        this.signalTimestampsPerDiscussion.clear();
+        this.globalSignalTimestamps = [];
+        // Unsubscribe from signals
+        if (this.signalHandler) {
+            this.clientManager.offSignal('messenger.new', this.signalHandler);
+            this.signalHandler = null;
+        }
+        if (this.processUpdatedHandler) {
+            this.clientManager.offSignal('process.updated', this.processUpdatedHandler);
+            this.processUpdatedHandler = null;
+        }
+        if (this.workspaceUpdatedHandler) {
+            this.clientManager.offSignal('workspace.updated', this.workspaceUpdatedHandler);
+            this.workspaceUpdatedHandler = null;
+        }
+        if (this.cacheInvalidateHandler) {
+            this.clientManager.offSignal('cache.invalidate', this.cacheInvalidateHandler);
+            this.cacheInvalidateHandler = null;
+        }
+        // Disconnect
+        this.clientManager.disconnect();
+        this._connected = false;
+        this.client = null;
+        this.logger.debug('Bot stopped');
+    }
+    // ===== SIGNAL HANDLING =====
+    async handleSignal(signal) {
+        if (!this._connected || !this.messageClassifier)
+            return;
+        try {
+            const rawMsgId = signal.data.msg_id;
+            if (rawMsgId) {
+                if (this.processedMessageIds.has(rawMsgId))
+                    return;
+                this.processedMessageIds.add(rawMsgId);
+            }
+            const message = await this.messageClassifier.extractIncomingMessage(signal);
+            if (!message) {
+                if (rawMsgId)
+                    this.processedMessageIds.delete(rawMsgId);
+                return;
+            }
+            // Self-message guard: prevent bot feedback loops
+            if (message.senderId === this.userId)
+                return;
+            // Rate limiting
+            const now = Date.now();
+            const cutoff = now - RATE_LIMIT_WINDOW;
+            // Per-discussion rate limit
+            const discId = message.discussionId;
+            let discTimestamps = this.signalTimestampsPerDiscussion.get(discId);
+            if (!discTimestamps) {
+                discTimestamps = [];
+                this.signalTimestampsPerDiscussion.set(discId, discTimestamps);
+            }
+            // Prune old entries
+            while (discTimestamps.length > 0 && discTimestamps[0] < cutoff) {
+                discTimestamps.shift();
+            }
+            if (discTimestamps.length >= RATE_LIMIT_PER_DISCUSSION) {
+                this.logger.warn('Per-discussion rate limit exceeded', {
+                    discussionId: discId,
+                    count: discTimestamps.length,
+                    window: RATE_LIMIT_WINDOW,
+                });
+                return;
+            }
+            discTimestamps.push(now);
+            // Global rate limit
+            while (this.globalSignalTimestamps.length > 0 && this.globalSignalTimestamps[0] < cutoff) {
+                this.globalSignalTimestamps.shift();
+            }
+            if (this.globalSignalTimestamps.length >= RATE_LIMIT_GLOBAL) {
+                this.logger.warn('Global rate limit exceeded', {
+                    count: this.globalSignalTimestamps.length,
+                    window: RATE_LIMIT_WINDOW,
+                });
+                return;
+            }
+            this.globalSignalTimestamps.push(now);
+            // Membership check - only respond to users who are members of the bot's workspace
+            if (this.init?.users && !this.init.users[message.senderId]) {
+                this.logger.debug('Ignoring message from non-workspace member', {
+                    senderId: message.senderId,
+                    senderName: message.senderName,
+                });
+                if (rawMsgId)
+                    this.processedMessageIds.delete(rawMsgId);
+                return;
+            }
+            // Prune dedup set
+            if (this.processedMessageIds.size > 500) {
+                const ids = Array.from(this.processedMessageIds);
+                this.processedMessageIds = new Set(ids.slice(-250));
+            }
+            const state = this.getOrCreateDiscussionState(discId);
+            // Always buffer the message
+            state.contextBuffer.push(message);
+            // Determine if this should trigger processing
+            const isExplicitTrigger = message.isMention || message.isReplyToBot || message.isDirectMessage;
+            if (state.state === 'idle') {
+                if (isExplicitTrigger) {
+                    state.state = 'engaged';
+                    state.consecutiveNonResponses = 0;
+                    this.opLogger.engage(discId, message.isMention ? 'mention' : message.isReplyToBot ? 'reply' : 'dm');
+                }
+                else {
+                    // Not addressed while idle — message sits in buffer as context only
+                    return;
+                }
+            }
+            // State is 'engaged' — trigger processing if not already running
+            if (!this.processingDiscussions.has(discId)) {
+                this.processDiscussion(discId).catch(err => {
+                    this.logger.error('processDiscussion failed', { discussionId: discId, error: err });
+                    this.processingDiscussions.delete(discId);
+                });
+            }
+            else {
+                // Already processing — message stays in contextBuffer.
+                // injectPendingContext delivers it between tool calls as <context>,
+                // and the LLM naturally decides whether to continue or stop.
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to handle signal', error);
+        }
+    }
+    async processDiscussion(discussionId) {
+        if (this.processingDiscussions.has(discussionId))
+            return;
+        this.processingDiscussions.add(discussionId);
+        const state = this.getOrCreateDiscussionState(discussionId);
+        try {
+            while (true) {
+                // Drain buffer
+                const messages = state.contextBuffer.splice(0);
+                if (messages.length === 0)
+                    break;
+                if (messages.length > 1) {
+                    this.opLogger.coalesce(discussionId, messages.length);
+                }
+                // Merge all buffered messages into a single user message (conversation alternation)
+                const conversation = this.conversationManager.getConversation(discussionId);
+                const parts = messages.map(msg => this.formatIncomingMessage(msg));
+                let merged = parts.join('\n\n');
+                if (messages.length > 1) {
+                    merged = `<context type="coalesced" count="${messages.length}">These ${messages.length} messages arrived while you were processing. Respond to the most recent/relevant.</context>\n\n${merged}`;
+                }
+                conversation.push({ role: 'user', content: merged });
+                // Use last message for routing/billing context
+                const primaryMessage = messages[messages.length - 1];
+                state.lastProgressTime = 0;
+                state.abortController = new AbortController();
+                // Log each incoming message
+                for (const msg of messages) {
+                    this.opLogger.messageIn(msg.discussionId, msg.senderName, msg.content);
+                }
+                // Process — the LLM decides whether to respond
+                let responded;
+                try {
+                    responded = await this.processMessage(primaryMessage, state.abortController.signal);
+                }
+                catch (error) {
+                    if (error instanceof sdk_1.default.APIUserAbortError) {
+                        // Aborted — new message arrived, loop will restart with updated buffer
+                        this.typingIndicator?.stop(discussionId);
+                        continue;
+                    }
+                    throw error;
+                }
+                if (responded) {
+                    state.consecutiveNonResponses = 0;
+                }
+                else {
+                    state.consecutiveNonResponses++;
+                    if (state.consecutiveNonResponses >= Bot.DISENGAGE_THRESHOLD) {
+                        state.state = 'idle';
+                        this.opLogger.disengage(discussionId, state.consecutiveNonResponses);
+                        break;
+                    }
+                }
+                // Check if more messages arrived during processing
+                if (state.contextBuffer.length === 0)
+                    break;
+                // If disengaged, only continue if there's an explicit trigger
+                if (state.state === 'idle') {
+                    const hasExplicit = state.contextBuffer.some(m => m.isMention || m.isReplyToBot || m.isDirectMessage);
+                    if (!hasExplicit)
+                        break;
+                    state.state = 'engaged';
+                    state.consecutiveNonResponses = 0;
+                    this.opLogger.engage(discussionId, 'reengaged');
+                }
+            }
+        }
+        finally {
+            this.processingDiscussions.delete(discussionId);
+            state.abortController = null;
+        }
+    }
+    // ===== MODEL ROUTING =====
+    /**
+     * Classify message complexity using a lightweight Haiku call.
+     * Returns model + max_tokens to use for the main LLM loop.
+     * Falls back to Haiku on any error.
+     */
+    async routeMessage(message, conversation, signal) {
+        const defaultRoute = {
+            model: MODEL_HAIKU,
+            maxTokens: 2000,
+            classification: 'SIMPLE',
+        };
+        try {
+            const wsName = this.init?.network?.name || 'Workspace';
+            const recentContext = this.getRecentContext(conversation);
+            const contextBlock = recentContext
+                ? `\nRecent context:\n${recentContext}\n`
+                : '';
+            const response = await this.anthropic.messages.create({
+                model: MODEL_HAIKU,
+                max_tokens: 10,
+                temperature: 0,
+                messages: [
+                    {
+                        role: 'user',
+                        content: `Classify this chat message as SIMPLE or COMPLEX.
+
+SIMPLE = can be answered in 1-2 tool calls with straightforward logic.
+COMPLEX = needs 3+ tool calls, reasoning across multiple data sources, fixing/creating structured data, or investigation.
+
+When in doubt, classify as COMPLEX.
+
+Workspace: ${wsName}
+${contextBlock}Current message: ${message.content}
+
+Reply with exactly one word: SIMPLE or COMPLEX`,
+                    },
+                ],
+            }, { signal });
+            // Bill the router call
+            this.trackRouterTokenUsage(response, message);
+            // Parse classification
+            const text = response.content
+                .filter((b) => b.type === 'text')
+                .map(b => b.text)
+                .join('')
+                .trim()
+                .toUpperCase();
+            if (text.includes('COMPLEX')) {
+                const route = {
+                    model: MODEL_SONNET,
+                    maxTokens: 16384,
+                    classification: 'COMPLEX',
+                };
+                this.opLogger.route(message.discussionId, route.classification, route.model, message.content);
+                return route;
+            }
+            this.opLogger.route(message.discussionId, defaultRoute.classification, defaultRoute.model, message.content);
+            return defaultRoute;
+        }
+        catch (error) {
+            this.logger.warn('Router failed, falling back to Haiku', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return defaultRoute;
+        }
+    }
+    /**
+     * Extract recent conversation text for the router prompt.
+     * Walks backwards, extracts only text blocks (no tool calls/results),
+     * truncates each to 200 chars. Returns up to 3 recent exchanges.
+     */
+    getRecentContext(conversation) {
+        const lines = [];
+        let count = 0;
+        for (let i = conversation.length - 1; i >= 0 && count < 3; i--) {
+            const msg = conversation[i];
+            const content = msg.content;
+            let text = '';
+            if (typeof content === 'string') {
+                text = content;
+            }
+            else if (Array.isArray(content)) {
+                text = content
+                    .filter((b) => b.type === 'text')
+                    .map((b) => b.text)
+                    .join(' ');
+            }
+            if (!text)
+                continue;
+            const truncated = text.length > 200 ? text.slice(0, 200) + '...' : text;
+            const role = msg.role === 'user' ? 'User' : 'Assistant';
+            lines.unshift(`${role}: ${truncated}`);
+            count++;
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Bill the router classification call the same way as main LLM calls.
+     */
+    trackRouterTokenUsage(response, message) {
+        if (!response.usage)
+            return;
+        const { input_tokens, output_tokens } = response.usage;
+        const cacheCreation = response.usage.cache_creation_input_tokens || 0;
+        const cacheRead = response.usage.cache_read_input_tokens || 0;
+        const burnWorkspaceId = this._workspaceId || message.workspaceId;
+        if (this.tokenBilling && burnWorkspaceId) {
+            const cost = this.tokenBilling.calculateCost(input_tokens, output_tokens, cacheCreation, cacheRead, MODEL_HAIKU);
+            this.tokenBilling.burnTokens({
+                workspaceId: burnWorkspaceId,
+                inputTokens: input_tokens,
+                outputTokens: output_tokens,
+                cacheCreationTokens: cacheCreation,
+                cacheReadTokens: cacheRead,
+                costUsd: cost,
+                sessionId: message.discussionId,
+                model: MODEL_HAIKU,
+            });
+        }
+    }
+    // ===== MESSAGE PROCESSING =====
+    async processMessage(message, signal) {
+        this.typingIndicator?.start(message.discussionId);
+        // Check token balance
+        const billingWorkspaceId = this._workspaceId || message.workspaceId;
+        if (this.tokenBilling && billingWorkspaceId) {
+            const balance = await this.tokenBilling.checkBalance(billingWorkspaceId);
+            const balanceStatus = balance.hasBalance ? (balance.balance < 5 ? 'LOW' : 'OK') : 'EMPTY';
+            this.opLogger.balanceCheck(message.discussionId, billingWorkspaceId, balance.balance, balanceStatus);
+            if (!balance.hasBalance) {
+                this.typingIndicator?.stop(message.discussionId);
+                await this.sendMessage(message.discussionId, 'Insufficient balance. Please top up your workspace AI credits to continue.');
+                return true; // We did respond (with balance error)
+            }
+        }
+        // Manage context size
+        this.conversationManager.manageContextSize(message.discussionId);
+        const conversation = this.conversationManager.getConversation(message.discussionId);
+        const snapshotLength = conversation.length;
+        try {
+            const route = await this.routeMessage(message, conversation, signal);
+            return await this.runLlmLoop(message, route, signal);
+        }
+        catch (error) {
+            if (error instanceof sdk_1.default.APIUserAbortError) {
+                throw error; // Let processDiscussion handle abort
+            }
+            this.logger.error('Message processing failed', error);
+            this.typingIndicator?.stop(message.discussionId);
+            conversation.length = snapshotLength;
+            return false;
+        }
+    }
+    async runLlmLoop(message, route, signal) {
+        const conversation = this.conversationManager.getConversation(message.discussionId);
+        const systemPrompt = this.buildSystemPrompt();
+        const tools = this.getAnthropicTools();
+        const processingStartTime = Date.now();
+        for (let i = 0; i < MAX_TOOL_ITERATIONS; i++) {
+            const cachedConversation = this.conversationManager.prepareForCaching(conversation);
+            let response;
+            let llmStart = Date.now();
+            try {
+                response = await this.anthropic.messages.create({
+                    model: route.model,
+                    max_tokens: route.maxTokens,
+                    temperature: 0,
+                    system: [{ type: 'text', text: systemPrompt, cache_control: { type: 'ephemeral' } }],
+                    messages: cachedConversation,
+                    tools,
+                }, { signal });
+            }
+            catch (error) {
+                // Handle abort — new message arrived, restart processing loop
+                if (error instanceof sdk_1.default.APIUserAbortError) {
+                    this.cleanupIncompleteExchange(conversation);
+                    this.opLogger.interrupt(message.discussionId, 'new message received');
+                    return false; // processDiscussion loop restarts with full context
+                }
+                // If Sonnet fails, fall back to Haiku and retry once
+                if (route.model !== MODEL_HAIKU) {
+                    this.logger.warn('Sonnet API call failed, falling back to Haiku', {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                    route = { model: MODEL_HAIKU, maxTokens: 2000, classification: 'SIMPLE' };
+                    llmStart = Date.now();
+                    response = await this.anthropic.messages.create({
+                        model: MODEL_HAIKU,
+                        max_tokens: 2000,
+                        temperature: 0,
+                        system: [{ type: 'text', text: systemPrompt, cache_control: { type: 'ephemeral' } }],
+                        messages: cachedConversation,
+                        tools,
+                    }, { signal });
+                }
+                else {
+                    throw error;
+                }
+            }
+            // Track token usage
+            this.trackTokenUsage(response, message, route.model);
+            // Log LLM call with timing and cache stats
+            const llmDuration = (Date.now() - llmStart) / 1000;
+            const usage = response.usage;
+            const cacheRead = usage.cache_read_input_tokens || 0;
+            const totalInput = usage.input_tokens + cacheRead + (usage.cache_creation_input_tokens || 0);
+            const cacheHitPct = totalInput > 0 ? Math.round((cacheRead / totalInput) * 100) : 0;
+            this.opLogger.llmCall(message.discussionId, route.model, usage.input_tokens, usage.output_tokens, cacheHitPct, llmDuration);
+            // Validate assistant response has content before adding to conversation
+            if (!response.content || (Array.isArray(response.content) && response.content.length === 0)) {
+                this.logger.warn('LLM returned empty content, skipping', {
+                    discussionId: message.discussionId,
+                    model: route.model,
+                    stopReason: response.stop_reason,
+                });
+                break;
+            }
+            // Add assistant response to conversation
+            conversation.push({
+                role: 'assistant',
+                content: response.content,
+            });
+            // Check for output truncation — if max_tokens was hit, tool call JSON is likely broken
+            if (response.stop_reason === 'max_tokens') {
+                this.logger.warn('LLM output truncated at max_tokens', {
+                    discussionId: message.discussionId,
+                    model: route.model,
+                    maxTokens: route.maxTokens,
+                    outputTokens: usage.output_tokens,
+                });
+                // Don't execute broken tool calls — tell the LLM to use smaller batches
+                conversation.push({
+                    role: 'user',
+                    content: 'Your previous response was truncated because it exceeded the output token limit. Do NOT try to generate all items at once. Break it into smaller batches of 25-50 items per tool call. You have multiple iterations available.',
+                });
+                continue;
+            }
+            // Check for tool calls
+            const toolUseBlocks = response.content.filter((b) => b.type === 'tool_use');
+            if (toolUseBlocks.length > 0) {
+                const toolResults = await this.executeTools(toolUseBlocks, message, signal);
+                conversation.push({ role: 'user', content: toolResults });
+                // Inject any messages that arrived during tool execution
+                this.injectPendingContext(message.discussionId, conversation);
+                // Auto-escalate: if Haiku is failing tool calls, switch to Sonnet
+                if (route.model === MODEL_HAIKU) {
+                    const failedCount = toolResults
+                        .filter(r => r.is_error).length;
+                    if (failedCount >= 2) {
+                        this.logger.info('Escalating to Sonnet — Haiku failing tool calls', {
+                            discussionId: message.discussionId,
+                            failedTools: failedCount,
+                            iteration: i,
+                        });
+                        route = { model: MODEL_SONNET, maxTokens: 16384, classification: 'COMPLEX' };
+                        await this.sendMessage(message.discussionId, `Switching to a more capable model to handle this.`);
+                    }
+                }
+                // Progress feedback: send contextual update every 20s during long operations
+                const state = this.discussionStates.get(message.discussionId);
+                const now = Date.now();
+                const elapsed = now - processingStartTime;
+                const lastProgress = state?.lastProgressTime || processingStartTime;
+                if (state && elapsed > 8000 && (now - lastProgress) >= 20000) {
+                    state.lastProgressTime = now;
+                    const toolCounts = new Map();
+                    for (const b of toolUseBlocks) {
+                        const name = b.name.replace(/_/g, ' ');
+                        toolCounts.set(name, (toolCounts.get(name) || 0) + 1);
+                    }
+                    const toolSummary = Array.from(toolCounts.entries())
+                        .map(([name, count]) => count > 1 ? `${name} x${count}` : name)
+                        .join(', ');
+                    const progressMsg = `Still working (step ${i + 1}) — ${toolSummary}`;
+                    await this.sendMessage(message.discussionId, progressMsg);
+                    this.opLogger.progress(message.discussionId);
+                }
+                continue; // Loop back for more tool calls or final response
+            }
+            // Extract text response
+            const textBlocks = response.content.filter((b) => b.type === 'text');
+            const responseText = textBlocks.map(b => b.text).join('\n').trim();
+            if (!responseText) {
+                // Remove the empty assistant message we just pushed
+                conversation.pop();
+                break;
+            }
+            // Post the response
+            this.typingIndicator?.stop(message.discussionId);
+            const formatted = await this.formatOutgoingMessage(responseText);
+            const links = this.messageFormatter.extractTagLinks(formatted);
+            await this.sendMessage(message.discussionId, formatted, links);
+            return true;
+        }
+        // Max iterations reached or empty response
+        this.typingIndicator?.stop(message.discussionId);
+        return false;
+    }
+    async executeTools(toolUseBlocks, message, signal) {
+        const discussionId = message.discussionId;
+        const results = [];
+        const WRITE_TOOLS = new Set(['create_activity', 'update_activity']);
+        for (const block of toolUseBlocks) {
+            const toolStart = Date.now();
+            // Permission gate: check if user has access to the workflow
+            const args = block.input;
+            const workflowId = args.workflowId;
+            if (workflowId && WORKFLOW_SCOPED_TOOLS.has(block.name)) {
+                const allowed = this.permissionIndex.get(workflowId);
+                if (allowed && !allowed.has(message.senderId) && !this.adminUserIds.has(message.senderId) && !this.ownerUserIds.has(message.senderId)) {
+                    this.opLogger.permDenied(discussionId, block.name, workflowId, message.senderId);
+                    results.push({
+                        type: 'tool_result',
+                        tool_use_id: block.id,
+                        content: `Permission denied: This user does not have access to workflow ${workflowId}. This is a workspace permission restriction on the user, not on you (the bot).`,
+                        is_error: true,
+                    });
+                    continue;
+                }
+            }
+            try {
+                let toolArgs = args;
+                // Auto-inject context for join_discussion calls
+                if (block.name === 'join_discussion') {
+                    toolArgs = { ...toolArgs };
+                    // Auto-inject inviteUserId from the sender if not already set
+                    if (!toolArgs.inviteUserId && message.senderId) {
+                        toolArgs.inviteUserId = message.senderId;
+                    }
+                    // Auto-inject sourceActivityId for wormhole (only if from an activity discussion, not DMs)
+                    if (!toolArgs.sourceActivityId && message.linkedActivityId) {
+                        toolArgs.sourceActivityId = message.linkedActivityId;
+                    }
+                    // Auto-inject welcomeReason with the actual message content for context
+                    if (!toolArgs.welcomeReason && message.content) {
+                        toolArgs.welcomeReason = message.content;
+                    }
+                }
+                const result = await this.toolExecutor.execute(block.name, toolArgs, this.getUserContext());
+                const text = result?.content?.[0]?.text ?? JSON.stringify(result);
+                let contentStr = typeof text === 'string' ? text : JSON.stringify(text);
+                const toolDuration = (Date.now() - toolStart) / 1000;
+                // Post-filter list_workflows results to only show accessible workflows
+                if ((block.name === 'list_workflows' || block.name === 'list_workflows_minimal') && this.permissionIndex.size > 0 && !this.adminUserIds.has(message.senderId) && !this.ownerUserIds.has(message.senderId)) {
+                    try {
+                        const parsed = JSON.parse(contentStr);
+                        if (parsed.workflows && Array.isArray(parsed.workflows)) {
+                            const before = parsed.workflows.length;
+                            parsed.workflows = parsed.workflows.filter((wf) => {
+                                const wfId = wf.id || wf._id || wf.workflowId;
+                                if (!wfId)
+                                    return true;
+                                const allowed = this.permissionIndex.get(wfId);
+                                return !allowed || allowed.has(message.senderId);
+                            });
+                            if (parsed.workflows.length < before) {
+                                this.opLogger.permFiltered(discussionId, block.name, before, parsed.workflows.length);
+                            }
+                            contentStr = JSON.stringify(parsed);
+                        }
+                    }
+                    catch {
+                        // Not JSON or unexpected format, pass through unfiltered
+                    }
+                }
+                // Post-execution permission check for tools not gated by workflowId arg
+                if (this.permissionIndex.size > 0 && UNGATED_TOOLS.has(block.name)) {
+                    const extractedWorkflowId = this.extractWorkflowIdFromResult(block.name, contentStr);
+                    if (extractedWorkflowId) {
+                        const allowed = this.permissionIndex.get(extractedWorkflowId);
+                        if (allowed && !allowed.has(message.senderId) && !this.adminUserIds.has(message.senderId) && !this.ownerUserIds.has(message.senderId)) {
+                            this.opLogger.permDenied(discussionId, block.name, extractedWorkflowId, message.senderId);
+                            results.push({
+                                type: 'tool_result',
+                                tool_use_id: block.id,
+                                content: `Permission denied: This user does not have access to the resource in workflow ${extractedWorkflowId}. This is a workspace permission restriction on the user, not on you (the bot).`,
+                                is_error: true,
+                            });
+                            continue;
+                        }
+                    }
+                }
+                // Check if tool returned an error in its response text
+                const lower = contentStr.toLowerCase();
+                const stripped = contentStr.replace(/[^\w]/g, ' ').trimStart().toLowerCase();
+                const isToolError = lower.includes('"error"') || lower.includes('❌') || stripped.startsWith('error');
+                const summary = (0, operation_logger_1.summarizeToolResult)(block.name, contentStr);
+                if (isToolError) {
+                    this.opLogger.toolCall(discussionId, block.name, 'error', toolDuration, 'FAIL', summary);
+                }
+                else {
+                    this.opLogger.toolCall(discussionId, block.name, summary, toolDuration, 'OK');
+                }
+                // Warn if a write tool completed before abort — not idempotent
+                if (signal?.aborted && WRITE_TOOLS.has(block.name)) {
+                    this.logger.warn('Write tool completed before abort', {
+                        discussionId, tool: block.name,
+                    });
+                }
+                results.push({
+                    type: 'tool_result',
+                    tool_use_id: block.id,
+                    content: contentStr,
+                });
+            }
+            catch (error) {
+                const toolDuration = (Date.now() - toolStart) / 1000;
+                const errMsg = error instanceof Error ? error.message : String(error);
+                this.opLogger.toolCall(discussionId, block.name, 'error', toolDuration, 'FAIL', errMsg);
+                results.push({
+                    type: 'tool_result',
+                    tool_use_id: block.id,
+                    content: `Error: ${errMsg}`,
+                    is_error: true,
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Inject pending messages from the context buffer into the conversation
+     * between LLM iterations. Merges into the existing user message to preserve
+     * Anthropic's alternation rule (user/assistant/user/assistant).
+     */
+    injectPendingContext(discussionId, conversation) {
+        const state = this.discussionStates.get(discussionId);
+        if (!state || state.contextBuffer.length === 0)
+            return;
+        const pending = state.contextBuffer.splice(0);
+        const lastMsg = conversation[conversation.length - 1];
+        if (lastMsg?.role === 'user' && Array.isArray(lastMsg.content)) {
+            const contextText = pending.map(m => this.formatIncomingMessage(m)).join('\n\n');
+            lastMsg.content.push({
+                type: 'text',
+                text: `<context type="messages-during-processing">\n${contextText}\n</context>`,
+            });
+            this.opLogger.contextInject(discussionId, pending.length);
+        }
+    }
+    /**
+     * Remove orphaned tool_use/tool_result pairs from conversation after abort.
+     * Walks backwards and removes incomplete exchanges to keep conversation valid.
+     */
+    cleanupIncompleteExchange(conversation) {
+        while (conversation.length > 0) {
+            const last = conversation[conversation.length - 1];
+            const content = Array.isArray(last.content) ? last.content : [];
+            if (last.role === 'assistant' && content.some((b) => b.type === 'tool_use')) {
+                conversation.pop();
+                continue;
+            }
+            if (last.role === 'user' && content.some((b) => b.type === 'tool_result')) {
+                conversation.pop();
+                continue;
+            }
+            break;
+        }
+    }
+    // ===== FORMATTING =====
+    formatIncomingMessage(message) {
+        const activityAttr = message.linkedActivityId ? ` activity_id="${message.linkedActivityId}"` : '';
+        const discName = message.discussionName || message.linkedActivityName;
+        const nameAttr = discName ? ` discussion_name="${discName}"` : '';
+        let fileInfo = '';
+        if (message.fileAttachments?.length) {
+            const ids = message.fileAttachments.map(f => f.fileId).join(', ');
+            fileInfo = `\n[File attached: ${message.fileAttachments.length} file(s) - IDs: ${ids}]\nUse download_file tool with fileId to read file contents.`;
+        }
+        return `<incoming discussion="${message.discussionId}"${nameAttr}${activityAttr} from="${message.senderName}" user_id="${message.senderId}" timestamp="${new Date(message.timestamp).toISOString()}">\n${message.content}${fileInfo}\n</incoming>`;
+    }
+    async formatOutgoingMessage(text) {
+        let formatted = await this.messageFormatter.resolveUserTags(text);
+        formatted = await this.messageFormatter.resolveActivityTags(formatted);
+        formatted = await this.messageFormatter.resolveHailerUrls(formatted);
+        formatted = this.messageFormatter.convertMentionsToTags(formatted);
+        // Remove redundant name after tags
+        formatted = formatted.replace(/(\[hailerTag\|[^\]]+\]\([a-f0-9]{24}\)\uFEFF?)\s*\([^)]+\)/gi, '$1');
+        // Auto-resolve bare 24-char hex IDs not already in hailerTag format
+        formatted = await this.resolveBareIds(formatted);
+        return formatted;
+    }
+    /**
+     * Find bare 24-char hex IDs in text that aren't already inside hailerTags
+     * and try to resolve them to clickable hailerTags.
+     */
+    async resolveBareIds(text) {
+        // Match 24-char hex IDs that are NOT preceded by ( which would mean they're already in a hailerTag
+        const bareIdPattern = /(?<!\()([a-f0-9]{24})(?!\)[^\[]*\[hailerTag)/gi;
+        const matches = [...text.matchAll(bareIdPattern)];
+        // Collect IDs that aren't already in hailerTags, limit to 5
+        const idsToResolve = [];
+        for (const match of matches) {
+            const id = match[1];
+            const tagCheck = new RegExp(`\\[hailerTag\\|[^\\]]+\\]\\(${id}\\)`, 'i');
+            if (tagCheck.test(text))
+                continue;
+            idsToResolve.push(id);
+            if (idsToResolve.length >= 5)
+                break;
+        }
+        if (idsToResolve.length === 0)
+            return text;
+        // Resolve all IDs in parallel
+        const resolutions = await Promise.all(idsToResolve.map(async (id) => {
+            try {
+                const result = await this.toolExecutor.execute('show_activity_by_id', { activityId: id }, this.getUserContext());
+                const resultText = result?.content?.[0]?.text;
+                if (resultText) {
+                    const jsonMatch = resultText.match(/\{[\s\S]*\}/);
+                    if (jsonMatch) {
+                        const parsed = JSON.parse(jsonMatch[0]);
+                        if (parsed.name)
+                            return { id, name: parsed.name };
+                    }
+                }
+            }
+            catch {
+                // Not an activity, skip
+            }
+            return null;
+        }));
+        // Apply replacements
+        for (const resolved of resolutions) {
+            if (!resolved)
+                continue;
+            const ZWNBSP = '\uFEFF';
+            const tag = `${ZWNBSP}[hailerTag|${resolved.name}](${resolved.id})${ZWNBSP}`;
+            text = text.replace(resolved.id, tag);
+        }
+        return text;
+    }
+    // ===== SYSTEM PROMPT =====
+    getBotDisplayName() {
+        if (!this.init?.users || !this.userId)
+            return 'Assistant';
+        const user = this.init.users[this.userId];
+        if (!user)
+            return 'Assistant';
+        const name = user.display_name || user.fullName ||
+            `${user.firstname || ''} ${user.lastname || ''}`.trim();
+        return name || 'Assistant';
+    }
+    buildSystemPrompt() {
+        const wsName = this.init?.network?.name || 'Workspace';
+        const botName = this.getBotDisplayName();
+        return `You are a workspace assistant for "${wsName}" on Hailer.
+
+<bot-identity>
+Your user ID: ${this.userId}
+Your display name: ${botName}
+</bot-identity>
+
+<rules>
+- Be concise. Short answers, no filler.
+- Never list your capabilities unprompted. If asked what you can do, give a 1-2 sentence summary based on the workspace context below, not a feature dump.
+- Never use emojis unless the user does first.
+- Use tools to answer questions - don't guess or make up data.
+- When a task will require multiple steps (investigating errors, fixing data, bulk lookups), briefly tell the user what you're specifically about to do before starting. Be concrete: "I'll check each insight's SQL and fix any broken column references." NEVER use vague filler like "Let me look into that" — always name the actual action.
+- When showing data, use clean formatting (tables, bullet points). Don't over-explain.
+- If a request is ambiguous, ask a clarifying question instead of guessing.
+- Always reference actual workspace data (workflow names, field values) - never speak in generic terms.
+- For bulk operations (creating/updating many items), batch into groups of 25-50 per tool call. Never try to create more than 50 items in a single tool call.
+- When a tool call fails, ALWAYS tell the user what failed and why. Never silently try alternatives. If an insight has a SQL error, tell the user the insight is broken, explain what's wrong (e.g. missing column), and offer to fix it using update_insight. Fix the root cause, don't work around it.
+- NEVER output raw URLs like https://app.hailer.com/...
+- When referencing activities, discussions, or users, use hailerTag format: [hailerTag|Display Name](objectId)
+  Examples: [hailerTag|AC Milan](691ffe654217e9e8434e578a) or [hailerTag|John Smith](691ffe654217e9e8434e5123)
+  You always have the name and ID from tool responses - use them directly in this format.
+</rules>
+
+<workspace-context>
+${this.workspaceOverview}
+</workspace-context>`;
+    }
+    // ===== TOOLS =====
+    getAnthropicTools() {
+        const defs = this.toolExecutor.getToolDefinitions({
+            allowedGroups: [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE, tool_registry_1.ToolGroup.PLAYGROUND, tool_registry_1.ToolGroup.BOT_INTERNAL],
+        });
+        return defs
+            .filter(d => BOT_TOOLS.has(d.name))
+            .map(d => ({
+            name: d.name,
+            description: d.description,
+            input_schema: d.inputSchema,
+        }));
+    }
+    // ===== HAILER MESSAGING =====
+    async sendMessage(discussionId, text, links) {
+        try {
+            const msgData = { msg: text };
+            if (links?.length)
+                msgData.links = links;
+            await this.client.socket.request('messenger.send', [msgData, discussionId]);
+            const tagCount = (text.match(/\[hailerTag\|/g) || []).length;
+            this.opLogger.messageOut(discussionId, text.length, tagCount);
+        }
+        catch (error) {
+            this.logger.error('Failed to send message', error);
+        }
+    }
+    // ===== HELPERS =====
+    /**
+     * Schedule a workspace data refresh with debounce.
+     * Signals can fire in bursts (e.g., bulk field edits), so we debounce
+     * to avoid hammering the API. 2-second delay is effectively instant
+     * from a user perspective but handles bursts.
+     */
+    scheduleRefresh(scope) {
+        this.refreshDirty = true;
+        if (scope === 'full') {
+            this.refreshScope.clear();
+            this.refreshScope.add('full');
+        }
+        else if (!this.refreshScope.has('full')) {
+            this.refreshScope.add(scope);
+        }
+        if (this.refreshTimer)
+            clearTimeout(this.refreshTimer);
+        this.refreshTimer = setTimeout(() => this.refreshWorkspaceData(), 2000);
+    }
+    /**
+     * Re-fetch workspace data and rebuild the overview.
+     * Called when process.updated, workspace.updated, or cache.invalidate signals fire.
+     */
+    async refreshWorkspaceData() {
+        if (!this.refreshDirty || !this.client)
+            return;
+        if (this.isRefreshing) {
+            this.refreshQueued = true;
+            return;
+        }
+        this.isRefreshing = true;
+        this.refreshDirty = false;
+        const scopes = new Set(this.refreshScope);
+        this.refreshScope.clear();
+        this.refreshTimer = null;
+        try {
+            // Determine what to re-fetch based on signal types
+            const isFull = scopes.has('full');
+            const keys = isFull
+                ? ['processes', 'users', 'network', 'networks', 'teams', 'groups']
+                : Array.from(scopes);
+            // Always include users with processes (membership check depends on it)
+            if (keys.includes('processes') && !keys.includes('users')) {
+                keys.push('users');
+            }
+            this.logger.debug('Refreshing workspace data', { keys, trigger: isFull ? 'full' : Array.from(scopes).join(',') });
+            const freshData = await this.client.socket.request('v2.core.init', [keys]);
+            // Merge fresh data into existing init (partial update)
+            if (!this.init) {
+                this.init = freshData;
+            }
+            else {
+                if (freshData.processes)
+                    this.init.processes = freshData.processes;
+                if (freshData.users)
+                    this.init.users = freshData.users;
+                if (freshData.network)
+                    this.init.network = freshData.network;
+                if (freshData.networks)
+                    this.init.networks = freshData.networks;
+                if (freshData.teams)
+                    this.init.teams = freshData.teams;
+                if (freshData.groups)
+                    this.init.groups = freshData.groups;
+            }
+            this._workspaceId = this.init.network?._id || this.config.workspaceId;
+            // Rebuild workspace cache
+            this.workspaceCache = (0, workspace_cache_1.createWorkspaceCache)(this.init, {
+                excludeTranslations: true,
+                excludeSystemMessages: true,
+                excludeEmptyFields: true,
+                compactUserData: true,
+                includeWorkspaceNamesInTools: false,
+            });
+            // Rebuild workspace overview for system prompt
+            this.workspaceOverview = (0, workspace_overview_1.generateWorkspaceOverview)(this.init);
+            // Update UserContext with fresh data
+            if (this.userContext) {
+                this.userContext.init = this.init;
+                this.userContext.workspaceCache = this.workspaceCache;
+            }
+            // Rebuild permission index
+            this.buildPermissionIndex();
+            this.logger.debug('Workspace data refreshed', {
+                keys,
+                workflowCount: this.init.processes?.length || 0,
+                userCount: Object.keys(this.init.users || {}).length,
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to refresh workspace data', error);
+        }
+        finally {
+            this.isRefreshing = false;
+            if (this.refreshQueued) {
+                this.refreshQueued = false;
+                this.refreshWorkspaceData();
+            }
+        }
+    }
+    buildPermissionIndex() {
+        this.permissionIndex.clear();
+        const wsId = this._workspaceId;
+        if (!this.init?.processes || !wsId)
+            return;
+        // Extract workspace admins from network members
+        this.adminUserIds.clear();
+        const network = this.init.network;
+        if (network?.members) {
+            const members = Array.isArray(network.members) ? network.members : Object.values(network.members);
+            for (const member of members) {
+                if (member.admin === true) {
+                    this.adminUserIds.add(member.uid);
+                }
+            }
+        }
+        // Extract workspace owners from network members
+        this.ownerUserIds.clear();
+        if (network?.members) {
+            const ownerMembers = Array.isArray(network.members) ? network.members : Object.values(network.members);
+            for (const member of ownerMembers) {
+                if (member.owner === true) {
+                    this.ownerUserIds.add(member.uid);
+                }
+            }
+        }
+        const teams = this.init.teams?.[wsId] || {};
+        const groups = this.init.groups?.[wsId] || {};
+        let networkOpenCount = 0;
+        for (const proc of this.init.processes) {
+            const members = proc.members || [];
+            // If any member is network_ (all workspace members), skip indexing — everyone has access
+            if (members.some((m) => m.id.startsWith('network_'))) {
+                networkOpenCount++;
+                continue;
+            }
+            // If any member references a public team, treat as open — all workspace members have access
+            let hasPublicTeam = false;
+            for (const m of members) {
+                if (!m.id.startsWith('team_'))
+                    continue;
+                const team = teams[m.id.slice(5)];
+                if (team) {
+                    if (team.public) {
+                        hasPublicTeam = true;
+                        break;
+                    }
+                }
+            }
+            if (hasPublicTeam) {
+                networkOpenCount++;
+                continue;
+            }
+            const userIds = new Set();
+            for (const member of members) {
+                const id = member.id;
+                if (id.startsWith('user_')) {
+                    userIds.add(id.slice(5));
+                }
+                else if (id.startsWith('team_')) {
+                    const team = teams[id.slice(5)];
+                    if (team?.members) {
+                        for (const uid of team.members) {
+                            userIds.add(typeof uid === 'string' ? uid : uid._id || uid.id || uid.uid);
+                        }
+                    }
+                }
+                else if (id.startsWith('group_')) {
+                    const group = groups[id.slice(6)];
+                    if (group?.members) {
+                        for (const uid of group.members) {
+                            userIds.add(typeof uid === 'string' ? uid : uid._id || uid.id || uid.uid);
+                        }
+                    }
+                }
+            }
+            // Workflow creator always has access
+            if (proc.uid)
+                userIds.add(proc.uid);
+            this.permissionIndex.set(proc._id, userIds);
+        }
+        this.logger.debug('Permission index built', {
+            restricted: this.permissionIndex.size,
+            open: networkOpenCount,
+            totalWorkflows: this.init.processes.length,
+            totalEntries: Array.from(this.permissionIndex.values()).reduce((n, s) => n + s.size, 0),
+            admins: this.adminUserIds.size,
+            owners: this.ownerUserIds.size,
+        });
+    }
+    getOrCreateDiscussionState(discussionId) {
+        let state = this.discussionStates.get(discussionId);
+        if (state) {
+            // LRU: move to end
+            this.discussionStates.delete(discussionId);
+            this.discussionStates.set(discussionId, state);
+            return state;
+        }
+        // Evict oldest if at capacity
+        if (this.discussionStates.size >= 200) {
+            const oldest = this.discussionStates.keys().next().value;
+            if (oldest)
+                this.discussionStates.delete(oldest);
+        }
+        state = {
+            contextBuffer: [],
+            abortController: null,
+            state: 'idle',
+            consecutiveNonResponses: 0,
+            lastProgressTime: 0,
+        };
+        this.discussionStates.set(discussionId, state);
+        return state;
+    }
+    getUserContext() {
+        if (!this.userContext)
+            throw new Error('Bot not started');
+        return this.userContext;
+    }
+    getDefaultTeamId() {
+        const teams = this.init?.teams;
+        if (!teams)
+            return undefined;
+        const workspaceTeams = Object.values(teams)[0];
+        if (!workspaceTeams || typeof workspaceTeams !== 'object')
+            return undefined;
+        return Object.keys(workspaceTeams)[0];
+    }
+    /**
+     * Extract workflow ID from tool result for post-execution permission checks.
+     * Returns the workflow ID if found, or undefined if extraction fails.
+     */
+    extractWorkflowIdFromResult(toolName, resultStr) {
+        try {
+            const jsonMatch = resultStr.match(/\{[\s\S]*\}/);
+            if (!jsonMatch)
+                return undefined;
+            const parsed = JSON.parse(jsonMatch[0]);
+            // show_activity_by_id: workflowId is in the activity result
+            if (toolName === 'show_activity_by_id') {
+                return parsed.workflowId || parsed.workflow_id || parsed.processId;
+            }
+            // get_activity_from_discussion: returns activity with workflow info
+            if (toolName === 'get_activity_from_discussion') {
+                return parsed.workflowId || parsed.workflow_id || parsed.processId
+                    || parsed.activity?.workflowId || parsed.activity?.processId;
+            }
+            // fetch_discussion_messages: result may contain a workflowId from linked activity
+            if (toolName === 'fetch_discussion_messages') {
+                return parsed.workflowId || parsed.workflow_id || parsed.processId
+                    || parsed.activity?.workflowId || parsed.activity?.processId;
+            }
+        }
+        catch {
+            // JSON parse failed, cannot extract
+        }
+        return undefined;
+    }
+    trackTokenUsage(response, message, model) {
+        if (!response.usage)
+            return;
+        const { input_tokens, output_tokens } = response.usage;
+        const cacheCreation = response.usage.cache_creation_input_tokens || 0;
+        const cacheRead = response.usage.cache_read_input_tokens || 0;
+        // Burn tokens - always use bot's workspace, not the discussion's workspace
+        const burnWorkspaceId = this._workspaceId || message.workspaceId;
+        if (this.tokenBilling && burnWorkspaceId) {
+            const cost = this.tokenBilling.calculateCost(input_tokens, output_tokens, cacheCreation, cacheRead, model);
+            this.tokenBilling.burnTokens({
+                workspaceId: burnWorkspaceId,
+                inputTokens: input_tokens,
+                outputTokens: output_tokens,
+                cacheCreationTokens: cacheCreation,
+                cacheReadTokens: cacheRead,
+                costUsd: cost,
+                sessionId: message.discussionId,
+                model,
+            });
+        }
+    }
+}
+exports.Bot = Bot;
+//# sourceMappingURL=bot.js.map