@hailer/mcp 0.1.16 → 0.2.1

package/dist/client/specialist-daemon.d.ts

@@ -1,77 +0,0 @@
-/**
- * Specialist Daemon
- *
- * A lightweight daemon for specialist bots that only responds when @mentioned.
- * Specialists are invited to discussions by the orchestrator (HAL) to handle
- * specific complex tasks.
- *
- * Key differences from ChatAgentDaemon:
- * - Only responds when @mentioned (not all messages)
- * - Has specialized system prompt from Specialist config
- * - More tool-focused, less conversational
- */
-import { ChatAgentDaemon, ChatAgentDaemonConfig, IncomingMessage } from "./chat-agent-daemon";
-import { Specialist } from "./specialists";
-import { HailerSignal } from "../mcp/signal-handler";
-export interface SpecialistDaemonConfig extends ChatAgentDaemonConfig {
-    /** The specialist configuration */
-    specialist: Specialist;
-}
-export declare class SpecialistDaemon extends ChatAgentDaemon {
-    private specialistLogger;
-    private specialist;
-    private lastResponseTime;
-    private minResponseGap;
-    constructor(config: SpecialistDaemonConfig);
-    /**
-     * Override agent name for Agent Directory - uses specialist's configured name
-     */
-    protected getAgentName(): {
-        firstName: string;
-        lastName: string;
-    };
-    /**
-     * Override agent description for Agent Directory - uses specialist's expertise
-     */
-    protected getAgentDescription(): string;
-    /**
-     * Override Position details for Specialist - uses specialist's expertise
-     */
-    protected getPositionDetails(): {
-        name: string;
-        purpose: string;
-        personaTone: string;
-        coreCapabilities: string;
-        boundaries: string;
-    };
-    /**
-     * Override to only process messages where we're @mentioned
-     */
-    protected extractIncomingMessage(signal: HailerSignal): Promise<IncomingMessage | null>;
-    /**
-     * Check if this specialist is mentioned in the message
-     * Supports various mention formats:
-     * - @"Specialist Name"
-     * - @SpecialistName (no spaces)
-     * - Direct user tag [hailerTag|Name](userId)
-     */
-    private isMentionedInMessage;
-    /**
-     * Override system prompt with specialist-specific prompt
-     */
-    protected getSystemPrompt(): string;
-    /**
-     * Track response time for rate limiting
-     */
-    protected postResponse(discussionId: string, content: string): Promise<void>;
-    /**
-     * Get specialist status
-     */
-    getSpecialistStatus(): {
-        name: string;
-        expertise: string[];
-        conversationState: ReturnType<ChatAgentDaemon["getConversationState"]>;
-        lastResponseTime: number;
-    };
-}
-//# sourceMappingURL=specialist-daemon.d.ts.map

package/dist/client/specialist-daemon.js

