@geometra/mcp 1.19.14 → 1.19.16

package/dist/session.d.ts

@@ -27,6 +27,7 @@ export interface A11yNode {
         pageUrl?: string;
         scrollX?: number;
         scrollY?: number;
+        controlTag?: string;
     };
     bounds: {
         x: number;
@@ -242,12 +243,16 @@ export interface PageSectionDetail {
     textPreview: string[];
 }
 export type FormSchemaFieldKind = 'text' | 'choice' | 'toggle' | 'multi_choice';
+export type FormSchemaChoiceType = 'select' | 'group' | 'listbox';
+export type FormSchemaContextMode = 'auto' | 'always' | 'none';
 export interface FormSchemaField {
     id: string;
     kind: FormSchemaFieldKind;
     label: string;
     required?: boolean;
     invalid?: boolean;
+    choiceType?: FormSchemaChoiceType;
+    booleanChoice?: boolean;
     controlType?: 'checkbox' | 'radio';
     value?: string;
     valueLength?: number;
@@ -265,6 +270,14 @@ export interface FormSchemaModel {
     invalidCount: number;
     fields: FormSchemaField[];
 }
+export interface FormSchemaBuildOptions {
+    formId?: string;
+    maxFields?: number;
+    onlyRequiredFields?: boolean;
+    onlyInvalidFields?: boolean;
+    includeOptions?: boolean;
+    includeContext?: FormSchemaContextMode;
+}
 export interface UiNodeUpdate {
     before: CompactUiNode;
     after: CompactUiNode;
@@ -312,6 +325,13 @@ export interface Session {
     updateRevision: number;
     /** Present when this session owns a child geometra-proxy process (pageUrl connect). */
     proxyChild?: ChildProcess;
+    proxyReusable?: boolean;
+    cachedA11y?: A11yNode | null;
+    cachedA11yRevision?: number;
+    cachedFormSchemas?: Map<string, {
+        revision: number;
+        forms: FormSchemaModel[];
+    }>;
 }
 export interface UpdateWaitResult {
     status: 'updated' | 'acknowledged' | 'timed_out';
@@ -319,16 +339,25 @@ export interface UpdateWaitResult {
     result?: unknown;
 }
 export type ProxyFillField = {
+    kind: 'auto';
+    fieldId?: string;
+    fieldLabel: string;
+    value: string | boolean;
+    exact?: boolean;
+} | {
     kind: 'text';
+    fieldId?: string;
     fieldLabel: string;
     value: string;
     exact?: boolean;
 } | {
     kind: 'choice';
+    fieldId?: string;
     fieldLabel: string;
     value: string;
     query?: string;
     exact?: boolean;
+    choiceType?: FormSchemaChoiceType;
 } | {
     kind: 'toggle';
     label: string;
@@ -337,6 +366,7 @@ export type ProxyFillField = {
     controlType?: 'checkbox' | 'radio';
 } | {
     kind: 'file';
+    fieldId?: string;
     fieldLabel: string;
     paths: string[];
     exact?: boolean;
@@ -349,6 +379,8 @@ export declare function connect(url: string, opts?: {
     width?: number;
     height?: number;
     skipInitialResize?: boolean;
+    closePreviousProxy?: boolean;
+    awaitInitialFrame?: boolean;
 }): Promise<Session>;
 /**
  * Start geometra-proxy for `pageUrl`, connect to its WebSocket, and attach the child
@@ -361,9 +393,12 @@ export declare function connectThroughProxy(options: {
     width?: number;
     height?: number;
     slowMo?: number;
+    awaitInitialFrame?: boolean;
 }): Promise<Session>;
 export declare function getSession(): Session | null;
-export declare function disconnect(): void;
+export declare function disconnect(opts?: {
+    closeProxy?: boolean;
+}): void;
 export declare function waitForUiCondition(session: Session, predicate: () => boolean, timeoutMs: number): Promise<boolean>;
 /**
  * Send a click event at (x, y) and wait for the next frame/patch response.
@@ -402,11 +437,14 @@ export declare function sendFileUpload(session: Session, paths: string[], opts?:
 /** Set a labeled text-like field (`input`, `textarea`, contenteditable, ARIA textbox) semantically. */
 export declare function sendFieldText(session: Session, fieldLabel: string, value: string, opts?: {
     exact?: boolean;
+    fieldId?: string;
 }, timeoutMs?: number): Promise<UpdateWaitResult>;
 /** Choose a value for a labeled choice field (select, custom combobox, or radio-style group). */
 export declare function sendFieldChoice(session: Session, fieldLabel: string, value: string, opts?: {
     exact?: boolean;
     query?: string;
+    choiceType?: FormSchemaChoiceType;
+    fieldId?: 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>;
@@ -438,6 +476,8 @@ export declare function sendWheel(session: Session, deltaY: number, opts?: {
     x?: number;
     y?: number;
 }, timeoutMs?: number): Promise<UpdateWaitResult>;
+/** Navigate the proxy page to a new URL while keeping the browser process alive. */
+export declare function sendNavigate(session: Session, url: string, timeoutMs?: number): Promise<UpdateWaitResult>;
 /**
  * Build a flat accessibility tree from the raw UI tree + layout.
  * This is a standalone reimplementation that works with raw JSON —
@@ -467,12 +507,7 @@ export declare function buildPageModel(root: A11yNode, options?: {
     maxPrimaryActions?: number;
     maxSectionsPerKind?: number;
 }): PageModel;
-export declare function buildFormSchemas(root: A11yNode, options?: {
-    formId?: string;
-    maxFields?: number;
-    onlyRequiredFields?: boolean;
-    onlyInvalidFields?: boolean;
-}): FormSchemaModel[];
+export declare function buildFormSchemas(root: A11yNode, options?: FormSchemaBuildOptions): FormSchemaModel[];
 /**
  * Expand a page-model section by stable ID into richer, on-demand details.
  */

package/dist/session.js

@@ -1,16 +1,69 @@
 import WebSocket from 'ws';
 import { spawnGeometraProxy } from './proxy-spawn.js';
 let activeSession = null;
+let reusableProxy = 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 = 250;
-const FILL_BATCH_CHOICE_FIELD_TIMEOUT_MS = 450;
-const FILL_BATCH_TOGGLE_FIELD_TIMEOUT_MS = 200;
+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 = 30_000;
+const FILL_BATCH_MAX_TIMEOUT_MS = 60_000;
 let nextRequestSequence = 0;
-function shutdownPreviousSession() {
+function invalidateSessionCaches(session) {
+    session.cachedA11y = null;
+    session.cachedA11yRevision = -1;
+    session.cachedFormSchemas?.clear();
+}
+function clearReusableProxyIfExited() {
+    if (!reusableProxy?.child.killed && reusableProxy?.child.exitCode === null && reusableProxy?.child.signalCode === null) {
+        return;
+    }
+    reusableProxy = null;
+}
+function setReusableProxy(child, wsUrl, opts) {
+    reusableProxy = {
+        child,
+        wsUrl,
+        headless: opts.headless === true,
+        slowMo: opts.slowMo ?? 0,
+        width: opts.width ?? 1280,
+        height: opts.height ?? 720,
+        pageUrl: opts.pageUrl,
+    };
+    const clear = () => {
+        if (reusableProxy?.child === child)
+            reusableProxy = null;
+    };
+    child.once('exit', clear);
+    child.once('close', clear);
+    child.once('error', clear);
+}
+function closeReusableProxy() {
+    clearReusableProxyIfExited();
+    const proxy = reusableProxy;
+    reusableProxy = null;
+    if (!proxy)
+        return;
+    try {
+        proxy.child.kill('SIGTERM');
+    }
+    catch {
+        /* ignore */
+    }
+}
+function rememberReusableProxyPageUrl(session) {
+    const pageUrl = session.cachedA11y?.meta?.pageUrl;
+    if (!pageUrl)
+        return;
+    if (session.proxyChild && reusableProxy?.child === session.proxyChild) {
+        reusableProxy.pageUrl = pageUrl;
+    }
+}
+function shutdownPreviousSession(opts) {
     const prev = activeSession;
     if (!prev)
         return;
@@ -22,6 +75,12 @@ function shutdownPreviousSession() {
         /* ignore */
     }
     if (prev.proxyChild) {
+        const shouldKeepProxy = prev.proxyReusable && opts?.closeProxy === false;
+        rememberReusableProxyPageUrl(prev);
+        if (shouldKeepProxy)
+            return;
+        if (reusableProxy?.child === prev.proxyChild)
+            reusableProxy = null;
         try {
             prev.proxyChild.kill('SIGTERM');
         }
@@ -36,9 +95,22 @@ function shutdownPreviousSession() {
  */
 export function connect(url, opts) {
     return new Promise((resolve, reject) => {
-        shutdownPreviousSession();
+        clearReusableProxyIfExited();
+        if (reusableProxy && reusableProxy.wsUrl !== url) {
+            closeReusableProxy();
+        }
+        shutdownPreviousSession({ closeProxy: opts?.closePreviousProxy ?? true });
         const ws = new WebSocket(url);
-        const session = { ws, layout: null, tree: null, url, updateRevision: 0 };
+        const session = {
+            ws,
+            layout: null,
+            tree: null,
+            url,
+            updateRevision: 0,
+            cachedA11y: null,
+            cachedA11yRevision: -1,
+            cachedFormSchemas: new Map(),
+        };
         let resolved = false;
         const timeout = setTimeout(() => {
             if (!resolved) {
@@ -48,11 +120,17 @@ export function connect(url, opts) {
             }
         }, 10_000);
         ws.on('open', () => {
-            if (opts?.skipInitialResize)
-                return;
-            const width = opts?.width ?? 1024;
-            const height = opts?.height ?? 768;
-            ws.send(JSON.stringify({ type: 'resize', width, height }));
+            if (!opts?.skipInitialResize) {
+                const width = opts?.width ?? 1024;
+                const height = opts?.height ?? 768;
+                ws.send(JSON.stringify({ type: 'resize', width, height }));
+            }
+            if (opts?.awaitInitialFrame === false && !resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                activeSession = session;
+                resolve(session);
+            }
         });
         ws.on('message', (data) => {
             try {
@@ -61,6 +139,7 @@ export function connect(url, opts) {
                     session.layout = msg.layout;
                     session.tree = msg.tree;
                     session.updateRevision++;
+                    invalidateSessionCaches(session);
                     if (!resolved) {
                         resolved = true;
                         clearTimeout(timeout);
@@ -71,6 +150,7 @@ export function connect(url, opts) {
                 else if (msg.type === 'patch' && session.layout) {
                     applyPatches(session.layout, msg.patches);
                     session.updateRevision++;
+                    invalidateSessionCaches(session);
                 }
             }
             catch { /* ignore malformed messages */ }
@@ -85,7 +165,7 @@ export function connect(url, opts) {
         ws.on('close', () => {
             if (activeSession === session) {
                 activeSession = null;
-                if (session.proxyChild) {
+                if (session.proxyChild && !session.proxyReusable) {
                     try {
                         session.proxyChild.kill('SIGTERM');
                     }
@@ -107,6 +187,47 @@ export function connect(url, opts) {
  * process to the session so disconnect / reconnect can clean it up.
  */
 export async function connectThroughProxy(options) {
+    clearReusableProxyIfExited();
+    const desiredHeadless = options.headless === true;
+    const desiredSlowMo = options.slowMo ?? 0;
+    if (reusableProxy &&
+        reusableProxy.headless === desiredHeadless &&
+        reusableProxy.slowMo === desiredSlowMo) {
+        const session = activeSession?.proxyChild === reusableProxy.child
+            ? activeSession
+            : await connect(reusableProxy.wsUrl, {
+                skipInitialResize: true,
+                closePreviousProxy: false,
+                awaitInitialFrame: options.awaitInitialFrame,
+            });
+        if (!session) {
+            throw new Error('Failed to attach to reusable proxy session');
+        }
+        session.proxyChild = reusableProxy.child;
+        session.proxyReusable = true;
+        const desiredWidth = options.width ?? reusableProxy.width;
+        const desiredHeight = options.height ?? reusableProxy.height;
+        if (desiredWidth !== reusableProxy.width || desiredHeight !== reusableProxy.height) {
+            await sendAndWaitForUpdate(session, {
+                type: 'resize',
+                width: desiredWidth,
+                height: desiredHeight,
+            }, 5_000);
+            reusableProxy.width = desiredWidth;
+            reusableProxy.height = desiredHeight;
+        }
+        if (options.pageUrl) {
+            const currentUrl = session.cachedA11y?.meta?.pageUrl ?? reusableProxy.pageUrl;
+            if (currentUrl !== options.pageUrl) {
+                await sendNavigate(session, options.pageUrl, 15_000);
+                if (reusableProxy?.child === session.proxyChild) {
+                    reusableProxy.pageUrl = options.pageUrl;
+                }
+            }
+        }
+        return session;
+    }
+    closeReusableProxy();
     const { child, wsUrl } = await spawnGeometraProxy({
         pageUrl: options.pageUrl,
         port: options.port ?? 0,
@@ -116,8 +237,20 @@ export async function connectThroughProxy(options) {
         slowMo: options.slowMo,
     });
     try {
-        const session = await connect(wsUrl, { skipInitialResize: true });
+        const session = await connect(wsUrl, {
+            skipInitialResize: true,
+            closePreviousProxy: false,
+            awaitInitialFrame: options.awaitInitialFrame,
+        });
         session.proxyChild = child;
+        session.proxyReusable = true;
+        setReusableProxy(child, wsUrl, {
+            headless: options.headless,
+            slowMo: options.slowMo,
+            width: options.width,
+            height: options.height,
+            pageUrl: options.pageUrl,
+        });
         return session;
     }
     catch (e) {
@@ -133,18 +266,26 @@ export async function connectThroughProxy(options) {
 export function getSession() {
     return activeSession;
 }
-export function disconnect() {
-    shutdownPreviousSession();
+export function disconnect(opts) {
+    shutdownPreviousSession({ closeProxy: opts?.closeProxy ?? false });
+    if (opts?.closeProxy)
+        closeReusableProxy();
 }
 function estimateFillBatchTimeout(fields) {
     let total = FILL_BATCH_BASE_TIMEOUT_MS;
+    let totalTextLength = 0;
     for (const field of fields) {
         switch (field.kind) {
+            case 'auto':
+                total += typeof field.value === 'boolean' ? FILL_BATCH_TOGGLE_FIELD_TIMEOUT_MS : FILL_BATCH_CHOICE_FIELD_TIMEOUT_MS;
+                break;
             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;
+                total += field.choiceType === 'group' ? FILL_BATCH_TOGGLE_FIELD_TIMEOUT_MS : FILL_BATCH_CHOICE_FIELD_TIMEOUT_MS;
                 break;
             case 'toggle':
                 total += FILL_BATCH_TOGGLE_FIELD_TIMEOUT_MS;
@@ -154,6 +295,9 @@ function estimateFillBatchTimeout(fields) {
                 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) {
@@ -277,6 +421,8 @@ export function sendFieldText(session, fieldLabel, value, opts, timeoutMs) {
     };
     if (opts?.exact !== undefined)
         payload.exact = opts.exact;
+    if (opts?.fieldId)
+        payload.fieldId = opts.fieldId;
     return sendAndWaitForUpdate(session, payload, timeoutMs);
 }
 /** Choose a value for a labeled choice field (select, custom combobox, or radio-style group). */
@@ -290,6 +436,10 @@ export function sendFieldChoice(session, fieldLabel, value, opts, timeoutMs = LI
         payload.exact = opts.exact;
     if (opts?.query)
         payload.query = opts.query;
+    if (opts?.choiceType)
+        payload.choiceType = opts.choiceType;
+    if (opts?.fieldId)
+        payload.fieldId = opts.fieldId;
     return sendAndWaitForUpdate(session, payload, timeoutMs);
 }
 /** Fill several semantic form fields in one proxy-side batch. */
@@ -341,6 +491,13 @@ export function sendWheel(session, deltaY, opts, timeoutMs) {
         ...(opts?.y !== undefined ? { y: opts.y } : {}),
     }, timeoutMs);
 }
+/** Navigate the proxy page to a new URL while keeping the browser process alive. */
+export function sendNavigate(session, url, timeoutMs = 15_000) {
+    return sendAndWaitForUpdate(session, {
+        type: 'navigate',
+        url,
+    }, timeoutMs, { requireUpdateOnAck: true });
+}
 /**
  * Build a flat accessibility tree from the raw UI tree + layout.
  * This is a standalone reimplementation that works with raw JSON —
@@ -966,10 +1123,16 @@ function simpleSchemaField(root, node) {
     const label = fieldLabel(node) ?? sanitizeInlineName(node.name, 80) ?? context?.prompt;
     if (!label)
         return null;
+    const choiceType = node.role === 'combobox'
+        ? node.meta?.controlTag === 'select'
+            ? 'select'
+            : 'listbox'
+        : undefined;
     return {
         id: formFieldIdForPath(node.path),
         kind: node.role === 'combobox' ? 'choice' : 'text',
         label,
+        ...(choiceType ? { choiceType } : {}),
         ...(node.state?.required ? { required: true } : {}),
         ...(node.state?.invalid ? { invalid: true } : {}),
         ...compactSchemaValue(node.value, 72),
@@ -994,6 +1157,7 @@ function groupedSchemaField(root, grouped) {
         id: formFieldIdForPath(grouped.container.path),
         kind: radioLike ? 'choice' : 'multi_choice',
         label: grouped.prompt,
+        ...(radioLike ? { choiceType: 'group' } : {}),
         ...(grouped.controls.some(control => control.state?.required) ? { required: true } : {}),
         ...(grouped.controls.some(control => control.state?.invalid) ? { invalid: true } : {}),
         ...(radioLike
@@ -1060,7 +1224,7 @@ function buildFormSchemaForNode(root, formNode, options) {
             consumed.add(candidateKey);
         }
     }
-    const compactFields = trimSchemaFieldContexts(fields);
+    const compactFields = presentFormSchemaFields(fields, options);
     const filteredFields = compactFields.filter(field => {
         if (options?.onlyRequiredFields && !field.required)
             return false;
@@ -1081,14 +1245,35 @@ function buildFormSchemaForNode(root, formNode, options) {
     };
 }
 function trimSchemaFieldContexts(fields) {
+    return presentFormSchemaFields(fields, { includeOptions: true, includeContext: 'auto' });
+}
+function presentFormSchemaFields(fields, options) {
+    const includeOptions = options?.includeOptions ?? false;
+    const includeContext = options?.includeContext ?? 'auto';
     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 => {
+        const booleanChoice = field.kind === 'choice' &&
+            field.choiceType === 'group' &&
+            field.optionCount === 2 &&
+            field.options?.length === 2 &&
+            field.options.every(option => ['yes', 'no'].includes(normalizeUiText(option).toLowerCase()));
+        const next = { ...field };
+        if (booleanChoice)
+            next.booleanChoice = true;
+        if (!includeOptions)
+            delete next.options;
+        if (includeContext === 'none') {
+            delete next.context;
+            return next;
+        }
         if (!field.context)
-            return field;
+            return next;
+        if (includeContext === 'always')
+            return next;
         const trimmed = {};
         if (field.context.prompt && normalizeUiText(field.context.prompt) !== normalizeUiText(field.label)) {
             trimmed.prompt = field.context.prompt;
@@ -1097,10 +1282,11 @@ function trimSchemaFieldContexts(fields) {
             trimmed.section = field.context.section;
         }
         if (Object.keys(trimmed).length === 0) {
-            const { context: _context, ...rest } = field;
-            return rest;
+            delete next.context;
+            return next;
         }
-        return { ...field, context: trimmed };
+        next.context = trimmed;
+        return next;
     });
 }
 function toLandmarkModel(node) {
@@ -1682,6 +1868,8 @@ function walkNode(element, layout, path) {
         meta.scrollX = semantic.scrollX;
     if (typeof semantic?.scrollY === 'number' && Number.isFinite(semantic.scrollY))
         meta.scrollY = semantic.scrollY;
+    if (typeof semantic?.tag === 'string' && semantic.tag.trim().length > 0)
+        meta.controlTag = semantic.tag;
     const children = [];
     const elementChildren = element.children;
     const layoutChildren = layout.children;
@@ -1781,7 +1969,7 @@ function applyPatches(layout, patches) {
             node.height = patch.height;
     }
 }
-function sendAndWaitForUpdate(session, message, timeoutMs = ACTION_UPDATE_TIMEOUT_MS) {
+function sendAndWaitForUpdate(session, message, timeoutMs = ACTION_UPDATE_TIMEOUT_MS, opts) {
     return new Promise((resolve, reject) => {
         if (session.ws.readyState !== WebSocket.OPEN) {
             reject(new Error('Not connected'));
@@ -1790,11 +1978,14 @@ function sendAndWaitForUpdate(session, message, timeoutMs = ACTION_UPDATE_TIMEOU
         const requestId = `req-${++nextRequestSequence}`;
         const startRevision = session.updateRevision;
         session.ws.send(JSON.stringify({ ...message, requestId }));
-        waitForNextUpdate(session, timeoutMs, requestId, startRevision).then(resolve).catch(reject);
+        waitForNextUpdate(session, timeoutMs, requestId, startRevision, opts).then(resolve).catch(reject);
     });
 }
-function waitForNextUpdate(session, timeoutMs = ACTION_UPDATE_TIMEOUT_MS, requestId, startRevision = session.updateRevision) {
+function waitForNextUpdate(session, timeoutMs = ACTION_UPDATE_TIMEOUT_MS, requestId, startRevision = session.updateRevision, opts) {
     return new Promise((resolve, reject) => {
+        let ackSeen = false;
+        let ackResult;
+        const ackPayload = () => (ackSeen && ackResult !== undefined ? { result: ackResult } : {});
         const onMessage = (data) => {
             try {
                 const msg = JSON.parse(String(data));
@@ -1805,13 +1996,26 @@ function waitForNextUpdate(session, timeoutMs = ACTION_UPDATE_TIMEOUT_MS, reques
                         reject(new Error(typeof msg.message === 'string' ? msg.message : 'Geometra server error'));
                         return;
                     }
-                    if (msg.type === 'ack' && messageRequestId === requestId) {
+                    if ((msg.type === 'frame' || (msg.type === 'patch' && session.layout)) && ackSeen && session.updateRevision > startRevision) {
                         cleanup();
                         resolve({
-                            status: session.updateRevision > startRevision ? 'updated' : 'acknowledged',
+                            status: 'updated',
                             timeoutMs,
-                            ...(msg.result !== undefined ? { result: msg.result } : {}),
+                            ...ackPayload(),
                         });
+                        return;
+                    }
+                    if (msg.type === 'ack' && messageRequestId === requestId) {
+                        ackSeen = true;
+                        ackResult = msg.result;
+                        if (!opts?.requireUpdateOnAck || session.updateRevision > startRevision) {
+                            cleanup();
+                            resolve({
+                                status: session.updateRevision > startRevision ? 'updated' : 'acknowledged',
+                                timeoutMs,
+                                ...ackPayload(),
+                            });
+                        }
                     }
                     return;
                 }
@@ -1843,7 +2047,11 @@ function waitForNextUpdate(session, timeoutMs = ACTION_UPDATE_TIMEOUT_MS, reques
         const timeout = setTimeout(() => {
             cleanup();
             if (requestId && session.updateRevision > startRevision) {
-                resolve({ status: 'updated', timeoutMs });
+                resolve({ status: 'updated', timeoutMs, ...ackPayload() });
+                return;
+            }
+            if (requestId && ackSeen) {
+                resolve({ status: 'acknowledged', timeoutMs, ...ackPayload() });
                 return;
             }
             resolve({ status: 'timed_out', timeoutMs });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geometra/mcp",
-  "version": "1.19.14",
+  "version": "1.19.16",
   "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.14",
+    "@geometra/proxy": "^1.19.16",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "ws": "^8.18.0",
     "zod": "^3.23.0"