@hailer/mcp 0.1.16 → 0.2.1

package/dist/client/orchestrator-daemon.js

@@ -1,444 +0,0 @@
-"use strict";
-/**
- * Orchestrator Daemon (HAL)
- *
- * The main conversational bot that handles general chat and coordinates
- * with specialist bots when tasks are too complex.
- *
- * HAL can:
- * - Handle general conversation and simple queries
- * - Detect when a task needs specialist help
- * - Invite specialist bots to the discussion
- * - Hand off context to specialists
- * - Summarize specialist responses for users
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OrchestratorDaemon = void 0;
-const chat_agent_daemon_1 = require("./chat-agent-daemon");
-const specialists_1 = require("./specialists");
-const logger_1 = require("../lib/logger");
-class OrchestratorDaemon extends chat_agent_daemon_1.ChatAgentDaemon {
-    orchestratorLogger;
-    specialists = new Map();
-    activeSpecialistsInDiscussion = new Map(); // discussionId -> Set<specialistUserId>
-    specialistUserIds = new Map(); // specialistKey -> userId
-    toolsUsedInCurrentMessage = false; // Track if tools were used in current message processing
-    constructor(config) {
-        super(config);
-        this.orchestratorLogger = (0, logger_1.createLogger)({
-            component: "OrchestratorDaemon",
-            botId: config.botClient.userId,
-        });
-        // Register specialists from config
-        for (const [key, specialist] of Object.entries(specialists_1.SPECIALISTS)) {
-            this.specialists.set(key, specialist);
-        }
-        // Set specialist user IDs if provided
-        if (config.specialistUserIds) {
-            this.specialistUserIds = config.specialistUserIds;
-        }
-    }
-    // ===== AGENT DIRECTORY OVERRIDES =====
-    /**
-     * Override agent name for Agent Directory
-     */
-    getAgentName() {
-        return { firstName: "HAL", lastName: "Orchestrator" };
-    }
-    /**
-     * Override agent description for Agent Directory
-     */
-    getAgentDescription() {
-        return "HAL - the main Hailer Assistant orchestrator. Handles general conversation and coordinates specialist bots for complex tasks.";
-    }
-    /**
-     * Override Position details for Orchestrator
-     */
-    getPositionDetails() {
-        return {
-            name: "HAL Orchestrator",
-            purpose: "Main point of contact for users. Handles general conversation, triages requests, and coordinates specialist bots for complex tasks.",
-            personaTone: "Sharp, efficient, and helpful. Professional but approachable. Uses clear, concise language.",
-            coreCapabilities: "- Monitor all workspace discussions\n- Respond to general queries and greetings\n- Detect when specialist help is needed\n- Invite specialists to discussions\n- Coordinate multi-step workflows\n- Execute MCP tools for data operations",
-            boundaries: "- Never fabricate data - always use tools\n- Don't attempt complex technical tasks alone\n- Hand off to specialists for: bulk operations, report creation, workflow setup\n- Don't share credentials or sensitive config",
-        };
-    }
-    /**
-     * Register a specialist's Hailer user ID
-     * Called during initialization when we know the specialist bot's user ID
-     */
-    registerSpecialistUserId(specialistKey, userId) {
-        this.specialistUserIds.set(specialistKey, userId);
-        const specialist = this.specialists.get(specialistKey);
-        if (specialist) {
-            specialist.botUserId = userId;
-            this.orchestratorLogger.info("Specialist registered", {
-                key: specialistKey,
-                name: specialist.name,
-                userId,
-            });
-        }
-    }
-    /**
-     * Check if a specialist is already active in a discussion
-     */
-    isSpecialistActiveInDiscussion(discussionId, specialistUserId) {
-        const active = this.activeSpecialistsInDiscussion.get(discussionId);
-        return active?.has(specialistUserId) ?? false;
-    }
-    /**
-     * Mark a specialist as active in a discussion
-     */
-    markSpecialistActive(discussionId, specialistUserId) {
-        if (!this.activeSpecialistsInDiscussion.has(discussionId)) {
-            this.activeSpecialistsInDiscussion.set(discussionId, new Set());
-        }
-        this.activeSpecialistsInDiscussion.get(discussionId).add(specialistUserId);
-    }
-    /**
-     * Invite a specialist to a discussion
-     */
-    async inviteSpecialist(specialist, discussionId, handoffContext) {
-        const specialistUserId = specialist.botUserId;
-        if (!specialistUserId) {
-            this.orchestratorLogger.warn("Specialist has no user ID", {
-                name: specialist.name,
-            });
-            return false;
-        }
-        // Check if already active
-        if (this.isSpecialistActiveInDiscussion(discussionId, specialistUserId)) {
-            this.orchestratorLogger.debug("Specialist already in discussion", {
-                name: specialist.name,
-                discussionId,
-            });
-            // Just tag them again
-            await this.postResponse(discussionId, `@"${specialist.name}" - ${handoffContext}`);
-            return true;
-        }
-        try {
-            this.orchestratorLogger.info("Inviting specialist to discussion", {
-                name: specialist.name,
-                userId: specialistUserId,
-                discussionId,
-            });
-            // Invite using MCP tool
-            await this.callMcpTool("invite_discussion_members", {
-                discussionId,
-                userIds: [specialistUserId],
-            });
-            this.markSpecialistActive(discussionId, specialistUserId);
-            // Post handoff message
-            await this.postResponse(discussionId, `@"${specialist.name}" - ${handoffContext}`);
-            this.orchestratorLogger.info("Specialist invited successfully", {
-                name: specialist.name,
-                discussionId,
-            });
-            return true;
-        }
-        catch (error) {
-            this.orchestratorLogger.error("Failed to invite specialist", {
-                name: specialist.name,
-                discussionId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return false;
-        }
-    }
-    /**
-     * Override system prompt to include orchestrator capabilities
-     */
-    getSystemPrompt() {
-        const now = new Date();
-        // Build specialist info for prompt
-        const specialistInfo = Array.from(this.specialists.entries())
-            .map(([key, spec]) => {
-            const hasUserId = !!spec.botUserId;
-            return `- **${spec.name}** ${hasUserId ? "(available)" : "(not configured)"}
-  Expertise: ${spec.expertise.join(", ")}
-  Triggers: ${spec.triggerKeywords.slice(0, 5).join(", ")}`;
-        })
-            .join("\n\n");
-        return `<identity>
-You are HAL - the Hailer Assistant. Sharp, efficient, and helpful.
-Bot ID: ${this.botClient.userId}
-
-You're the main point of contact for users. You handle general conversation
-and simple tasks yourself, but can bring in specialist bots for complex work.
-</identity>
-
-<current_time>${now.toISOString()}</current_time>
-
-<personality>
-**BUSINESS MODE** (default):
-- Professional, direct, competent
-- Get things done efficiently
-- Provide accurate information
-
-**SARCASM MODE** (for ridiculous requests):
-- Dry wit, not mean-spirited
-- Still help after the gentle mockery
-</personality>
-
-<decision_framework>
-For each message, decide:
-
-1. **HIGH PRIORITY** (priority="high"):
-   - Direct messages (1:1) -> ALWAYS respond helpfully
-   - @mentions -> ALWAYS respond
-   - Replies to your messages -> ALWAYS respond
-
-2. **NORMAL PRIORITY** (general chat) - STRICT FILTERING:
-
-   **RESPOND ONLY IF the message:**
-   - Explicitly asks about Hailer (workflows, activities, insights, apps, discussions)
-   - Requests to find/list/create/update workspace data
-   - Discusses a specific activity, customer, project, or workflow by name
-   - You can genuinely help with workspace-related context
-   - Is a complex task needing specialist help
-
-   **ALWAYS IGNORE (output <ignore/>) if:**
-   - Random characters, gibberish, keyboard mashing (no real words, repeated patterns)
-   - General chit-chat unrelated to workspace ("how are you", jokes)
-   - Conversations between other users that don't need you
-   - Bare greetings without a question ("hi", "hey")
-   - Off-topic discussions (sports, weather, personal chat)
-   - Anything you're uncertain about
-
-   **CRITICAL:** If no clear workspace-related question/task, output <ignore/>.
-   When in doubt, IGNORE. Your DEFAULT for normal priority is <ignore/>.
-
-3. **RESPOND FORMAT** (only when you have something helpful):
-   <respond discussion="DISCUSSION_ID">
-   Your response
-   </respond>
-
-4. **IGNORE FORMAT** (use liberally - this is your DEFAULT):
-   <ignore/>
-</decision_framework>
-
-<specialists>
-You can invite specialist bots when tasks are too complex.
-
-${specialistInfo}
-
-**When to invite a specialist:**
-- Creating new workflows/pipelines
-- Setting up reports/insights/dashboards
-- Bulk operations (10+ items)
-- Complex multi-step data tasks
-- Workflow configuration changes
-
-**When to handle yourself:**
-- General chat, greetings
-- Simple queries (list activities, show details)
-- Single create/update operations
-- Questions about the conversation
-- Clarifying user requirements
-
-**How to invite:**
-<invite specialist="hailerExpert">
-Clear description of what you need done.
-Include relevant context from the conversation.
-</invite>
-
-After using <invite>, I will:
-1. Invite them to the discussion
-2. Post your handoff message mentioning them
-3. They will see it and take action
-</specialists>
-
-<your_tools>
-You have access to basic MCP tools for simple operations:
-- list_workflows, list_workflow_phases, get_workflow_schema
-- list_activities, show_activity_by_id, count_activities
-- create_activity, update_activity (single operations)
-- search_workspace_users
-- Discussion tools (join_discussion, add_discussion_message, invite_discussion_members)
-
-For complex operations (workflow creation, insights, bulk ops), invite a specialist.
-
-**CRITICAL for join_discussion when inviting users:**
-ALWAYS pass these parameters from the incoming message:
-- inviteUserId = user_id attribute
-- sourceActivityId = activity_id attribute (creates "came from" link!)
-- welcomeReason = why they're being invited
-</your_tools>
-
-<tagging>
-**Activity Tags:** #ACTIVITY_ID (24-char hex)
-- Correct: "Check out #691ffe874217e9e8434e57fc"
-- Wrong: "Check out #691ffe874217e9e8434e57fc (Name)" - name auto-displays
-
-**User Mentions:** @"Full Name" or @userId
-</tagging>
-
-<rules>
-- Be concise - snappy responses, not essays
-- Use your memory - reference past conversations
-- For HIGH priority: respond immediately
-- For NORMAL priority: your DEFAULT is <ignore/>. Only break if you see a clear workspace question.
-- **Gibberish test:** No recognizable words, no vowels, repeated patterns = <ignore/>
-- **Relevance test:** Is this about workflows/activities/insights? If not = <ignore/>
-- When inviting specialists, explain to the user what's happening
-- After specialist responds, summarize for the user if needed
-</rules>`;
-    }
-    /**
-     * Override response handling to detect specialist invitations
-     */
-    async handleLlmResponse(response, originalMessage) {
-        // Add assistant response to conversation
-        this.conversationMessages.push({
-            role: "assistant",
-            content: response.content,
-        });
-        // Check for specialist invitation in text content
-        const textBlocks = response.content.filter((block) => block.type === "text");
-        const textContent = textBlocks.map((b) => b.text).join("\n");
-        // Look for <invite specialist="...">...</invite> pattern
-        const inviteMatch = textContent.match(/<invite specialist="(\w+)">([\s\S]*?)<\/invite>/);
-        if (inviteMatch) {
-            const [fullMatch, specialistKey, handoffContext] = inviteMatch;
-            const specialist = this.specialists.get(specialistKey);
-            if (specialist && specialist.botUserId) {
-                this.orchestratorLogger.info("LLM requested specialist invitation", {
-                    specialist: specialistKey,
-                    discussionId: originalMessage.discussionId,
-                });
-                // Extract any text before the invite tag to post as acknowledgment
-                const preInviteText = textContent
-                    .substring(0, textContent.indexOf("<invite"))
-                    .trim();
-                // Check for respond wrapper
-                const respondMatch = preInviteText.match(/<respond discussion="([^"]+)">([\s\S]*)/);
-                if (respondMatch) {
-                    const [, discussionId, content] = respondMatch;
-                    const cleanContent = content.replace(/<\/respond>.*$/s, "").trim();
-                    if (cleanContent) {
-                        await this.postResponse(discussionId, cleanContent);
-                    }
-                }
-                else if (preInviteText) {
-                    // No respond wrapper, but there's text - might be for high priority
-                    if (originalMessage.priority === "high") {
-                        await this.postResponse(originalMessage.discussionId, preInviteText);
-                    }
-                }
-                // Invite the specialist
-                const invited = await this.inviteSpecialist(specialist, originalMessage.discussionId, handoffContext.trim());
-                if (!invited) {
-                    // Failed to invite - let user know
-                    await this.postResponse(originalMessage.discussionId, `I tried to bring in ${specialist.name} but couldn't reach them. Let me try handling this myself...`);
-                    // Continue with normal handling
-                }
-                return; // Don't continue with normal response handling
-            }
-            else {
-                this.orchestratorLogger.warn("Specialist not available", {
-                    key: specialistKey,
-                    hasSpecialist: !!specialist,
-                    hasUserId: !!specialist?.botUserId,
-                });
-            }
-        }
-        // Check for tool calls
-        const toolUseBlocks = response.content.filter((block) => block.type === "tool_use");
-        if (toolUseBlocks.length > 0) {
-            // Mark that tools were used - subsequent responses should be posted
-            this.toolsUsedInCurrentMessage = true;
-            // Execute tools and continue conversation
-            await this.executeToolsAndContinue(toolUseBlocks, originalMessage);
-            return;
-        }
-        // Check for regular response (no invite, no tools)
-        if (textBlocks.length > 0) {
-            const responseText = textContent.trim();
-            this.orchestratorLogger.info("LLM raw response", {
-                discussion: originalMessage.discussionId,
-                priority: originalMessage.priority,
-                responseLength: responseText.length,
-                fullResponse: responseText.substring(0, 500),
-                hasIgnoreTag: responseText.includes("<ignore"),
-                hasRespondTag: responseText.includes("<respond"),
-            });
-            // Check for IGNORE decision - remove from context to keep it clean
-            if (responseText.includes("<decision>IGNORE</decision>") ||
-                responseText.includes("<ignore")) {
-                this.orchestratorLogger.debug("LLM decided to ignore - removing from context", {
-                    discussion: originalMessage.discussionId,
-                });
-                // Remove both the assistant's response AND the incoming message from context
-                this.conversationMessages.pop(); // Remove assistant response we just added
-                this.conversationMessages.pop(); // Remove the incoming message
-                this.toolsUsedInCurrentMessage = false; // Reset for next message
-                return;
-            }
-            // Check for explicit response directive
-            const responseMatch = responseText.match(/<respond discussion="([^"]+)">([\s\S]*?)<\/respond>/);
-            if (responseMatch) {
-                const targetDiscussion = responseMatch[1];
-                const content = responseMatch[2].trim();
-                await this.postResponse(targetDiscussion, content);
-                this.toolsUsedInCurrentMessage = false; // Reset for next message
-                return;
-            }
-            // For high priority messages, always send substantive responses
-            if (originalMessage.priority === "high" &&
-                responseText &&
-                !responseText.includes("<thinking>") &&
-                !responseText.startsWith("I'll") &&
-                responseText.length > 10) {
-                await this.postResponse(originalMessage.discussionId, responseText);
-                this.toolsUsedInCurrentMessage = false; // Reset for next message
-                return;
-            }
-            // For normal priority:
-            // - If tools were used, post substantive responses (LLM was doing real work)
-            // - Otherwise, require explicit <respond> tag
-            if (originalMessage.priority === "normal") {
-                if (this.toolsUsedInCurrentMessage && responseText.length > 50 && !responseText.includes("<ignore")) {
-                    // Tools were used and we have a substantive response - post it
-                    this.orchestratorLogger.info("Posting tool-assisted response", {
-                        discussion: originalMessage.discussionId,
-                        responseLength: responseText.length,
-                    });
-                    await this.postResponse(originalMessage.discussionId, responseText);
-                    this.toolsUsedInCurrentMessage = false; // Reset for next message
-                    return;
-                }
-                this.orchestratorLogger.debug("Normal priority without <respond> tag - removing from context", {
-                    discussion: originalMessage.discussionId,
-                    responsePreview: responseText.substring(0, 100),
-                    toolsUsed: this.toolsUsedInCurrentMessage,
-                });
-                // Remove from context - we didn't respond
-                this.conversationMessages.pop(); // Remove assistant response
-                this.conversationMessages.pop(); // Remove incoming message
-                this.toolsUsedInCurrentMessage = false; // Reset for next message
-            }
-        }
-    }
-    /**
-     * Get orchestrator status including specialist info
-     */
-    getOrchestratorStatus() {
-        const specialists = Array.from(this.specialists.entries()).map(([key, spec]) => ({
-            key,
-            name: spec.name,
-            available: !!spec.botUserId,
-            userId: spec.botUserId,
-        }));
-        const activeInDiscussions = {};
-        for (const [discussionId, userIds] of this.activeSpecialistsInDiscussion) {
-            activeInDiscussions[discussionId] = Array.from(userIds);
-        }
-        return {
-            conversationState: this.getConversationState(),
-            specialists,
-            activeInDiscussions,
-        };
-    }
-}
-exports.OrchestratorDaemon = OrchestratorDaemon;
-//# sourceMappingURL=orchestrator-daemon.js.map

package/dist/client/server.d.ts

@@ -1,8 +0,0 @@
-/**
- * Bot Control Server - API for AI Hub app
- *
- * Uses API key authentication (resolved to email/password internally via CLIENT_CONFIGS)
- */
-declare const app: import("express-serve-static-core").Express;
-export { app };
-//# sourceMappingURL=server.d.ts.map