autoform-mcp-server 1.6.0 → 1.7.0

package/README.md

@@ -38,13 +38,14 @@ Config file location:
 - **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
 - **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
 
-## Tools (9)
+## Tools (11)
 
 ### PDF Analysis
 | Tool | Description |
 |------|-------------|
 | `autoform_get_pdf_info` | Get page count and dimensions of a PDF |
 | `autoform_detect_fields` | Detect AcroForm fields in interactive PDFs |
+| `autoform_analyze_static_pdf` | Classify PDF type and suggest field positions for static PDFs |
 
 ### Fill Single PDF
 | Tool | Description |
@@ -55,6 +56,7 @@ Config file location:
 ### Batch Generation
 | Tool | Description |
 |------|-------------|
+| `autoform_fill_batch_acroform` | Generate multiple PDFs from an AcroForm PDF + data array |
 | `autoform_fill_batch_at_coordinates` | Generate multiple PDFs from one template + data, using coordinates |
 | `autoform_generate_batch` | Generate multiple PDFs using a saved template + data array |
 
@@ -65,6 +67,20 @@ Config file location:
 | `autoform_import_template` | Import a template JSON exported from the AutoForm web app |
 | `autoform_list_templates` | List all saved templates |
 
+### Experimental Parameters (v1.7.0+)
+
+All tools accept optional `_session_id` and `_mode` parameters for experimental instrumentation:
+
+- `_session_id`: Groups related tool calls in `metrics.jsonl` (format: `<pdf_id>_<mode>_<rep>`)
+- `_mode`: Labels the autonomy mode (`1_manual_web`, `2_hybrid`, `3a_acroform`, `3b_vision`)
+
+### Metrics (v1.7.0+)
+
+Every tool call is logged to `~/.autoform-mcp/metrics.jsonl` with:
+- Timestamp, tool name, duration, success/error
+- Per-field details: coordinates (PDF points), text written, field IDs
+- Session and mode labels for experimental analysis
+
 ## Usage Examples
 
 ### Fill a certificate (Claude analyzes the PDF visually)

package/dist/index.js

@@ -13,7 +13,7 @@ import { handleGenerateBatch, generateBatchSchema } from './tools/generateBatch.
 import { handleListTemplates, listTemplatesSchema } from './tools/manageTemplates.js';
 import { handleImportTemplate, importTemplateSchema } from './tools/importTemplate.js';
 import { withMetrics } from './services/metricsLogger.js';
-const server = new Server({ name: 'autoform', version: '1.6.0' }, { capabilities: { tools: {} } });
+const server = new Server({ name: 'autoform', version: '1.7.0' }, { capabilities: { tools: {} } });
 // Register all tools
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
@@ -78,4 +78,4 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 // Start server
 const transport = new StdioServerTransport();
 await server.connect(transport);
-console.error('[AutoForm MCP] Server v1.6.0 started — 11 tools registered (metrics enabled)');
+console.error('[AutoForm MCP] Server v1.7.0 started — 11 tools registered (metrics enabled)');

package/dist/services/metricsLogger.d.ts

@@ -5,13 +5,10 @@ export interface MetricsEvent {
     success: boolean;
     error_message?: string;
     session_id?: string;
-    input?: Record<string, number | string | boolean>;
+    mode?: string;
+    input?: Record<string, any>;
     output?: Record<string, number | string | boolean>;
 }
