@geometra/mcp 1.55.0 → 1.56.0

package/dist/__tests__/server-batch-results.test.js

@@ -1086,6 +1086,53 @@ describe('submit_form tool', () => {
         expect(mockState.sendFillFields).not.toHaveBeenCalled();
         expect(mockState.sendClick).toHaveBeenCalledTimes(1);
     });
+    it('aggregates fill + submit fallback into a top-level fallbacks[] on the submit_form result', async () => {
+        const handler = getToolHandler('geometra_submit_form');
+        mockState.currentA11yRoot = node('group', undefined, {
+            bounds: { x: 0, y: 0, width: 1280, height: 800 },
+            meta: { pageUrl: 'https://jobs.example.com/application', scrollX: 0, scrollY: 0 },
+            children: [
+                node('textbox', 'Full name', { value: '', path: [0] }),
+                node('button', 'Submit', {
+                    // Fully offscreen so the fullyVisible resolve misses and the
+                    // relaxed-visibility fallback picks it up — mirrors the click test above.
+                    bounds: { x: 60, y: 780, width: 180, height: 60 },
+                    path: [1],
+                }),
+            ],
+        });
+        mockState.formSchemas = [{
+                formId: 'fm:0',
+                name: 'Application',
+                fieldCount: 1,
+                requiredCount: 1,
+                invalidCount: 1,
+                fields: [{ id: 'ff:0.0', kind: 'text', label: 'Full name' }],
+            }];
+        // Force the fill batched path to throw a recoverable error so submit_form
+        // falls through to the sequential fill loop and tags fill fallback.
+        mockState.sendFillFields.mockRejectedValue(new Error('Unsupported client message type "fillFields"'));
+        mockState.sendClick.mockResolvedValueOnce({ status: 'updated', timeoutMs: 2000 });
+        const result = await handler({
+            valuesByLabel: { 'Full name': 'Taylor Applicant' },
+            submit: { role: 'button', name: 'Submit' },
+            submitTimeoutMs: 1000,
+            detail: 'minimal',
+        });
+        const payload = JSON.parse(result.content[0].text);
+        const fallbacks = payload.fallbacks;
+        expect(Array.isArray(fallbacks)).toBe(true);
+        const phases = fallbacks.map(f => f.phase);
+        expect(phases).toContain('fill');
+        expect(phases).toContain('submit');
+        expect(fallbacks.find(f => f.phase === 'fill')).toMatchObject({
+            attempted: true, used: true, reason: 'batched-threw',
+        });
+        expect(fallbacks.find(f => f.phase === 'submit')).toMatchObject({
+            attempted: true, used: true, reason: 'relaxed-visibility',
+        });
+        expect(payload.fill).toMatchObject({ execution: 'sequential' });
+    });
 });
 describe('fill transparent fallback', () => {
     beforeEach(() => {

package/dist/server.js

@@ -330,7 +330,7 @@ const batchActionSchema = z.discriminatedUnion('type', [
     }),
 ]);
 export function createServer() {
-    const server = new McpServer({ name: 'geometra', version: '1.19.24' }, { capabilities: { tools: {} } });
+    const server = new McpServer({ name: 'geometra', version: '1.19.25' }, { capabilities: { tools: {} } });
     const sessionIdInput = z.string().optional().describe('Session identifier returned by geometra_connect. Omit to use the most recent session.');
     // ── connect ──────────────────────────────────────────────────
     server.tool('geometra_connect', `Connect to a Geometra WebSocket peer, or start \`geometra-proxy\` automatically for a normal web page.
@@ -1205,6 +1205,7 @@ Pass \`pageUrl\`/\`url\` to auto-connect in the same call — use \`isolated: tr
             return err('No UI tree available for form submission');
         const entryUrl = entryA11y.meta?.pageUrl;
         let fillSummary;
+        let fillFallback;
         if (!skipFill) {
             const entryCount = Object.keys(valuesById ?? {}).length + Object.keys(valuesByLabel ?? {}).length;
             if (entryCount === 0) {
@@ -1220,6 +1221,7 @@ Pass \`pageUrl\`/\`url\` to auto-connect in the same call — use \`isolated: tr
             const planned = planFormFill(schema, { valuesById, valuesByLabel });
             if (!planned.ok)
                 return err(planned.error);
+            let usedBatch = true;
             try {
                 const startRevision = session.updateRevision;
                 const wait = await sendFillFields(session, planned.fields);
@@ -1227,25 +1229,63 @@ Pass \`pageUrl\`/\`url\` to auto-connect in the same call — use \`isolated: tr
                 await waitForDeferredBatchUpdate(session, startRevision, wait);
                 fillSummary = {
                     formId: schema.formId,
+                    execution: 'batched',
                     fieldCount: planned.fields.length,
                     ...(ack ? { invalidCount: ack.invalidCount, alertCount: ack.alertCount } : {}),
                     ...(entryCount !== planned.fields.length ? { requestedValueCount: entryCount } : {}),
                 };
             }
             catch (e) {
-                const message = e instanceof Error ? e.message : String(e);
-                return err(`Failed to fill form before submit: ${message}`);
+                if (!canFallbackToSequentialFill(e)) {
+                    const message = e instanceof Error ? e.message : String(e);
+                    return err(`Failed to fill form before submit: ${message}`);
+                }
+                usedBatch = false;
+                fillFallback = { attempted: true, used: true, reason: 'batched-threw', attempts: 2 };
+            }
+            if (!usedBatch) {
+                let successCount = 0;
+                let firstErr;
+                for (const field of planned.fields) {
+                    try {
+                        await executeFillField(session, field, detail);
+                        successCount += 1;
+                    }
+                    catch (e) {
+                        firstErr = e instanceof Error ? e.message : String(e);
+                        break;
+                    }
+                }
+                if (firstErr !== undefined && successCount === 0) {
+                    return err(`Failed to fill form before submit (sequential fallback): ${firstErr}`);
+                }
+                fillSummary = {
+                    formId: schema.formId,
+                    execution: 'sequential',
+                    fieldCount: planned.fields.length,
+                    successCount,
+                    ...(entryCount !== planned.fields.length ? { requestedValueCount: entryCount } : {}),
+                };
             }
         }
         const submitFilter = submit ?? { role: 'button', name: 'Submit' };
-        const resolvedClick = await resolveClickLocation(session, {
+        const resolvedClick = await resolveClickLocationWithFallback(session, {
             filter: submitFilter,
             index: submitIndex,
             fullyVisible: true,
             revealTimeoutMs: 2_500,
         });
-        if (!resolvedClick.ok)
-            return err(`Submit target not found: ${resolvedClick.error}`);
+        if (!resolvedClick.ok) {
+            const payload = {
+                ...connection,
+                completed: false,
+                ...(fillSummary ? { fill: fillSummary } : {}),
+                ...(fillFallback ? { fill_fallback: fillFallback } : {}),
+                submit: { ok: false, error: `Submit target not found: ${resolvedClick.error}` },
+                ...(resolvedClick.fallback ? { submit_fallback: resolvedClick.fallback } : {}),
+            };
+            return err(JSON.stringify(payload, null, detail === 'verbose' ? 2 : undefined));
+        }
         const beforeSubmit = sessionA11y(session);
         const clickWait = await sendClick(session, resolvedClick.value.x, resolvedClick.value.y, submitTimeoutMs);
         let waitResult;
@@ -1274,6 +1314,11 @@ Pass \`pageUrl\`/\`url\` to auto-connect in the same call — use \`isolated: tr
                 timeoutMs: waitFor.timeoutMs ?? 15_000,
             });
             if (!postWait.ok) {
+                const preErrFallbacks = [];
+                if (fillFallback)
+                    preErrFallbacks.push({ phase: 'fill', ...fillFallback });
+                if (resolvedClick.fallback)
+                    preErrFallbacks.push({ phase: 'submit', ...resolvedClick.fallback });
                 const payload = {
                     ...connection,
                     completed: false,
@@ -1283,6 +1328,7 @@ Pass \`pageUrl\`/\`url\` to auto-connect in the same call — use \`isolated: tr
                         ...(resolvedClick.value.target ? { target: compactNodeReference(resolvedClick.value.target) } : {}),
                         ...waitStatusPayload(clickWait),
                     },
+                    ...(preErrFallbacks.length > 0 ? { fallbacks: preErrFallbacks } : {}),
                     waitFor: { ok: false, error: postWait.error },
                 };
                 return err(JSON.stringify(payload, null, detail === 'verbose' ? 2 : undefined));
@@ -1293,6 +1339,16 @@ Pass \`pageUrl\`/\`url\` to auto-connect in the same call — use \`isolated: tr
         const signals = after ? collectSessionSignals(after) : undefined;
         const afterUrl = after?.meta?.pageUrl;
         const navigated = Boolean(afterUrl && entryUrl && afterUrl !== entryUrl);
+        // Aggregate all fallback usage into a single top-level `fallbacks[]`
+        // array so this tool matches the shape emitted by `geometra_run_actions`
+        // and can be aggregated the same way by operators.
+        const fallbackRecords = [];
+        if (fillFallback) {
+            fallbackRecords.push({ phase: 'fill', ...fillFallback });
+        }
+        if (resolvedClick.fallback) {
+            fallbackRecords.push({ phase: 'submit', ...resolvedClick.fallback });
+        }
         const payload = {
             ...connection,
             completed: true,
@@ -1303,6 +1359,7 @@ Pass \`pageUrl\`/\`url\` to auto-connect in the same call — use \`isolated: tr
                 ...waitStatusPayload(clickWait),
             },
             ...(waitResult ? { waitFor: waitConditionCompact(waitResult) } : {}),
+            ...(fallbackRecords.length > 0 ? { fallbacks: fallbackRecords } : {}),
             ...(navigated ? { navigated: true, afterUrl } : {}),
             ...(signals ? { final: sessionSignalsPayload(signals, detail) } : {}),
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geometra/mcp",
-  "version": "1.55.0",
+  "version": "1.56.0",
   "description": "MCP server for Geometra — interact with running Geometra apps via the geometry protocol, no browser needed",
   "license": "MIT",
   "type": "module",