@hailer/mcp 1.0.28 → 1.1.2

package/dist/mcp/tools/document.js

@@ -0,0 +1,741 @@
+"use strict";
+/**
+ * Document Tools - PDF/CSV Generation
+ *
+ * Tools for generating documents from templates:
+ * - List document templates (READ)
+ * - Generate PDF documents from activities (WRITE)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDocumentTool = exports.listDocumentTemplatesTool = void 0;
+const zod_1 = require("zod");
+const tool_registry_1 = require("../tool-registry");
+const index_1 = require("../utils/index");
+const request_logger_1 = require("../../lib/request-logger");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const logger = (0, index_1.createLogger)({ component: 'document-tools' });
+// Helper: 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);
+        if ('error' in error) {
+            const e = error.error;
+            return typeof e === 'string' ? e : JSON.stringify(e);
+        }
+        try {
+            return JSON.stringify(error);
+        }
+        catch {
+            return '[Complex error object]';
+        }
+    }
+    return String(error);
+}
+function convertFiltersToApiFormat(mcpFilters) {
+    const apiFilters = { and: [] };
+    for (const [fieldId, filter] of Object.entries(mcpFilters)) {
+        switch (filter.operator) {
+            case 'text_search':
+                if (filter.value !== undefined) {
+                    apiFilters.and.push({ [fieldId]: { textSearch: filter.value } });
+                }
+                break;
+            case 'equals':
+                if (filter.value !== undefined) {
+                    apiFilters.and.push({ [fieldId]: { equalTo: filter.value } });
+                }
+                break;
+            case 'not_equals':
+                if (filter.value !== undefined) {
+                    apiFilters.and.push({ [fieldId]: { notEqualTo: filter.value } });
+                }
+                break;
+            case 'contains':
+                if (filter.value !== undefined) {
+                    apiFilters.and.push({ [fieldId]: { contains: filter.value } });
+                }
+                break;
+            case 'greater_than':
+                if (filter.value !== undefined && typeof filter.value === 'number') {
+                    apiFilters.and.push({ [fieldId]: { greaterThan: filter.value } });
+                }
+                break;
+            case 'less_than':
+                if (filter.value !== undefined && typeof filter.value === 'number') {
+                    apiFilters.and.push({ [fieldId]: { lessThan: filter.value } });
+                }
+                break;
+            case 'range':
+                if (filter.start !== undefined && filter.end !== undefined) {
+                    apiFilters.and.push({ [fieldId]: { between: [String(filter.start), String(filter.end)] } });
+                }
+                break;
+            default:
+                // Unknown operator, try text_search as fallback
+                if (filter.value !== undefined) {
+                    apiFilters.and.push({ [fieldId]: { textSearch: filter.value } });
+                }
+        }
+    }
+    return apiFilters;
+}
+// Helper: delay for rate limiting and retry backoff
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+// Retry configuration
+const RETRY_CONFIG = {
+    maxRetries: 3,
+    baseDelayMs: 1000, // 1 second base delay
+    batchDelayMs: 500, // 500ms between batches
+    retryableCodes: [502, 503, 504, 429] // Gateway errors and rate limits
+};
+// ============================================================================
+// TOOL 1: LIST DOCUMENT TEMPLATES
+// ============================================================================
+const listDocumentTemplatesDescription = `List available document templates for PDF/CSV generation
+
+**Returns**: Template IDs, names, types, and associated workflow IDs
+
+**Example**:
+\`\`\`javascript
+list_document_templates({ workflowId: "691ffdf84217e9e8434e5694" })
+\`\`\``;
+exports.listDocumentTemplatesTool = {
+    name: 'list_document_templates',
+    group: tool_registry_1.ToolGroup.READ,
+    description: listDocumentTemplatesDescription,
+    schema: zod_1.z.object({
+        workflowId: zod_1.z
+            .string()
+            .optional()
+            .describe("Optional workflow ID to filter templates for a specific workflow")
+    }),
+    async execute(args, context) {
+        logger.debug('Listing document templates', {
+            workflowId: args.workflowId,
+            apiKey: context.apiKey.substring(0, 8) + '...'
+        });
+        try {
+            const rawInit = context.init;
+            let templates = [];
+            // Method 1: Check workspace-level templates
+            if (rawInit.templates) {
+                const workspaceTemplates = Array.isArray(rawInit.templates)
+                    ? rawInit.templates
+                    : Object.values(rawInit.templates);
+                templates.push(...workspaceTemplates);
+            }
+            if (rawInit.documentTemplates) {
+                const docTemplates = Array.isArray(rawInit.documentTemplates)
+                    ? rawInit.documentTemplates
+                    : Object.values(rawInit.documentTemplates);
+                templates.push(...docTemplates);
+            }
+            // Method 2: Check per-workflow templates (in processes)
+            if (rawInit.processes) {
+                const processes = Array.isArray(rawInit.processes)
+                    ? rawInit.processes
+                    : Object.values(rawInit.processes);
+                for (const process of processes) {
+                    // Check templates in process
+                    if (process.templates) {
+                        const procTemplates = Array.isArray(process.templates)
+                            ? process.templates
+                            : Object.values(process.templates);
+                        // Add workflowId to each template
+                        for (const t of procTemplates) {
+                            templates.push({ ...t, workflowId: process._id, workflowName: process.name });
+                        }
+                    }
+                    // Check documentTemplates in process
+                    if (process.documentTemplates) {
+                        const procDocTemplates = Array.isArray(process.documentTemplates)
+                            ? process.documentTemplates
+                            : Object.values(process.documentTemplates);
+                        for (const t of procDocTemplates) {
+                            templates.push({ ...t, workflowId: process._id, workflowName: process.name });
+                        }
+                    }
+                    // Check printTemplates in process
+                    if (process.printTemplates) {
+                        const printTemplates = Array.isArray(process.printTemplates)
+                            ? process.printTemplates
+                            : Object.values(process.printTemplates);
+                        for (const t of printTemplates) {
+                            templates.push({ ...t, workflowId: process._id, workflowName: process.name });
+                        }
+                    }
+                }
+            }
+            // Method 3: Try dedicated API call if no templates found
+            if (templates.length === 0) {
+                try {
+                    // Try v3.template.list or similar
+                    const apiTemplates = await context.hailer.request('v3.documentTemplate.list', []);
+                    if (Array.isArray(apiTemplates)) {
+                        templates.push(...apiTemplates);
+                    }
+                    else if (apiTemplates?.templates) {
+                        templates.push(...apiTemplates.templates);
+                    }
+                }
+                catch (apiError) {
+                    logger.debug('v3.documentTemplate.list not available', { error: apiError });
+                }
+            }
+            logger.debug('Template discovery results', {
+                initKeys: Object.keys(rawInit),
+                processCount: rawInit.processes ? Object.keys(rawInit.processes).length : 0,
+                templatesFound: templates.length
+            });
+            // Filter by workflow if provided
+            if (args.workflowId) {
+                templates = templates.filter((t) => t.workflowId === args.workflowId ||
+                    t.processId === args.workflowId ||
+                    t.pid === args.workflowId);
+            }
+            if (templates.length === 0) {
+                // Return diagnostic info to help debug
+                const processInfo = rawInit.processes
+                    ? Object.entries(rawInit.processes).slice(0, 3).map(([id, p]) => ({
+                        id,
+                        name: p.name,
+                        hasTemplates: !!p.templates,
+                        hasDocumentTemplates: !!p.documentTemplates,
+                        hasPrintTemplates: !!p.printTemplates,
+                        keys: Object.keys(p).filter(k => k.toLowerCase().includes('template'))
+                    }))
+                    : [];
+                return {
+                    content: [{
+                            type: "text",
+                            text: `📄 No document templates found${args.workflowId ? ` for workflow ${args.workflowId}` : ''}.\n\n` +
+                                `**Init data keys**: ${Object.keys(rawInit).join(', ')}\n\n` +
+                                `**Process sample** (first 3):\n${JSON.stringify(processInfo, null, 2)}\n\n` +
+                                `💡 Document templates may need to be created in Hailer UI first.`
+                        }]
+                };
+            }
+            let responseText = `📄 **Document Templates** (${templates.length} total):\n\n`;
+            templates.forEach((template, index) => {
+                // Get template ID from various possible fields
+                const templateId = template._id || template.id || template.templateId || template.key || Object.keys(template)[0];
+                const templateName = template.name || template.label || template.title || 'Untitled';
+                responseText += `${index + 1}. **${templateName}**\n`;
+                responseText += `   - Template ID: \`${templateId}\`\n`;
+                if (template.type)
+                    responseText += `   - Type: ${template.type}\n`;
+                if (template.workflowId || template.processId) {
+                    responseText += `   - Workflow: ${template.workflowName || ''} (\`${template.workflowId || template.processId}\`)\n`;
+                }
+                responseText += `\n`;
+            });
+            responseText += `\n💡 **Usage**: Use \`generate_document\` with a template ID and activity IDs to create PDF documents.`;
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText
+                    }]
+            };
+        }
+        catch (error) {
+            if (!request_logger_1.RequestLogger.getCurrent())
+                logger.error("Failed to list document templates", error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `❌ Failed to list document templates: ${error instanceof Error ? error.message : String(error)}\n\n` +
+                            `💡 Document templates may not be available in this workspace.`
+                    }]
+            };
+        }
+    }
+};
+// ============================================================================
+// TOOL 2: GENERATE DOCUMENT
+// ============================================================================
+const generateDocumentDescription = `Generate PDF document from template and activities, upload to Hailer
+
+**Two modes:**
+1. **Direct IDs**: Pass \`activityIds\` array directly
+2. **Filter-based**: Pass \`workflowId\` + optional filters (fetches IDs internally - saves context!)
+
+**Auto-batching**: For large activity lists (>50), automatically splits into batches to avoid timeouts.
+
+**Parameters**:
+- \`templateId\`: Document template ID (from list_document_templates)
+- \`activityIds\`: Array of activity IDs (OR use workflowId + filters)
+- \`workflowId\`: Workflow to fetch activities from (alternative to activityIds)
+- \`phaseId\`: Optional phase filter (used with workflowId)
+- \`filters\`: Optional field filters, same format as list_activities
+- \`limit\`: Max activities to process (default: 1000)
+- \`discussionId\`: Optional - post PDF(s) to this discussion
+- \`batchSize\`: Optional - activities per PDF (default: 50)
+
+**Example with filters (recommended for large datasets):**
+\`\`\`javascript
+generate_document({
+  templateId: "abc123",
+  workflowId: "workflow-id",
+  phaseId: "phase-id",
+  filters: { "fieldId": { "operator": "equals", "value": "Defender" }},
+  discussionId: "discussion-id"
+})
+\`\`\`
+
+**Example with direct IDs:**
+\`\`\`javascript
+generate_document({
+  templateId: "abc123",
+  activityIds: ["id1", "id2"],
+  discussionId: "discussion-id"
+})
+\`\`\``;
+exports.generateDocumentTool = {
+    name: 'generate_document',
+    group: tool_registry_1.ToolGroup.WRITE,
+    description: generateDocumentDescription,
+    schema: zod_1.z.object({
+        templateId: zod_1.z
+            .string()
+            .min(1, "Template ID is required")
+            .describe("Document template ID (use list_document_templates to find available templates)"),
+        // Option 1: Direct activity IDs
+        activityIds: zod_1.z
+            .preprocess((val) => {
+            if (typeof val === 'string') {
+                try {
+                    return JSON.parse(val);
+                }
+                catch {
+                    return val.split(',').map(id => id.trim()).filter(Boolean);
+                }
+            }
+            return val;
+        }, zod_1.z.array(zod_1.z.string()))
+            .optional()
+            .describe("Array of activity IDs (OR use workflowId + filters instead)"),
+        // Option 2: Filter-based (fetches IDs internally)
+        workflowId: zod_1.z
+            .string()
+            .optional()
+            .describe("Workflow ID to fetch activities from (alternative to activityIds)"),
+        phaseId: zod_1.z
+            .string()
+            .optional()
+            .describe("Optional phase ID filter (used with workflowId)"),
+        filters: zod_1.z
+            .any()
+            .optional()
+            .describe("Field filters, same format as list_activities: { fieldId: { operator, value }}"),
+        limit: zod_1.z
+            .number()
+            .optional()
+            .default(1000)
+            .describe("Max activities to fetch when using workflowId (default: 1000)"),
+        // Common options
+        discussionId: zod_1.z
+            .string()
+            .optional()
+            .describe("Optional discussion ID - if provided, the PDF(s) will be posted to this discussion"),
+        timeZone: zod_1.z
+            .string()
+            .optional()
+            .default("Europe/Helsinki")
+            .describe("Timezone for date formatting in document (default: Europe/Helsinki)"),
+        batchSize: zod_1.z
+            .number()
+            .optional()
+            .default(50)
+            .describe("Activities per PDF batch (default: 50). Large lists are auto-batched to avoid timeouts.")
+    }),
+    async execute(args, context) {
+        const batchSize = args.batchSize || 50;
+        const limit = args.limit || 1000;
+        let activityIds = args.activityIds || [];
+        // Validate: need either activityIds or workflowId
+        if (activityIds.length === 0 && !args.workflowId) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `❌ Missing required parameter: provide either \`activityIds\` or \`workflowId\`.\n\n` +
+                            `**Option 1 - Direct IDs:**\n` +
+                            `\`\`\`json\n{ "templateId": "...", "activityIds": ["id1", "id2"] }\n\`\`\`\n\n` +
+                            `**Option 2 - Filter-based (recommended for large datasets):**\n` +
+                            `\`\`\`json\n{ "templateId": "...", "workflowId": "...", "phaseId": "...", "filters": {...} }\n\`\`\``
+                    }]
+            };
+        }
+        // If workflowId provided, fetch activity IDs internally
+        if (args.workflowId && activityIds.length === 0) {
+            logger.debug('Fetching activities via filters', {
+                workflowId: args.workflowId,
+                phaseId: args.phaseId,
+                hasFilters: !!args.filters,
+                limit
+            });
+            try {
+                // Get phases if phaseId not provided - we need at least one phase
+                let phaseIds = [];
+                if (args.phaseId) {
+                    phaseIds = [args.phaseId];
+                }
+                else {
+                    // Get all phases for this workflow
+                    const workflow = context.init.processes.find((p) => p._id === args.workflowId);
+                    if (workflow?.phases) {
+                        phaseIds = Object.keys(workflow.phases);
+                    }
+                    if (phaseIds.length === 0) {
+                        throw new Error(`No phases found for workflow ${args.workflowId}`);
+                    }
+                }
+                // Convert filters to API format if provided
+                let apiFilters;
+                if (args.filters && typeof args.filters === 'object') {
+                    apiFilters = convertFiltersToApiFormat(args.filters);
+                    logger.debug('Converted filters to API format', {
+                        original: args.filters,
+                        converted: apiFilters
+                    });
+                }
+                // Fetch activities from each phase with pagination
+                const allIds = [];
+                const PAGE_SIZE = 200; // Fetch in pages of 200
+                for (const phaseId of phaseIds) {
+                    if (allIds.length >= limit)
+                        break;
+                    let page = 0;
+                    let hasMore = true;
+                    // Paginate through all results for this phase
+                    while (hasMore && allIds.length < limit) {
+                        const remaining = limit - allIds.length;
+                        const result = await context.hailer.fetchActivityList(args.workflowId, phaseId, Math.min(remaining, PAGE_SIZE), {
+                            page,
+                            filters: apiFilters,
+                            returnFlat: true,
+                            includeStats: true
+                            // Don't pass fields - API returns _id by default
+                        });
+                        // Extract IDs from result
+                        const activities = result?.activities || result?.list || result?.data || [];
+                        const metadata = result?.metadata || {};
+                        for (const activity of activities) {
+                            if (allIds.length >= limit)
+                                break;
+                            if (activity._id) {
+                                allIds.push(activity._id);
+                            }
+                        }
+                        logger.debug(`Fetched page ${page + 1} from phase ${phaseId}`, {
+                            phaseId,
+                            page: page + 1,
+                            fetched: activities.length,
+                            totalInPhase: metadata.totalCount,
+                            totalSoFar: allIds.length
+                        });
+                        // Check if there are more pages
+                        const totalInPhase = metadata.totalCount || 0;
+                        const fetchedSoFarInPhase = (page + 1) * PAGE_SIZE;
+                        hasMore = activities.length === PAGE_SIZE && fetchedSoFarInPhase < totalInPhase;
+                        page++;
+                        // Safety: max 50 pages (10,000 activities per phase)
+                        if (page >= 50) {
+                            logger.warn('Hit pagination safety limit', { phaseId, page });
+                            break;
+                        }
+                    }
+                }
+                activityIds = allIds;
+                if (activityIds.length === 0) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `📄 No activities found matching the filters.\n\n` +
+                                    `**Workflow:** ${args.workflowId}\n` +
+                                    `**Phase:** ${args.phaseId || 'all phases'}\n` +
+                                    `**Filters:** ${args.filters ? JSON.stringify(args.filters) : 'none'}\n\n` +
+                                    `💡 Try adjusting your filters or check that activities exist in this workflow.`
+                            }]
+                    };
+                }
+                logger.debug('Activity IDs fetched via filters', {
+                    count: activityIds.length,
+                    limit,
+                    phaseCount: phaseIds.length
+                });
+            }
+            catch (fetchError) {
+                const errorMsg = extractErrorMessage(fetchError);
+                logger.error('Failed to fetch activities via filters', { error: errorMsg });
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ Failed to fetch activities: ${errorMsg}\n\n` +
+                                `**Workflow:** ${args.workflowId}\n` +
+                                `**Phase:** ${args.phaseId || 'all phases'}\n` +
+                                `**Filters:** ${args.filters ? JSON.stringify(args.filters) : 'none'}\n\n` +
+                                `💡 Check that:\n` +
+                                `- Workflow and phase IDs are correct\n` +
+                                `- Filter field IDs exist in the workflow\n` +
+                                `- Filter format is correct: { "fieldId": { "operator": "text_search", "value": "..." }}`
+                        }]
+                };
+            }
+        }
+        const totalActivities = activityIds.length;
+        logger.debug('Generating document', {
+            templateId: args.templateId,
+            activityCount: totalActivities,
+            batchSize,
+            batchCount: Math.ceil(totalActivities / batchSize),
+            hasDiscussionId: !!args.discussionId,
+            timeZone: args.timeZone,
+            mode: args.workflowId ? 'filter-based' : 'direct-ids'
+        });
+        try {
+            // Split activities into batches
+            const batches = [];
+            for (let i = 0; i < activityIds.length; i += batchSize) {
+                batches.push(activityIds.slice(i, i + batchSize));
+            }
+            const results = [];
+            const errors = [];
+            // Process each batch with retry logic and delays
+            for (let batchNum = 0; batchNum < batches.length; batchNum++) {
+                const batch = batches[batchNum];
+                // Add delay between batches (except first one)
+                if (batchNum > 0) {
+                    await delay(RETRY_CONFIG.batchDelayMs);
+                }
+                logger.debug(`Processing batch ${batchNum + 1}/${batches.length}`, {
+                    batchNum: batchNum + 1,
+                    activityCount: batch.length
+                });
+                let lastError = '';
+                let success = false;
+                // Retry loop for this batch
+                for (let attempt = 0; attempt < RETRY_CONFIG.maxRetries && !success; attempt++) {
+                    if (attempt > 0) {
+                        // Exponential backoff: 1s, 2s, 4s
+                        const backoffMs = RETRY_CONFIG.baseDelayMs * Math.pow(2, attempt - 1);
+                        logger.debug(`Retry attempt ${attempt + 1} for batch ${batchNum + 1} after ${backoffMs}ms`);
+                        await delay(backoffMs);
+                    }
+                    try {
+                        // Build templateMap for this batch
+                        const templateMap = { [args.templateId]: batch };
+                        const requestBody = {
+                            templateMap,
+                            timeZone: args.timeZone || "Europe/Helsinki",
+                            save: 0
+                        };
+                        // Call REST API to generate PDF (binary response)
+                        const pdfBuffer = await context.hailer.callRest({
+                            operation: 'generate_document',
+                            endpoint: '/documentgenerator',
+                            method: 'POST',
+                            body: requestBody,
+                            timeout: 120000, // 2 minutes per batch
+                            responseType: 'binary'
+                        });
+                        // Convert buffer to Buffer instance if needed
+                        let buffer;
+                        if (typeof pdfBuffer === 'string') {
+                            buffer = Buffer.from(pdfBuffer, 'base64');
+                        }
+                        else if (Buffer.isBuffer(pdfBuffer)) {
+                            buffer = pdfBuffer;
+                        }
+                        else if (pdfBuffer instanceof ArrayBuffer) {
+                            buffer = Buffer.from(pdfBuffer);
+                        }
+                        else {
+                            throw new Error('Unexpected PDF response format');
+                        }
+                        // Save to temporary file
+                        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                        const filename = batches.length > 1
+                            ? `document-batch${batchNum + 1}-${timestamp}.pdf`
+                            : `document-${timestamp}.pdf`;
+                        const tempDir = os.tmpdir();
+                        const tempPath = path.join(tempDir, filename);
+                        fs.writeFileSync(tempPath, buffer);
+                        // Upload PDF to Hailer (also with retry for upload failures)
+                        let uploadResult;
+                        for (let uploadAttempt = 0; uploadAttempt < RETRY_CONFIG.maxRetries; uploadAttempt++) {
+                            if (uploadAttempt > 0) {
+                                const backoffMs = RETRY_CONFIG.baseDelayMs * Math.pow(2, uploadAttempt - 1);
+                                logger.debug(`Retry upload attempt ${uploadAttempt + 1} after ${backoffMs}ms`);
+                                await delay(backoffMs);
+                            }
+                            uploadResult = await context.hailer.uploadFile({
+                                path: tempPath,
+                                filename
+                            });
+                            if (uploadResult.success)
+                                break;
+                            // Check if error is retryable
+                            const isRetryable = RETRY_CONFIG.retryableCodes.some(code => uploadResult.error?.includes(String(code)));
+                            if (!isRetryable)
+                                break;
+                        }
+                        // Clean up temp file
+                        try {
+                            fs.unlinkSync(tempPath);
+                        }
+                        catch { /* ignore */ }
+                        if (!uploadResult.success) {
+                            throw new Error(`PDF upload failed: ${uploadResult.error}`);
+                        }
+                        results.push({
+                            fileId: uploadResult.fileId || '',
+                            sizeKB: uploadResult.sizeKB || '',
+                            activityCount: batch.length,
+                            batchNum: batchNum + 1
+                        });
+                        logger.debug(`Batch ${batchNum + 1} complete`, {
+                            fileId: uploadResult.fileId,
+                            sizeKB: uploadResult.sizeKB,
+                            attempts: attempt + 1
+                        });
+                        success = true;
+                    }
+                    catch (batchError) {
+                        lastError = batchError instanceof Error ? batchError.message : String(batchError);
+                        // Check if error is retryable (502, 503, 504, 429)
+                        const isRetryable = RETRY_CONFIG.retryableCodes.some(code => lastError.includes(String(code)));
+                        if (!isRetryable) {
+                            logger.debug(`Non-retryable error for batch ${batchNum + 1}: ${lastError}`);
+                            break; // Don't retry non-retryable errors
+                        }
+                        logger.debug(`Retryable error for batch ${batchNum + 1} (attempt ${attempt + 1}): ${lastError}`);
+                    }
+                }
+                if (!success) {
+                    errors.push({ batchNum: batchNum + 1, error: lastError });
+                    logger.error(`Batch ${batchNum + 1} failed after ${RETRY_CONFIG.maxRetries} attempts`, { error: lastError });
+                }
+            }
+            // Check if all batches failed
+            if (results.length === 0) {
+                throw new Error(`All ${batches.length} batches failed. First error: ${errors[0]?.error || 'Unknown'}`);
+            }
+            // Post to discussion if requested
+            if (args.discussionId && results.length > 0) {
+                const fileIds = results.map(r => r.fileId);
+                const message = batches.length > 1
+                    ? `📄 Generated ${results.length} PDFs from ${totalActivities} activities (${batches.length} batches)`
+                    : `📄 Generated document from ${totalActivities} ${totalActivities === 1 ? 'activity' : 'activities'}`;
+                await context.hailer.sendDiscussionMessage(args.discussionId, message, fileIds);
+                logger.debug('Posted PDFs to discussion', {
+                    discussionId: args.discussionId,
+                    fileCount: fileIds.length
+                });
+            }
+            // Build response
+            const totalSizeKB = results.reduce((sum, r) => sum + parseFloat(r.sizeKB || '0'), 0).toFixed(2);
+            if (batches.length === 1) {
+                // Single batch response
+                const r = results[0];
+                let responseText = `✅ **Document generated successfully!**\n\n` +
+                    `📄 **File Details:**\n` +
+                    `- File ID: \`${r.fileId}\`\n` +
+                    `- Size: ${r.sizeKB} KB\n` +
+                    `- Activities: ${totalActivities}\n`;
+                if (args.discussionId) {
+                    responseText += `\n💬 **Posted to discussion**: ${args.discussionId}`;
+                }
+                else {
+                    responseText += `\n💡 **Next Steps:**\n` +
+                        `- Download: \`download_file({ fileId: "${r.fileId}" })\`\n` +
+                        `- Post to discussion: \`add_discussion_message({ discussionId: "...", fileIds: ["${r.fileId}"] })\``;
+                }
+                return { content: [{ type: "text", text: responseText }] };
+            }
+            // Multi-batch response
+            let responseText = `✅ **Documents generated successfully!**\n\n` +
+                `📊 **Summary:**\n` +
+                `- Total activities: ${totalActivities}\n` +
+                `- Batches: ${batches.length} (${batchSize} per batch)\n` +
+                `- PDFs generated: ${results.length}\n` +
+                `- Total size: ${totalSizeKB} KB\n`;
+            if (errors.length > 0) {
+                responseText += `- Failed batches: ${errors.length}\n`;
+            }
+            responseText += `\n📄 **Generated Files:**\n`;
+            results.forEach(r => {
+                responseText += `- Batch ${r.batchNum}: \`${r.fileId}\` (${r.activityCount} activities, ${r.sizeKB} KB)\n`;
+            });
+            if (errors.length > 0) {
+                responseText += `\n⚠️ **Failed Batches:**\n`;
+                errors.forEach(e => {
+                    responseText += `- Batch ${e.batchNum}: ${e.error}\n`;
+                });
+            }
+            if (args.discussionId) {
+                responseText += `\n💬 **Posted to discussion**: ${args.discussionId}`;
+            }
+            return { content: [{ type: "text", text: responseText }] };
+        }
+        catch (error) {
+            if (!request_logger_1.RequestLogger.getCurrent())
+                logger.error("Failed to generate document", error);
+            const errorMessage = error instanceof Error
+                ? error.message
+                : (typeof error === 'object' && error !== null)
+                    ? JSON.stringify(error, null, 2)
+                    : String(error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `❌ Document generation failed: ${errorMessage}\n\n` +
+                            `💡 **Troubleshooting:**\n` +
+                            `- Verify the template ID is correct (use list_document_templates)\n` +
+                            `- Ensure all activity IDs are valid and accessible\n` +
+                            `- For large batches, try reducing batchSize\n` +
+                            `- Check that the template is compatible with the provided activities`
+                    }]
+            };
+        }
+    }
+};
+//# sourceMappingURL=document.js.map