-/**
- * Wrap a tool handler to automatically measure and log metrics.
- * The handler's behavior is unchanged; metrics are captured transparently.
- */
 export declare function withMetrics<T>(toolName: string, args: any, handler: (args: any) => Promise<T>): Promise<T>;
 /**
  * Generate a new random session ID (not used automatically — exported for future use).

package/dist/services/metricsLogger.js

@@ -22,10 +22,6 @@ import * as crypto from 'crypto';
 const METRICS_DIR = path.join(os.homedir(), '.autoform-mcp');
 const METRICS_FILE = path.join(METRICS_DIR, 'metrics.jsonl');
 const METRICS_DISABLED = process.env.AUTOFORM_METRICS_DISABLED === '1';
-/**
- * Extract structural stats from tool arguments without leaking raw data.
- * Only records COUNTS and sizes, never the actual content of fields or user data.
- */
 function summarizeInput(toolName, args) {
     const summary = {};
     if (!args || typeof args !== 'object')
@@ -72,8 +68,93 @@ function summarizeInput(toolName, args) {
     if (typeof args.template_name === 'string') {
         summary.template_name = args.template_name;
     }
+    // ─── Ítem 1: Exact coordinate logging per field written ───
+    // For fill tools, extract detailed per-field info (coordinates + text)
+    try {
+        if (toolName === 'autoform_fill_at_coordinates' && fields) {
+            summary.fields_written = extractFieldsWritten(fields);
+        }
+        if (toolName === 'autoform_fill_batch_at_coordinates' && fieldDefs && dataRows) {
+            // For batch: log fields per row (first row only for brevity, full set in fields_written_all)
+            summary.fields_written = extractFieldDefsWritten(fieldDefs, dataRows[0]);
+            if (dataRows.length > 1) {
+                summary.fields_written_all_rows = dataRows.map((row) => extractFieldDefsWritten(fieldDefs, row));
+            }
+        }
+        if (toolName === 'autoform_fill_batch_acroform' && dataRows) {
+            // AcroForm: we know the field names from data_rows keys + optional field_map
+            const fieldMap = args.field_map && typeof args.field_map === 'object' ? args.field_map : null;
+            summary.fields_written = extractAcroFormFieldsWritten(dataRows[0], fieldMap);
+            if (dataRows.length > 1) {
+                summary.fields_written_all_rows = dataRows.map((row) => extractAcroFormFieldsWritten(row, fieldMap));
+            }
+        }
+        if (toolName === 'autoform_fill_pdf') {
+            // fill_pdf with field_values — AcroForm or template-based
+            if (args.field_values && typeof args.field_values === 'object') {
+                const fieldMap = args.field_map && typeof args.field_map === 'object' ? args.field_map : null;
+                summary.fields_written = extractAcroFormFieldsWritten(args.field_values, fieldMap);
+            }
+        }
+    }
+    catch {
+        // Never let field extraction break the logger
+    }
     return summary;
 }
+/** Extract per-field details from fill_at_coordinates fields array */
+function extractFieldsWritten(fields) {
+    return fields.map((f) => {
+        const detail = {
+            text: String(f.text ?? ''),
+            x_pt: Number(f.x) || 0,
+            y_pt: Number(f.y) || 0,
+            page: Number(f.page) || 1,
+            coordinate_origin: 'bottom_left'
+        };
+        if (f.width != null)
+            detail.width_pt = Number(f.width);
+        if (f.height != null)
+            detail.height_pt = Number(f.height);
+        if (f.fontSize != null)
+            detail.fontSize = Number(f.fontSize);
+        return detail;
+    });
+}
+/** Extract per-field details from fill_batch_at_coordinates (field_definitions + one data row) */
+function extractFieldDefsWritten(fieldDefs, dataRow) {
+    if (!dataRow || typeof dataRow !== 'object')
+        return [];
+    return fieldDefs.map((fd) => {
+        const label = fd.label || '';
+        const detail = {
+            text: String(dataRow[label] ?? ''),
+            x_pt: Number(fd.x) || 0,
+            y_pt: Number(fd.y) || 0,
+            page: Number(fd.page) || 1,
+            coordinate_origin: 'bottom_left',
+            semantic_label: label
+        };
+        if (fd.width != null)
+            detail.width_pt = Number(fd.width);
+        if (fd.height != null)
+            detail.height_pt = Number(fd.height);
+        if (fd.fontSize != null)
+            detail.fontSize = Number(fd.fontSize);
+        return detail;
+    });
+}
+/** Extract per-field details from AcroForm fill (field_values object) */
+function extractAcroFormFieldsWritten(fieldValues, fieldMap) {
+    if (!fieldValues || typeof fieldValues !== 'object')
+        return [];
+    return Object.entries(fieldValues).map(([key, value]) => ({
+        text: String(value ?? ''),
+        coordinates_available: false, // AcroForm positions handled internally by pdf-lib — harness uses field_id matching
+        field_id: fieldMap ? (fieldMap[key] || key) : key,
+        semantic_label: key
+    }));
+}
 /**
  * Extract structural stats from the MCP tool response.
  * Parses the returned JSON text to extract counts (documents_generated, total_fields, etc.).
@@ -175,13 +256,18 @@ function writeEvent(event) {
  * Wrap a tool handler to automatically measure and log metrics.
  * The handler's behavior is unchanged; metrics are captured transparently.
  */
+/** Valid experimental modes for _mode parameter */
+const VALID_MODES = ['1_manual_web', '2_hybrid', '3a_acroform', '3b_vision'];
 export async function withMetrics(toolName, args, handler) {
     const startTime = Date.now();
     const sessionId = typeof args?._session_id === 'string' ? args._session_id : undefined;
-    // Strip _session_id from args before passing to handler (internal only)
-    const cleanArgs = args && typeof args === 'object' && '_session_id' in args
-        ? (() => { const { _session_id, ...rest } = args; return rest; })()
-        : args;
+    const mode = typeof args?._mode === 'string' && VALID_MODES.includes(args._mode) ? args._mode : undefined;
+    // Strip _session_id and _mode from args before passing to handler (internal only)
+    let cleanArgs = args;
+    if (args && typeof args === 'object' && ('_session_id' in args || '_mode' in args)) {
+        const { _session_id, _mode, ...rest } = args;
+        cleanArgs = rest;
+    }
     let result;
     let success = true;
     let errorMessage;
@@ -208,6 +294,7 @@ export async function withMetrics(toolName, args, handler) {
             success: false,
             error_message: errorMessage,
             ...(sessionId ? { session_id: sessionId } : {}),
+            ...(mode ? { mode } : {}),
             input: summarizeInput(toolName, cleanArgs)
         };
         writeEvent(event);
@@ -220,6 +307,7 @@ export async function withMetrics(toolName, args, handler) {
         success,
         ...(errorMessage ? { error_message: errorMessage } : {}),
         ...(sessionId ? { session_id: sessionId } : {}),
+        ...(mode ? { mode } : {}),
         input: summarizeInput(toolName, cleanArgs),
         output: summarizeOutput(result)
     };

package/dist/services/pdfTextExtractor.d.ts

@@ -11,16 +11,31 @@ export interface TextItem {
     page: number;
 }
 /**
- * Horizontal line detected as a drawing operator.
+ * A graphic element detected from PDF drawing operators.
  */
-export interface HorizontalLine {
+export interface GraphicElement {
+    type: 'checkbox' | 'field_box' | 'horizontal_line' | 'rectangle';
     x: number;
     y: number;
     width: number;
+    height: number;
     page: number;
+    nearbyLabel?: string;
+    labelPosition?: 'left' | 'right' | 'above' | 'below';
+}
+/**
+ * Complete page information including text AND graphic elements.
+ */
+export interface PageFullInfo {
+    page: number;
+    width: number;
+    height: number;
+    textItems: TextItem[];
+    graphicElements: GraphicElement[];
+    totalCharacters: number;
 }
 /**
- * A page's extracted information.
+ * A page's extracted information (text only, for backward compatibility).
  */
 export interface PageTextInfo {
     page: number;
@@ -40,6 +55,38 @@ export type PdfContentType = 'acroform' | 'text_vectorial' | 'image_only' | 'mix
 export declare class PdfTextExtractor {
     /** Extract all text items from all pages of a PDF */
     static extractAllText(pdfPath: string): Promise<PageTextInfo[]>;
+    /**
+     * Extract ALL information from a PDF: text items + graphic elements (rectangles, lines).
+     * Uses both getTextContent() and getOperatorList() to build a complete map of the page.
+     *
+     * Graphic elements are classified as:
+     * - checkbox: small square (6-16pt per side), likely a check box
+     * - field_box: medium/large rectangle (width > 40pt), likely an input field area
+     * - horizontal_line: very thin rectangle (height < 2pt, width > 30pt), likely an underline for writing
+     * - rectangle: anything else
+     *
+     * Each graphic element gets a nearbyLabel from the closest text item.
+     */
+    static extractFullPageInfo(pdfPath: string): Promise<PageFullInfo[]>;
+    /**
+     * Extract all text items from a PDF with positions converted to top-left origin.
+     * Used for post-hoc validation: verify that pdf-lib actually wrote where the MCP said it wrote.
+     *
+     * Returns items grouped by proximity (consecutive items on the same Y line are merged).
+     * Coordinates: PDF points, origin top-left (y=0 at top of page).
+     *
+     * This is an internal function called by the analysis harness (research/scripts/analyze-experiment.js),
+     * NOT exposed as an MCP tool.
+     */
+    static extractWrittenTextPositions(pdfPath: string): Promise<Array<{
+        text: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        fontSize: number;
+        page: number;
+    }>>;
     /**
      * Classify a PDF based on extractable text density.
      * Thresholds are empirical; can be tuned.

package/dist/services/pdfTextExtractor.js

@@ -55,6 +55,253 @@ export class PdfTextExtractor {
         }
         return pages;
     }
+    /**
+     * Extract ALL information from a PDF: text items + graphic elements (rectangles, lines).
+     * Uses both getTextContent() and getOperatorList() to build a complete map of the page.
+     *
+     * Graphic elements are classified as:
+     * - checkbox: small square (6-16pt per side), likely a check box
+     * - field_box: medium/large rectangle (width > 40pt), likely an input field area
+     * - horizontal_line: very thin rectangle (height < 2pt, width > 30pt), likely an underline for writing
+     * - rectangle: anything else
+     *
+     * Each graphic element gets a nearbyLabel from the closest text item.
+     */
+    static async extractFullPageInfo(pdfPath) {
+        const bytes = fs.readFileSync(pdfPath);
+        const pdf = await pdfjsLib.getDocument({
+            data: new Uint8Array(bytes),
+            useSystemFonts: true,
+            verbosity: 0
+        }).promise;
+        const results = [];
+        for (let pageNum = 1; pageNum <= pdf.numPages; pageNum++) {
+            const page = await pdf.getPage(pageNum);
+            const viewport = page.getViewport({ scale: 1 });
+            // 1. Extract text (same as extractAllText)
+            const textContent = await page.getTextContent();
+            const textItems = [];
+            let totalChars = 0;
+            for (const raw of textContent.items) {
+                const text = String(raw.str ?? '').trim();
+                if (text === '')
+                    continue;
+                const [, , , scaleY, tx, ty] = raw.transform;
+                const fontSize = Math.abs(scaleY);
+                const width = Math.abs(raw.width ?? 0);
+                const height = Math.abs(raw.height ?? fontSize);
+                textItems.push({ text, x: tx, y: ty, width, height, fontSize, page: pageNum });
+                totalChars += text.length;
+            }
+            // 2. Extract graphic elements from operator list
+            const operatorList = await page.getOperatorList();
+            const graphicElements = [];
+            // pdfjs OPS constants
+            const OPS = pdfjsLib.OPS;
+            // Track current transform matrix for coordinate conversion
+            // The operator list contains transform operations + rectangle draws
+            let currentTransform = [1, 0, 0, 1, 0, 0]; // identity
+            for (let i = 0; i < operatorList.fnArray.length; i++) {
+                const fn = operatorList.fnArray[i];
+                const args = operatorList.argsArray[i];
+                // Track transform changes
+                if (fn === OPS.transform) {
+                    if (args && args.length >= 6) {
+                        currentTransform = args;
+                    }
+                }
+                // Detect rectangle operations: constructPath contains 'rectangle' ops
+                if (fn === OPS.constructPath) {
+                    const ops = args[0]; // array of sub-operations
+                    const pathArgs = args[1]; // array of coordinates [x, y, w, h, ...]
+                    if (!ops || !pathArgs)
+                        continue;
+                    let argIdx = 0;
+                    for (const op of ops) {
+                        // op 13 = rectangle in pdfjs (OPS.rectangle)
+                        if (op === 13 && argIdx + 3 < pathArgs.length) {
+                            const rx = pathArgs[argIdx];
+                            const ry = pathArgs[argIdx + 1];
+                            const rw = pathArgs[argIdx + 2];
+                            const rh = pathArgs[argIdx + 3];
+                            // Apply current transform to get absolute coordinates
+                            const absX = currentTransform[4] + rx * currentTransform[0];
+                            const absY = currentTransform[5] + ry * currentTransform[3];
+                            const absW = Math.abs(rw * currentTransform[0]);
+                            const absH = Math.abs(rh * currentTransform[3]);
+                            // Filter: skip tiny rects (artifacts) and page-sized rects (backgrounds)
+                            if (absW < 4 || absH < 1) {
+                                argIdx += 4;
+                                continue;
+                            }
+                            if (absW > viewport.width * 0.95 && absH > viewport.height * 0.95) {
+                                argIdx += 4;
+                                continue;
+                            }
+                            // Classify the rectangle
+                            let type;
+                            if (absH < 2.5 && absW > 30) {
+                                type = 'horizontal_line';
+                            }
+                            else if (absW >= 6 && absW <= 25 && absH >= 6 && absH <= 25 && Math.abs(absW - absH) < 6) {
+                                type = 'checkbox';
+                            }
+                            else if (absW > 50 && absH > 10 && absH < 40) {
+                                type = 'field_box';
+                            }
+                            else {
+                                type = 'rectangle';
+                            }
+                            graphicElements.push({
+                                type,
+                                x: Math.round(absX * 100) / 100,
+                                y: Math.round(absY * 100) / 100,
+                                width: Math.round(absW * 100) / 100,
+                                height: Math.round(absH * 100) / 100,
+                                page: pageNum
+                            });
+                            argIdx += 4;
+                        }
+                        else {
+                            // Other path ops: moveTo(2 args), lineTo(2 args), etc.
+                            if (op === 14 || op === 15)
+                                argIdx += 2; // moveTo, lineTo
+                            else if (op === 16)
+                                argIdx += 6; // bezierCurveTo
+                            else if (op === 17)
+                                argIdx += 0; // closePath
+                            else
+                                argIdx += 2; // safe default
+                        }
+                    }
+                }
+            }
+            // 2.5. Deduplicate overlapping graphic elements of the same type
+            // PDFs often have multiple border layers for the same visual element
+            const deduped = [];
+            for (const elem of graphicElements) {
+                const isDuplicate = deduped.some(existing => existing.type === elem.type &&
+                    existing.page === elem.page &&
+                    Math.abs(existing.x - elem.x) < 8 &&
+                    Math.abs(existing.y - elem.y) < 8 &&
+                    Math.abs(existing.width - elem.width) < 10 &&
+                    Math.abs(existing.height - elem.height) < 10);
+                if (!isDuplicate)
+                    deduped.push(elem);
+            }
+            graphicElements.length = 0;
+            graphicElements.push(...deduped);
+            // 3. Correlate each graphic element with the nearest text label
+            for (const elem of graphicElements) {
+                const elemCenterX = elem.x + elem.width / 2;
+                const elemCenterY = elem.y + elem.height / 2;
+                let bestLabel = '';
+                let bestDist = Infinity;
+                let bestPos = 'left';
+                for (const ti of textItems) {
+                    const textCenterX = ti.x + ti.width / 2;
+                    const textCenterY = ti.y + ti.height / 2;
+                    const dx = elemCenterX - textCenterX;
+                    const dy = elemCenterY - textCenterY;
+                    const dist = Math.sqrt(dx * dx + dy * dy);
+                    if (dist < bestDist && dist < 200) { // max 200pt search radius
+                        bestDist = dist;
+                        bestLabel = ti.text;
+                        const absDx = Math.abs(dx);
+                        const absDy = Math.abs(dy);
+                        if (absDx > absDy) {
+                            bestPos = dx > 0 ? 'left' : 'right';
+                        }
+                        else {
+                            bestPos = dy > 0 ? 'below' : 'above';
+                        }
+                    }
+                }
+                if (bestLabel) {
+                    elem.nearbyLabel = bestLabel;
+                    elem.labelPosition = bestPos;
+                }
+            }
+            results.push({
+                page: pageNum,
+                width: viewport.width,
+                height: viewport.height,
+                textItems,
+                graphicElements,
+                totalCharacters: totalChars
+            });
+        }
+        return results;
+    }
+    /**
+     * Extract all text items from a PDF with positions converted to top-left origin.
+     * Used for post-hoc validation: verify that pdf-lib actually wrote where the MCP said it wrote.
+     *
+     * Returns items grouped by proximity (consecutive items on the same Y line are merged).
+     * Coordinates: PDF points, origin top-left (y=0 at top of page).
+     *
+     * This is an internal function called by the analysis harness (research/scripts/analyze-experiment.js),
+     * NOT exposed as an MCP tool.
+     */
+    static async extractWrittenTextPositions(pdfPath) {
+        const bytes = fs.readFileSync(pdfPath);
+        const pdf = await pdfjsLib.getDocument({
+            data: new Uint8Array(bytes),
+            useSystemFonts: true,
+            verbosity: 0
+        }).promise;
+        const results = [];
+        for (let pageNum = 1; pageNum <= pdf.numPages; pageNum++) {
+            const page = await pdf.getPage(pageNum);
+            const viewport = page.getViewport({ scale: 1 });
+            const pageHeight = viewport.height;
+            const textContent = await page.getTextContent();
+            // Collect raw items with top-left coordinates
+            const rawItems = [];
+            for (const raw of textContent.items) {
+                const text = String(raw.str ?? '');
+                if (text === '')
+                    continue;
+                const [, , , scaleY, tx, ty] = raw.transform;
+                const fontSize = Math.abs(scaleY);
+                const width = Math.abs(raw.width ?? 0);
+                const height = Math.abs(raw.height ?? fontSize);
+                // Convert from PDF bottom-left to top-left origin
+                // ty is the text baseline; subtract height to get the top edge of the text
+                const yTopLeft = pageHeight - ty - height;
+                rawItems.push({
+                    text,
+                    x: tx,
+                    y: yTopLeft,
+                    width,
+                    height,
+                    fontSize,
+                    page: pageNum
+                });
+            }
+            // Group consecutive items on the same Y line (within 2pt tolerance)
+            // pdfjs-dist fragments text into runs; pdf-lib may write a whole string as one item
+            const grouped = [];
+            for (const item of rawItems) {
+                const last = grouped[grouped.length - 1];
+                if (last &&
+                    last.page === item.page &&
+                    Math.abs(last.y - item.y) < 2 &&
+                    Math.abs((last.x + last.width) - item.x) < 5) {
+                    // Merge: extend text and width
+                    last.text += item.text;
+                    last.width = (item.x + item.width) - last.x;
+                    last.height = Math.max(last.height, item.height);
+                    last.fontSize = Math.max(last.fontSize, item.fontSize);
+                }
+                else {
+                    grouped.push({ ...item });
+                }
+            }
+            results.push(...grouped);
+        }
+        return results;
+    }
     /**
      * Classify a PDF based on extractable text density.
      * Thresholds are empirical; can be tuned.

package/dist/tools/analyzeStaticPdf.d.ts

@@ -8,6 +8,15 @@ export declare const analyzeStaticPdfSchema: {
                 type: string;
                 description: string;
             };
+            _session_id: {
+                type: string;
+                description: string;
+            };
+            _mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
         };
         required: string[];
     };

package/dist/tools/analyzeStaticPdf.js

@@ -21,11 +21,18 @@ Si recibes este tipo, NO intentes procesar el PDF con los otros tools. En su lug
 3. Proporcionar coordenadas manualmente si ya las conoces
 
 ⚠️ CASO text_vectorial:
-- suggested_fields son SUGERENCIAS heuristicas (asumen layout "Label: ___" a la derecha).
-- Para layouts atipicos (certificados con campo DEBAJO del label, diplomas con layout centrado, etc.) las sugerencias pueden estar en posiciones incorrectas.
-- USA all_text_items para ver TODOS los textos del PDF con sus posiciones exactas y razona sobre el layout real antes de decidir las coordenadas finales.
-- Los campos "CERTIFICADO", "Firma 1/2" que se detectan como sugerencias probablemente NO son campos editables — son etiquetas del certificado. Descarta sugerencias que claramente son texto decorativo.
-- Cuando no estes seguro, PREGUNTA al usuario donde va cada dato en lugar de adivinar.
+- suggested_fields son SUGERENCIAS heuristicas que pueden estar en posiciones incorrectas para layouts atipicos (centrados, tabulares complejos).
+- USA all_text_items para razonar sobre el layout real del PDF.
+- Descarta sugerencias que son texto decorativo ("CERTIFICADO", "Firma 1/2").
+- Cuando no estes seguro del layout, PREGUNTA al usuario o pidele que adjunte el PDF al chat para verlo visualmente.
+
+⚠️ FORMULARIOS COMPLEJOS:
+- Si el formulario tiene muchos campos (>10), tablas densas, o un layout no obvio, RECOMIENDA al usuario adjuntar el PDF al chat para verificacion visual antes de generar. Dile algo como: "Este formulario es complejo. Para asegurar precision, te recomiendo adjuntarme el PDF al chat para que pueda verificar las posiciones visualmente."
+- Si el usuario ya adjunto el PDF al chat Y tambien te dio la ruta, APROVECHA ambos: usa la imagen visual para verificar que tus coordenadas son correctas.
+
+⚠️ CHECKBOXES:
+- Si detectas textos tipo opciones multiples en la misma linea Y (ej: "ALUMNO", "DOCENTE", "ADMINISTRATIVO"), es probable que haya casillas de verificacion.
+- NO adivines la posicion de los cuadrados. Pide al usuario que adjunte el PDF para verlo visualmente.
 
 ⚠️ CASO mixed:
 Hay algo de texto pero poca densidad. Puede haber campos que NO se detectaron automaticamente porque el label es una imagen. Usa suggested_fields como punto de partida pero verifica visualmente si faltan campos.`,
@@ -35,6 +42,15 @@ Hay algo de texto pero poca densidad. Puede haber campos que NO se detectaron au
             pdf_path: {
                 type: 'string',
                 description: 'Ruta absoluta al PDF estatico a analizar'
+            },
+            _session_id: {
+                type: 'string',
+                description: '(Opcional) ID de sesion experimental para agrupar tool calls en metrics.jsonl.'
+            },
+            _mode: {
+                type: 'string',
+                enum: ['1_manual_web', '2_hybrid', '3a_acroform', '3b_vision'],
+                description: '(Opcional) Modo de autonomia experimental.'
             }
         },
         required: ['pdf_path']
@@ -127,7 +143,7 @@ export async function handleAnalyzeStaticPdf(args) {
     })));
     const summary = suggestedFields.length > 0
         ? `Se detectaron ${suggestedFields.length} campos candidatos automaticamente:\n${suggestedFields.map(f => `- "${f.inferredLabel}" en pag ${f.page}, pos (${f.suggestedX}, ${f.suggestedY}), ${f.suggestedWidth}x${f.suggestedHeight} [${f.confidence}]`).join('\n')}`
-        : 'No se detectaron campos candidatos automaticamente. El PDF tiene texto pero no hay patrones claros de "Label: ___" reconocibles.';
+        : 'No se detectaron campos candidatos automaticamente. El PDF tiene texto pero no hay patrones claros de "Label: ___" reconocibles. Revisa all_text_items para ver todo el texto del PDF con posiciones y razona sobre el layout.';
     return {
         content: [{
                 type: 'text',
@@ -143,14 +159,14 @@ export async function handleAnalyzeStaticPdf(args) {
                     },
                     total_text_items: allTextItems.length,
                     suggested_fields: suggestedFields,
-                    all_text_items: allTextItems.slice(0, 100), // Limit to avoid huge responses
+                    all_text_items: allTextItems.slice(0, 100),
                     text_items_truncated: allTextItems.length > 100,
                     summary,
                     guidance: contentType === 'mixed'
-                        ? 'El PDF tiene densidad baja de texto — puede tener elementos visuales (titulos como imagen, logos) que no se extraen. Usa los suggested_fields como punto de partida pero verifica si faltan campos.'
+                        ? 'El PDF tiene densidad baja de texto. Usa all_text_items como referencia y pregunta al usuario si faltan campos.'
                         : suggestedFields.length > 0
-                            ? 'Usa los suggested_fields directamente con autoform_fill_at_coordinates (un documento) o autoform_fill_batch_at_coordinates (multiples documentos).'
-                            : 'No hay campos obvios detectables. Pregunta al usuario donde quiere colocar los datos o pidele que abra el PDF en la app web de AutoForm.'
+                            ? 'Usa los suggested_fields como punto de partida. IMPORTANTE SOBRE CHECKBOXES: si detectas en all_text_items textos que parecen opciones multiples en la misma linea (ej: "ALUMNO", "DOCENTE", "ADMINISTRATIVO" con coordenadas Y similares), es MUY probable que el formulario tenga casillas de verificacion. En ese caso, NO adivines la posicion de los cuadrados — pide al usuario que adjunte el PDF al chat para que puedas verlo visualmente y determinar la posicion exacta de cada casilla antes de marcar con "X".'
+                            : 'No hay campos obvios detectables por heuristicas. IMPORTANTE: si en all_text_items detectas textos que parecen opciones multiples (ej: varias opciones en la misma linea Y), probablemente hay casillas de verificacion cuya posicion exacta no puedo determinar solo con texto. Pide al usuario que adjunte el PDF al chat para verlo visualmente, o que te indique donde estan las casillas.'
                 }, null, 2)
             }]
     };

package/dist/tools/detectFields.d.ts

@@ -8,6 +8,15 @@ export declare const detectFieldsSchema: {
                 type: string;
                 description: string;
             };
+            _session_id: {
+                type: string;
+                description: string;
+            };
+            _mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
         };
         required: string[];
     };

package/dist/tools/detectFields.js

@@ -36,6 +36,15 @@ FLUJO RECOMENDADO PARA MULTIPLES DOCUMENTOS:
             pdf_path: {
                 type: 'string',
                 description: 'Ruta absoluta al archivo PDF'
+            },
+            _session_id: {
+                type: 'string',
+                description: '(Opcional) ID de sesion experimental para agrupar tool calls en metrics.jsonl.'
+            },
+            _mode: {
+                type: 'string',
+                enum: ['1_manual_web', '2_hybrid', '3a_acroform', '3b_vision'],
+                description: '(Opcional) Modo de autonomia experimental.'
             }
         },
         required: ['pdf_path']

package/dist/tools/fillAtCoordinates.d.ts

@@ -55,6 +55,15 @@ export declare const fillAtCoordinatesSchema: {
                 type: string;
                 description: string;
             };
+            _session_id: {
+                type: string;
+                description: string;
+            };
+            _mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
         };
         required: string[];
     };
@@ -69,6 +78,15 @@ export declare const getPdfInfoSchema: {
                 type: string;
                 description: string;
             };
+            _session_id: {
+                type: string;
+                description: string;
+            };
+            _mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
         };
         required: string[];
     };

package/dist/tools/fillAtCoordinates.js

@@ -1,31 +1,24 @@
 import * as path from 'path';
-import * as os from 'os';
 import { PdfService } from '../services/pdfService.js';
-const OUTPUT_DIR = path.join(os.homedir(), '.autoform-mcp', 'output');
 export const fillAtCoordinatesSchema = {
     name: 'autoform_fill_at_coordinates',
-    description: `Escribe texto en posiciones exactas de UN PDF usando coordenadas en puntos PDF (origen: esquina inferior-izquierda).
-Ideal cuando Claude analiza visualmente un PDF y determina dónde colocar el texto.
+    description: `Escribe texto en posiciones exactas de UN PDF.
 
-⚠️ ESTA TOOL ES PARA UN UNICO DOCUMENTO. Si necesitas generar multiples PDFs con los mismos campos pero datos diferentes, USA autoform_fill_batch_at_coordinates (mas eficiente, una sola llamada).
+⚠️ PARA MULTIPLES DOCUMENTOS usa autoform_fill_batch_at_coordinates (una sola llamada, mas eficiente).
 
-IMPORTANTE — Codificación de texto:
-- El texto se pasa EXACTAMENTE como lo envías. NO simplifiques ni modifiques caracteres.
-- Acentos españoles (á é í ó ú ñ Ñ ü) están soportados completamente.
-- Nombres como "Sofía", "Benítez", "Peña" deben pasarse con sus tildes intactas.
-- Solo se filtran: emojis, caracteres de control invisibles, y patrones de script malicioso.
+CODIFICACION: Acentos (á é í ó ú ñ Ñ ü) soportados. NO simplifiques caracteres.
 
-FLUJO RECOMENDADO:
-1. Primero usa autoform_get_pdf_info para obtener las dimensiones de cada página
-2. Basándote en el análisis visual del PDF, calcula las coordenadas en puntos PDF
-3. Recuerda: Y=0 está ABAJO, Y aumenta hacia ARRIBA
+CHECKBOXES: Solo marca casillas si puedes VER el PDF visualmente. Si no, pide al usuario que lo adjunte al chat.
 
-SISTEMA DE COORDENADAS:
-- Origen (0,0) = esquina inferior-izquierda de la página
-- X aumenta hacia la derecha
-- Y aumenta hacia arriba
-- Una página A4 típica mide ~595 x 842 puntos
-- Una página Letter típica mide ~612 x 792 puntos`,
+VERIFICACION VISUAL: Si el usuario adjunto el PDF Y dio la ruta, aprovecha la imagen para verificar coordenadas antes de escribir.
+
+DIRECTORIO DE SALIDA: Si no se especifica output_path, guarda en el MISMO directorio del pdf_path original.
+
+NO GENERES PDF DE PRUEBA: Genera el resultado final directamente. No hagas "tests" individuales a menos que el usuario lo pida.
+
+CUANDO TENGAS DUDAS: Si el formulario es complejo y no estas seguro de las posiciones, PREGUNTA al usuario o pidele que adjunte el PDF al chat. Mejor preguntar que generar mal.
+
+COORDENADAS: Origen (0,0) = esquina inferior-izquierda. Y aumenta hacia arriba. Puntos PDF (A4 ≈ 595x842, Letter ≈ 612x792).`,
     inputSchema: {
         type: 'object',
         properties: {
@@ -54,6 +47,15 @@ SISTEMA DE COORDENADAS:
             output_path: {
                 type: 'string',
                 description: '(Opcional) Ruta donde guardar el PDF. Default: ~/.autoform-mcp/output/'
+            },
+            _session_id: {
+                type: 'string',
+                description: '(Opcional) ID de sesion experimental para agrupar tool calls en metrics.jsonl. Formato: <pdf_id>_<mode>_<rep>'
+            },
+            _mode: {
+                type: 'string',
+                enum: ['1_manual_web', '2_hybrid', '3a_acroform', '3b_vision'],
+                description: '(Opcional) Modo de autonomia experimental. Se registra en metrics.jsonl.'
             }
         },
         required: ['pdf_path', 'fields']
@@ -68,6 +70,15 @@ export const getPdfInfoSchema = {
             pdf_path: {
                 type: 'string',
                 description: 'Ruta absoluta al archivo PDF'
+            },
+            _session_id: {
+                type: 'string',
+                description: '(Opcional) ID de sesion experimental para agrupar tool calls en metrics.jsonl.'
+            },
+            _mode: {
+                type: 'string',
+                enum: ['1_manual_web', '2_hybrid', '3a_acroform', '3b_vision'],
+                description: '(Opcional) Modo de autonomia experimental.'
             }
         },
         required: ['pdf_path']
@@ -89,7 +100,7 @@ export async function handleFillAtCoordinates(args) {
             isError: true
         };
     }
-    const outputFile = output_path || path.join(OUTPUT_DIR, `coords_${path.basename(pdf_path, '.pdf')}_${Date.now()}.pdf`);
+    const outputFile = output_path || path.join(path.dirname(pdf_path), `${path.basename(pdf_path, '.pdf')}_filled_${Date.now()}.pdf`);
     const filled = await PdfService.fillAtCoordinates(pdf_path, fields, outputFile);
     return {
         content: [{

package/dist/tools/fillBatchAcroForm.d.ts

@@ -33,6 +33,15 @@ export declare const fillBatchAcroFormSchema: {
                 type: string;
                 description: string;
             };
+            _session_id: {
+                type: string;
+                description: string;
+            };
+            _mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
         };
         required: string[];
     };

package/dist/tools/fillBatchAcroForm.js

@@ -1,7 +1,5 @@
 import * as path from 'path';
-import * as os from 'os';
 import { PdfService } from '../services/pdfService.js';
-const OUTPUT_DIR = path.join(os.homedir(), '.autoform-mcp', 'output');
 export const fillBatchAcroFormSchema = {
     name: 'autoform_fill_batch_acroform',
     description: `Genera MULTIPLES PDFs a partir de un PDF con campos AcroForm (formulario interactivo) + array de datos. Una sola llamada genera N documentos.
@@ -17,9 +15,15 @@ IMPORTANTE sobre nombres de campos:
 - Si las claves de tus data_rows NO coinciden con los nombres tecnicos, usa el parametro field_map para traducir: { "nombre_logico": "nombre_tecnico" }
 - Ejemplo: si el campo tecnico es "Text1" pero visualmente corresponde al label "Nombre:", pasa field_map={"nombre": "Text1"} y data_rows=[{"nombre": "Juan"}]
 
-MERGE: Si merge_into_single=true, se genera SOLO el PDF unificado (los individuales son temporales y se borran automaticamente).
+MERGE: Si merge_into_single=true, se genera SOLO el PDF unificado.
 
-CODIFICACION: Los datos se escriben EXACTAMENTE como los envias. Acentos espanoles (a e i o u n N u con tildes) estan completamente soportados. NO simplifiques caracteres.`,
+CODIFICACION: Acentos (á é í ó ú ñ) soportados completamente. NO simplifiques caracteres.
+
+DIRECTORIO DE SALIDA: Si no se especifica output_dir, usa el MISMO directorio donde esta el pdf_path original.
+
+NO GENERES PDF DE PRUEBA: Genera el batch completo directamente. No hagas un "test" individual primero a menos que el usuario lo pida.
+
+VERIFICACION: Si el usuario adjunto el PDF al chat Y dio la ruta, aprovecha la imagen visual para verificar que los inferred_labels son correctos.`,
     inputSchema: {
         type: 'object',
         properties: {
@@ -47,6 +51,15 @@ CODIFICACION: Los datos se escriben EXACTAMENTE como los envias. Acentos espanol
             output_dir: {
                 type: 'string',
                 description: '(Opcional) Directorio de salida. Default: ~/.autoform-mcp/output/'
+            },
+            _session_id: {
+                type: 'string',
+                description: '(Opcional) ID de sesion experimental para agrupar tool calls en metrics.jsonl. Formato: <pdf_id>_<mode>_<rep>'
+            },
+            _mode: {
+                type: 'string',
+                enum: ['1_manual_web', '2_hybrid', '3a_acroform', '3b_vision'],
+                description: '(Opcional) Modo de autonomia experimental. Se registra en metrics.jsonl.'
             }
         },
         required: ['pdf_path', 'data_rows']
@@ -74,7 +87,7 @@ export async function handleFillBatchAcroForm(args) {
             isError: true
         };
     }
-    const outDir = output_dir || OUTPUT_DIR;
+    const outDir = output_dir || path.dirname(pdf_path);
     const baseName = path.basename(pdf_path, '.pdf').replace(/[^a-zA-Z0-9_\-]/g, '_');
     const result = await PdfService.batchFillAcroForm(pdf_path, data_rows, outDir, baseName, merge_into_single, field_map);
     return {

package/dist/tools/fillBatchAtCoordinates.d.ts

@@ -69,6 +69,15 @@ export declare const fillBatchAtCoordinatesSchema: {
                 type: string;
                 description: string;
             };
+            _session_id: {
+                type: string;
+                description: string;
+            };
+            _mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
         };
         required: string[];
     };

package/dist/tools/fillBatchAtCoordinates.js

@@ -1,7 +1,5 @@
 import * as path from 'path';
-import * as os from 'os';
 import { PdfService } from '../services/pdfService.js';
-const OUTPUT_DIR = path.join(os.homedir(), '.autoform-mcp', 'output');
 export const fillBatchAtCoordinatesSchema = {
     name: 'autoform_fill_batch_at_coordinates',
     description: `Genera MULTIPLES PDFs a partir de un mismo PDF base, escribiendo datos diferentes en las mismas posiciones de cada copia.
@@ -11,16 +9,30 @@ CUANDO USAR: El usuario pasa un PDF (certificado, diploma, constancia) y una LIS
 IMPORTANTE — Codificación de texto:
 - Los datos se escriben EXACTAMENTE como los envías. NO simplifiques ni modifiques caracteres.
 - Acentos españoles (á é í ó ú ñ Ñ ü) están soportados completamente.
-- Nombres como "Sofía", "Benítez", "Peña" deben pasarse con sus tildes intactas.
+
+IMPORTANTE — Casillas de verificación (checkboxes) en PDFs estaticos:
+- Si detectas opciones tipo checkbox, SOLO marcalas si puedes VER el PDF visualmente (adjuntado al chat). Si no puedes verlo, pide al usuario que lo adjunte.
+- Para marcar: text="X", fontSize=10, en las coordenadas exactas del cuadrado.
+
+IMPORTANTE — Verificación visual:
+- Si el usuario adjunto el PDF al chat Y tambien dio la ruta, APROVECHA la imagen visual para verificar que tus coordenadas son correctas antes de generar.
+- Si tienes dudas sobre el layout de un formulario complejo (tablas densas, campos no claros), PREGUNTA al usuario antes de generar. Es mejor preguntar que generar mal.
+
+DIRECTORIO DE SALIDA POR DEFECTO:
+- Si el usuario NO especifica output_dir, usa el MISMO directorio donde esta el PDF base (pdf_path). No uses ~/.autoform-mcp/output/ por defecto — el usuario espera los archivos cerca de su PDF original.
+
+NO GENERES PDFs DE PRUEBA/TEST:
+- Genera directamente el batch completo. NO generes un "test" individual primero a menos que el usuario lo pida explicitamente. Generar tests innecesarios desperdicia tiempo y confunde al usuario con archivos extra.
 
 MERGE: Si merge_into_single=true, se genera SOLO el PDF unificado (los individuales son temporales y se borran automáticamente).
 
-FLUJO:
-1. Usa autoform_get_pdf_info para obtener las dimensiones de la pagina
-2. Analiza visualmente el PDF para determinar donde van los campos
-3. Define los campos con label (nombre logico) + coordenadas
-4. Pasa las filas de datos como array de objetos {label: valor}
-5. Opcionalmente unifica todo en un solo PDF con merge_into_single
+FLUJO CORRECTO:
+1. Usa autoform_get_pdf_info para dimensiones
+2. Si puedes ver el PDF (adjuntado al chat): analiza visualmente donde van los campos
+3. Si NO puedes verlo: usa autoform_analyze_static_pdf para obtener texto+posiciones, y si detectas posibles checkboxes o layout complejo, pide al usuario que adjunte el PDF
+4. Define los campos con coordenadas
+5. Genera el batch completo de una vez (NO hagas un test primero)
+6. Informa al usuario la ruta del resultado
 
 SISTEMA DE COORDENADAS: Origen (0,0) = esquina inferior-izquierda. Y aumenta hacia arriba. Unidades: puntos PDF.`,
     inputSchema: {
@@ -63,6 +75,15 @@ SISTEMA DE COORDENADAS: Origen (0,0) = esquina inferior-izquierda. Y aumenta hac
             output_dir: {
                 type: 'string',
                 description: '(Opcional) Directorio de salida. Default: ~/.autoform-mcp/output/'
+            },
+            _session_id: {
+                type: 'string',
+                description: '(Opcional) ID de sesion experimental para agrupar tool calls en metrics.jsonl. Formato: <pdf_id>_<mode>_<rep>'
+            },
+            _mode: {
+                type: 'string',
+                enum: ['1_manual_web', '2_hybrid', '3a_acroform', '3b_vision'],
+                description: '(Opcional) Modo de autonomia experimental. Se registra en metrics.jsonl.'
             }
         },
         required: ['pdf_path', 'field_definitions', 'data_rows']
@@ -90,7 +111,7 @@ export async function handleFillBatchAtCoordinates(args) {
     if (!data_rows || !Array.isArray(data_rows) || data_rows.length === 0) {
         return { content: [{ type: 'text', text: JSON.stringify({ error: true, message: 'data_rows es requerido (array de objetos con datos)' }, null, 2) }], isError: true };
     }
-    const outDir = output_dir || OUTPUT_DIR;
+    const outDir = output_dir || path.dirname(pdf_path);
     const baseName = path.basename(pdf_path, '.pdf').replace(/[^a-zA-Z0-9_\-]/g, '_');
     const result = await PdfService.batchFillAtCoordinates(pdf_path, field_definitions, data_rows, outDir, baseName, merge_into_single);
     return {

package/dist/tools/fillPdf.d.ts

@@ -23,6 +23,15 @@ export declare const fillPdfSchema: {
                 type: string;
                 description: string;
             };
+            _session_id: {
+                type: string;
+                description: string;
+            };
+            _mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
         };
         required: string[];
     };

package/dist/tools/fillPdf.js

@@ -1,8 +1,6 @@
 import * as path from 'path';
-import * as os from 'os';
 import { PdfService } from '../services/pdfService.js';
 import { TemplateStore } from '../services/templateStore.js';
-const OUTPUT_DIR = path.join(os.homedir(), '.autoform-mcp', 'output');
 export const fillPdfSchema = {
     name: 'autoform_fill_pdf',
     description: `Llena UN SOLO PDF con valores. Detecta automaticamente si tiene AcroForm o usa un template guardado.
@@ -13,8 +11,10 @@ export const fillPdfSchema = {
   - Template guardado + multiples filas → autoform_generate_batch
 
 CUANDO USAR: Solo cuando el usuario pide llenar UN documento especifico.
-NO USAR PARA BATCH: Nunca llames esta tool en loop para generar multiples PDFs — usa las tools batch que existen para eso.
-NO USAR SI: El PDF es estatico sin template → usa autoform_fill_at_coordinates.`,
+NO USAR PARA BATCH: Nunca llames esta tool en loop — usa las tools batch.
+NO USAR SI: El PDF es estatico sin template → usa autoform_fill_at_coordinates.
+
+DIRECTORIO DE SALIDA: Si no se especifica output_path, guarda en el MISMO directorio del pdf_path original.`,
     inputSchema: {
         type: 'object',
         properties: {
@@ -34,6 +34,15 @@ NO USAR SI: El PDF es estatico sin template → usa autoform_fill_at_coordinates
             template_name: {
                 type: 'string',
                 description: '(Opcional) Nombre del template a usar para posicionar los campos. Solo necesario si el PDF no tiene AcroForm.'
+            },
+            _session_id: {
+                type: 'string',
+                description: '(Opcional) ID de sesion experimental para agrupar tool calls en metrics.jsonl.'
+            },
+            _mode: {
+                type: 'string',
+                enum: ['1_manual_web', '2_hybrid', '3a_acroform', '3b_vision'],
+                description: '(Opcional) Modo de autonomia experimental.'
             }
         },
         required: ['pdf_path', 'field_values']
@@ -48,7 +57,7 @@ export async function handleFillPdf(args) {
         }
         catch { /* keep as-is */ }
     }
-    const outputFile = output_path || path.join(OUTPUT_DIR, `filled_${path.basename(pdf_path, '.pdf')}_${Date.now()}.pdf`);
+    const outputFile = output_path || path.join(path.dirname(pdf_path), `${path.basename(pdf_path, '.pdf')}_filled_${Date.now()}.pdf`);
     // Try AcroForm first
     const { fields, hasAcroform } = await PdfService.detectFields(pdf_path);
     if (hasAcroform && fields.length > 0) {

package/dist/tools/generateBatch.d.ts

@@ -27,6 +27,15 @@ export declare const generateBatchSchema: {
                 type: string;
                 description: string;
             };
+            _session_id: {
+                type: string;
+                description: string;
+            };
+            _mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
         };
         required: string[];
     };

package/dist/tools/generateBatch.js

@@ -35,6 +35,15 @@ Modos de distribucion:
             merge_into_single: {
                 type: 'boolean',
                 description: 'Si es true, une todos los PDFs en uno solo. Default: false.'
+            },
+            _session_id: {
+                type: 'string',
+                description: '(Opcional) ID de sesion experimental para agrupar tool calls en metrics.jsonl.'
+            },
+            _mode: {
+                type: 'string',
+                enum: ['1_manual_web', '2_hybrid', '3a_acroform', '3b_vision'],
+                description: '(Opcional) Modo de autonomia experimental.'
             }
         },
         required: ['template_name', 'data']

package/dist/tools/importTemplate.d.ts

@@ -8,6 +8,15 @@ export declare const importTemplateSchema: {
                 type: string;
                 description: string;
             };
+            _session_id: {
+                type: string;
+                description: string;
+            };
+            _mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
         };
         required: string[];
     };

