@hailer/mcp 0.0.1

package/dist/mcp/tools/workflow.js

@@ -0,0 +1,1362 @@
+"use strict";
+/**
+ * Workflow Management Tools - Clean Architecture
+ *
+ * Tools for managing Hailer workflows (install, remove, update fields, test functions).
+ * These are PLAYGROUND tools requiring workspace administrator permissions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateWorkflowPhaseTool = exports.countActivitiesTool = exports.listWorkflowsMinimalTool = exports.testFunctionFieldTool = exports.updateWorkflowFieldTool = exports.removeWorkflowTool = exports.installWorkflowTool = exports.listWorkflowsTool = exports.listWorkflowPhasesTool = exports.getWorkflowSchemaTool = void 0;
+const zod_1 = require("zod");
+const tool_registry_1 = require("../tool-registry");
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)({ component: 'workflow-tools' });
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Convert field label to camelCase key
+ * Example: "Start Date" -> "startDate", "Related To" -> "relatedTo"
+ */
+function labelToCamelCase(label) {
+    return label
+        .trim()
+        .split(/\s+/)
+        .map((word, index) => {
+        const cleaned = word.replace(/[^\w]/g, ''); // Remove non-word characters
+        if (index === 0) {
+            return cleaned.toLowerCase();
+        }
+        return cleaned.charAt(0).toUpperCase() + cleaned.slice(1).toLowerCase();
+    })
+        .join('');
+}
+/**
+ * Extract error from v2.activities.evaluate response
+ * Checks three possible error locations in the API response
+ */
+function extractEvaluationError(result, fieldId) {
+    const evaluatedField = result?.activity?.fields?.find((f) => f.id === fieldId);
+    return evaluatedField?.error
+        || result?.meta?.fields?.[fieldId]?.error
+        || result?.meta?.error
+        || null;
+}
+/**
+ * Parse JavaScript error type from error message
+ */
+function parseErrorType(errorMessage) {
+    const match = errorMessage.match(/^(SyntaxError|ReferenceError|TypeError)/);
+    return match ? match[1] : 'Error';
+}
+// ============================================================================
+// READ TOOLS - Workflow Schema and Information
+// ============================================================================
+const getWorkflowSchemaDescription = `📋 Get workflow field schema and structure - REQUIRED before using list_activities to understand available fields. Shows all field IDs, labels, types, and options. Requires both workflowId and phaseId (use list_workflow_phases first).`;
+exports.getWorkflowSchemaTool = {
+    name: 'get_workflow_schema',
+    group: tool_registry_1.ToolGroup.READ,
+    description: getWorkflowSchemaDescription,
+    schema: zod_1.z.object({
+        workflowId: zod_1.z.string().describe("Workflow ID to get schema from"),
+        phaseId: zod_1.z.string().describe("Phase ID to get schema from (use list_workflow_phases to get available phases)"),
+    }),
+    async execute(args, context) {
+        try {
+            // Fetch complete workflow definition from API (includes field keys)
+            const initData = await context.hailer.request('v2.core.init', [['processes']]);
+            const workflow = initData.processes?.find(p => p._id === args.workflowId);
+            if (!workflow) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ Workflow "${args.workflowId}" not found`,
+                        }],
+                };
+            }
+            // Get schema for field validation/requirements (optional, mainly for name field info)
+            const schemaData = await context.hailer.getWorkflowSchema(args.workflowId, args.phaseId);
+            // Get complete field definitions from workflow (includes keys and all metadata)
+            const workflowFields = workflow.fields || {};
+            const fieldsOrder = workflow.fieldsOrder || Object.keys(workflowFields);
+            let responseText = `📋 **WORKFLOW SCHEMA** for "${workflow.name}":\n\n`;
+            if (schemaData.name) {
+                responseText += `**Name Field:**\n`;
+                responseText += `- Type: ${schemaData.name.type}\n`;
+                responseText += `- Required: ${schemaData.name.required || false}\n`;
+                if (schemaData.name.placeholder) {
+                    responseText += `- Placeholder: "${schemaData.name.placeholder}"\n`;
+                }
+                responseText += `\n`;
+            }
+            // Use fieldsOrder to display fields in correct order
+            if (fieldsOrder.length > 0) {
+                responseText += `**Available Fields (${fieldsOrder.length} total):**\n\n`;
+                fieldsOrder.forEach((fieldId, index) => {
+                    const field = workflowFields[fieldId];
+                    if (!field)
+                        return;
+                    responseText += `${index + 1}. **${field.label || 'Unnamed Field'}**\n`;
+                    responseText += `   - Field ID: \`${fieldId}\`\n`;
+                    if (field.key)
+                        responseText += `   - Key: \`${field.key}\`\n`;
+                    responseText += `   - Type: ${field.type}`;
+                    if (field.subtype)
+                        responseText += ` (${field.subtype})`;
+                    responseText += `\n`;
+                    if (field.required)
+                        responseText += `   - Required: Yes\n`;
+                    if (field.description)
+                        responseText += `   - Description: ${field.description}\n`;
+                    if (field.placeholder)
+                        responseText += `   - Placeholder: "${field.placeholder}"\n`;
+                    if (field.data && field.data.length > 0) {
+                        responseText += `   - Options: ${field.data.slice(0, 3).join(', ')}`;
+                        if (field.data.length > 3)
+                            responseText += ` (and ${field.data.length - 3} more)`;
+                        responseText += `\n`;
+                    }
+                    responseText += `\n`;
+                });
+            }
+            responseText += `💡 **USAGE:**\n`;
+            responseText += `- Use field IDs (or keys if available) in the 'fields' parameter of list_activities\n`;
+            responseText += `- **Select ONLY 2-3 essential fields** to minimize token costs\n`;
+            const firstFieldId = fieldsOrder[0];
+            const secondFieldId = fieldsOrder[1];
+            const firstFieldKey = firstFieldId && workflowFields[firstFieldId]?.key;
+            const secondFieldKey = secondFieldId && workflowFields[secondFieldId]?.key;
+            if (firstFieldId && secondFieldId) {
+                responseText += `- Example with IDs: fields: ["${firstFieldId}", "${secondFieldId}"] (just 2 fields)\n`;
+                if (firstFieldKey && secondFieldKey) {
+                    responseText += `- Example with keys: fields: ["${firstFieldKey}", "${secondFieldKey}"] (more readable)\n`;
+                }
+            }
+            responseText += `- For listings: name + key metric (price/status) is usually sufficient\n`;
+            responseText += `- Only add description/detail fields when user explicitly needs them`;
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText,
+                    }],
+            };
+        }
+        catch (error) {
+            logger.error("Failed to get workflow schema", error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `❌ Failed to get workflow schema: ${error instanceof Error ? error.message : String(error)}`,
+                    }],
+            };
+        }
+    },
+};
+const listWorkflowPhasesDescription = `📊 List available phases in a workflow - Required before using list_activities to get phase IDs. Use this first to see all phases, then call list_activities for each phase to get complete workflow overview. TIP: Also call get_workflow_schema to understand field structure.`;
+exports.listWorkflowPhasesTool = {
+    name: 'list_workflow_phases',
+    group: tool_registry_1.ToolGroup.READ,
+    description: listWorkflowPhasesDescription,
+    schema: zod_1.z.object({
+        workflowId: zod_1.z.string().describe("Workflow ID to get phases from"),
+    }),
+    async execute(args, context) {
+        try {
+            // Fetch workflow definition directly from API
+            const initData = await context.hailer.request('v2.core.init', [["processes"]]);
+            const workflowData = initData.processes?.find(p => p._id === args.workflowId);
+            if (!workflowData) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ Workflow "${args.workflowId}" not found`,
+                        }],
+                };
+            }
+            const phases = workflowData.phases || {};
+            const phasesOrder = workflowData.phasesOrder || [];
+            let responseText = `📊 **WORKFLOW PHASES** for "${workflowData.name}":\n\n`;
+            if (Object.keys(phases).length === 0) {
+                responseText += `❌ No phases found in workflow "${workflowData.name}".`;
+                return {
+                    content: [{ type: "text", text: responseText }],
+                };
+            }
+            responseText += `Found ${Object.keys(phases).length} phases:\n\n`;
+            const orderedPhaseIds = phasesOrder.length > 0 ? phasesOrder : Object.keys(phases);
+            orderedPhaseIds.forEach((phaseId, index) => {
+                const phase = phases[phaseId];
+                if (phase) {
+                    responseText += `${index + 1}. **${phase.name}**\n`;
+                    responseText += `   - Phase ID: \`${phase._id}\`\n`;
+                    if (phase.description) {
+                        responseText += `   - Description: ${phase.description}\n`;
+                    }
+                    if (phase.color) {
+                        responseText += `   - Color: ${phase.color}\n`;
+                    }
+                    if (phase.isInitial) {
+                        responseText += `   - Initial Phase: Yes\n`;
+                    }
+                    if (phase.isEndpoint) {
+                        responseText += `   - Endpoint Phase: Yes\n`;
+                    }
+                    responseText += `\n`;
+                }
+            });
+            responseText += `💡 **USAGE:** Use any of these Phase IDs with the \`list_activities\` tool to get activities in that phase.\n\n`;
+            responseText += `🔍 **FOR COMPREHENSIVE WORKFLOW VIEW:**\n`;
+            responseText += `- To see ALL activities across the entire workflow, call \`list_activities\` for each phase ID above\n`;
+            responseText += `- Each phase contains different activities at different stages of the workflow\n`;
+            responseText += `- Combine results from all phases to get the complete picture of the workflow\n`;
+            responseText += `\n**Example workflow:**\n`;
+            responseText += `1. First call: \`list_activities\` with first phase ID to see new/pending activities\n`;
+            responseText += `2. Second call: \`list_activities\` with second phase ID to see completed activities\n`;
+            responseText += `3. Continue for all phases to see the full workflow status`;
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText,
+                    }],
+            };
+        }
+        catch (error) {
+            logger.error("Failed to list workflow phases", error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `❌ Failed to list workflow phases: ${error instanceof Error ? error.message : String(error)}`,
+                    }],
+            };
+        }
+    },
+};
+const listWorkflowsDescription = `List workflows - Get workflow info with optional detailed data`;
+exports.listWorkflowsTool = {
+    name: 'list_workflows',
+    group: tool_registry_1.ToolGroup.READ,
+    description: listWorkflowsDescription,
+    schema: zod_1.z.object({
+        workspace: zod_1.z.string().optional().describe("Optional workspace ID or name"),
+        includeRelationships: zod_1.z.coerce.boolean().optional().default(true).describe("Show ActivityLink relationships between workflows"),
+    }),
+    async execute(args, context) {
+        logger.debug('Listing workflows', {
+            apiKey: context.apiKey.substring(0, 8) + '...'
+        });
+        try {
+            // Fetch workflows directly from API
+            const initData = await context.hailer.request('v2.core.init', [["processes"]]);
+            let workflows = initData.processes || [];
+            if (args.workspace) {
+                // Filter by workspace ID or name
+                const workspaceFilter = args.workspace;
+                workflows = workflows.filter(w => w.cid === workspaceFilter ||
+                    w.cid === workspaceFilter // Could add name-based lookup here if needed
+                );
+            }
+            const workflowSummary = workflows.map((workflow) => {
+                const activityLinkFields = Object.entries(workflow.fields ?? {})
+                    .filter(([_, field]) => field.type === 'activitylink');
+                const initialPhases = Object.values(workflow.phases || {})
+                    .filter(phase => phase.isInitial)
+                    .map(phase => ({
+                    id: phase._id,
+                    name: phase.name
+                }));
+                // Calculate linksTo from activitylink fields
+                const linksTo = activityLinkFields.flatMap(([_, field]) => field.data || []);
+                return {
+                    id: workflow._id,
+                    name: workflow.name,
+                    workspaceId: workflow.cid,
+                    activityCount: workflow.createdActivities || 0,
+                    isStarred: workflow.isStarred || false,
+                    hasActivityLinks: activityLinkFields.length > 0,
+                    linksTo,
+                    linkedFrom: [], // Would need to scan all workflows - skip for now
+                    initialPhases: initialPhases,
+                };
+            });
+            let responseText = `📋 **${workflows.length} Workflows Found**\n\n`;
+            responseText += JSON.stringify(workflowSummary, null, 2);
+            if (args.includeRelationships) {
+                const relationships = [];
+                for (const workflow of workflows) {
+                    const activityLinkFields = Object.entries(workflow.fields ?? {})
+                        .filter(([_, field]) => field.type === 'activitylink')
+                        .map(([fieldId, field]) => ({
+                        id: fieldId,
+                        label: field.label,
+                        key: field.key,
+                        targetWorkflowIds: field.data || [],
+                        required: field.required || false,
+                    }));
+                    for (const field of activityLinkFields) {
+                        for (const targetWorkflowId of field.targetWorkflowIds) {
+                            const targetWorkflow = workflows.find(w => w._id === targetWorkflowId);
+                            relationships.push({
+                                sourceWorkflowId: workflow._id,
+                                sourceWorkflowName: workflow.name,
+                                targetWorkflowId,
+                                targetWorkflowName: targetWorkflow?.name || 'Unknown',
+                                fieldLabel: field.label,
+                                fieldKey: field.key,
+                                required: field.required,
+                            });
+                        }
+                    }
+                }
+                if (relationships.length > 0) {
+                    responseText += `\n\n🔗 **Workflow Relationships:**\n`;
+                    relationships.forEach(rel => {
+                        responseText += `• ${rel.sourceWorkflowName} → ${rel.targetWorkflowName} (${rel.fieldLabel})\n`;
+                    });
+                }
+            }
+            responseText += `\n\n💡 Use get_workflow_info with specific workflow ID for detailed information.`;
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText,
+                    }],
+            };
+        }
+        catch (error) {
+            logger.error("Error listing workflows", error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `❌ Error listing workflows: ${error instanceof Error ? error.message : String(error)}`,
+                    }],
+            };
+        }
+    },
+};
+// ============================================================================
+// PLAYGROUND TOOLS - Workflow Management (Admin/Dev)
+// ============================================================================
+// ============================================================================
+// TOOL 1: INSTALL WORKFLOW
+// ============================================================================
+const installWorkflowDescription = `🧪 [PLAYGROUND] Install workflow(s) from template
+
+⚠️ **MANDATORY: YOU MUST LOAD SKILL FIRST**
+**BEFORE calling this tool, you are REQUIRED to:**
+1. Load the skill: \`get_skill({ skillName: "install-workflow-skill" })\`
+2. Read the complete documentation
+3. Follow the examples and patterns shown in the skill
+**FAILURE TO LOAD THE SKILL FIRST IS AN ERROR**
+
+⚠️ COPY THIS EXACT STRUCTURE (modify values only):
+\`\`\`json
+{
+  "workflowTemplates": [{
+    "name": "My Workflow Name",
+    "fields": {
+      "_1000": { "label": "Title", "type": "text" }
+    },
+    "phases": {
+      "_2000": { "name": "To Do", "isInitial": true }
+    }
+  }]
+}
+\`\`\`
+
+**CRITICAL RULES (breaking these causes API rejection):**
+1. ✅ MUST wrap in \`workflowTemplates\` array
+2. ✅ MUST use objects for fields/phases: \`{ "_1000": {...} }\` NOT arrays \`[{...}]\`
+3. ✅ MUST use \`label\` in fields (NOT "name")
+4. ✅ MUST use \`data\` for options (NOT "options")
+5. ✅ MUST use template IDs: \`_0001\`, \`_1000\`, \`_2000\` (underscore + 4 digits)
+
+**Field properties allowed:**
+- \`label\` (required) - Display name
+- \`type\` (required) - Field type: text, date, numeric, textpredefinedoptions, activitylink
+- \`key\` (recommended) - API key for readable names
+- \`data\` (for dropdowns/links) - Array of options or workflow IDs
+- \`required\` (optional) - Boolean
+
+**Workflow = DB table, Fields = Columns, Activities = Rows**`;
+const installWorkflowSchema = zod_1.z.object({
+    workspaceId: zod_1.z
+        .string()
+        .optional()
+        .describe("Optional workspace ID or name - defaults to current workspace"),
+    workflowTemplates: zod_1.z
+        .array(zod_1.z.object({
+        _id: zod_1.z
+            .string()
+            .regex(/^_\d{4}$/, "Workflow _id must match pattern _0001, _0002, etc. (underscore + 4 digits)")
+            .optional()
+            .describe("Workflow _id for cross-references in activitylink fields (e.g., '_0001', '_0002')"),
+        name: zod_1.z.string().min(1).describe("Workflow name"),
+        description: zod_1.z.string().optional().describe("Workflow description"),
+        fields: zod_1.z
+            .record(zod_1.z.object({
+            label: zod_1.z.string().describe("Field label shown in UI"),
+            type: zod_1.z.enum([
+                'activitylink', 'country', 'teams', 'text', 'textarea', 'textunit',
+                'textpredefinedoptions', 'users', 'numeric', 'numericunit', 'date',
+                'time', 'datetime', 'daterange', 'timerange', 'datetimerange', 'subheader'
+            ]).describe("Field type"),
+            key: zod_1.z.string().optional().describe("Readable field name (like SQL column name) - RECOMMENDED"),
+            required: zod_1.z.boolean().optional().describe("Whether field is required"),
+            data: zod_1.z.array(zod_1.z.string()).optional().describe("For activitylink: workflow IDs to link to. For textpredefinedoptions: allowed option values"),
+            placeholder: zod_1.z.string().optional().describe("Placeholder text"),
+            unit: zod_1.z.string().optional().describe("Unit for numeric/textunit fields"),
+            description: zod_1.z.string().optional().describe("Field description"),
+            editable: zod_1.z.boolean().optional().describe("Whether field is editable"),
+        }).passthrough())
+            .optional()
+            .refine((fields) => !fields || Object.keys(fields).every(id => /^_\d{4}$/.test(id)), { message: "Field IDs must match pattern _1000, _1001, etc. (underscore + 4 digits)" })
+            .describe("Field definitions keyed by field ID (_1000, _1001, etc.)"),
+        phases: zod_1.z
+            .record(zod_1.z.object({
+            name: zod_1.z.string().describe("Phase name"),
+            isInitial: zod_1.z.boolean().optional().describe("Whether activities can be created in this phase"),
+            fields: zod_1.z.array(zod_1.z.string()).optional().describe("Field IDs visible in this phase (defaults to all)"),
+            description: zod_1.z.string().optional().describe("Phase description"),
+        }).passthrough())
+            .optional()
+            .refine((phases) => !phases || Object.keys(phases).every(id => /^_\d{4}$/.test(id)), { message: "Phase IDs must match pattern _2000, _2001, etc. (underscore + 4 digits)" })
+            .describe("Phase definitions keyed by phase ID (_2000, _2001, etc.)"),
+        fieldsOrder: zod_1.z.array(zod_1.z.string()).optional().describe("Order of field IDs (auto-generated if omitted)"),
+        phasesOrder: zod_1.z.array(zod_1.z.string()).optional().describe("Order of phase IDs (auto-generated if omitted)"),
+        enableMessenger: zod_1.z.boolean().optional().describe("Enable discussion features (defaults to true)"),
+        enableLinkedAnnouncements: zod_1.z.boolean().optional().describe("Enable announcements (defaults to true)"),
+        defaultView: zod_1.z.enum(['timeline', 'table', 'kanban', 'calendar', 'map']).optional().describe("Default view type"),
+    }).passthrough())
+        .min(1, "At least one workflow template is required")
+        .max(100, "Maximum 100 workflow templates per installation")
+        .describe("Array of workflow template objects to install"),
+});
+exports.installWorkflowTool = {
+    name: 'install_workflow',
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: installWorkflowDescription,
+    schema: installWorkflowSchema,
+    async execute(args, context) {
+        logger.debug('Installing workflow', {
+            templateCount: args.workflowTemplates.length,
+            apiKey: context.apiKey.substring(0, 8) + '...'
+        });
+        try {
+            // Get current workspace from API if not specified
+            let workspaceId = args.workspaceId;
+            if (!workspaceId) {
+                const initData = await context.hailer.request('v2.core.init', [["network"]]);
+                workspaceId = initData.network?._id;
+            }
+            if (!workspaceId) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ Could not resolve workspace`,
+                        }],
+                };
+            }
+            logger.debug('Calling v3.workflow.install', {
+                workspaceId,
+                templatesCount: args.workflowTemplates.length
+            });
+            // Call v3.workflow.install endpoint
+            const result = await context.hailer.request('v3.workflow.install', [
+                workspaceId,
+                args.workflowTemplates
+            ]);
+            logger.debug('Workflow installation successful', { result });
+            // Build success response
+            let responseText = `✅ **Workflow Installation Successful**\n\n`;
+            responseText += `**Workspace:** ${workspaceId}\n`;
+            responseText += `**Workflows Installed:** ${args.workflowTemplates.length}\n\n`;
+            // Show workflow names and their real IDs
+            const templates = args.workflowTemplates;
+            const workflowMappings = templates
+                .filter((wf) => wf._id)
+                .map((wf) => `- ${wf.name}: \`${result[wf._id]}\` (from workflow _id \`${wf._id}\`)`)
+                .join('\n');
+            if (workflowMappings) {
+                responseText += `**Created Workflows:**\n${workflowMappings}\n\n`;
+            }
+            responseText += `**Complete ID Mapping (template_id → real_id):**\n`;
+            responseText += `\`\`\`json\n${JSON.stringify(result, null, 2)}\n\`\`\`\n\n`;
+            responseText += `💡 **Next Steps:**\n`;
+            responseText += `- Use \`list_workflows\` to see the new workflows in context\n`;
+            responseText += `- Use \`create_activity\` with the real workflow IDs to create activities\n`;
+            responseText += `- Field IDs from mapping are used when setting activity field values\n\n`;
+            responseText += `**Example Activity Creation:**\n`;
+            responseText += `\`\`\`javascript\n`;
+            if (templates[0]?._id) {
+                const firstTemplate = templates[0];
+                const workflowId = result[firstTemplate._id];
+                const firstFieldId = Object.keys(firstTemplate.fields || {})[0];
+                const realFieldId = firstFieldId ? result[firstFieldId] : 'field_id';
+                responseText += `// Using workflow: ${firstTemplate.name}\n`;
+                responseText += `create_activity({\n`;
+                responseText += `  workflowId: "${workflowId}",\n`;
+                responseText += `  name: "New Activity",\n`;
+                responseText += `  fields: { "${realFieldId}": "value" }\n`;
+                responseText += `});\n`;
+            }
+            else {
+                responseText += `create_activity({\n`;
+                responseText += `  workflowId: result._0001,\n`;
+                responseText += `  name: "New Activity",\n`;
+                responseText += `  fields: { [result._1000]: "value" }\n`;
+                responseText += `});\n`;
+            }
+            responseText += `\`\`\``;
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText,
+                    }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error("Error installing workflow", new Error(errorMessage));
+            // Handle permission errors
+            if (errorMessage.includes('network admin') || errorMessage.includes('PermissionDenied')) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ **Permission Denied**\n\nYou must be a workspace administrator to install workflows.\n\n**Error:** ${errorMessage}`,
+                        }],
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `❌ **Error installing workflow**\n\n**Error:** ${errorMessage}\n\n**Common Issues:**\n- User must be workspace administrator\n- Templates must have valid structure (name, fields, phases)\n- Field/Phase IDs must match pattern _0001, _1000, _2000 (underscore + 4 digits)\n- Workspace ID must be valid`,
+                    }],
+            };
+        }
+    }
+};
+// ============================================================================
+// TOOL 2: REMOVE WORKFLOW
+// ============================================================================
+const removeWorkflowDescription = `🧪 [PLAYGROUND] Remove workflow - ⚠️ DANGER: Permanently deletes workflow, activities, and discussions
+
+⚠️ **MANDATORY: GATHER COMPLETE CONTEXT BEFORE CALLING THIS TOOL**
+**BEFORE calling this tool, you are REQUIRED to:**
+1. Load the skill: \`get_skill({ skillName: "remove-workflow-skill" })\`
+2. Fetch workflow details with \`list_workflows\` to get:
+   - Workflow name and ID
+   - Workspace ID and name
+   - Activity count
+   - Relationships (which workflows link to this one)
+3. Show comprehensive confirmation message including:
+   - Workspace ID and name
+   - Workflow ID and name
+   - Exact count of activities that will be deleted
+   - Impact analysis - which other workflows will be affected (broken activity links)
+   - Clear irreversibility warning
+4. Wait for explicit user confirmation
+**FAILURE TO GATHER AND SHOW THIS CONTEXT IS AN ERROR**
+
+**Required**: workflowId
+**Permission**: Workspace administrator`;
+const removeWorkflowSchema = zod_1.z.object({
+    workflowId: zod_1.z
+        .string()
+        .min(1, "Workflow ID is required")
+        .describe("The workflow ID to remove (get from list_workflows)"),
+    workspaceId: zod_1.z
+        .string()
+        .optional()
+        .describe("Optional workspace ID or name - defaults to current workspace"),
+    confirmed: zod_1.z
+        .boolean()
+        .optional()
+        .describe("First confirmation - must be true to proceed"),
+    secondConfirmed: zod_1.z
+        .boolean()
+        .optional()
+        .describe("Second confirmation - must be true to proceed (required for double-check safety)"),
+});
+exports.removeWorkflowTool = {
+    name: 'remove_workflow',
+    group: tool_registry_1.ToolGroup.NUCLEAR,
+    description: removeWorkflowDescription,
+    schema: removeWorkflowSchema,
+    async execute(args, context) {
+        logger.debug('Removing workflow', {
+            workflowId: args.workflowId,
+            confirmed: args.confirmed,
+            secondConfirmed: args.secondConfirmed,
+            apiKey: context.apiKey.substring(0, 8) + '...'
+        });
+        try {
+            // Fetch workflow info from API to get name
+            const initData = await context.hailer.request('v2.core.init', [["processes", "network"]]);
+            const workflow = initData.processes?.find(p => p._id === args.workflowId);
+            if (!workflow) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ Workflow "${args.workflowId}" not found`,
+                        }],
+                };
+            }
+            const workflowName = workflow.name;
+            const workspaceId = args.workspaceId || initData.network?._id;
+            const workspaceName = initData.network?.name || 'Unknown';
+            // SAFETY CHECK: Require double confirmation
+            if (!args.confirmed || !args.secondConfirmed) {
+                let warningText = `⚠️ **DESTRUCTIVE OPERATION - CONFIRMATION REQUIRED**\n\n`;
+                warningText += `You are about to **permanently delete** the following:\n\n`;
+                warningText += `**Workflow:** ${workflowName}\n`;
+                warningText += `**Workflow ID:** \`${args.workflowId}\`\n`;
+                warningText += `**Workspace:** ${workspaceName} (\`${workspaceId}\`)\n\n`;
+                warningText += `**⚠️ This will permanently delete:**\n`;
+                warningText += `- Workflow structure (fields, phases)\n`;
+                warningText += `- ALL activities/records in this workflow\n`;
+                warningText += `- ALL discussions and messages\n`;
+                warningText += `- ALL relationships (ActivityLinks)\n\n`;
+                warningText += `**🚨 THIS CANNOT BE UNDONE! 🚨**\n\n`;
+                warningText += `**To proceed, you must:**\n`;
+                warningText += `1. Review the \`remove-workflow-skill\` (REQUIRED)\n`;
+                warningText += `2. Call this tool again with BOTH confirmations:\n\n`;
+                warningText += `\`\`\`javascript\n`;
+                warningText += `remove_workflow({\n`;
+                warningText += `  workflowId: "${args.workflowId}",\n`;
+                warningText += `  confirmed: true,\n`;
+                warningText += `  secondConfirmed: true\n`;
+                warningText += `})\n`;
+                warningText += `\`\`\`\n\n`;
+                warningText += `💡 **Before proceeding:**\n`;
+                warningText += `- Load \`remove-workflow-skill\` to review safety checklist\n`;
+                warningText += `- Export data if needed (\`list_activities\`)\n`;
+                warningText += `- Check for dependencies (\`list_workflows\`)\n`;
+                warningText += `- Verify with user that this is intentional`;
+                return {
+                    content: [{
+                            type: "text",
+                            text: warningText,
+                        }],
+                };
+            }
+            logger.debug('Calling process.remove', {
+                workflowId: args.workflowId,
+                workflowName,
+                workspaceId,
+                workspaceName
+            });
+            // Call process.remove endpoint
+            await context.hailer.request('process.remove', [args.workflowId]);
+            logger.debug('Workflow removal successful', {
+                workflowId: args.workflowId,
+                workflowName,
+                workspaceId,
+                workspaceName
+            });
+            // Build success response
+            let responseText = `✅ **Workflow Removed Successfully**\n\n`;
+            responseText += `**Workflow:** ${workflowName}\n`;
+            responseText += `**Workflow ID:** \`${args.workflowId}\`\n`;
+            responseText += `**Workspace:** ${workspaceName} (\`${workspaceId}\`)\n\n`;
+            responseText += `⚠️ **All activities and discussions in this workflow have been permanently deleted.**\n\n`;
+            responseText += `💡 Use \`list_workflows\` to see remaining workflows in the workspace.`;
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText,
+                    }],
+            };
+        }
+        catch (error) {
+            logger.error("Error removing workflow", error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Handle permission errors
+            if (errorMessage.includes('network admin') || errorMessage.includes('PermissionDenied') || errorMessage.includes('permission')) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ **Permission Denied**\n\nYou must be a workspace administrator to remove workflows.\n\n**Error:** ${errorMessage}`,
+                        }],
+                };
+            }
+            // Handle not found errors
+            if (errorMessage.includes('not found') || errorMessage.includes('NotFound')) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ **Workflow Not Found**\n\nThe specified workflow does not exist or you don't have access to it.\n\n**Workflow ID:** \`${args.workflowId}\`\n\n**Error:** ${errorMessage}\n\n💡 Use \`list_workflows\` to see available workflows.`,
+                        }],
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `❌ **Error removing workflow**\n\n**Error:** ${errorMessage}\n\n**Common Issues:**\n- User must be workspace administrator\n- Workflow ID must be valid and exist in the workspace\n- Workflow must not be referenced by other workflows (check ActivityLinks)`,
+                    }],
+            };
+        }
+    }
+};
+// ============================================================================
+// TOOL 3: UPDATE WORKFLOW FIELD
+// ============================================================================
+const updateWorkflowFieldDescription = `🧪 [PLAYGROUND] Update workflow field - Modify field properties and configure function fields
+
+⚠️ **MANDATORY: YOU MUST LOAD SKILL FIRST**
+**BEFORE calling this tool, you are REQUIRED to:**
+1. Load the skill: \`get_skill({ skillName: "update-workflow-field-skill" })\`
+2. Read the examples and best practices
+3. Understand function fields and field type restrictions
+**FAILURE TO LOAD THE SKILL FIRST IS AN ERROR**
+
+**Required Parameters**:
+- workflowId: Workflow ID
+- fieldId: Field ID to update
+- fieldData: Properties to update (label, key, type, data, required, function, functionVariables, functionEnabled)
+
+**IMPORTANT - Updating Labels Only:**
+When updating ONLY the label (not the key), set \`autoGenerateKey: false\` to prevent key regeneration:
+- ✅ Correct: \`{ fieldData: { label: "Nationality" }, autoGenerateKey: false }\`
+- ❌ Wrong: \`{ fieldData: { label: "Nationality" } }\` (will try to regenerate key and may fail)
+
+**Auto-generate key**: When creating NEW keys, set label only and key auto-generates as camelCase ("Start Date" → "startDate")
+
+**Field Type Changes**: Avoid changing field types (text → country, etc.) as this may be restricted by the API
+
+**Use Cases**: Add keys, update labels, update activitylink targets, configure calculated fields, modify options
+
+**Examples**:
+- Update label only: \`update_workflow_field({ workflowId: "xxx", fieldId: "yyy", fieldData: { label: "New Label" }, autoGenerateKey: false })\`
+- Update label and options: \`update_workflow_field({ workflowId: "xxx", fieldId: "yyy", fieldData: { label: "Status", data: ["Active", "Inactive"] }, autoGenerateKey: false })\`
+- Add new key to field: \`update_workflow_field({ workflowId: "xxx", fieldId: "yyy", fieldData: { label: "My Field" }, autoGenerateKey: true })\` (generates key: "myField")`;
+const updateWorkflowFieldSchema = zod_1.z.object({
+    workflowId: zod_1.z
+        .string()
+        .min(1, "Workflow ID is required")
+        .describe("The workflow ID containing the field (get from list_workflows)"),
+    fieldId: zod_1.z
+        .string()
+        .min(1, "Field ID is required")
+        .describe("The field ID to update (get from workflow schema)"),
+    fieldData: zod_1.z
+        .record(zod_1.z.unknown())
+        .describe("Field properties to update (label, key, type, data, required, etc.)"),
+    workspaceId: zod_1.z
+        .string()
+        .optional()
+        .describe("Optional workspace ID or name - defaults to current workspace"),
+    language: zod_1.z
+        .string()
+        .default("en")
+        .optional()
+        .describe("Language code for the update (default: 'en')"),
+    autoGenerateKey: zod_1.z
+        .boolean()
+        .default(true)
+        .optional()
+        .describe("Auto-generate camelCase key from label if key not provided (default: true). IMPORTANT: Set to false when updating ONLY the label to prevent key regeneration errors."),
+});
+exports.updateWorkflowFieldTool = {
+    name: 'update_workflow_field',
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: updateWorkflowFieldDescription,
+    schema: updateWorkflowFieldSchema,
+    async execute(args, context) {
+        logger.debug('Updating workflow field', {
+            workflowId: args.workflowId,
+            fieldId: args.fieldId,
+            apiKey: context.apiKey.substring(0, 8) + '...'
+        });
+        try {
+            // Get current workspace from API if not specified
+            let workspaceId = args.workspaceId;
+            if (!workspaceId) {
+                const initData = await context.hailer.request('v2.core.init', [["network"]]);
+                workspaceId = initData.network?._id;
+            }
+            // Process field data - auto-generate key from label if requested
+            const fieldData = { ...args.fieldData };
+            const autoGenerateKey = args.autoGenerateKey !== false; // Default to true
+            if (autoGenerateKey && fieldData.label && !fieldData.key) {
+                const generatedKey = labelToCamelCase(fieldData.label);
+                fieldData.key = generatedKey;
+                logger.debug('Auto-generated key from label', {
+                    label: fieldData.label,
+                    key: generatedKey
+                });
+            }
+            const language = args.language || 'en';
+            logger.debug('Calling process.update_field', {
+                workflowId: args.workflowId,
+                fieldId: args.fieldId,
+                language,
+                fieldData
+            });
+            // Call process.update_field endpoint
+            await context.hailer.request('process.update_field', [
+                args.workflowId,
+                args.fieldId,
+                fieldData,
+                language
+            ]);
+            logger.debug('Workflow field update successful', {
+                workflowId: args.workflowId,
+                fieldId: args.fieldId
+            });
+            // Build success response
+            let responseText = `✅ **Workflow Field Updated Successfully**\n\n`;
+            responseText += `**Workflow ID:** \`${args.workflowId}\`\n`;
+            responseText += `**Field ID:** \`${args.fieldId}\`\n`;
+            responseText += `**Workspace:** ${workspaceId}\n\n`;
+            responseText += `**Updated Properties:**\n`;
+            Object.entries(fieldData).forEach(([key, value]) => {
+                const valueStr = typeof value === 'object' ? JSON.stringify(value) : String(value);
+                responseText += `- ${key}: \`${valueStr}\`\n`;
+            });
+            responseText += `\n💡 **Next Steps:**\n`;
+            responseText += `- Use \`get_workflow_schema\` to verify the field changes\n`;
+            responseText += `- Use \`list_activities\` with \`returnFlat: true\` to see the key in action\n`;
+            if (fieldData.key) {
+                responseText += `\n**Using the new key:**\n`;
+                responseText += `When creating/updating activities with \`returnFlat: true\`, use:\n`;
+                responseText += `\`\`\`javascript\n`;
+                responseText += `fields: { "${fieldData.key}": "value" }\n`;
+                responseText += `\`\`\``;
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText,
+                    }],
+            };
+        }
+        catch (error) {
+            logger.error("Error updating workflow field", error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Handle permission errors
+            if (errorMessage.includes('network admin') || errorMessage.includes('PermissionDenied') || errorMessage.includes('permission')) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ **Permission Denied**\n\nYou must be a workspace administrator to update workflow fields.\n\n**Error:** ${errorMessage}`,
+                        }],
+                };
+            }
+            // Handle not found errors
+            if (errorMessage.includes('not found') || errorMessage.includes('NotFound')) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ **Workflow or Field Not Found**\n\nThe specified workflow or field does not exist.\n\n**Workflow ID:** \`${args.workflowId}\`\n**Field ID:** \`${args.fieldId}\`\n\n**Error:** ${errorMessage}\n\n💡 Use \`list_workflows\` and \`get_workflow_schema\` to see available workflows and fields.`,
+                        }],
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `❌ **Error updating workflow field**\n\n**Error:** ${errorMessage}\n\n**Common Issues:**\n- User must be workspace administrator\n- Workflow ID and Field ID must be valid\n- Field data must match field type requirements\n- Some field types may have restrictions on updates`,
+                    }],
+            };
+        }
+    }
+};
+// ============================================================================
+// TOOL 4: TEST FUNCTION FIELD
+// ============================================================================
+const testFunctionFieldDescription = `🧪 [PLAYGROUND] Test function field - Dry-run test function code against real activity before saving
+
+**Required**: activityId, fieldId, function (JavaScript accessing dep.variableName)
+**Returns**: Result value, resolved dependencies, execution stats, or detailed errors
+**Workflow**: Configure with update_workflow_field → test → fix → re-test → deploy`;
+const testFunctionFieldSchema = zod_1.z.object({
+    activityId: zod_1.z
+        .string()
+        .min(1, "Activity ID is required")
+        .describe("Activity ID to test the function against (must have dependency field values)"),
+    fieldId: zod_1.z
+        .string()
+        .min(1, "Field ID is required")
+        .describe("Field ID for context and to get field configuration (label, type, etc.)"),
+    function: zod_1.z
+        .string()
+        .min(1, "Function code is required")
+        .describe("JavaScript function code to test - access dependencies via dep.variableName"),
+    functionVariables: zod_1.z
+        .record(zod_1.z.object({
+        type: zod_1.z.string().describe("Dependency type - use '=' for same-activity field"),
+        data: zod_1.z.array(zod_1.z.string()).describe("Array with field ID to depend on")
+    }))
+        .optional()
+        .describe("Optional function dependencies - if not provided, reads from field definition"),
+});
+exports.testFunctionFieldTool = {
+    name: 'test_function_field',
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: testFunctionFieldDescription,
+    schema: testFunctionFieldSchema,
+    async execute(args, context) {
+        logger.debug('Testing function field', {
+            activityId: args.activityId,
+            fieldId: args.fieldId
+        });
+        try {
+            // Fetch activity to get workflow context
+            const activity = await context.hailer.fetchActivityById(args.activityId);
+            if (!activity?.process) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ Could not find activity or workflow for activity ID: ${args.activityId}`
+                        }],
+                };
+            }
+            // Get workflow field definition from API
+            const initData = await context.hailer.request('v2.core.init', [["processes"]]);
+            const workflow = initData.processes?.find(p => p._id === activity.process);
+            const field = workflow?.fields?.[args.fieldId];
+            if (!field) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ Field not found in workflow.
+
+**Field ID:** \`${args.fieldId}\`
+**Workflow ID:** \`${activity.process}\`
+
+💡 Use \`get_workflow_schema\` to see available fields.`,
+                        }],
+                };
+            }
+            // Resolve function variables (use provided or field defaults)
+            const functionVariables = args.functionVariables || field.functionVariables;
+            if (!functionVariables) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ No function dependencies provided.
+
+**Field:** ${field.label || args.fieldId}
+
+You must provide \`functionVariables\` parameter, or the field must have dependencies configured.
+
+**Example:**
+\`\`\`javascript
+functionVariables: {
+  "likelihood": { "type": "=", "data": ["field-id-1"] },
+  "impact": { "type": "=", "data": ["field-id-2"] }
+}
+\`\`\``,
+                        }],
+                };
+            }
+            // Evaluate the function code
+            const result = await context.hailer.request('v2.activities.evaluate', [
+                args.activityId,
+                args.fieldId,
+                args.function,
+                functionVariables
+            ]);
+            // Check for JavaScript errors in the evaluation
+            const errorMessage = extractEvaluationError(result, args.fieldId);
+            if (errorMessage) {
+                const errorType = parseErrorType(errorMessage);
+                const cleanMessage = errorMessage.replace(/^(SyntaxError|ReferenceError|TypeError):\s*/, '');
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ **Function Field Test Failed**
+
+**Error Type:** ${errorType}
+**Error Message:** ${cleanMessage}
+
+💡 **Common Issues:**
+- **SyntaxError**: Missing brackets, semicolons, or quotes in JavaScript code
+- **ReferenceError**: Variable not defined or typo in dependency name (\`dep.variableName\`)
+- **TypeError**: Invalid operation on wrong data type
+
+**Next Steps:**
+1. Fix the function code syntax/logic
+2. Test again with \`test_function_field\`
+3. When test passes, save with \`update_workflow_field\``,
+                        }],
+                };
+            }
+            // Build success response
+            const evaluatedField = result?.activity?.fields?.find((f) => f.id === args.fieldId);
+            const calculatedValue = evaluatedField?.value;
+            const dependencies = result?.context?.dependencies || {};
+            const stats = result?.context?.stats || {};
+            let text = `✅ **Function Field Test Successful**
+
+**Field:** ${field.label || args.fieldId} (${field.type || 'unknown'})
+**Activity:** ${activity.name || activity._id}
+
+**📊 Calculated Result:** \`${calculatedValue !== undefined ? calculatedValue : 'undefined'}\``;
+            if (field.type === 'numeric' && typeof calculatedValue === 'number' && field.unit) {
+                text += ` (${calculatedValue} ${field.unit})`;
+            }
+            text += '\n';
+            // Show resolved dependencies
+            if (Object.keys(dependencies).length > 0) {
+                text += '\n**🔗 Dependencies Resolved:**\n';
+                Object.entries(dependencies).forEach(([varName, value]) => {
+                    text += `- ${varName}: \`${value}\`\n`;
+                });
+            }
+            // Show execution stats
+            const executionTime = stats['Executing Sandbox (ms) (It:0/Ops:1)'];
+            const iterations = stats['Iterations Used'];
+            if (executionTime !== undefined || iterations !== undefined) {
+                text += '\n**⏱️  Execution Statistics:**\n';
+                if (executionTime !== undefined)
+                    text += `- Execution Time: ${executionTime}ms\n`;
+                if (iterations !== undefined)
+                    text += `- Iterations: ${iterations}\n`;
+            }
+            text += `
+**✅ Next Steps:**
+- Test with other activities to verify edge cases
+- Check activities where dependencies might be null/undefined
+- If you need to modify the function, use \`update_workflow_field\` to save changes
+- Function is working correctly and ready for production use!`;
+            return {
+                content: [{ type: "text", text }],
+            };
+        }
+        catch (error) {
+            logger.error("Error testing function field", error);
+            const errorMessage = error instanceof Error
+                ? error.message
+                : JSON.stringify(error, null, 2);
+            return {
+                content: [{
+                        type: "text",
+                        text: `❌ **Error Testing Function Field**
+
+${errorMessage}
+
+💡 This might indicate:
+- API connection issue
+- Invalid activity or field ID
+- Backend processing error`,
+                    }],
+            };
+        }
+    }
+};
+// ============================================================================
+// TOOL 5: LIST WORKFLOWS MINIMAL
+// ============================================================================
+const listWorkflowsMinimalDescription = `🧪 [PLAYGROUND] List workflows with minimal output - Returns only id and name to avoid token limits`;
+const listWorkflowsMinimalSchema = zod_1.z.object({
+    workspace: zod_1.z.string().optional().describe("Optional workspace ID or name"),
+    limit: zod_1.z.coerce.number().optional().describe("Maximum number of workflows to return"),
+    offset: zod_1.z.coerce.number().optional().default(0).describe("Number of workflows to skip (for pagination)"),
+    search: zod_1.z.string().optional().describe("Filter workflows by name (case-insensitive partial match)"),
+    starredOnly: zod_1.z.coerce.boolean().optional().default(false).describe("Only return starred workflows"),
+});
+exports.listWorkflowsMinimalTool = {
+    name: 'list_workflows_minimal',
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: listWorkflowsMinimalDescription,
+    schema: listWorkflowsMinimalSchema,
+    async execute(args, context) {
+        logger.debug('Listing workflows (minimal)', {
+            apiKey: context.apiKey.substring(0, 8) + '...'
+        });
+        try {
+            // Fetch workflows directly from API
+            const initData = await context.hailer.request('v2.core.init', [["processes"]]);
+            let workflows = initData.processes || [];
+            // Filter by workspace if specified
+            if (args.workspace) {
+                workflows = workflows.filter(w => w.cid === args.workspace);
+            }
+            // Filter by starred if requested
+            if (args.starredOnly) {
+                workflows = workflows.filter(w => w.isStarred);
+            }
+            // Search by name if provided
+            if (args.search) {
+                const searchLower = args.search.toLowerCase();
+                workflows = workflows.filter(w => w.name.toLowerCase().includes(searchLower));
+            }
+            // Apply pagination
+            const offset = args.offset || 0;
+            const limit = args.limit;
+            const totalCount = workflows.length;
+            if (limit) {
+                workflows = workflows.slice(offset, offset + limit);
+            }
+            else if (offset > 0) {
+                workflows = workflows.slice(offset);
+            }
+            // Build minimal response - only id and name
+            const minimalWorkflows = workflows.map(w => ({
+                id: w._id,
+                name: w.name,
+                workspaceId: w.cid,
+                activityCount: w.createdActivities || 0,
+                isStarred: w.isStarred || false
+            }));
+            let responseText = `📋 **Workflows Found**\n\n`;
+            responseText += `Total: ${totalCount}\n`;
+            responseText += `Showing: ${workflows.length}\n`;
+            if (offset > 0)
+                responseText += `Offset: ${offset}\n`;
+            responseText += `\n`;
+            minimalWorkflows.forEach(w => {
+                const star = w.isStarred ? '⭐ ' : '';
+                responseText += `${star}**${w.name}**\n`;
+                responseText += `  ID: \`${w.id}\`\n`;
+                responseText += `  Activities: ${w.activityCount}\n\n`;
+            });
+            responseText += `\n💡 **Next Steps:**\n`;
+            responseText += `- Use \`get_workflow_schema\` with workflow ID to see fields\n`;
+            responseText += `- Use \`list_workflow_phases\` to see available phases\n`;
+            if (limit && (offset + limit) < totalCount) {
+                responseText += `- Use \`offset: ${offset + limit}\` to see next page\n`;
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText,
+                    }],
+            };
+        }
+        catch (error) {
+            logger.error("Error listing workflows (minimal)", error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `❌ Error listing workflows: ${error instanceof Error ? error.message : String(error)}`,
+                    }],
+            };
+        }
+    }
+};
+// ============================================================================
+// COUNT ACTIVITIES TOOL
+// ============================================================================
+const countActivitiesDescription = `🔢 Count Activities - Get total count of activities in a workflow
+
+**Purpose**: Returns the total number of activities in a specific workflow. Useful for analytics, reporting, and understanding workflow size.
+
+**Example**:
+\`\`\`javascript
+count_activities({
+  workflowId: "691b136906e6923eac972902"
+})
+\`\`\`
+
+**Response**: Returns count in details object
+
+**Use Cases**:
+- Analytics and reporting
+- Workflow size estimation
+- Data migration planning
+- Performance monitoring
+
+**Tips**:
+- Much faster than list_activities for just getting count
+- Use list_workflows to get workflow IDs`;
+const countActivitiesSchema = zod_1.z.object({
+    workflowId: zod_1.z.string().describe("Workflow ID to count activities from (24 characters)"),
+});
+exports.countActivitiesTool = {
+    name: 'count_activities',
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: countActivitiesDescription,
+    schema: countActivitiesSchema,
+    async execute(args, context) {
+        logger.debug('Counting activities', {
+            workflowId: args.workflowId,
+            apiKey: context.apiKey.substring(0, 8) + '...'
+        });
+        try {
+            // Get workflow name for better response
+            const initData = await context.hailer.request('v2.core.init', [["processes"]]);
+            const workflow = initData.processes?.find(p => p._id === args.workflowId);
+            if (!workflow) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ Workflow "${args.workflowId}" not found`,
+                        }],
+                };
+            }
+            logger.debug('Calling v3.activity.count', {
+                workflowId: args.workflowId,
+                workflowName: workflow.name
+            });
+            // Call v3.activity.count endpoint
+            // Returns object with phase IDs as keys and counts as values
+            const result = await context.hailer.request('v3.activity.count', [args.workflowId]);
+            logger.debug('Activity count retrieved', {
+                result: JSON.stringify(result)
+            });
+            // Sum all counts across phases
+            const count = Object.values(result).reduce((sum, phaseCount) => sum + phaseCount, 0);
+            // Build success response
+            let responseText = `🔢 **Activity Count for "${workflow.name}"**\n\n`;
+            responseText += `**Workflow ID:** \`${args.workflowId}\`\n`;
+            responseText += `**Total Activities:** ${count}\n\n`;
+            if (count === 0) {
+                responseText += `💡 This workflow has no activities yet. Use \`create_activity\` to add one.\n`;
+            }
+            else {
+                responseText += `💡 **Next Steps:**\n`;
+                responseText += `- Use \`list_activities\` to see the activities\n`;
+                responseText += `- Use \`get_workflow_schema\` to see workflow structure\n`;
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText,
+                    }],
+            };
+        }
+        catch (error) {
+            logger.error("Error counting activities", error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `❌ Error counting activities: ${error instanceof Error ? error.message : String(error)}\n\n**Tips:**\n- Check that workflow ID is valid (24 characters)\n- Use \`list_workflows\` to find workflow IDs`,
+                    }],
+            };
+        }
+    }
+};
+// ============================================================================
+// UPDATE WORKFLOW PHASE
+// ============================================================================
+const updateWorkflowPhaseDescription = `🏷️ Update Workflow Phase - Modify phase name and properties
+
+**What does this do?**
+Updates an existing workflow phase's properties like name, description, and settings.
+
+**Required Parameters**:
+- workflowId: Workflow ID containing the phase
+- phaseId: Phase ID to update
+- phaseData: Properties to update (name, description, etc.)
+
+**Example - Rename phase**:
+\`\`\`javascript
+update_workflow_phase({
+  workflowId: "68446dc05b30685f67c6fcd4",
+  phaseId: "181",
+  phaseData: { name: "Injured" }
+})
+\`\`\`
+
+**Updatable Properties**:
+- name - Phase display name
+- description - Phase description
+- color - Phase color code
+
+**Requirements**:
+- User must be workspace administrator
+`;
+const updateWorkflowPhaseSchema = zod_1.z.object({
+    workflowId: zod_1.z.string().describe("The workflow ID containing the phase (24 characters)"),
+    phaseId: zod_1.z.string().describe("The phase ID to update"),
+    phaseData: zod_1.z.object({
+        name: zod_1.z.string().optional().describe("New phase name"),
+        description: zod_1.z.string().optional().describe("New phase description"),
+        color: zod_1.z.string().optional().describe("Phase color code"),
+    }).passthrough().describe("Phase properties to update"),
+    workspaceId: zod_1.z.string().optional().describe("Optional workspace ID - defaults to current workspace"),
+});
+exports.updateWorkflowPhaseTool = {
+    name: 'update_workflow_phase',
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: updateWorkflowPhaseDescription,
+    schema: updateWorkflowPhaseSchema,
+    async execute(args, context) {
+        logger.debug('Updating workflow phase', {
+            workflowId: args.workflowId,
+            phaseId: args.phaseId,
+            apiKey: context.apiKey.substring(0, 8) + '...'
+        });
+        try {
+            // Get current workspace from API if not specified
+            let workspaceId = args.workspaceId;
+            if (!workspaceId) {
+                const initData = await context.hailer.request('v2.core.init', [["network"]]);
+                workspaceId = initData.network?._id;
+            }
+            const phaseData = args.phaseData;
+            const language = 'en'; // Default language
+            logger.debug('Calling REST /phase/update', {
+                workflowId: args.workflowId,
+                phaseId: args.phaseId,
+                phaseData
+            });
+            // Call REST endpoint /api/phase/update
+            // API format: {"0": workflowId, "1": phaseId, "2": phaseSettings, "3": language}
+            await context.hailer.callRest({
+                operation: 'update_workflow_phase',
+                endpoint: '/api/phase/update',
+                method: 'POST',
+                body: {
+                    "0": args.workflowId,
+                    "1": args.phaseId,
+                    "2": phaseData,
+                    "3": language
+                }
+            });
+            logger.debug('Workflow phase update successful', {
+                workflowId: args.workflowId,
+                phaseId: args.phaseId
+            });
+            // Build success response
+            let responseText = `✅ **Workflow Phase Updated Successfully**\n\n`;
+            responseText += `**Workflow ID:** \`${args.workflowId}\`\n`;
+            responseText += `**Phase ID:** \`${args.phaseId}\`\n`;
+            responseText += `**Workspace:** ${workspaceId}\n\n`;
+            responseText += `**Updated Properties:**\n`;
+            Object.entries(phaseData).forEach(([key, value]) => {
+                const valueStr = typeof value === 'object' ? JSON.stringify(value) : String(value);
+                responseText += `- ${key}: \`${valueStr}\`\n`;
+            });
+            responseText += `\n💡 **Next Steps:**\n`;
+            responseText += `- Use \`list_workflow_phases\` to verify the phase changes\n`;
+            responseText += `- Phase changes will be immediately visible in the workflow\n`;
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText,
+                    }],
+            };
+        }
+        catch (error) {
+            logger.error("Error updating workflow phase", error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Handle permission errors
+            if (errorMessage.includes('network admin') || errorMessage.includes('PermissionDenied') || errorMessage.includes('permission')) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ **Permission Denied**\n\nYou must be a workspace administrator to update workflow phases.\n\n**Error:** ${errorMessage}`,
+                        }],
+                };
+            }
+            // Handle method not found errors
+            if (errorMessage.includes('Method not found')) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ **API Method Not Available**\n\nThe \`process.update_phase\` API method may not be available in this Hailer version.\n\n**Alternative:** Use the Hailer web interface to update phase names manually.\n\n**Error:** ${errorMessage}`,
+                        }],
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `❌ **Error updating workflow phase**\n\n**Error:** ${errorMessage}\n\n**Common Issues:**\n- User must be workspace administrator\n- Workflow ID must be valid (24 characters)\n- Phase ID must exist in the workflow\n- Use \`list_workflow_phases\` to find phase IDs`,
+                    }],
+            };
+        }
+    }
+};
+//# sourceMappingURL=workflow.js.map