@hailer/mcp 0.1.8 → 0.1.9

package/dist/client/agents/definitions.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Specialist Bot Configuration
+ *
+ * Defines specialist bots that can be invited by the orchestrator (HAL)
+ * when tasks are too complex for general handling.
+ *
+ * Each specialist has:
+ * - Trigger patterns: When HAL should consider inviting them
+ * - Expertise areas: What they're good at
+ * - System prompt: How they behave when invited
+ */
+export interface Specialist {
+    /** Display name (used in @mentions) */
+    name: string;
+    /** Hailer user ID of this bot (set at runtime from config) */
+    botUserId?: string;
+    /** Email of this bot (for matching with config) */
+    botEmail: string;
+    /** What this specialist is good at */
+    expertise: string[];
+    /** Regex patterns that trigger consideration of this specialist */
+    triggerPatterns: RegExp[];
+    /** Keywords that suggest this specialist (less strict than patterns) */
+    triggerKeywords: string[];
+    /** System prompt for this specialist when active */
+    systemPrompt: string;
+    /** Model to use (defaults to parent config) */
+    model?: string;
+}
+/**
+ * Registry of available specialists
+ * Key is the specialist identifier used internally
+ */
+export declare const SPECIALISTS: Record<string, Specialist>;
+/**
+ * Find a specialist that matches the given message content
+ * Returns the specialist if patterns match, null otherwise
+ */
+export declare function findMatchingSpecialist(content: string): Specialist | null;
+/**
+ * Check if content contains keywords suggesting a specialist might help
+ * Less strict than pattern matching - used for secondary consideration
+ */
+export declare function hasSpecialistKeywords(content: string, specialist: Specialist): boolean;
+/**
+ * Get specialist by key
+ */
+export declare function getSpecialist(key: string): Specialist | undefined;
+/**
+ * Get all specialist keys
+ */
+export declare function getSpecialistKeys(): string[];
+//# sourceMappingURL=definitions.d.ts.map