package/dist/tools/importTemplate.js

@@ -11,6 +11,15 @@ ALTERNATIVA: Si no usas la app web, usa autoform_save_coordinates_as_template pa
             json_file_path: {
                 type: 'string',
                 description: 'Ruta absoluta al archivo JSON exportado desde la app web de AutoForm'
+            },
+            _session_id: {
+                type: 'string',
+                description: '(Opcional) ID de sesion experimental para agrupar tool calls en metrics.jsonl.'
+            },
+            _mode: {
+                type: 'string',
+                enum: ['1_manual_web', '2_hybrid', '3a_acroform', '3b_vision'],
+                description: '(Opcional) Modo de autonomia experimental.'
             }
         },
         required: ['json_file_path']

package/dist/tools/manageTemplates.d.ts

@@ -3,8 +3,18 @@ export declare const listTemplatesSchema: {
     description: string;
     inputSchema: {
         type: "object";
-        properties: {};
-        required: never[];
+        properties: {
+            _session_id: {
+                type: string;
+                description: string;
+            };
+            _mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: string[];
     };
 };
 export declare function handleListTemplates(): Promise<{

package/dist/tools/manageTemplates.js

@@ -6,7 +6,17 @@ export const listTemplatesSchema = {
 CUANDO USAR: Antes de autoform_generate_batch para verificar que el template existe y ver sus columnas requeridas.`,
     inputSchema: {
         type: 'object',
-        properties: {},
+        properties: {
+            _session_id: {
+                type: 'string',
+                description: '(Opcional) ID de sesion experimental para agrupar tool calls en metrics.jsonl.'
+            },
+            _mode: {
+                type: 'string',
+                enum: ['1_manual_web', '2_hybrid', '3a_acroform', '3b_vision'],
+                description: '(Opcional) Modo de autonomia experimental.'
+            }
+        },
         required: []
     }
 };

package/dist/tools/saveCoordinatesAsTemplate.d.ts

@@ -59,6 +59,15 @@ export declare const saveCoordinatesAsTemplateSchema: {
                     required: string[];
                 };
             };
+            _session_id: {
+                type: string;
+                description: string;
+            };
+            _mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
         };
         required: string[];
     };

package/dist/tools/saveCoordinatesAsTemplate.js

@@ -45,6 +45,15 @@ FLUJO TIPICO:
                     },
                     required: ['label', 'page', 'x', 'y', 'width', 'height']
                 }
+            },
+            _session_id: {
+                type: 'string',
+                description: '(Opcional) ID de sesion experimental para agrupar tool calls en metrics.jsonl.'
+            },
+            _mode: {
+                type: 'string',
+                enum: ['1_manual_web', '2_hybrid', '3a_acroform', '3b_vision'],
+                description: '(Opcional) Modo de autonomia experimental.'
             }
         },
         required: ['pdf_path', 'template_name', 'fields']

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autoform-mcp-server",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "MCP server for bulk PDF form filling. Detect fields, fill templates, and generate hundreds of PDFs from data — directly from Claude.",
   "type": "module",
   "main": "dist/index.js",