@@ -1,197 +0,0 @@
-"use strict";
-/**
- * Specialist Daemon
- *
- * A lightweight daemon for specialist bots that only responds when @mentioned.
- * Specialists are invited to discussions by the orchestrator (HAL) to handle
- * specific complex tasks.
- *
- * Key differences from ChatAgentDaemon:
- * - Only responds when @mentioned (not all messages)
- * - Has specialized system prompt from Specialist config
- * - More tool-focused, less conversational
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SpecialistDaemon = void 0;
-const chat_agent_daemon_1 = require("./chat-agent-daemon");
-const logger_1 = require("../lib/logger");
-class SpecialistDaemon extends chat_agent_daemon_1.ChatAgentDaemon {
-    specialistLogger;
-    specialist;
-    lastResponseTime = 0;
-    minResponseGap = 2000; // 2 seconds minimum between responses
-    constructor(config) {
-        super(config);
-        this.specialist = config.specialist;
-        this.specialistLogger = (0, logger_1.createLogger)({
-            component: "SpecialistDaemon",
-            botId: config.botClient.userId,
-            specialistName: config.specialist.name,
-        });
-    }
-    // ===== AGENT DIRECTORY OVERRIDES =====
-    /**
-     * Override agent name for Agent Directory - uses specialist's configured name
-     */
-    getAgentName() {
-        const nameParts = this.specialist.name.split(" ");
-        const firstName = nameParts[0] || "Specialist";
-        const lastName = nameParts.slice(1).join(" ") || "Bot";
-        return { firstName, lastName };
-    }
-    /**
-     * Override agent description for Agent Directory - uses specialist's expertise
-     */
-    getAgentDescription() {
-        return `${this.specialist.name} - Specialist bot.\n\nExpertise: ${this.specialist.expertise.join(", ")}\n\n${this.specialist.systemPrompt.substring(0, 500)}...`;
-    }
-    /**
-     * Override Position details for Specialist - uses specialist's expertise
-     */
-    getPositionDetails() {
-        return {
-            name: `${this.specialist.name} Position`,
-            purpose: `Specialist bot for: ${this.specialist.expertise.join(", ")}`,
-            personaTone: "Technical, precise, and data-focused. Responds with structured results.",
-            coreCapabilities: this.specialist.expertise.map(e => `- ${e}`).join("\n"),
-            boundaries: "- Only respond when explicitly @mentioned\n- Never fabricate data - always use tools\n- Stay focused on specialty area\n- Hand back to orchestrator when done",
-        };
-    }
-    /**
-     * Override to only process messages where we're @mentioned
-     */
-    async extractIncomingMessage(signal) {
-        // Get base message extraction
-        const message = await super.extractIncomingMessage(signal);
-        if (!message)
-            return null;
-        // Specialists only respond when mentioned
-        if (!this.isMentionedInMessage(message)) {
-            this.specialistLogger.debug("Message doesn't mention specialist, ignoring", {
-                discussion: message.discussionId,
-                from: message.senderName,
-            });
-            return null;
-        }
-        // Rate limit responses
-        const now = Date.now();
-        if (now - this.lastResponseTime < this.minResponseGap) {
-            this.specialistLogger.debug("Rate limiting specialist response", {
-                timeSinceLastResponse: now - this.lastResponseTime,
-            });
-            return null;
-        }
-        // Mark as high priority since we're explicitly mentioned
-        message.priority = "high";
-        message.priorityReason = `Specialist ${this.specialist.name} was tagged`;
-        this.specialistLogger.info("Specialist mentioned, processing message", {
-            discussion: message.discussionId,
-            from: message.senderName,
-            preview: message.content.substring(0, 50),
-        });
-        return message;
-    }
-    /**
-     * Check if this specialist is mentioned in the message
-     * Supports various mention formats:
-     * - @"Specialist Name"
-     * - @SpecialistName (no spaces)
-     * - Direct user tag [hailerTag|Name](userId)
-     */
-    isMentionedInMessage(message) {
-        const content = message.content;
-        const name = this.specialist.name;
-        const userId = this.botClient.userId;
-        // Check for hailerTag mention (most reliable)
-        const hailerTagPattern = new RegExp(`\\[hailerTag\\|[^\\]]*\\]\\(${userId}\\)`, "i");
-        if (hailerTagPattern.test(content)) {
-            return true;
-        }
-        // Check for @"Name" mention
-        if (content.includes(`@"${name}"`)) {
-            return true;
-        }
-        // Check for @Name (no spaces version)
-        const nameNoSpaces = name.replace(/\s+/g, "");
-        if (content.includes(`@${nameNoSpaces}`)) {
-            return true;
-        }
-        // Check for @Name (first word)
-        const firstName = name.split(" ")[0];
-        if (content.includes(`@${firstName}`)) {
-            return true;
-        }
-        // Check message.isMention (set by parent class)
-        if (message.isMention) {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Override system prompt with specialist-specific prompt
-     */
-    getSystemPrompt() {
-        const now = new Date();
-        return `${this.specialist.systemPrompt}
-
-<current_time>${now.toISOString()}</current_time>
-
-<bot_info>
-Bot ID: ${this.botClient.userId}
-Name: ${this.specialist.name}
-</bot_info>
-
-<response_rules>
-- You were invited to this discussion to help with a specific task
-- Read HAL's handoff message to understand what's needed
-- Use MCP tools to complete the task - NEVER fabricate data
-- Respond with clear, structured results
-- Include activity links using #activityId format
-- Be concise and technical - data first, explanation second
-</response_rules>
-
-<response_format>
-When you complete a task, respond with:
-<respond discussion="DISCUSSION_ID">
-[Status emoji] [Brief summary]
-
-**What I did:**
-- Step 1: ...
-- Step 2: ...
-
-**Results:**
-[Data, links, or confirmation]
-
-**Next steps (if applicable):**
-[Suggestions for follow-up]
-</respond>
-
-If you need clarification:
-<respond discussion="DISCUSSION_ID">
-I need more information to complete this task:
-- Question 1?
-- Question 2?
-</respond>
-</response_format>`;
-    }
-    /**
-     * Track response time for rate limiting
-     */
-    async postResponse(discussionId, content) {
-        await super.postResponse(discussionId, content);
-        this.lastResponseTime = Date.now();
-    }
-    /**
-     * Get specialist status
-     */
-    getSpecialistStatus() {
-        return {
-            name: this.specialist.name,
-            expertise: this.specialist.expertise,
-            conversationState: this.getConversationState(),
-            lastResponseTime: this.lastResponseTime,
-        };
-    }
-}
-exports.SpecialistDaemon = SpecialistDaemon;
-//# sourceMappingURL=specialist-daemon.js.map

package/dist/client/specialists.d.ts

@@ -1,53 +0,0 @@
-/**
- * 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=specialists.d.ts.map

package/dist/client/specialists.js

@@ -1,178 +0,0 @@
-"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=specialists.js.map

package/dist/client/tool-schema-loader.d.ts

@@ -1,62 +0,0 @@
-/**
- * Tool Schema Loader
- *
- * Manages MCP tool discovery, schema loading, and filtering.
- * Shared between all LLM providers (Anthropic, OpenAI, etc.)
- *
- * Key Features:
- * - Load lightweight tool index from MCP server
- * - Filter tools by groups (READ, WRITE, PLAYGROUND)
- * - Load full schemas on-demand (token-efficient)
- * - Cache loaded schemas
- */
-import { ToolGroup } from '../mcp/tool-registry';
-import { JsonSchema } from './types';
-import Anthropic from '@anthropic-ai/sdk';
-export interface ToolIndexEntry {
-    name: string;
-    category: string;
-    description: string;
-}
-export interface ToolDefinition {
-    name: string;
-    description: string;
-    input_schema: JsonSchema;
-}
-export interface LoadToolsOptions {
-    mcpServerUrl: string;
-    mcpServerApiKey: string;
-    allowedGroups: ToolGroup[];
-    allowedTools?: string[];
-    excludeMessageFetchTools?: boolean;
-}
-export declare class ToolSchemaLoader {
-    private toolSchemaCache;
-    /**
-     * Load tool index with filtering
-     * Returns lightweight tool list with optional exclusions
-     */
-    loadToolIndex(options: LoadToolsOptions): Promise<ToolIndexEntry[]>;
-    /**
-     * Load full schema for a specific tool on-demand
-     */
-    loadToolSchema(mcpServerUrl: string, mcpServerApiKey: string, toolName: string): Promise<any>;
-    /**
-     * Convert tool index to minimal tool definitions (stubs)
-     * Full schemas will be loaded on-demand when needed
-     */
-    toMinimalToolDefinitions(toolIndex: ToolIndexEntry[]): Anthropic.Tool[];
-    /**
-     * Get count of loaded schemas
-     */
-    getLoadedSchemaCount(): number;
-    /**
-     * Clear schema cache
-     */
-    clearCache(): void;
-    /**
-     * Fetch tool index from MCP server
-     */
-    private fetchMcpToolIndex;
-}
-//# sourceMappingURL=tool-schema-loader.d.ts.map