@hailer/mcp 0.0.1

package/dist/mcp/tools/activity.js

@@ -0,0 +1,955 @@
+"use strict";
+/**
+ * Activity Tools - Clean Architecture Implementation
+ *
+ * Tools for managing Hailer activities:
+ * - List activities with filtering and pagination (READ)
+ * - Show activity details (READ)
+ * - Create new activities (WRITE)
+ * - Update existing activities (WRITE)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateActivityTool = exports.createActivityTool = exports.showActivityByIdTool = exports.listActivitiesTool = void 0;
+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 logger = (0, index_1.createLogger)({ component: 'activity-tools' });
+/**
+ * Extract error message from various error types
+ */
+function extractErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    else if (error && typeof error === 'object') {
+        if ('message' in error) {
+            return String(error.message);
+        }
+        else if ('error' in error) {
+            return String(error.error);
+        }
+        else if ('statusText' in error) {
+            return String(error.statusText);
+        }
+        else {
+            try {
+                return JSON.stringify(error, null, 2);
+            }
+            catch {
+                return 'Complex error object (cannot serialize)';
+            }
+        }
+    }
+    else {
+        return String(error);
+    }
+}
+/**
+ * Validate and get workflow from init data
+ */
+function validateAndGetWorkflow(workflowId, init) {
+    const workflow = init.processes.find((p) => p._id === workflowId);
+    if (!workflow) {
+        throw new Error(`Workflow "${workflowId}" not found. Use get_workflow_info to find available workflows.`);
+    }
+    return (0, index_1.transformWorkflow)(workflow);
+}
+/**
+ * Resolve phase for listing activities
+ */
+async function resolvePhaseForListing(workflow, args, init) {
+    if (!args.phaseId) {
+        throw new Error(`Phase ID is required. Use the list_workflow_phases tool to get available phase IDs for workflow "${workflow.name}".`);
+    }
+    return args.phaseId;
+}
+/**
+ * Filter fieldsAndValues to only include requested fields
+ */
+function filterFieldsAndValues(activities, requestedFieldIds, workflowFields) {
+    logger.debug('🔍 Filtering fieldsAndValues', {
+        activityCount: activities.length,
+        requestedFieldCount: requestedFieldIds.length,
+        requestedFieldIds,
+    });
+    const fieldNameToId = new Map();
+    const fieldIdSet = new Set(requestedFieldIds);
+    for (const [fieldId, fieldInfo] of Object.entries(workflowFields)) {
+        if (fieldIdSet.has(fieldId) && fieldInfo.label) {
+            fieldNameToId.set(fieldInfo.label, fieldId);
+        }
+    }
+    logger.debug('🗺️ Field mapping', {
+        fieldNameToIdSize: fieldNameToId.size,
+        fieldMap: Array.from(fieldNameToId.entries()),
+    });
+    return activities.map((activity) => {
+        if (!activity.fieldsAndValues || !Array.isArray(activity.fieldsAndValues)) {
+            logger.debug('⚠️ Activity has no fieldsAndValues', {
+                activityId: activity._id,
+                hasFieldsAndValues: !!activity.fieldsAndValues,
+                isArray: Array.isArray(activity.fieldsAndValues),
+            });
+            return activity;
+        }
+        const originalFieldCount = activity.fieldsAndValues.length;
+        const filteredFieldsAndValues = activity.fieldsAndValues.filter((field) => {
+            const fieldId = fieldNameToId.get(field.fieldName);
+            const isIncluded = !!fieldId;
+            if (originalFieldCount <= 3) {
+                logger.debug('🔍 Field filter check', {
+                    fieldName: field.fieldName,
+                    mappedFieldId: fieldId,
+                    isIncluded,
+                    hasValue: field.value !== undefined && field.value !== null,
+                });
+            }
+            return isIncluded;
+        });
+        logger.debug('✂️ Filtered activity fields', {
+            activityId: activity._id,
+            originalFieldCount,
+            filteredFieldCount: filteredFieldsAndValues.length,
+        });
+        return {
+            ...activity,
+            fieldsAndValues: filteredFieldsAndValues,
+        };
+    });
+}
+/**
+ * Convert activity filters from MCP tool format to API format
+ */
+function convertActivityFilters(mcpToolActivityListFilters) {
+    const apiActivityFilters = { and: [] };
+    let malformatFilterErrorMessage = undefined;
+    for (const [fieldId, filterConfig] of Object.entries(mcpToolActivityListFilters)) {
+        switch (filterConfig.operator) {
+            case "text_search":
+                if (filterConfig.value !== undefined) {
+                    apiActivityFilters.and.push({ [fieldId]: { textSearch: filterConfig.value } });
+                }
+                else {
+                    malformatFilterErrorMessage = 'text_search filter requires a value';
+                }
+                break;
+            case "equals":
+                if (filterConfig.value !== undefined) {
+                    apiActivityFilters.and.push({ [fieldId]: { equalTo: filterConfig.value } });
+                }
+                else {
+                    malformatFilterErrorMessage = 'equals filter requires a value';
+                }
+                break;
+            case "not_equals":
+                if (filterConfig.value !== undefined) {
+                    apiActivityFilters.and.push({ [fieldId]: { notEqualTo: filterConfig.value } });
+                }
+                else {
+                    malformatFilterErrorMessage = 'not_equals filter requires a value';
+                }
+                break;
+            case "contains":
+                if (filterConfig.value !== undefined) {
+                    apiActivityFilters.and.push({ [fieldId]: { contains: filterConfig.value } });
+                }
+                else {
+                    malformatFilterErrorMessage = 'contains filter requires a value';
+                }
+                break;
+            case "greater_than":
+                if (filterConfig.value !== undefined && typeof filterConfig.value === 'number') {
+                    apiActivityFilters.and.push({ [fieldId]: { greaterThan: filterConfig.value } });
+                }
+                else {
+                    malformatFilterErrorMessage = 'greater_than filter requires a numeric value';
+                }
+                break;
+            case "greater_than_or_equal":
+                if (filterConfig.value !== undefined && typeof filterConfig.value === 'number') {
+                    apiActivityFilters.and.push({ [fieldId]: { greaterThanOrEqual: filterConfig.value } });
+                }
+                else {
+                    malformatFilterErrorMessage = 'greater_than_or_equal filter requires a numeric value';
+                }
+                break;
+            case "less_than":
+                if (filterConfig.value !== undefined && typeof filterConfig.value === 'number') {
+                    apiActivityFilters.and.push({ [fieldId]: { lessThan: filterConfig.value } });
+                }
+                else {
+                    malformatFilterErrorMessage = 'less_than filter requires a numeric value';
+                }
+                break;
+            case "less_than_or_equal":
+                if (filterConfig.value !== undefined && typeof filterConfig.value === 'number') {
+                    apiActivityFilters.and.push({ [fieldId]: { lessThanOrEqual: filterConfig.value } });
+                }
+                else {
+                    malformatFilterErrorMessage = 'less_than_or_equal filter requires a numeric value';
+                }
+                break;
+            case "range":
+                if (!filterConfig.start || !filterConfig.end) {
+                    malformatFilterErrorMessage = 'Incorrect filter format, either start or end not provided for range';
+                    break;
+                }
+                apiActivityFilters.and.push({ [fieldId]: { between: [String(filterConfig.start), String(filterConfig.end)] } });
+                break;
+            default:
+                malformatFilterErrorMessage = 'Unknown filter provided';
+                break;
+        }
+    }
+    return { errorMessage: malformatFilterErrorMessage, V3ActivityListFilters: apiActivityFilters };
+}
+/**
+ * Format activity list response with pagination
+ */
+function formatActivityListResponseWithPagination(activityData, workflow, init, phaseName, args) {
+    const activities = Array.isArray(activityData) ? activityData : (activityData.activities || activityData || []);
+    const metadata = activityData.metadata || {};
+    const cleanedActivities = (0, index_1.transformActivities)(activities, workflow, init.users);
+    const filteredActivities = args?.fields
+        ? filterFieldsAndValues(cleanedActivities, args.fields, workflow.fields)
+        : cleanedActivities;
+    const totalCount = metadata.totalCount || activities.length;
+    const currentPage = args?.page || 0;
+    const limit = args?.limit || 50;
+    const hasMorePages = activities.length === limit;
+    const totalPages = Math.ceil(totalCount / limit);
+    let responseText = `📊 **PAGINATION INFO:**\n`;
+    responseText += `- Current page: ${currentPage + 1}\n`;
+    responseText += `- Activities on this page: ${activities.length}\n`;
+    responseText += `- Limit per page: ${limit}\n`;
+    if (hasMorePages) {
+        responseText += `- ⚠️  **MORE DATA AVAILABLE**: Use page=${currentPage + 1} to get next ${limit} activities\n`;
+    }
+    if (activities.length === limit && currentPage === 0) {
+        responseText += `\n💡 **TIP**: This shows the first ${limit} activities.\n`;
+        responseText += `  - Use 'page' parameter to paginate through all results\n`;
+        responseText += `  - Use 'search' parameter to filter by name, description, or field content\n`;
+        responseText += `  - Use different 'sortBy' and 'sortOrder' for different ordering\n`;
+    }
+    responseText += `\n` + (0, index_1.formatActivityListResponse)(filteredActivities, workflow, phaseName);
+    return {
+        content: [
+            {
+                type: "text",
+                text: responseText,
+            },
+        ],
+    };
+}
+/**
+ * Format filtered activity list response
+ */
+function formatFilteredActivityListResponse(activityData, workflow, init, args) {
+    const activities = Array.isArray(activityData) ? activityData : (activityData.activities || activityData || []);
+    const metadata = activityData.metadata || {};
+    const cleanedActivities = (0, index_1.transformActivities)(activities, workflow, init.users);
+    const filteredActivities = args.fields
+        ? filterFieldsAndValues(cleanedActivities, args.fields, workflow.fields)
+        : cleanedActivities;
+    const totalCount = metadata.totalCount || activities.length;
+    const currentPage = args?.page || 0;
+    const limit = args?.limit || 50;
+    const hasMorePages = activities.length === limit;
+    const totalPages = Math.ceil(totalCount / limit);
+    let responseText = `🎯 **FILTERED ACTIVITIES** in "${workflow.name}":\n\n`;
+    const filterCount = Object.keys(args.filters || {}).length;
+    responseText += `**Applied Filters:** ${filterCount} field filter(s)\n`;
+    for (const [fieldId, filter] of Object.entries(args.filters || {})) {
+        const filterConfig = filter;
+        responseText += `- Field \`${fieldId}\`: ${filterConfig.operator}`;
+        if (filterConfig.value !== undefined)
+            responseText += ` = "${filterConfig.value}"`;
+        if (filterConfig.start !== undefined)
+            responseText += ` from ${filterConfig.start} to ${filterConfig.end}`;
+        responseText += "\n";
+    }
+    if (args.search) {
+        responseText += `- Text search: "${args.search}"\n`;
+    }
+    responseText += `\n`;
+    responseText += `📊 **RESULTS:**\n`;
+    responseText += `- Total matching activities: ${totalCount}\n`;
+    responseText += `- Showing: ${activities.length} activities (page ${currentPage + 1} of ${totalPages})\n`;
+    responseText += `- Limit per page: ${limit}\n`;
+    if (hasMorePages) {
+        responseText += `- ⚠️  **MORE DATA AVAILABLE**: Use page=${currentPage + 1} to get next ${limit} activities\n`;
+    }
+    if (activities.length === 0) {
+        responseText += `\n❌ No activities match your filters.\n\n`;
+        responseText += `💡 **TROUBLESHOOTING:**\n`;
+        responseText += `- Try broader filter criteria\n`;
+        responseText += `- Remove some filters to see if data exists\n`;
+        responseText += `- Call get_workflow_schema to verify field IDs are correct\n`;
+        responseText += `- Use list_activities without filters to see all activities`;
+        return {
+            content: [{ type: "text", text: responseText }],
+        };
+    }
+    responseText += `\n` + (0, index_1.formatActivityListResponse)(filteredActivities, workflow, undefined);
+    responseText += `\n\n💡 **FILTER TIPS:**\n`;
+    responseText += `- Use 'equals' operator for exact matches (company IDs, relationship fields)\n`;
+    responseText += `- Use 'range' operator for date/number ranges (created/updated timestamps)\n`;
+    responseText += `- Use 'contains' or 'text_search' for partial text matching\n`;
+    responseText += `- Combine multiple filters for precise results\n`;
+    responseText += `- Call get_workflow_schema to discover available fields and their types`;
+    return {
+        content: [
+            {
+                type: "text",
+                text: responseText,
+            },
+        ],
+    };
+}
+/** Build activity update object */
+function buildActivityUpdate(args, context) {
+    let parsedFields = args.fields;
+    if (typeof args.fields === "string") {
+        try {
+            parsedFields = JSON.parse(args.fields);
+        }
+        catch (e) {
+            throw new Error(`Invalid fields JSON: ${args.fields}`);
+        }
+    }
+    if (parsedFields &&
+        typeof parsedFields === "object" &&
+        context.workspaceCache) {
+        const invalidUsers = [];
+        for (const [fieldId, fieldValue] of Object.entries(parsedFields)) {
+            if (typeof fieldValue === "string" &&
+                /^[a-f0-9]{24}$/i.test(fieldValue)) {
+                const user = (0, workspace_cache_1.getUserById)(context.workspaceCache, fieldValue);
+                if (!user) {
+                    invalidUsers.push(`${fieldId}: ${fieldValue}`);
+                }
+            }
+        }
+        if (invalidUsers.length > 0) {
+            throw new Error(`Invalid user IDs in fields: ${invalidUsers.join(", ")}. Use search_workspace_users to find valid user IDs.`);
+        }
+    }
+    return {
+        _id: args.activityId,
+        ...(args.name && { name: args.name }),
+        ...(parsedFields &&
+            typeof parsedFields === "object" && {
+            fields: parsedFields,
+        }),
+        ...(args.phaseId && { phaseId: args.phaseId }),
+    };
+}
+/**
+ * Format update activity response
+ */
+function formatUpdateActivityResponse(args, result) {
+    const changesText = [
+        args.name ? `- Name: "${args.name}"` : "",
+        args.fields ? `- Fields: ${JSON.stringify(args.fields, null, 2)}` : "",
+        args.phaseId ? `- Moved to phase: ${args.phaseId}` : "",
+    ]
+        .filter(Boolean)
+        .join("\n");
+    const responseText = `✅ Successfully updated activity ${args.activityId}!\n\n📝 Changes applied:\n${changesText}\n\n💡 The activity has been updated in your Hailer workspace.\n\nAPI Response:\n${JSON.stringify(result, null, 2)}`;
+    return {
+        content: [
+            {
+                type: "text",
+                text: responseText,
+            },
+        ],
+    };
+}
+exports.listActivitiesTool = {
+    name: 'list_activities',
+    group: tool_registry_1.ToolGroup.READ,
+    description: `📋 Retrieves list of activities for a specific workflow phase. ⚠️ CRITICAL: phaseId is MANDATORY string parameter, must match workflow's current phase. ✅ CORRECT: {"workflowId":"6756e099410306cab03a7dfb","phaseId":"specific_phase_identifier"} ❌ WRONG: {"workflowId":"6756e099410306cab03a7dfb"} (missing required phaseId)`,
+    schema: zod_1.z.object({
+        workflowId: zod_1.z.string().describe("Workflow ID to list activities from"),
+        phaseId: zod_1.z.string().describe("Phase ID to filter activities (required - use list_workflow_phases to get available phases)"),
+        fields: zod_1.z.preprocess((val) => {
+            if (typeof val === 'string') {
+                try {
+                    return JSON.parse(val);
+                }
+                catch {
+                    return val;
+                }
+            }
+            return val;
+        }, zod_1.z.array(zod_1.z.string()).optional()).describe("Array of field IDs to return (use get_workflow_schema to see available fields). Select the fields needed for the task - use fewer fields for listings (name, status, etc.) and more fields when detailed information is required. If not provided, you must call get_workflow_schema first."),
+        filters: zod_1.z.record(zod_1.z.object({
+            operator: zod_1.z.enum([
+                "text_search",
+                "equals",
+                "not_equals",
+                "contains",
+                "greater_than",
+                "greater_than_or_equal",
+                "less_than",
+                "less_than_or_equal",
+                "range",
+            ]).describe("Filter operator: text_search for partial text match in field (BEST for filtering by text in relationship fields when you only have a name), equals for exact match (requires activity ID), range for date/number ranges, contains for partial text, comparison operators for numbers/dates"),
+            value: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]).optional().describe("Value to filter by - REQUIRED for text_search, equals, not_equals, contains, greater_than, less_than operators. NOT USED for range operator (use start/end instead). For text_search: use the text/name to search for. For equals: use the entity ID."),
+            start: zod_1.z.coerce.number().optional().describe("Start value - ONLY for range operator (NOT in 'value' field). Unix timestamp in milliseconds for date ranges. Example: for June 2025 date range, use start=1717200000000 directly here, NOT nested in 'value'."),
+            end: zod_1.z.coerce.number().optional().describe("End value - ONLY for range operator (NOT in 'value' field). Unix timestamp in milliseconds for date ranges. Example: for June 2025 date range, use end=1719791999000 directly here, NOT nested in 'value'."),
+        })).optional().describe("Field-based filters - PREFERRED over search parameter for reliable results. Key is the field ID from get_workflow_schema. CRITICAL: For range operator, use 'start' and 'end' as direct properties, NOT nested inside 'value'. Example: {fieldId: {operator: 'range', start: 1717200000000, end: 1719791999000}}. BEST use cases: 1) Date ranges: use range operator with created/updated field IDs, 2) Company/site by NAME: use text_search operator, 3) Exact ID matches: use equals operator."),
+        search: zod_1.z.string().optional().describe("Text search across activity content - USE FILTERS INSTEAD when possible for reliable results. Only use search for truly exploratory queries."),
+        limit: zod_1.z.coerce.number().optional().default(50).describe("Maximum number of activities to return (default: 50, max: 20000)"),
+        page: zod_1.z.coerce.number().optional().default(0).describe("Page number for pagination (0-based)"),
+        sortBy: zod_1.z.enum(["name", "created", "updated", "priority"]).optional().default("updated").describe("Field to sort by"),
+        sortOrder: zod_1.z.enum(["asc", "desc"]).optional().default("desc").describe("Sort direction"),
+        includeStats: zod_1.z.coerce.boolean().optional().default(true).describe("Include total count and pagination metadata"),
+    }),
+    async execute(args, context) {
+        try {
+            const workflow = validateAndGetWorkflow(args.workflowId, context.init);
+            const phaseId = await resolvePhaseForListing(workflow, args, context.init);
+            if (!args.fields || args.fields.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `❌ **Fields parameter required**: You must specify which fields to return to avoid huge responses.\n\n` +
+                                `📋 **Next steps:**\n` +
+                                `1. Call \`get_workflow_schema\` with workflowId: "${args.workflowId}" and phaseId: "${phaseId}" to see available fields\n` +
+                                `2. Then call \`list_activities\` again with 2-3 essential field IDs\n\n` +
+                                `💡 **Best practices:**\n` +
+                                `- For product listings: ["name", "price", "stock"] (3 fields)\n` +
+                                `- For quick view: ["name", "status"] (2 fields)\n` +
+                                `- Only add description fields when user explicitly asks for details\n` +
+                                `- More fields = exponentially higher token costs\n\n` +
+                                `⚡ **Pro tip:** Use 'filters' parameter to narrow results instead of fetching everything\n\n` +
+                                `This optimization prevents responses with hundreds of thousands of tokens.`,
+                        },
+                    ],
+                };
+            }
+            let apiFilters = undefined;
+            let filterErrorMessage = undefined;
+            if (args.filters && Object.keys(args.filters).length > 0) {
+                logger.debug('🎯 Converting filters for list_activities', {
+                    filterCount: Object.keys(args.filters).length,
+                    filters: args.filters
+                });
+                const convertedResult = convertActivityFilters(args.filters);
+                apiFilters = convertedResult.V3ActivityListFilters;
+                filterErrorMessage = convertedResult.errorMessage;
+                if (filterErrorMessage) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `❌ **Filter Error:** ${filterErrorMessage}\n\n` +
+                                    `💡 **Valid operators:** equals, not_equals, contains, text_search, greater_than, less_than, range\n` +
+                                    `📋 Call \`get_workflow_schema\` to see available field IDs and types`,
+                            }
+                        ],
+                    };
+                }
+                logger.debug('✅ Filters converted successfully', {
+                    apiFiltersAndCount: apiFilters.and.length,
+                    apiFilters: JSON.stringify(apiFilters)
+                });
+            }
+            const options = {
+                page: args.page,
+                search: args.search,
+                sortBy: args.sortBy,
+                sortOrder: args.sortOrder,
+                filters: apiFilters,
+                includeStats: args.includeStats,
+                returnFlat: true,
+            };
+            logger.debug('📋 Calling list_activities', {
+                workflowId: args.workflowId,
+                phaseId,
+                hasFilters: !!apiFilters,
+                filterCount: apiFilters?.and?.length || 0,
+                hasSearch: !!args.search,
+            });
+            const activityData = await context.hailer.fetchActivityList(args.workflowId, phaseId, args.limit, options);
+            let response;
+            if (args.filters && Object.keys(args.filters).length > 0) {
+                response = formatFilteredActivityListResponse(activityData, workflow, context.init, args);
+            }
+            else {
+                response = formatActivityListResponseWithPagination(activityData, workflow, context.init, undefined, args);
+            }
+            return response;
+        }
+        catch (error) {
+            logger.error("Failed to list activities", error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ Failed to list activities: ${extractErrorMessage(error)}`,
+                    },
+                ],
+            };
+        }
+    },
+};
+exports.showActivityByIdTool = {
+    name: 'show_activity_by_id',
+    group: tool_registry_1.ToolGroup.READ,
+    description: `📄 Load specific activity by ID with full details`,
+    schema: zod_1.z.object({
+        activityId: zod_1.z.string().describe("Activity ID to load"),
+    }),
+    async execute(args, context) {
+        try {
+            const activity = await context.hailer.fetchActivityById(args.activityId);
+            let responseText = `✅ Loaded activity with ID "${activity._id}":\n\n${JSON.stringify(activity, null, 2)}`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            logger.error("Failed to load activity", error, {
+                activityId: args.activityId,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ Failed to load activity: ${extractErrorMessage(error)}`,
+                    },
+                ],
+            };
+        }
+    },
+};
+// ============================================================================
+// TOOL 3: CREATE ACTIVITY
+// ============================================================================
+const createActivityDescription = `Create one or multiple activities - Supports both single and bulk creation
+
+**BULK CREATION (3+ activities):**
+Use the 'activities' parameter to create multiple activities efficiently:
+- activities: [{ name, fields, phaseId }, { name, fields, phaseId }, ...]
+- All activities created in one API call
+- Much faster for creating 10, 50, or 100+ activities
+- Recommended for sample data generation and batch imports
+
+**SINGLE CREATION:**
+Use individual parameters (name, fields, phaseId) for creating one activity
+
+**IMPORTANT - Field Type Rules:**
+- textpredefinedoptions: MUST be a single STRING value (e.g., "Option1"), NOT an array
+- activitylink: MUST be a STRING (activity ID), NOT an array
+- users/teams: STRING user/team ID
+- numeric/date: NUMBER (timestamp for dates)
+- text/textarea: STRING
+
+**Field Keys vs Field IDs:**
+If workflow uses field 'key' (recommended), you can use readable names:
+- With keys: { "vendor": "activity-id", "priority": "High" }
+- Without keys: { "507f191e810c19729de860ea": "activity-id" }
+
+**Examples:**
+Single: { workflowId, name: "Customer Lead", fields: { customerName: "John" } }
+Bulk: { workflowId, activities: [{ name: "Lead 1", fields: {...} }, { name: "Lead 2", fields: {...} }] }`;
+exports.createActivityTool = {
+    name: 'create_activity',
+    group: tool_registry_1.ToolGroup.WRITE,
+    description: createActivityDescription,
+    schema: zod_1.z.object({
+        workflowId: zod_1.z
+            .string()
+            .min(24, "Workflow ID must be at least 24 characters")
+            .describe("The workflow/dataset ID where to create the activity/activities. Find this in any list_* tool results"),
+        // BULK CREATION (optional - takes precedence over single parameters)
+        activities: zod_1.z
+            .array(zod_1.z.object({
+            name: zod_1.z.string().min(1, "Activity name cannot be empty").describe("Activity name/title"),
+            fields: zod_1.z.union([zod_1.z.record(zod_1.z.any()), zod_1.z.string()]).optional().describe("Custom field values (field keys or IDs)"),
+            phaseId: zod_1.z.string().optional().describe("Phase ID for this activity"),
+            teamId: zod_1.z.string().optional().describe("Team ID for this activity"),
+            discussionId: zod_1.z.string().optional().describe("Link to existing discussion"),
+            followerIds: zod_1.z.union([zod_1.z.array(zod_1.z.string()), zod_1.z.string()]).optional().describe("User IDs to invite"),
+            fileIds: zod_1.z.union([zod_1.z.array(zod_1.z.string()), zod_1.z.string()]).optional().describe("File IDs to attach"),
+        }))
+            .optional()
+            .describe("BULK: Array of activities to create. Use this for creating 3+ activities efficiently. If provided, single activity parameters (name, fields) are ignored."),
+        // SINGLE CREATION (used when 'activities' is not provided)
+        name: zod_1.z
+            .string()
+            .min(1, "Activity name cannot be empty")
+            .optional()
+            .describe("SINGLE: The activity name/title (e.g. '🤖 AI Analysis Bot', 'Customer Research Task')"),
+        description: zod_1.z
+            .string()
+            .optional()
+            .describe("SINGLE: Optional detailed description"),
+        phaseId: zod_1.z
+            .string()
+            .optional()
+            .describe("SINGLE: Optional phase/category ID. If not specified, uses the default phase"),
+        teamId: zod_1.z
+            .string()
+            .optional()
+            .describe("SINGLE: Optional team ID for team-specific activities"),
+        fields: zod_1.z
+            .union([zod_1.z.record(zod_1.z.any()), zod_1.z.string()])
+            .optional()
+            .describe("SINGLE: Optional custom field values. IMPORTANT: activitylink values must be STRINGS (activity IDs), not arrays. Example: { 'vendor': 'activity-id-string' }"),
+        discussionId: zod_1.z
+            .string()
+            .optional()
+            .describe("SINGLE: Optional discussion ID to link to existing conversation"),
+        followerIds: zod_1.z
+            .union([zod_1.z.array(zod_1.z.string()), zod_1.z.string()])
+            .optional()
+            .describe("SINGLE: Optional array of user IDs to invite"),
+        fileIds: zod_1.z
+            .union([zod_1.z.array(zod_1.z.string()), zod_1.z.string()])
+            .optional()
+            .describe("SINGLE: Optional array of file IDs to attach"),
+    }),
+    async execute(args, context) {
+        try {
+            // Helper function to process a single activity object
+            const processActivity = (activityData) => {
+                const activity = {
+                    name: activityData.name,
+                };
+                if (activityData.fields) {
+                    let parsedFields = activityData.fields;
+                    if (typeof activityData.fields === "string" && activityData.fields.trim() !== "") {
+                        try {
+                            parsedFields = JSON.parse(activityData.fields);
+                        }
+                        catch (e) {
+                            throw new Error(`Invalid fields JSON: ${activityData.fields}`);
+                        }
+                    }
+                    if (parsedFields &&
+                        typeof parsedFields === "object" &&
+                        Object.keys(parsedFields).length > 0) {
+                        activity.fields = parsedFields;
+                    }
+                }
+                if (activityData.phaseId && activityData.phaseId.trim() !== "") {
+                    activity.phaseId = activityData.phaseId;
+                }
+                if (activityData.teamId && activityData.teamId.trim() !== "") {
+                    activity.teamId = activityData.teamId;
+                }
+                if (activityData.followerIds) {
+                    let parsedFollowerIds = activityData.followerIds;
+                    if (typeof activityData.followerIds === "string" &&
+                        activityData.followerIds.trim() !== "") {
+                        try {
+                            parsedFollowerIds = JSON.parse(activityData.followerIds);
+                        }
+                        catch (e) {
+                            throw new Error(`Invalid followerIds JSON: ${activityData.followerIds}`);
+                        }
+                    }
+                    if (Array.isArray(parsedFollowerIds) &&
+                        parsedFollowerIds.length > 0) {
+                        if (context.workspaceCache) {
+                            const invalidUsers = [];
+                            for (const userId of parsedFollowerIds) {
+                                const user = (0, workspace_cache_1.getUserById)(context.workspaceCache, userId);
+                                if (!user) {
+                                    invalidUsers.push(userId);
+                                }
+                            }
+                            if (invalidUsers.length > 0) {
+                                throw new Error(`Invalid user IDs in followerIds: ${invalidUsers.join(", ")}. Use search_workspace_users to find valid user IDs.`);
+                            }
+                        }
+                        activity.followerIds = parsedFollowerIds;
+                    }
+                }
+                if (activityData.fileIds) {
+                    let parsedFileIds = activityData.fileIds;
+                    if (typeof activityData.fileIds === "string" &&
+                        activityData.fileIds.trim() !== "") {
+                        try {
+                            parsedFileIds = JSON.parse(activityData.fileIds);
+                        }
+                        catch (e) {
+                            throw new Error(`Invalid fileIds JSON: ${activityData.fileIds}`);
+                        }
+                    }
+                    if (Array.isArray(parsedFileIds) && parsedFileIds.length > 0) {
+                        activity.fileIds = parsedFileIds;
+                    }
+                }
+                return activity;
+            };
+            // Determine if this is bulk or single creation
+            const isBulk = args.activities && Array.isArray(args.activities) && args.activities.length > 0;
+            // Get workflow's default team (owner team) if available
+            const rawWorkflow = context.init.processes.find((p) => p._id === args.workflowId);
+            const defaultTeamId = rawWorkflow?.team;
+            let activitiesToCreate;
+            let options = {
+                returnDocument: true,
+            };
+            if (isBulk) {
+                // BULK CREATION
+                logger.info(`Creating ${args.activities.length} activities in bulk`, {
+                    workflowId: args.workflowId,
+                    count: args.activities.length,
+                    defaultTeamId: defaultTeamId,
+                });
+                activitiesToCreate = args.activities.map((activityData) => {
+                    const activity = processActivity(activityData);
+                    // Use default team if no teamId provided
+                    if (!activity.teamId && defaultTeamId) {
+                        activity.teamId = defaultTeamId;
+                    }
+                    return activity;
+                });
+                // Check for common discussionId in bulk
+                if (args.discussionId && args.discussionId.trim() !== "") {
+                    options.discussionId = args.discussionId;
+                }
+            }
+            else {
+                // SINGLE CREATION
+                if (!args.name) {
+                    throw new Error("Either 'activities' array or 'name' parameter is required");
+                }
+                logger.info("Creating single activity", {
+                    workflowId: args.workflowId,
+                    name: args.name,
+                    defaultTeamId: defaultTeamId,
+                });
+                const activity = processActivity(args);
+                // Use default team if no teamId provided
+                if (!activity.teamId && defaultTeamId) {
+                    activity.teamId = defaultTeamId;
+                }
+                activitiesToCreate = [activity];
+                if (args.discussionId && args.discussionId.trim() !== "") {
+                    options.discussionId = args.discussionId;
+                }
+            }
+            // Call API
+            const result = await context.hailer.createActivities(args.workflowId, activitiesToCreate, options);
+            // Handle response
+            const createdActivities = Array.isArray(result) ? result : [result];
+            if (isBulk) {
+                // BULK RESPONSE
+                const workflowUrl = `https://app.hailer.com/#/processes/${args.workflowId}`;
+                const responseText = `🎉 Successfully created ${createdActivities.length} activities in workflow ${args.workflowId}!
+
+📊 **Bulk Creation Summary:**
+- **Total Created**: ${createdActivities.length} activities
+- **Workflow**: ${args.workflowId}
+- **Status**: All activities created successfully
+
+🔗 **View Workflow**: ${workflowUrl}
+
+📋 **Created Activities:**
+${createdActivities.slice(0, 10).map((act, idx) => `${idx + 1}. "${act.name}" (ID: ${act._id}, Phase: ${act.currentPhase})`).join('\n')}${createdActivities.length > 10 ? `\n... and ${createdActivities.length - 10} more` : ''}
+
+✅ All activities are now active and ready for use!`;
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: responseText,
+                        },
+                    ],
+                };
+            }
+            else {
+                // SINGLE RESPONSE
+                const createdActivity = createdActivities[0];
+                const activityId = createdActivity._id;
+                const discussionId = createdActivity.discussion;
+                const sequence = createdActivity.sequence;
+                const currentPhase = createdActivity.currentPhase;
+                const workspaceId = createdActivity.cid;
+                const activityUrl = `https://app.hailer.com/#/activities/${activityId}`;
+                const discussionUrl = `https://app.hailer.com/#/discussions/${discussionId}`;
+                const workflowUrl = `https://app.hailer.com/#/processes/${args.workflowId}`;
+                const responseText = `🎉 Successfully created activity "${args.name}" in workflow ${args.workflowId}!
+
+📋 **Activity Details:**
+- **ID**: ${activityId}
+- **Discussion**: ${discussionId}
+- **Sequence**: #${sequence}
+- **Current Phase**: ${currentPhase}
+- **Status**: Active and ready for use
+
+🔗 **Direct Links:**
+- **View Activity**: ${activityUrl}
+- **Open Discussion**: ${discussionUrl}
+- **View Workflow**: ${workflowUrl}
+
+💬 ${args.discussionId ? "Activity linked to existing discussion" : "New discussion created automatically"} for team collaboration.
+
+🔧 **Debug Info:**
+- **Workspace ID**: ${workspaceId}
+- **Final Phase**: ${currentPhase}`;
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: responseText,
+                        },
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            logger.error("Failed to create activity/activities", error, {
+                workflowId: args.workflowId,
+                isBulk: !!(args.activities && args.activities.length > 0),
+            });
+            const errorMessage = error instanceof Error
+                ? error.message
+                : (typeof error === 'object' && error !== null)
+                    ? JSON.stringify(error, null, 2)
+                    : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ Error creating activity: ${errorMessage}\n\n💡 Troubleshooting Tips:\n- Verify the workflowId exists and is accessible\n- Check that you have permission to create activities in this workflow\n- Ensure field IDs in the fields object match the workflow's field definitions\n- Use search_workspace_users to find valid user IDs for assignment\n- Verify user IDs in followerIds exist and are accessible`,
+                    },
+                ],
+            };
+        }
+    },
+};
+// ============================================================================
+// TOOL 4: UPDATE ACTIVITY
+// ============================================================================
+const updateActivityDescription = `Update one or multiple activities in any Hailer workflow
+
+**BULK UPDATE (3+ activities):**
+Use the 'activities' parameter to update multiple activities efficiently:
+- activities: [{ _id, name?, fields? }, { _id, name?, fields? }, ...]
+- All activities updated in one API call
+- Much faster for updating 10, 50, or 100+ activities
+- Recommended for batch operations and data migrations
+
+**SINGLE UPDATE:**
+Use individual parameters (_id or activityId, name, fields, phaseId) for updating one activity
+
+**IMPORTANT - ActivityLink Field Values:**
+When updating activitylink fields, use STRING values (the activity ID to link to), NOT arrays:
+- ✅ Correct: { "vendorField": "507f1f77bcf86cd799439011" }
+- ❌ Wrong: { "vendorField": ["507f1f77bcf86cd799439011"] }
+
+**Field Keys vs Field IDs:**
+If workflow uses field 'key' (recommended), you can use readable names:
+- With keys: { "vendor": "new-activity-id", "priority": "High" }
+- Without keys: { "507f191e810c19729de860ea": "new-activity-id" }
+
+**Examples:**
+Single: update_activity({ activityId: "xxx", fields: { status: "Active" } })
+Bulk: update_activity({ activities: [{ _id: "xxx", fields: { status: "Active" } }, { _id: "yyy", fields: { status: "Inactive" } }] })`;
+exports.updateActivityTool = {
+    name: 'update_activity',
+    group: tool_registry_1.ToolGroup.WRITE,
+    description: updateActivityDescription,
+    schema: zod_1.z.object({
+        // BULK: Array of activities to update
+        activities: zod_1.z
+            .preprocess((val) => (typeof val === "string" ? JSON.parse(val) : val), zod_1.z
+            .array(zod_1.z.object({
+            _id: zod_1.z.string().min(24, "Activity ID must be at least 24 characters"),
+            name: zod_1.z.string().optional(),
+            fields: zod_1.z.record(zod_1.z.any()).optional(),
+            phaseId: zod_1.z.string().optional(),
+        }))
+            .min(1))
+            .optional()
+            .describe("BULK: Array of activities to update. Use this for updating 3+ activities efficiently. If provided, single activity parameters (activityId, name, fields) are ignored."),
+        // SINGLE: Individual activity parameters
+        activityId: zod_1.z
+            .string()
+            .min(24, "Activity ID must be at least 24 characters")
+            .optional()
+            .describe("SINGLE: The unique ID of the activity to update (works for any workflow)"),
+        name: zod_1.z.string().optional().describe("SINGLE: New activity title/name"),
+        fields: zod_1.z
+            .union([zod_1.z.record(zod_1.z.any()), zod_1.z.string()])
+            .optional()
+            .describe("SINGLE: Updated field values as key-value pairs. IMPORTANT: activitylink values must be STRINGS (activity IDs), not arrays. Example: { 'vendor': 'activity-id-string', 'priority': 'High' }. Can be object or JSON string"),
+        phaseId: zod_1.z
+            .string()
+            .optional()
+            .describe("SINGLE: Optional phase ID to move the activity to"),
+    }),
+    async execute(args, context) {
+        try {
+            // BULK MODE: Update multiple activities
+            if (args.activities && Array.isArray(args.activities)) {
+                logger.debug("Bulk update mode", { activityCount: args.activities.length });
+                // Build updates for each activity
+                const updates = args.activities.map((activity) => {
+                    const activityUpdate = { _id: activity._id };
+                    if (activity.name)
+                        activityUpdate.name = activity.name;
+                    if (activity.fields) {
+                        // Parse fields if string
+                        const parsedFields = typeof activity.fields === 'string'
+                            ? JSON.parse(activity.fields)
+                            : activity.fields;
+                        activityUpdate.fields = parsedFields;
+                    }
+                    return activityUpdate;
+                });
+                // Collect unique phase IDs (most activities will have the same phase)
+                const phaseIds = args.activities
+                    .map((a) => a.phaseId)
+                    .filter((p) => p);
+                const commonPhaseId = phaseIds.length > 0 ? phaseIds[0] : undefined;
+                // Call API with all updates
+                const options = commonPhaseId ? { phaseId: commonPhaseId } : undefined;
+                const result = await context.hailer.updateActivities(updates, options);
+                // Format bulk response
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `🎉 Successfully updated ${args.activities.length} activities!\n\n📊 **Bulk Update Summary:**\n- **Total Updated**: ${args.activities.length} activities\n- **Status**: All activities updated successfully\n\n✅ All activities have been updated in your Hailer workspace!`,
+                        },
+                    ],
+                };
+            }
+            // SINGLE MODE: Update one activity
+            const updates = buildActivityUpdate(args, context);
+            const options = args.phaseId ? { phaseId: args.phaseId } : undefined;
+            const result = await context.hailer.updateActivities([updates], options);
+            return formatUpdateActivityResponse(args, result);
+        }
+        catch (error) {
+            logger.error("Failed to update activity", error, {
+                activityId: args.activityId || 'bulk',
+                activityCount: args.activities?.length,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ Error updating ${args.activities ? 'activities' : 'activity'}: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    },
+};
+//# sourceMappingURL=activity.js.map