@hailer/mcp 0.1.6 → 0.1.9

package/dist/client/orchestrator-daemon.js

@@ -0,0 +1,444 @@
+"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/services/agent-registry.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Agent Registry Service
+ *
+ * Handles registration of agents in Hailer workspace workflows:
+ * - Agent Directory: Main registry of all bots
+ * - Positions: Job descriptions/roles
+ * - Teams: Groups of agents
+ * - Tool Registry: MCP server configurations
+ * - MCP Config: Per-agent MCP configuration
+ *
+ * WORKSPACE ISOLATION: Uses WorkspaceSchemaCacheService for dynamic ID lookup.
+ * Never relies on hardcoded IDs - each workspace has its own workflow IDs.
+ */
+import { Logger } from "../../lib/logger";
+import { McpToolCallback, ToolDefinition } from "../types";
+import { WorkspaceSchemaCacheService } from "./workspace-schema-cache";
+export interface AgentInfo {
+    firstName: string;
+    lastName: string;
+    description: string;
+    email: string;
+    userId: string;
+}
+export interface PositionDetails {
+    name: string;
+    purpose: string;
+    personaTone: string;
+    coreCapabilities: string;
+    boundaries: string;
+}
+export declare class AgentRegistryService {
+    private schemaCache;
+    private logger;
+    private callMcpTool;
+    private getDefaultTeamId;
+    private agentDirectoryId;
+    private positionId;
+    private teamId;
+    private toolRegistryId;
+    private mcpConfigId;
+    private currentWorkspaceId;
+    constructor(schemaCache: WorkspaceSchemaCacheService, logger: Logger, callMcpTool: McpToolCallback, getDefaultTeamId: () => string | undefined);
+    /**
+     * Load registration data - always returns false to force fresh Hailer lookup
+     * Kept for API compatibility with base.ts
+     */
+    loadFromCache(_userId: string, _workspaceId: string): Promise<boolean>;
+    /**
+     * Get agent directory ID
+     */
+    getAgentDirectoryId(): string | null;
+    /**
+     * Get position ID
+     */
+    getPositionId(): string | null;
+    /**
+     * Get team ID
+     */
+    getTeamId(): string | null;
+    /**
+     * Register all agent data across all workflows
+     * Uses schemaCache for dynamic workflow ID lookup
+     */
+    registerAllAgentData(agentInfo: AgentInfo, positionDetails: PositionDetails, mcpServerUrl: string, toolIndex: ToolDefinition[], workspaceId: string): Promise<void>;
+    /**
+     * Register this agent in the Agent Directory
+     * Uses dynamic schema lookup for workflow/field IDs
+     */
+    private registerAgentInDirectory;
+    /**
+     * Find phase ID by trying multiple names (case insensitive, partial match)
+     */
+    private findPhaseId;
+    /**
+     * Find existing agent entry by hailerProfile (userId) - most reliable method
+     */
+    private findAgentByUserId;
+    /**
+     * Parse first activity from list_activities response
+     */
+    private parseFirstActivity;
+    /**
+     * Register/find shared Team for AI agents
+     */
+    private registerTeam;
+    /**
+     * Register MCP server in Tool Registry (per-agent)
+     */
+    private registerToolRegistry;
+    /**
+     * Register Position for this agent
+     */
+    private registerPosition;
+    /**
+     * Register MCP Config for this agent
+     */
+    private registerMcpConfig;
+    /**
+     * Link Agent Directory entry to Position and Team
+     */
+    private linkAgentToPositionAndTeam;
+    /**
+     * Extract activity ID from MCP tool response text
+     * Specifically looks for created activity IDs, not workflow IDs
+     */
+    private extractActivityId;
+}
+//# sourceMappingURL=agent-registry.d.ts.map