package/dist/client/agents/definitions.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * Specialist Bot Configuration
+ *
+ * Defines specialist bots that can be invited by the orchestrator (HAL)
+ * when tasks are too complex for general handling.
+ *
+ * Each specialist has:
+ * - Trigger patterns: When HAL should consider inviting them
+ * - Expertise areas: What they're good at
+ * - System prompt: How they behave when invited
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPECIALISTS = void 0;
+exports.findMatchingSpecialist = findMatchingSpecialist;
+exports.hasSpecialistKeywords = hasSpecialistKeywords;
+exports.getSpecialist = getSpecialist;
+exports.getSpecialistKeys = getSpecialistKeys;
+/**
+ * Registry of available specialists
+ * Key is the specialist identifier used internally
+ */
+exports.SPECIALISTS = {
+    hailerExpert: {
+        name: "Hailer Expert",
+        botEmail: "", // Set from config at runtime
+        expertise: [
+            "workflow creation and management",
+            "activity bulk operations",
+            "insights and SQL reports",
+            "complex data queries",
+            "workflow configuration",
+        ],
+        triggerPatterns: [
+            // Workflow creation
+            /create\s+(a\s+)?(new\s+)?(workflow|pipeline|process|tracker)/i,
+            /set\s+up\s+(a\s+)?(new\s+)?(workflow|pipeline|process)/i,
+            /build\s+(me\s+)?(a\s+)?(workflow|pipeline|crm|tracker)/i,
+            // Insight/report creation
+            /create\s+(a\s+)?(new\s+)?(report|insight|dashboard)/i,
+            /set\s+up\s+(a\s+)?(report|insight|analytics)/i,
+            /build\s+(a\s+)?(report|dashboard)\s+(showing|for)/i,
+            // Bulk operations
+            /create\s+(\d{2,}|multiple|several|many)\s+(activities|tasks|records)/i,
+            /bulk\s+(create|update|import)/i,
+            /import\s+(\d+|these|the)\s+(activities|tasks|records|items)/i,
+            // Complex queries
+            /complex\s+(query|filter|search)/i,
+            /advanced\s+(search|filter)/i,
+            // Multi-step operations
+            /(and|then|also)\s+(create|set up|add)\s+(a\s+)?(report|insight|workflow)/i,
+        ],
+        triggerKeywords: [
+            "workflow",
+            "pipeline",
+            "insight",
+            "report",
+            "dashboard",
+            "bulk",
+            "import",
+            "phases",
+            "stages",
+        ],
+        systemPrompt: `<identity>
+You are the Hailer Expert - a specialized assistant for Hailer workspace operations.
+You were invited to this discussion by HAL to help with a specific task.
+</identity>
+
+<capabilities>
+You have access to these MCP tools:
+
+**Workflow Management:**
+- list_workflows, list_workflows_minimal - See available workflows
+- list_workflow_phases - See phases in a workflow
+- get_workflow_schema - See fields and structure
+- install_workflow - Create new workflows
+- update_workflow_field - Modify workflow fields
+- update_workflow_phase - Modify phases
+
+**Activity Operations:**
+- list_activities(workflowId, phaseId, filters?, fields?, search?, limit?) - Query activities
+- show_activity_by_id(activityId) - Get activity details
+- create_activity(workflowId, name, fields?) OR create_activity(workflowId, activities[{name, fields}]) - Create single/bulk
+- update_activity(activityId, name?, fields?, phaseId?) - Update SINGLE activity
+- update_activity(activities: [{_id, name?, fields?, phaseId?}]) - Update BULK (3+ activities)
+- count_activities(workflowId, phaseId?) - Count activities
+
+**CRITICAL for update_activity:**
+- SINGLE: use "activityId" parameter (NOT "_id")
+- BULK: use "activities" array, each object MUST have "_id" (the activity ID)
+
+**Insights (SQL Reports):**
+- list_insights - See existing insights
+- create_insight - Create SQL-like reports
+- preview_insight - Test SQL queries
+- get_insight_data - Execute and get results
+
+**Other:**
+- search_workspace_users - Find users
+- Discussion tools for chat
+</capabilities>
+
+<protocol>
+1. Read HAL's handoff message carefully - it contains the task context
+2. Plan the operations needed
+3. Execute using MCP tools - NEVER fabricate data
+4. Report back with:
+   - What you did
+   - Results with clickable links (#activityId format)
+   - Any follow-up suggestions
+</protocol>
+
+<response_format>
+When completing a task:
+<respond discussion="DISCUSSION_ID">
+[Brief status emoji + summary]
+
+**What I did:**
+- Step 1: ...
+- Step 2: ...
+
+**Results:**
+[Data, links, or confirmation]
+
+**Next steps (optional):**
+[Suggestions for follow-up]
+</respond>
+</response_format>
+
+<rules>
+- Only respond when @mentioned - you were invited for a specific task
+- Always use tools - never make up data or IDs
+- Use #activityId format for activity links (auto-resolves to names)
+- Be concise and technical
+- If a tool call fails, DO NOT retry with the same parameters - explain the error to the user
+- If you get "activityId is required" error, you forgot to pass the activity ID - fix your parameters
+- Maximum 5 tool calls per task - if you need more, ask the user to break it down
+</rules>`,
+    },
+};
+/**
+ * Find a specialist that matches the given message content
+ * Returns the specialist if patterns match, null otherwise
+ */
+function findMatchingSpecialist(content) {
+    for (const specialist of Object.values(exports.SPECIALISTS)) {
+        // Check trigger patterns (strict match)
+        for (const pattern of specialist.triggerPatterns) {
+            if (pattern.test(content)) {
+                return specialist;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Check if content contains keywords suggesting a specialist might help
+ * Less strict than pattern matching - used for secondary consideration
+ */
+function hasSpecialistKeywords(content, specialist) {
+    const contentLower = content.toLowerCase();
+    const keywordCount = specialist.triggerKeywords.filter((kw) => contentLower.includes(kw.toLowerCase())).length;
+    // Require at least 2 keywords for a soft match
+    return keywordCount >= 2;
+}
+/**
+ * Get specialist by key
+ */
+function getSpecialist(key) {
+    return exports.SPECIALISTS[key];
+}
+/**
+ * Get all specialist keys
+ */
+function getSpecialistKeys() {
+    return Object.keys(exports.SPECIALISTS);
+}
+//# sourceMappingURL=definitions.js.map

package/dist/client/agents/orchestrator.d.ts

@@ -0,0 +1,119 @@
+/**
+ * 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
+ */
+import { ChatAgentDaemon, ChatAgentDaemonConfig, IncomingMessage } from "./base";
+import { HailerSignal } from "../../mcp/signal-handler";
+import { ToolInput } from "../types";
+import Anthropic from "@anthropic-ai/sdk";
+export interface OrchestratorDaemonConfig extends ChatAgentDaemonConfig {
+    /** Map of specialist key to their Hailer user ID */
+    specialistUserIds?: Map<string, string>;
+}
+export declare class OrchestratorDaemon extends ChatAgentDaemon {
+    private orchestratorLogger;
+    private specialists;
+    private activeSpecialistsInDiscussion;
+    private specialistUserIds;
+    private toolsUsedInCurrentMessage;
+    private lastToolsUsed;
+    private lastToolsFailed;
+    private static SILENT_SUCCESS_TOOLS;
+    private lastKnownActivityId;
+    private lastKnownActivityName;
+    private lastKnownActivityTime;
+    private static CONTEXT_MEMORY_TIMEOUT;
+    constructor(config: OrchestratorDaemonConfig);
+    /**
+     * Override agent name for Agent Directory
+     * Uses the actual Hailer user name from BotClient (set in workspace)
+     */
+    protected getAgentName(): {
+        firstName: string;
+        lastName: string;
+    };
+    /**
+     * Override agent description for Agent Directory
+     */
+    protected getAgentDescription(): string;
+    /**
+     * Override Position details for Orchestrator
+     */
+    protected getPositionDetails(): {
+        name: string;
+        purpose: string;
+        personaTone: string;
+        coreCapabilities: string;
+        boundaries: string;
+    };
+    /**
+     * Orchestrator only needs basic tools - complex ops go to specialists
+     */
+    protected getToolWhitelist(): string[];
+    /**
+     * Preprocess tool input - inject context for certain tools
+     * Uses cross-discussion memory to maintain context awareness
+     */
+    protected preprocessToolInput(toolName: string, input: ToolInput): ToolInput;
+    /**
+     * Override to detect tool failures for silent success feature
+     */
+    protected executeToolsAndContinue(toolUseBlocks: Anthropic.ToolUseBlock[], originalMessage: IncomingMessage): Promise<void>;
+    /**
+     * Update cross-discussion memory when processing messages
+     * Call this when entering an activity discussion to remember context
+     */
+    private updateContextMemory;
+    /**
+     * Override to update cross-discussion memory when entering activity discussions
+     */
+    protected extractIncomingMessage(signal: HailerSignal): Promise<IncomingMessage | null>;
+    /**
+     * Register a specialist's Hailer user ID
+     * Called during initialization when we know the specialist bot's user ID
+     */
+    registerSpecialistUserId(specialistKey: string, userId: string): void;
+    /**
+     * Check if a specialist is already active in a discussion
+     */
+    private isSpecialistActiveInDiscussion;
+    /**
+     * Mark a specialist as active in a discussion
+     */
+    private markSpecialistActive;
+    /**
+     * Invite a specialist to a discussion
+     */
+    private inviteSpecialist;
+    /**
+     * Override system prompt to include orchestrator capabilities
+     */
+    protected getSystemPrompt(): string;
+    /**
+     * Override response handling to detect specialist invitations
+     */
+    protected handleLlmResponse(response: Anthropic.Message, originalMessage: IncomingMessage): Promise<void>;
+    /**
+     * Get orchestrator status including specialist info
+     */
+    getOrchestratorStatus(): {
+        conversationState: ReturnType<ChatAgentDaemon["getConversationState"]>;
+        specialists: Array<{
+            key: string;
+            name: string;
+            available: boolean;
+            userId?: string;
+        }>;
+        activeInDiscussions: Record<string, string[]>;
+    };
+}
+//# sourceMappingURL=orchestrator.d.ts.map