@geometra/mcp 1.19.13 → 1.19.15

package/dist/__tests__/proxy-session-actions.test.js

@@ -1,6 +1,6 @@
 import { afterAll, describe, expect, it } from 'vitest';
 import { WebSocketServer } from 'ws';
-import { connect, disconnect, sendClick, sendListboxPick } from '../session.js';
+import { connect, disconnect, sendClick, sendFillFields, sendListboxPick } from '../session.js';
 describe('proxy-backed MCP actions', () => {
     afterAll(() => {
         disconnect();
@@ -97,6 +97,83 @@ describe('proxy-backed MCP actions', () => {
             await new Promise((resolve, reject) => wss.close(err => (err ? reject(err) : resolve())));
         }
     });
+    it('waits for the post-batch update before resolving fillFields acks', async () => {
+        const wss = new WebSocketServer({ port: 0 });
+        let seenMessage;
+        wss.on('connection', ws => {
+            ws.on('message', raw => {
+                const msg = JSON.parse(String(raw));
+                if (msg.type === 'resize') {
+                    ws.send(JSON.stringify({
+                        type: 'frame',
+                        layout: { x: 0, y: 0, width: 1024, height: 768, children: [] },
+                        tree: { kind: 'box', props: {}, semantic: { tag: 'body', role: 'group' }, children: [] },
+                    }));
+                    return;
+                }
+                if (msg.type === 'fillFields') {
+                    seenMessage = msg;
+                    ws.send(JSON.stringify({
+                        type: 'frame',
+                        layout: { x: 0, y: 0, width: 1024, height: 768, children: [] },
+                        tree: {
+                            kind: 'box',
+                            props: {},
+                            semantic: { tag: 'body', role: 'group', ariaLabel: 'Filled' },
+                            children: [],
+                        },
+                    }));
+                    ws.send(JSON.stringify({
+                        type: 'ack',
+                        requestId: msg.requestId,
+                        result: {
+                            pageUrl: 'https://jobs.example.com/application',
+                            invalidCount: 0,
+                            alertCount: 0,
+                            dialogCount: 0,
+                            busyCount: 0,
+                        },
+                    }));
+                }
+            });
+        });
+        const port = await new Promise((resolve, reject) => {
+            wss.once('listening', () => {
+                const address = wss.address();
+                if (typeof address === 'object' && address)
+                    resolve(address.port);
+                else
+                    reject(new Error('Failed to resolve ephemeral WebSocket port'));
+            });
+            wss.once('error', reject);
+        });
+        try {
+            const session = await connect(`ws://127.0.0.1:${port}`);
+            await expect(sendFillFields(session, [
+                { kind: 'text', fieldLabel: 'Full name', value: 'Taylor Applicant' },
+                { kind: 'choice', fieldLabel: 'Country', value: 'Germany' },
+            ], 80)).resolves.toMatchObject({
+                status: 'updated',
+                timeoutMs: 80,
+                result: {
+                    pageUrl: 'https://jobs.example.com/application',
+                    invalidCount: 0,
+                    alertCount: 0,
+                },
+            });
+            expect(seenMessage).toMatchObject({
+                type: 'fillFields',
+                fields: [
+                    { kind: 'text', fieldLabel: 'Full name', value: 'Taylor Applicant' },
+                    { kind: 'choice', fieldLabel: 'Country', value: 'Germany' },
+                ],
+            });
+        }
+        finally {
+            disconnect();
+            await new Promise((resolve, reject) => wss.close(err => (err ? reject(err) : resolve())));
+        }
+    });
     it('ignores invalid patch paths instead of mutating ancestor layout nodes', async () => {
         const wss = new WebSocketServer({ port: 0 });
         wss.on('connection', ws => {

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

@@ -32,6 +32,11 @@ const mockState = vi.hoisted(() => ({
     sendFileUpload: vi.fn(async () => ({ status: 'updated', timeoutMs: 8000 })),
     sendFieldText: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
     sendFieldChoice: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
+    sendFillFields: vi.fn(async () => ({
+        status: 'updated',
+        timeoutMs: 6000,
+        result: undefined,
+    })),
     sendListboxPick: vi.fn(async () => ({ status: 'updated', timeoutMs: 4500 })),
     sendSelectOption: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
     sendSetChecked: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
@@ -49,6 +54,7 @@ vi.mock('../session.js', () => ({
     sendFileUpload: mockState.sendFileUpload,
     sendFieldText: mockState.sendFieldText,
     sendFieldChoice: mockState.sendFieldChoice,
+    sendFillFields: mockState.sendFillFields,
     sendListboxPick: mockState.sendListboxPick,
     sendSelectOption: mockState.sendSelectOption,
     sendSetChecked: mockState.sendSetChecked,
@@ -314,6 +320,82 @@ describe('batch MCP result shaping', () => {
             readback: { role: 'textbox', valueLength: 220 },
         });
     });
+    it('uses batched proxy fill for compact fill_form responses', async () => {
+        const handler = getToolHandler('geometra_fill_form');
+        mockState.sendFillFields.mockResolvedValueOnce({
+            status: 'acknowledged',
+            timeoutMs: 6000,
+            result: {
+                pageUrl: 'https://jobs.example.com/application',
+                invalidCount: 0,
+                alertCount: 0,
+                dialogCount: 0,
+                busyCount: 0,
+            },
+        });
+        mockState.formSchemas = [
+            {
+                formId: 'fm:0',
+                name: 'Application',
+                fieldCount: 3,
+                requiredCount: 2,
+                invalidCount: 0,
+                fields: [
+                    { id: 'ff:0.0', kind: 'text', label: 'Full name', required: true },
+                    { id: 'ff:0.1', kind: 'choice', label: 'Preferred location', required: true },
+                    { id: 'ff:0.2', kind: 'toggle', label: 'Share my profile for future roles', controlType: 'checkbox' },
+                ],
+            },
+        ];
+        mockState.currentA11yRoot = node('group', undefined, {
+            meta: { pageUrl: 'https://jobs.example.com/application', scrollX: 0, scrollY: 640 },
+            children: [
+                node('textbox', 'Full name', { value: 'Taylor Applicant', path: [0] }),
+                node('combobox', 'Preferred location', { value: 'Berlin, Germany', path: [1] }),
+                node('checkbox', 'Share my profile for future roles', {
+                    path: [2],
+                    state: { checked: true },
+                }),
+            ],
+        });
+        const result = await handler({
+            valuesById: {
+                'ff:0.0': 'Taylor Applicant',
+                'ff:0.1': 'Berlin, Germany',
+                'ff:0.2': true,
+            },
+            includeSteps: false,
+            detail: 'minimal',
+        });
+        const payload = JSON.parse(result.content[0].text);
+        expect(mockState.sendFillFields).toHaveBeenCalledWith(mockState.session, [
+            { kind: 'text', fieldLabel: 'Full name', value: 'Taylor Applicant' },
+            { kind: 'choice', fieldLabel: 'Preferred location', value: 'Berlin, Germany' },
+            {
+                kind: 'toggle',
+                label: 'Share my profile for future roles',
+                checked: true,
+                controlType: 'checkbox',
+            },
+        ]);
+        expect(mockState.sendFieldText).not.toHaveBeenCalled();
+        expect(mockState.sendFieldChoice).not.toHaveBeenCalled();
+        expect(mockState.sendSetChecked).not.toHaveBeenCalled();
+        expect(payload).toMatchObject({
+            completed: true,
+            execution: 'batched',
+            finalSource: 'proxy',
+            formId: 'fm:0',
+            fieldCount: 3,
+            successCount: 3,
+            errorCount: 0,
+            final: {
+                invalidCount: 0,
+                alertCount: 0,
+            },
+        });
+        expect(payload).not.toHaveProperty('steps');
+    });
 });
 describe('query and reveal tools', () => {
     beforeEach(() => {
@@ -363,6 +445,63 @@ describe('query and reveal tools', () => {
             },
         });
     });
+    it('falls back to sequential fill when a batched fill ends without a clean ack and invalid fields remain', async () => {
+        const handler = getToolHandler('geometra_fill_form');
+        mockState.sendFillFields.mockResolvedValueOnce({
+            status: 'updated',
+            timeoutMs: 6000,
+            result: undefined,
+        });
+        mockState.formSchemas = [
+            {
+                formId: 'fm:0',
+                name: 'Application',
+                fieldCount: 2,
+                requiredCount: 2,
+                invalidCount: 2,
+                fields: [
+                    { id: 'ff:0.0', kind: 'text', label: 'Full name', required: true, invalid: true },
+                    { id: 'ff:0.1', kind: 'choice', label: 'Preferred location', required: true, invalid: true },
+                ],
+            },
+        ];
+        mockState.currentA11yRoot = node('group', undefined, {
+            meta: { pageUrl: 'https://jobs.example.com/application', scrollX: 0, scrollY: 640 },
+            children: [
+                node('textbox', 'Full name', {
+                    path: [0],
+                    state: { required: true, invalid: true },
+                }),
+                node('combobox', 'Preferred location', {
+                    path: [1],
+                    value: 'Select',
+                    state: { required: true, invalid: true },
+                }),
+            ],
+        });
+        const result = await handler({
+            valuesById: {
+                'ff:0.0': 'Taylor Applicant',
+                'ff:0.1': 'Berlin, Germany',
+            },
+            includeSteps: false,
+            detail: 'minimal',
+            failOnInvalid: false,
+        });
+        const payload = JSON.parse(result.content[0].text);
+        expect(mockState.sendFillFields).toHaveBeenCalledTimes(1);
+        expect(mockState.sendFieldText).toHaveBeenCalledWith(mockState.session, 'Full name', 'Taylor Applicant', { exact: undefined }, undefined);
+        expect(mockState.sendFieldChoice).toHaveBeenCalledWith(mockState.session, 'Preferred location', 'Berlin, Germany', { exact: undefined, query: undefined }, undefined);
+        expect(payload).toMatchObject({
+            completed: true,
+            execution: 'sequential',
+            formId: 'fm:0',
+            requestedValueCount: 2,
+            fieldCount: 2,
+            successCount: 2,
+            errorCount: 0,
+        });
+    });
     it('reveals an offscreen target with semantic scrolling instead of requiring manual wheels', async () => {
         const handler = getToolHandler('geometra_reveal');
         mockState.currentA11yRoot = node('group', undefined, {

package/dist/server.js

@@ -1,7 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import { formatConnectFailureMessage, isHttpUrl, normalizeConnectTarget } from './connect-utils.js';
-import { connect, connectThroughProxy, disconnect, getSession, sendClick, sendType, sendKey, sendFileUpload, sendFieldText, sendFieldChoice, sendListboxPick, sendSelectOption, sendSetChecked, sendWheel, buildA11yTree, buildCompactUiIndex, buildPageModel, buildFormSchemas, expandPageSection, buildUiDelta, hasUiDelta, nodeIdForPath, summarizeCompactIndex, summarizePageModel, summarizeUiDelta, waitForUiCondition, } from './session.js';
+import { connect, connectThroughProxy, disconnect, getSession, sendClick, sendFillFields, sendType, sendKey, sendFileUpload, sendFieldText, sendFieldChoice, sendListboxPick, sendSelectOption, sendSetChecked, sendWheel, buildA11yTree, buildCompactUiIndex, buildPageModel, buildFormSchemas, expandPageSection, buildUiDelta, hasUiDelta, nodeIdForPath, summarizeCompactIndex, summarizePageModel, summarizeUiDelta, waitForUiCondition, } from './session.js';
 function checkedStateInput() {
     return z
         .union([z.boolean(), z.literal('mixed')])
@@ -152,7 +152,7 @@ const batchActionSchema = z.discriminatedUnion('type', [
     }),
 ]);
 export function createServer() {
-    const server = new McpServer({ name: 'geometra', version: '1.19.13' }, { capabilities: { tools: {} } });
+    const server = new McpServer({ name: 'geometra', version: '1.19.14' }, { capabilities: { tools: {} } });
     // ── connect ──────────────────────────────────────────────────
     server.tool('geometra_connect', `Connect to a Geometra WebSocket peer, or start \`geometra-proxy\` automatically for a normal web page.
 
@@ -213,7 +213,10 @@ Chromium opens **visible** by default unless \`headless: true\`. File upload / w
                     detail: input.detail,
                 }), null, input.detail === 'verbose' ? 2 : undefined));
             }
-            const session = await connect(target.wsUrl);
+            const session = await connect(target.wsUrl, {
+                width: input.width,
+                height: input.height,
+            });
             return ok(JSON.stringify(connectPayload(session, {
                 transport: 'ws',
                 requestedWsUrl: target.wsUrl,
@@ -413,6 +416,68 @@ Pass \`valuesById\` with field ids from \`geometra_form_schema\` for the most st
         const planned = planFormFill(schema, { valuesById, valuesByLabel });
         if (!planned.ok)
             return err(planned.error);
+        if (!includeSteps) {
+            let usedBatch = false;
+            let batchAckResult;
+            try {
+                const startRevision = session.updateRevision;
+                const wait = await sendFillFields(session, planned.fields);
+                const ackResult = parseProxyFillAckResult(wait.result);
+                batchAckResult = ackResult;
+                if (ackResult && ackResult.invalidCount === 0) {
+                    usedBatch = true;
+                    const payload = {
+                        completed: true,
+                        execution: 'batched',
+                        finalSource: 'proxy',
+                        formId: schema.formId,
+                        requestedValueCount: entryCount,
+                        fieldCount: planned.fields.length,
+                        successCount: planned.fields.length,
+                        errorCount: 0,
+                        final: ackResult,
+                    };
+                    return ok(JSON.stringify(payload, null, detail === 'verbose' ? 2 : undefined));
+                }
+                await waitForDeferredBatchUpdate(session, startRevision, wait);
+                await waitForBatchFieldReadback(session, planned.fields);
+                usedBatch = true;
+            }
+            catch (e) {
+                if (!canFallbackToSequentialFill(e)) {
+                    const message = e instanceof Error ? e.message : String(e);
+                    return err(message);
+                }
+            }
+            if (usedBatch) {
+                const after = sessionA11y(session);
+                const signals = after ? collectSessionSignals(after) : undefined;
+                const invalidRemaining = signals?.invalidFields.length ?? 0;
+                if ((!batchAckResult || batchAckResult.invalidCount > 0) && invalidRemaining > 0) {
+                    usedBatch = false;
+                }
+            }
+            if (usedBatch) {
+                const after = sessionA11y(session);
+                const signals = after ? collectSessionSignals(after) : undefined;
+                const invalidRemaining = signals?.invalidFields.length ?? 0;
+                const payload = {
+                    completed: true,
+                    execution: 'batched',
+                    finalSource: 'session',
+                    formId: schema.formId,
+                    requestedValueCount: entryCount,
+                    fieldCount: planned.fields.length,
+                    successCount: planned.fields.length,
+                    errorCount: 0,
+                    ...(signals ? { final: sessionSignalsPayload(signals, detail) } : {}),
+                };
+                if (failOnInvalid && invalidRemaining > 0) {
+                    return err(JSON.stringify(payload, null, detail === 'verbose' ? 2 : undefined));
+                }
+                return ok(JSON.stringify(payload, null, detail === 'verbose' ? 2 : undefined));
+            }
+        }
         const steps = [];
         let stoppedAt;
         for (let index = 0; index < planned.fields.length; index++) {
@@ -439,6 +504,7 @@ Pass \`valuesById\` with field ids from \`geometra_form_schema\` for the most st
         const errorCount = steps.length - successCount;
         const payload = {
             completed: stoppedAt === undefined && steps.length === planned.fields.length,
+            execution: 'sequential',
             formId: schema.formId,
             requestedValueCount: entryCount,
             fieldCount: planned.fields.length,
@@ -1314,6 +1380,69 @@ function planFormFill(schema, opts) {
     }
     return { ok: true, fields: planned };
 }
+function canFallbackToSequentialFill(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return (message.includes('Unsupported client message type "fillFields"') ||
+        message.includes('Client message type "fillFields" is not supported'));
+}
+function parseProxyFillAckResult(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const candidate = value;
+    if (typeof candidate.invalidCount !== 'number' ||
+        typeof candidate.alertCount !== 'number' ||
+        typeof candidate.dialogCount !== 'number' ||
+        typeof candidate.busyCount !== 'number') {
+        return undefined;
+    }
+    return {
+        ...(typeof candidate.pageUrl === 'string' ? { pageUrl: candidate.pageUrl } : {}),
+        invalidCount: candidate.invalidCount,
+        alertCount: candidate.alertCount,
+        dialogCount: candidate.dialogCount,
+        busyCount: candidate.busyCount,
+    };
+}
+async function waitForDeferredBatchUpdate(session, startRevision, wait) {
+    if (wait.status !== 'acknowledged' || session.updateRevision > startRevision)
+        return;
+    await waitForUiCondition(session, () => session.updateRevision > startRevision, 750);
+}
+async function waitForBatchFieldReadback(session, fields) {
+    await waitForUiCondition(session, () => {
+        const a11y = sessionA11y(session);
+        if (!a11y)
+            return false;
+        return fields.every(field => batchFieldReadbackMatches(a11y, field));
+    }, 1500);
+}
+function batchFieldReadbackMatches(a11y, field) {
+    switch (field.kind) {
+        case 'text': {
+            const matches = findNodes(a11y, { name: field.fieldLabel, role: 'textbox' });
+            return matches.some(match => normalizeLookupKey(match.value ?? '') === normalizeLookupKey(field.value));
+        }
+        case 'choice': {
+            const directMatches = [
+                ...findNodes(a11y, { name: field.fieldLabel, role: 'combobox' }),
+                ...findNodes(a11y, { name: field.fieldLabel, role: 'textbox' }),
+                ...findNodes(a11y, { name: field.fieldLabel, role: 'button' }),
+            ];
+            if (directMatches.length === 0)
+                return true;
+            return directMatches.some(match => normalizeLookupKey(match.value ?? '') === normalizeLookupKey(field.value));
+        }
+        case 'toggle':
+            return true;
+        case 'file': {
+            const matches = [
+                ...findNodes(a11y, { name: field.fieldLabel, role: 'textbox' }),
+                ...findNodes(a11y, { name: field.fieldLabel, role: 'button' }),
+            ];
+            return matches.length === 0 || matches.some(match => Boolean(match.value && match.value.trim()));
+        }
+    }
+}
 async function executeBatchAction(session, action, detail, includeSteps) {
     switch (action.type) {
         case 'click': {

package/dist/session.d.ts

@@ -316,12 +316,40 @@ export interface Session {
 export interface UpdateWaitResult {
     status: 'updated' | 'acknowledged' | 'timed_out';
     timeoutMs: number;
+    result?: unknown;
 }
+export type ProxyFillField = {
+    kind: 'text';
+    fieldLabel: string;
+    value: string;
+    exact?: boolean;
+} | {
+    kind: 'choice';
+    fieldLabel: string;
+    value: string;
+    query?: string;
+    exact?: boolean;
+} | {
+    kind: 'toggle';
+    label: string;
+    checked?: boolean;
+    exact?: boolean;
+    controlType?: 'checkbox' | 'radio';
+} | {
+    kind: 'file';
+    fieldLabel: string;
+    paths: string[];
+    exact?: boolean;
+};
 /**
  * Connect to a running Geometra server. Waits for the first frame so that
  * layout/tree state is available immediately after connection.
  */
-export declare function connect(url: string): Promise<Session>;
+export declare function connect(url: string, opts?: {
+    width?: number;
+    height?: number;
+    skipInitialResize?: boolean;
+}): Promise<Session>;
 /**
  * Start geometra-proxy for `pageUrl`, connect to its WebSocket, and attach the child
  * process to the session so disconnect / reconnect can clean it up.
@@ -380,6 +408,8 @@ export declare function sendFieldChoice(session: Session, fieldLabel: string, va
     exact?: boolean;
     query?: string;
 }, timeoutMs?: number): Promise<UpdateWaitResult>;
+/** Fill several semantic form fields in one proxy-side batch. */
+export declare function sendFillFields(session: Session, fields: ProxyFillField[], timeoutMs?: number): Promise<UpdateWaitResult>;
 /** ARIA `role=option` listbox (e.g. React Select). Optional click opens the list. */
 export declare function sendListboxPick(session: Session, label: string, opts?: {
     exact?: boolean;

package/dist/session.js

@@ -3,6 +3,14 @@ import { spawnGeometraProxy } from './proxy-spawn.js';
 let activeSession = null;
 const ACTION_UPDATE_TIMEOUT_MS = 2000;
 const LISTBOX_UPDATE_TIMEOUT_MS = 4500;
+const FILL_BATCH_BASE_TIMEOUT_MS = 2500;
+const FILL_BATCH_TEXT_FIELD_TIMEOUT_MS = 275;
+const FILL_BATCH_TEXT_LENGTH_TIMEOUT_MS = 120;
+const FILL_BATCH_TEXT_LENGTH_SLICE = 80;
+const FILL_BATCH_CHOICE_FIELD_TIMEOUT_MS = 500;
+const FILL_BATCH_TOGGLE_FIELD_TIMEOUT_MS = 225;
+const FILL_BATCH_FILE_FIELD_TIMEOUT_MS = 5000;
+const FILL_BATCH_MAX_TIMEOUT_MS = 60_000;
 let nextRequestSequence = 0;
 function shutdownPreviousSession() {
     const prev = activeSession;
@@ -28,7 +36,7 @@ function shutdownPreviousSession() {
  * Connect to a running Geometra server. Waits for the first frame so that
  * layout/tree state is available immediately after connection.
  */
-export function connect(url) {
+export function connect(url, opts) {
     return new Promise((resolve, reject) => {
         shutdownPreviousSession();
         const ws = new WebSocket(url);
@@ -42,8 +50,11 @@ export function connect(url) {
             }
         }, 10_000);
         ws.on('open', () => {
-            // Send initial resize so server computes layout
-            ws.send(JSON.stringify({ type: 'resize', width: 1024, height: 768 }));
+            if (opts?.skipInitialResize)
+                return;
+            const width = opts?.width ?? 1024;
+            const height = opts?.height ?? 768;
+            ws.send(JSON.stringify({ type: 'resize', width, height }));
         });
         ws.on('message', (data) => {
             try {
@@ -107,7 +118,7 @@ export async function connectThroughProxy(options) {
         slowMo: options.slowMo,
     });
     try {
-        const session = await connect(wsUrl);
+        const session = await connect(wsUrl, { skipInitialResize: true });
         session.proxyChild = child;
         return session;
     }
@@ -127,6 +138,32 @@ export function getSession() {
 export function disconnect() {
     shutdownPreviousSession();
 }
+function estimateFillBatchTimeout(fields) {
+    let total = FILL_BATCH_BASE_TIMEOUT_MS;
+    let totalTextLength = 0;
+    for (const field of fields) {
+        switch (field.kind) {
+            case 'text':
+                totalTextLength += field.value.length;
+                total += FILL_BATCH_TEXT_FIELD_TIMEOUT_MS;
+                total += Math.ceil(Math.max(1, field.value.length) / FILL_BATCH_TEXT_LENGTH_SLICE) * FILL_BATCH_TEXT_LENGTH_TIMEOUT_MS;
+                break;
+            case 'choice':
+                total += FILL_BATCH_CHOICE_FIELD_TIMEOUT_MS;
+                break;
+            case 'toggle':
+                total += FILL_BATCH_TOGGLE_FIELD_TIMEOUT_MS;
+                break;
+            case 'file':
+                total += FILL_BATCH_FILE_FIELD_TIMEOUT_MS;
+                break;
+        }
+    }
+    if (fields.length >= 20 || totalTextLength >= 1500) {
+        total = Math.max(total, 30_000);
+    }
+    return Math.min(total, FILL_BATCH_MAX_TIMEOUT_MS);
+}
 export function waitForUiCondition(session, predicate, timeoutMs) {
     return new Promise((resolve) => {
         const check = () => {
@@ -263,6 +300,10 @@ export function sendFieldChoice(session, fieldLabel, value, opts, timeoutMs = LI
         payload.query = opts.query;
     return sendAndWaitForUpdate(session, payload, timeoutMs);
 }
+/** Fill several semantic form fields in one proxy-side batch. */
+export function sendFillFields(session, fields, timeoutMs = estimateFillBatchTimeout(fields)) {
+    return sendAndWaitForUpdate(session, { type: 'fillFields', fields }, timeoutMs);
+}
 /** ARIA `role=option` listbox (e.g. React Select). Optional click opens the list. */
 export function sendListboxPick(session, label, opts, timeoutMs = LISTBOX_UPDATE_TIMEOUT_MS) {
     const payload = { type: 'listboxPick', label };
@@ -1027,7 +1068,8 @@ function buildFormSchemaForNode(root, formNode, options) {
             consumed.add(candidateKey);
         }
     }
-    const filteredFields = fields.filter(field => {
+    const compactFields = trimSchemaFieldContexts(fields);
+    const filteredFields = compactFields.filter(field => {
         if (options?.onlyRequiredFields && !field.required)
             return false;
         if (options?.onlyInvalidFields && !field.invalid)
@@ -1040,12 +1082,35 @@ function buildFormSchemaForNode(root, formNode, options) {
     return {
         formId: sectionIdForPath('form', formNode.path),
         ...(name ? { name } : {}),
-        fieldCount: fields.length,
-        requiredCount: fields.filter(field => field.required).length,
-        invalidCount: fields.filter(field => field.invalid).length,
+        fieldCount: compactFields.length,
+        requiredCount: compactFields.filter(field => field.required).length,
+        invalidCount: compactFields.filter(field => field.invalid).length,
         fields: pageFields,
     };
 }
+function trimSchemaFieldContexts(fields) {
+    const labelCounts = new Map();
+    for (const field of fields) {
+        const key = normalizeUiText(field.label);
+        labelCounts.set(key, (labelCounts.get(key) ?? 0) + 1);
+    }
+    return fields.map(field => {
+        if (!field.context)
+            return field;
+        const trimmed = {};
+        if (field.context.prompt && normalizeUiText(field.context.prompt) !== normalizeUiText(field.label)) {
+            trimmed.prompt = field.context.prompt;
+        }
+        if ((labelCounts.get(normalizeUiText(field.label)) ?? 0) > 1 && field.context.section) {
+            trimmed.section = field.context.section;
+        }
+        if (Object.keys(trimmed).length === 0) {
+            const { context: _context, ...rest } = field;
+            return rest;
+        }
+        return { ...field, context: trimmed };
+    });
+}
 function toLandmarkModel(node) {
     const name = sectionDisplayName(node, 'landmark');
     return {
@@ -1753,6 +1818,7 @@ function waitForNextUpdate(session, timeoutMs = ACTION_UPDATE_TIMEOUT_MS, reques
                         resolve({
                             status: session.updateRevision > startRevision ? 'updated' : 'acknowledged',
                             timeoutMs,
+                            ...(msg.result !== undefined ? { result: msg.result } : {}),
                         });
                     }
                     return;
@@ -1772,7 +1838,11 @@ function waitForNextUpdate(session, timeoutMs = ACTION_UPDATE_TIMEOUT_MS, reques
                 }
                 else if (msg.type === 'ack') {
                     cleanup();
-                    resolve({ status: 'acknowledged', timeoutMs });
+                    resolve({
+                        status: 'acknowledged',
+                        timeoutMs,
+                        ...(msg.result !== undefined ? { result: msg.result } : {}),
+                    });
                 }
             }
             catch { /* ignore */ }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geometra/mcp",
-  "version": "1.19.13",
+  "version": "1.19.15",
   "description": "MCP server for Geometra — interact with running Geometra apps via the geometry protocol, no browser needed",
   "license": "MIT",
   "type": "module",
@@ -30,7 +30,7 @@
     "ui-testing"
   ],
   "dependencies": {
-    "@geometra/proxy": "^1.19.13",
+    "@geometra/proxy": "^1.19.15",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "ws": "^8.18.0",
     "zod": "^3.23.0"