@hailer/mcp 0.2.7 → 1.0.21

package/dist/mcp/hailer-clients.js

@@ -91,23 +91,24 @@ class HailerClientManager {
             password: this.password,
             ...(isLocalDev && { rejectUnauthorized: false }), // Add for local dev with self-signed certs
         };
-        // Track timeout for proper cleanup
+        // Track timeout with single settled flag to prevent race conditions
         let timeoutId = null;
-        let timeoutCleared = false;
+        let settled = false;
         try {
             // Create socket client using @hailer/cli with cancellable timeout
             this.socketClient = (await Promise.race([
                 cli_1.Client.create(clientOptions).then(client => {
-                    // Clear timeout on success
-                    if (timeoutId && !timeoutCleared) {
-                        clearTimeout(timeoutId);
-                        timeoutCleared = true;
+                    if (!settled) {
+                        settled = true;
+                        if (timeoutId)
+                            clearTimeout(timeoutId);
                     }
                     return client;
                 }),
                 new Promise((_, reject) => {
                     timeoutId = setTimeout(() => {
-                        if (!timeoutCleared) {
+                        if (!settled) {
+                            settled = true;
                             reject(new Error(`Timeout connecting to: ${this.host}`));
                         }
                     }, 30000);
@@ -115,10 +116,10 @@ class HailerClientManager {
             ]));
         }
         catch (error) {
-            // Ensure timeout is cleared on error too
-            if (timeoutId && !timeoutCleared) {
+            // Ensure timeout is cleared on error
+            if (timeoutId && !settled) {
+                settled = true;
                 clearTimeout(timeoutId);
-                timeoutCleared = true;
             }
             logger.error('Failed to create socket client', error, { username: this.username });
             throw error;
@@ -345,7 +346,7 @@ function registerBotCredentials(botId, email, password, options) {
     config_1.environment.CLIENT_CONFIGS[apiKey] = {
         email,
         password,
-        apiBaseUrl: 'https://api.hailer.com',
+        apiBaseUrl: config_1.environment.BOT_API_BASE_URL || 'https://api.hailer.com',
         ...(options?.allowedGroups && { allowedGroups: options.allowedGroups }),
     };
     logger.info('Bot credentials registered', {

package/dist/mcp/tool-registry.d.ts

@@ -109,6 +109,10 @@ export declare class ToolRegistry {
      * Execute tool with validation
      */
     executeTool(name: string, args: any, context: UserContext): Promise<any>;
+    /**
+     * Pre-transform install_workflow args to fix common LLM mistakes BEFORE validation
+     */
+    private preTransformInstallWorkflow;
     /**
      * Get tool metadata (for access control checks)
      */

package/dist/mcp/tool-registry.js

@@ -277,9 +277,14 @@ class ToolRegistry {
             name,
             apiKey: context.apiKey.substring(0, 8) + '...'
         });
+        // Pre-transform for specific tools (fix common LLM mistakes before validation)
+        let transformedArgs = args;
+        if (name === 'install_workflow' && args.workflowTemplates) {
+            transformedArgs = this.preTransformInstallWorkflow(args);
+        }
         // Zod validation
         try {
-            const validated = tool.schema.parse(args);
+            const validated = tool.schema.parse(transformedArgs);
             return await tool.execute(validated, context);
         }
         catch (error) {
@@ -318,6 +323,78 @@ Then retry \`${name}\` with the correct format from the skill examples.` : `💡
             throw error;
         }
     }
+    /**
+     * Pre-transform install_workflow args to fix common LLM mistakes BEFORE validation
+     */
+    preTransformInstallWorkflow(args) {
+        let templates = args.workflowTemplates;
+        // Fix: single object instead of array
+        if (!Array.isArray(templates)) {
+            templates = [templates];
+        }
+        // Transform each template
+        templates = templates.map((template, tIdx) => {
+            const result = { ...template };
+            // Fix: fields as array instead of object
+            if (Array.isArray(template.fields)) {
+                const fieldsObj = {};
+                template.fields.forEach((field, idx) => {
+                    const fieldId = `_${1000 + idx}`;
+                    const { name, ...rest } = field;
+                    fieldsObj[fieldId] = { ...rest, label: rest.label || name };
+                });
+                result.fields = fieldsObj;
+            }
+            else if (template.fields) {
+                // Fix: field IDs not matching pattern
+                const fieldsObj = {};
+                let idx = 0;
+                for (const [key, field] of Object.entries(template.fields)) {
+                    const fieldId = /^_\d{4}$/.test(key) ? key : `_${1000 + idx}`;
+                    const f = field;
+                    const { name, ...rest } = f;
+                    fieldsObj[fieldId] = { ...rest, label: rest.label || name || key };
+                    idx++;
+                }
+                result.fields = fieldsObj;
+            }
+            // Fix: phases as array instead of object
+            if (Array.isArray(template.phases)) {
+                const phasesObj = {};
+                template.phases.forEach((phase, idx) => {
+                    const phaseId = `_${2000 + idx}`;
+                    phasesObj[phaseId] = { name: phase.name };
+                });
+                result.phases = phasesObj;
+            }
+            else if (template.phases) {
+                // Fix: phase IDs not matching pattern
+                const phasesObj = {};
+                let idx = 0;
+                for (const [key, phase] of Object.entries(template.phases)) {
+                    const phaseId = /^_\d{4}$/.test(key) ? key : `_${2000 + idx}`;
+                    const p = phase;
+                    phasesObj[phaseId] = { name: p.name || key };
+                    idx++;
+                }
+                result.phases = phasesObj;
+            }
+            // Fix: wrong field types
+            if (result.fields) {
+                for (const fieldId of Object.keys(result.fields)) {
+                    const f = result.fields[fieldId];
+                    // select → textpredefinedoptions
+                    if (f.type === 'select')
+                        f.type = 'textpredefinedoptions';
+                    // user → users
+                    if (f.type === 'user')
+                        f.type = 'users';
+                }
+            }
+            return result;
+        });
+        return { ...args, workflowTemplates: templates };
+    }
     /**
      * Get tool metadata (for access control checks)
      */

package/dist/mcp/tools/activity.js

@@ -658,6 +658,16 @@ exports.createActivityTool = {
     }),
     async execute(args, context) {
         try {
+            // DEBUG: Log raw input to diagnose LLM tool calling issues
+            logger.info("create_activity called", {
+                hasName: !!args.name,
+                hasActivities: !!args.activities,
+                activitiesType: typeof args.activities,
+                activitiesIsArray: Array.isArray(args.activities),
+                activitiesLength: Array.isArray(args.activities) ? args.activities.length :
+                    (typeof args.activities === 'string' ? args.activities.length : 0),
+                rawArgs: JSON.stringify(args, null, 2).slice(0, 500), // First 500 chars to avoid huge logs
+            });
             // Helper function to process a single activity object
             const processActivity = (activityData) => {
                 const activity = {
@@ -797,6 +807,43 @@ exports.createActivityTool = {
                     options.discussionId = args.discussionId;
                 }
             }
+            // Pre-validate required fields before API call
+            const workflow = context.init.processes?.find((p) => p._id === args.workflowId);
+            if (workflow?.fields) {
+                const requiredFields = [];
+                for (const [fieldId, field] of Object.entries(workflow.fields)) {
+                    const f = field;
+                    if (f.required) {
+                        requiredFields.push({
+                            id: fieldId,
+                            label: f.label || f.key || fieldId,
+                            key: f.key || fieldId,
+                        });
+                    }
+                }
+                if (requiredFields.length > 0) {
+                    const missingByActivity = [];
+                    for (let i = 0; i < activitiesToCreate.length; i++) {
+                        const activity = activitiesToCreate[i];
+                        const activityFields = activity.fields || {};
+                        const missing = requiredFields.filter(rf => activityFields[rf.id] === undefined &&
+                            activityFields[rf.key] === undefined);
+                        if (missing.length > 0) {
+                            const activityName = activity.name || `Activity ${i + 1}`;
+                            missingByActivity.push(`${activityName}: missing ${missing.map(m => `"${m.label}" (${m.key})`).join(', ')}`);
+                        }
+                    }
+                    if (missingByActivity.length > 0) {
+                        const fieldList = requiredFields.map(f => `- ${f.label} (key: ${f.key}, id: ${f.id})`).join('\n');
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `❌ Missing required fields - cannot create activities.\n\n**Required fields for this workflow:**\n${fieldList}\n\n**Activities with missing fields:**\n${missingByActivity.map(m => `- ${m}`).join('\n')}\n\n💡 Add the missing fields to each activity's \`fields\` object using either the field key or ID.`,
+                                }],
+                        };
+                    }
+                }
+            }
             // Call API
             const result = await context.hailer.createActivities(args.workflowId, activitiesToCreate, options);
             // Handle response

package/dist/mcp/tools/discussion.js

@@ -14,6 +14,7 @@ const zod_1 = require("zod");
 const tool_registry_1 = require("../tool-registry");
 const index_1 = require("../utils/index");
 const workspace_cache_1 = require("../workspace-cache");
+const hailer_clients_1 = require("../hailer-clients");
 const logger = (0, index_1.createLogger)({ component: 'discussion-tools' });
 // ============================================================================
 // HELPER FUNCTIONS
@@ -786,7 +787,17 @@ exports.joinDiscussionTool = {
 // ============================================================================
 // TOOL 5: LEAVE DISCUSSION
 // ============================================================================
-const leaveDiscussionDescription = `Leave a discussion - Works for activity discussions (provide activityId) or general discussions (provide discussionId)`;
+const leaveDiscussionDescription = `Leave a discussion - Bot removes itself from a discussion.
+
+**Parameters (at least one required):**
+- \`discussionId\`: The discussion ID to leave (preferred for DMs and general discussions)
+- \`activityId\`: The activity ID whose discussion to leave (for activity-linked discussions)
+
+**Examples:**
+- Leave by discussion ID: \`leave_discussion({ discussionId: "69525ce11d392644b7323050" })\`
+- Leave by activity ID: \`leave_discussion({ activityId: "69525ce11d392644b732304f" })\`
+
+**Note:** You MUST provide at least one parameter. The parameter cannot be inferred automatically.`;
 exports.leaveDiscussionTool = {
     name: 'leave_discussion',
     group: tool_registry_1.ToolGroup.WRITE,
@@ -806,6 +817,14 @@ exports.leaveDiscussionTool = {
         message: "Either activityId or discussionId must be provided"
     }),
     async execute(args, context) {
+        // DEBUG: Log raw input to diagnose LLM tool calling issues
+        logger.info("leave_discussion called", {
+            hasActivityId: !!args.activityId,
+            hasDiscussionId: !!args.discussionId,
+            activityId: args.activityId || '(not provided)',
+            discussionId: args.discussionId || '(not provided)',
+            rawArgs: JSON.stringify(args, null, 2),
+        });
         logger.debug('Leaving discussion', {
             activityId: args.activityId,
             discussionId: args.discussionId,
@@ -969,6 +988,30 @@ exports.inviteDiscussionMembersTool = {
                 };
             }
             const existingMembers = new Set(discussion?.participants || []);
+            // Ensure the bot is a member before inviting others
+            // This allows the bot to post messages after inviting users
+            try {
+                const botUserId = await (0, hailer_clients_1.getCurrentUserId)(context.client);
+                if (botUserId && !existingMembers.has(botUserId)) {
+                    try {
+                        await context.hailer.joinDiscussion(args.discussionId);
+                        logger.debug('Bot joined discussion before inviting', { discussionId: args.discussionId });
+                    }
+                    catch (joinError) {
+                        // Non-fatal: bot might not be able to join some discussion types
+                        logger.debug('Bot join before invite failed (non-fatal)', {
+                            discussionId: args.discussionId,
+                            error: joinError instanceof Error ? joinError.message : String(joinError)
+                        });
+                    }
+                }
+            }
+            catch (userIdError) {
+                // Non-fatal: if we can't get the bot's user ID, continue with the invite
+                logger.debug('Could not get bot user ID (non-fatal)', {
+                    error: userIdError instanceof Error ? userIdError.message : String(userIdError)
+                });
+            }
             // Filter out users who are already members
             const alreadyMembers = [];
             const newUsers = [];

package/dist/mcp/tools/metrics.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Victoria Metrics Tools - Query and List Metrics
+ *
+ * Tools for querying Hailer metrics from Victoria Metrics:
+ * - Query metrics with PromQL (READ)
+ * - List available metrics (READ)
+ */
+import { Tool } from '../tool-registry';
+export declare const queryMetricTool: Tool;
+export declare const listMetricsTool: Tool;
+export declare const searchWorkspaceForMetricsTool: Tool;
+export declare const searchUserForMetricsTool: Tool;
+//# sourceMappingURL=metrics.d.ts.map