@hailer/mcp 1.2.0 → 1.3.9

package/dist/mcp/tools/document.js

@@ -1,741 +0,0 @@
-"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