@godscene/core 1.7.11

package/dist/es/agent/utils.mjs

@@ -0,0 +1,167 @@
+import { ScreenshotItem } from "../screenshot-item.mjs";
+import { uploadTestInfoToServer } from "../utils.mjs";
+import { MIDSCENE_REPORT_QUIET, MIDSCENE_REPORT_TAG_NAME, globalConfigManager } from "@godscene/shared/env";
+import { generateElementByRect } from "@godscene/shared/extractor";
+import { imageInfoOfBase64, resizeImgBase64 } from "@godscene/shared/img";
+import { getDebug } from "@godscene/shared/logger";
+import { assert, logMsg, uuid } from "@godscene/shared/utils";
+import dayjs from "dayjs";
+import { debug as external_task_cache_mjs_debug } from "./task-cache.mjs";
+async function commonContextParser(interfaceInstance, _opt) {
+    const debug = getDebug('commonContextParser');
+    assert(interfaceInstance, 'interfaceInstance is required');
+    debug("Getting interface description");
+    const description = interfaceInstance.describe?.() || '';
+    debug("Interface description end");
+    debug('Uploading test info to server');
+    uploadTestInfoToServer({
+        testUrl: description,
+        serverUrl: _opt.uploadServerUrl
+    });
+    debug('UploadTestInfoToServer end');
+    debug('will get size');
+    const interfaceSize = await interfaceInstance.size();
+    const { width: logicalWidth, height: logicalHeight } = interfaceSize;
+    if (interfaceSize.dpr) console.warn('Warning: return value of interface.size() include a dpr property, which is not expected and ignored. ');
+    if (!Number.isFinite(logicalWidth) || !Number.isFinite(logicalHeight)) throw new Error(`Invalid interface size: width and height must be finite numbers. Received width: ${logicalWidth}, height: ${logicalHeight}`);
+    if (logicalWidth <= 0 || logicalHeight <= 0) throw new Error(`Invalid interface size: width and height must be positive numbers. Received width: ${logicalWidth}, height: ${logicalHeight}`);
+    debug(`size: ${logicalWidth}x${logicalHeight}`);
+    const screenshotBase64 = await interfaceInstance.screenshotBase64();
+    const screenshotCapturedAt = Date.now();
+    assert(screenshotBase64, 'screenshotBase64 is required');
+    debug('will get screenshot dimensions');
+    const { width: imgWidth, height: imgHeight } = await imageInfoOfBase64(screenshotBase64);
+    if (!Number.isFinite(imgWidth) || !Number.isFinite(imgHeight)) throw new Error(`Invalid screenshot dimensions: width and height must be finite numbers. Received width: ${imgWidth}, height: ${imgHeight}`);
+    if (imgWidth <= 0 || imgHeight <= 0) throw new Error(`Invalid screenshot dimensions: width and height must be positive numbers. Received width: ${imgWidth}, height: ${imgHeight}`);
+    debug('screenshot dimensions', imgWidth, 'x', imgHeight);
+    const logicalIsPortrait = logicalWidth < logicalHeight;
+    const screenshotIsPortrait = imgWidth < imgHeight;
+    let finalLogicalWidth = logicalWidth;
+    if (logicalIsPortrait !== screenshotIsPortrait) {
+        debug(`Orientation mismatch detected: logical size ${logicalWidth}x${logicalHeight} (${logicalIsPortrait ? 'portrait' : 'landscape'}) vs screenshot ${imgWidth}x${imgHeight} (${screenshotIsPortrait ? 'portrait' : 'landscape'}). Swapping logical dimensions.`);
+        finalLogicalWidth = logicalHeight;
+    }
+    const userShrinkFactor = _opt.screenshotShrinkFactor ?? 1;
+    if (!Number.isFinite(userShrinkFactor) || userShrinkFactor < 1) throw new Error(`Invalid screenshotShrinkFactor: must be a finite number >= 1. Received: ${userShrinkFactor}`);
+    const dpr = imgWidth / finalLogicalWidth;
+    debug('calculated dpr:', dpr);
+    const shrunkShotToLogicalRatio = dpr / userShrinkFactor;
+    debug('shrunkShotToLogicalRatio', shrunkShotToLogicalRatio);
+    if (1 !== userShrinkFactor) {
+        const targetWidth = Math.round(imgWidth / userShrinkFactor);
+        const targetHeight = Math.round(imgHeight / userShrinkFactor);
+        debug(`Applying screenshot shrink factor: ${userShrinkFactor} (physical: ${imgWidth}x${imgHeight} -> target: ${targetWidth}x${targetHeight})`);
+        const resizedBase64 = await resizeImgBase64(screenshotBase64, {
+            width: targetWidth,
+            height: targetHeight
+        });
+        return {
+            shotSize: {
+                width: targetWidth,
+                height: targetHeight
+            },
+            deprecatedDpr: dpr,
+            screenshot: ScreenshotItem.create(resizedBase64, screenshotCapturedAt),
+            shrunkShotToLogicalRatio
+        };
+    }
+    return {
+        shotSize: {
+            width: imgWidth,
+            height: imgHeight
+        },
+        deprecatedDpr: dpr,
+        screenshot: ScreenshotItem.create(screenshotBase64, screenshotCapturedAt),
+        shrunkShotToLogicalRatio
+    };
+}
+function getReportFileName(tag = 'web') {
+    const reportTagName = globalConfigManager.getEnvConfigValue(MIDSCENE_REPORT_TAG_NAME);
+    const dateTimeInFileName = dayjs().format('YYYY-MM-DD_HH-mm-ss');
+    const uniqueId = uuid().substring(0, 8);
+    return `${reportTagName || tag}-${dateTimeInFileName}-${uniqueId}`;
+}
+function printReportMsg(filepath) {
+    if (globalConfigManager.getEnvConfigInBoolean(MIDSCENE_REPORT_QUIET)) return;
+    logMsg(`Midscene - report file updated: ${filepath}`);
+}
+function ifPlanLocateParamIsBbox(planLocateParam) {
+    return !!(planLocateParam.bbox && Array.isArray(planLocateParam.bbox) && 4 === planLocateParam.bbox.length);
+}
+function matchElementFromPlan(planLocateParam) {
+    if (!planLocateParam) return;
+    if (planLocateParam.bbox) {
+        const rect = {
+            left: planLocateParam.bbox[0],
+            top: planLocateParam.bbox[1],
+            width: planLocateParam.bbox[2] - planLocateParam.bbox[0] + 1,
+            height: planLocateParam.bbox[3] - planLocateParam.bbox[1] + 1
+        };
+        const element = generateElementByRect(rect, 'string' == typeof planLocateParam.prompt ? planLocateParam.prompt : planLocateParam.prompt?.prompt || '');
+        return element;
+    }
+}
+async function matchElementFromCache(context, cacheEntry, cachePrompt, cacheable) {
+    if (!cacheEntry) return;
+    if (false === cacheable) return void external_task_cache_mjs_debug('cache disabled for prompt: %s', cachePrompt);
+    if (!context.taskCache?.isCacheResultUsed) return;
+    if (!context.interfaceInstance.rectMatchesCacheFeature) return void external_task_cache_mjs_debug('interface does not implement rectMatchesCacheFeature, skip cache');
+    try {
+        const rect = await context.interfaceInstance.rectMatchesCacheFeature(cacheEntry);
+        const element = {
+            center: [
+                Math.round(rect.left + rect.width / 2),
+                Math.round(rect.top + rect.height / 2)
+            ],
+            rect,
+            description: 'string' == typeof cachePrompt ? cachePrompt : cachePrompt.prompt || ''
+        };
+        external_task_cache_mjs_debug('cache hit, prompt: %s', cachePrompt);
+        return element;
+    } catch (error) {
+        external_task_cache_mjs_debug('rectMatchesCacheFeature error: %s', error);
+        return;
+    }
+}
+const getMidsceneVersion = ()=>"1.7.10";
+const parsePrompt = (prompt)=>{
+    if ('string' == typeof prompt) return {
+        textPrompt: prompt,
+        multimodalPrompt: void 0
+    };
+    return {
+        textPrompt: prompt.prompt,
+        multimodalPrompt: prompt.images ? {
+            images: prompt.images,
+            convertHttpImage2Base64: !!prompt.convertHttpImage2Base64
+        } : void 0
+    };
+};
+const transformLogicalElementToScreenshot = (element, shrunkShotToLogicalRatio)=>{
+    if (1 === shrunkShotToLogicalRatio) return element;
+    return {
+        ...element,
+        center: [
+            Math.round(element.center[0] * shrunkShotToLogicalRatio),
+            Math.round(element.center[1] * shrunkShotToLogicalRatio)
+        ],
+        rect: {
+            ...element.rect,
+            left: Math.round(element.rect.left * shrunkShotToLogicalRatio),
+            top: Math.round(element.rect.top * shrunkShotToLogicalRatio),
+            width: Math.round(element.rect.width * shrunkShotToLogicalRatio),
+            height: Math.round(element.rect.height * shrunkShotToLogicalRatio)
+        }
+    };
+};
+const transformLogicalRectToScreenshotRect = (rect, shrunkShotToLogicalRatio)=>{
+    if (1 === shrunkShotToLogicalRatio) return rect;
+    return {
+        ...rect,
+        left: Math.round(rect.left * shrunkShotToLogicalRatio),
+        top: Math.round(rect.top * shrunkShotToLogicalRatio),
+        width: Math.round(rect.width * shrunkShotToLogicalRatio),
+        height: Math.round(rect.height * shrunkShotToLogicalRatio)
+    };
+};
+export { commonContextParser, getMidsceneVersion, getReportFileName, ifPlanLocateParamIsBbox, matchElementFromCache, matchElementFromPlan, parsePrompt, printReportMsg, transformLogicalElementToScreenshot, transformLogicalRectToScreenshotRect };

package/dist/es/ai-model/auto-glm/actions.mjs

@@ -0,0 +1,237 @@
+import { adaptBbox, pointToBbox } from "../../common.mjs";
+import { getDebug } from "@godscene/shared/logger";
+const debug = getDebug('auto-glm-actions');
+const AUTO_GLM_COORDINATE_MAX = 1000;
+function autoGLMCoordinateToBbox(x, y, width, height) {
+    const bbox = pointToBbox(x, y, 10);
+    return adaptBbox(bbox, width, height, 'auto-glm');
+}
+const BACK_BUTTON_NAMES = [
+    'AndroidBackButton',
+    'HarmonyBackButton'
+];
+const HOME_BUTTON_NAMES = [
+    'AndroidHomeButton',
+    'HarmonyHomeButton'
+];
+function findActionName(actionSpace, knownNames, defaultName) {
+    if (!actionSpace) return defaultName;
+    const match = actionSpace.find((a)=>knownNames.includes(a.name));
+    return match ? match.name : defaultName;
+}
+function transformAutoGLMAction(action, size, actionSpace) {
+    try {
+        switch(action._metadata){
+            case 'finish':
+                {
+                    const finishAction = action;
+                    debug('Transform finish action:', finishAction);
+                    return [
+                        {
+                            type: 'Finished',
+                            param: {},
+                            thought: finishAction.message
+                        }
+                    ];
+                }
+            case 'do':
+                {
+                    const doAction = action;
+                    switch(doAction.action){
+                        case 'Tap':
+                            {
+                                const tapAction = doAction;
+                                debug('Transform Tap action:', tapAction);
+                                const [x1, y1, x2, y2] = autoGLMCoordinateToBbox(tapAction.element[0], tapAction.element[1], size.width, size.height);
+                                const locate = {
+                                    prompt: '',
+                                    bbox: [
+                                        x1,
+                                        y1,
+                                        x2,
+                                        y2
+                                    ]
+                                };
+                                return [
+                                    {
+                                        type: 'Tap',
+                                        param: {
+                                            locate
+                                        }
+                                    }
+                                ];
+                            }
+                        case 'Double Tap':
+                            {
+                                const doubleTapAction = doAction;
+                                debug('Transform Double Tap action:', doubleTapAction);
+                                const [x1, y1, x2, y2] = autoGLMCoordinateToBbox(doubleTapAction.element[0], doubleTapAction.element[1], size.width, size.height);
+                                const locate = {
+                                    prompt: '',
+                                    bbox: [
+                                        x1,
+                                        y1,
+                                        x2,
+                                        y2
+                                    ]
+                                };
+                                return [
+                                    {
+                                        type: 'DoubleClick',
+                                        param: {
+                                            locate
+                                        }
+                                    }
+                                ];
+                            }
+                        case 'Type':
+                            {
+                                const typeAction = doAction;
+                                debug('Transform Type action:', typeAction);
+                                return [
+                                    {
+                                        type: 'Input',
+                                        param: {
+                                            value: typeAction.text
+                                        }
+                                    }
+                                ];
+                            }
+                        case 'Swipe':
+                            {
+                                const swipeAction = doAction;
+                                debug('Transform Swipe action:', swipeAction);
+                                const [x1, y1, x2, y2] = autoGLMCoordinateToBbox(swipeAction.start[0], swipeAction.start[1], size.width, size.height);
+                                const locate = {
+                                    prompt: '',
+                                    bbox: [
+                                        x1,
+                                        y1,
+                                        x2,
+                                        y2
+                                    ]
+                                };
+                                const deltaX = swipeAction.end[0] - swipeAction.start[0];
+                                const deltaY = swipeAction.end[1] - swipeAction.start[1];
+                                let direction;
+                                let distance;
+                                const absDeltaX = Math.abs(deltaX);
+                                const absDeltaY = Math.abs(deltaY);
+                                if (absDeltaY > absDeltaX) {
+                                    distance = Math.round(absDeltaY * size.height / AUTO_GLM_COORDINATE_MAX);
+                                    direction = deltaY > 0 ? 'up' : 'down';
+                                } else {
+                                    distance = Math.round(absDeltaX * size.width / AUTO_GLM_COORDINATE_MAX);
+                                    direction = deltaX > 0 ? 'left' : 'right';
+                                }
+                                debug(`Calculate swipe direction: ${direction}, distance: ${distance}`);
+                                return [
+                                    {
+                                        type: 'Scroll',
+                                        param: {
+                                            locate,
+                                            distance,
+                                            direction
+                                        },
+                                        thought: swipeAction.think || ''
+                                    }
+                                ];
+                            }
+                        case 'Long Press':
+                            {
+                                const longPressAction = doAction;
+                                debug('Transform Long Press action:', longPressAction);
+                                const [x1, y1, x2, y2] = autoGLMCoordinateToBbox(longPressAction.element[0], longPressAction.element[1], size.width, size.height);
+                                const locate = {
+                                    prompt: '',
+                                    bbox: [
+                                        x1,
+                                        y1,
+                                        x2,
+                                        y2
+                                    ]
+                                };
+                                return [
+                                    {
+                                        type: 'LongPress',
+                                        param: {
+                                            locate
+                                        },
+                                        thought: longPressAction.think || ''
+                                    }
+                                ];
+                            }
+                        case 'Back':
+                            {
+                                const backAction = doAction;
+                                debug('Transform Back action:', backAction);
+                                return [
+                                    {
+                                        type: findActionName(actionSpace, BACK_BUTTON_NAMES, 'AndroidBackButton'),
+                                        param: {},
+                                        thought: backAction.think || ''
+                                    }
+                                ];
+                            }
+                        case 'Home':
+                            {
+                                const homeAction = doAction;
+                                debug('Transform Home action:', homeAction);
+                                return [
+                                    {
+                                        type: findActionName(actionSpace, HOME_BUTTON_NAMES, 'AndroidHomeButton'),
+                                        param: {},
+                                        thought: homeAction.think || ''
+                                    }
+                                ];
+                            }
+                        case 'Wait':
+                            {
+                                const waitAction = doAction;
+                                debug('Transform Wait action:', waitAction);
+                                return [
+                                    {
+                                        type: 'Sleep',
+                                        param: {
+                                            timeMs: waitAction.durationMs
+                                        },
+                                        thought: waitAction.think || ''
+                                    }
+                                ];
+                            }
+                        case 'Launch':
+                            {
+                                const launchAction = doAction;
+                                debug('Transform Launch action:', launchAction);
+                                return [
+                                    {
+                                        type: 'Launch',
+                                        param: {
+                                            uri: launchAction.app
+                                        },
+                                        thought: launchAction.think || ''
+                                    }
+                                ];
+                            }
+                        case 'Interact':
+                            throw new Error('Action "Interact" from auto-glm is not supported in the current implementation.');
+                        case 'Call_API':
+                            throw new Error('Action "Call_API" from auto-glm is not supported in the current implementation.');
+                        case 'Take_over':
+                            throw new Error('Action "Take_over" from auto-glm is not supported in the current implementation.');
+                        case 'Note':
+                            throw new Error('Action "Note" from auto-glm is not supported in the current implementation.');
+                        default:
+                            throw new Error(`Unknown do() action type: ${doAction.action}`);
+                    }
+                }
+            default:
+                throw new Error(`Unknown action metadata: ${action._metadata}`);
+        }
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        debug('Transform error:', errorMessage);
+        throw new Error(`Failed to transform action: ${errorMessage}`);
+    }
+}
+export { transformAutoGLMAction };

package/dist/es/ai-model/auto-glm/index.mjs

@@ -0,0 +1,6 @@
+import { getAutoGLMLocatePrompt, getAutoGLMPlanPrompt } from "./prompt.mjs";
+import { parseAction, parseAutoGLMLocateResponse, parseAutoGLMResponse } from "./parser.mjs";
+import { autoGLMPlanning } from "./planning.mjs";
+import { transformAutoGLMAction } from "./actions.mjs";
+import { isAutoGLM, isUITars } from "./util.mjs";
+export { autoGLMPlanning, getAutoGLMLocatePrompt, getAutoGLMPlanPrompt, isAutoGLM, isUITars, parseAction, parseAutoGLMLocateResponse, parseAutoGLMResponse, transformAutoGLMAction };

package/dist/es/ai-model/auto-glm/parser.mjs

@@ -0,0 +1,237 @@
+import { getDebug } from "@godscene/shared/logger";
+const debug = getDebug('auto-glm-parser');
+const extractValueAfter = (src, key)=>{
+    const idx = src.indexOf(key);
+    if (-1 === idx) throw new Error(`Missing key ${key} in action payload ${src}`);
+    let rest = src.slice(idx + key.length).trim();
+    if (rest.endsWith('")')) rest = rest.slice(0, -2);
+    return rest;
+};
+function parseAction(response) {
+    debug('Parsing action:', response);
+    let trimmedResponse = '';
+    try {
+        trimmedResponse = response.content.trim();
+        if (trimmedResponse.startsWith('do(action="Type"') || trimmedResponse.startsWith('do(action="Type_Name"')) {
+            const text = extractValueAfter(trimmedResponse, 'text="');
+            return {
+                _metadata: 'do',
+                action: 'Type',
+                text,
+                think: response.think
+            };
+        }
+        if (trimmedResponse.startsWith('finish(message=')) {
+            let message = extractValueAfter(trimmedResponse, 'finish(message="');
+            if (message.endsWith(')')) message = message.slice(0, -1);
+            return {
+                _metadata: 'finish',
+                message,
+                think: response.think
+            };
+        }
+        if (trimmedResponse.startsWith('do(')) {
+            const actionMatch = trimmedResponse.match(/do\(action="([^"]+)"/);
+            if (!actionMatch) throw new Error(`Failed to extract action type from do() call; raw="${trimmedResponse}"`);
+            const actionType = actionMatch[1];
+            const baseAction = {
+                _metadata: 'do',
+                think: response.think
+            };
+            switch(actionType){
+                case 'Tap':
+                    {
+                        const elementMatch = trimmedResponse.match(/element=\[(\d+),(\d+)\]/);
+                        if (!elementMatch) throw new Error(`Failed to extract element coordinates for Tap; raw="${trimmedResponse}"`);
+                        return {
+                            ...baseAction,
+                            action: 'Tap',
+                            element: [
+                                Number(elementMatch[1]),
+                                Number(elementMatch[2])
+                            ]
+                        };
+                    }
+                case 'Double Tap':
+                    {
+                        const elementMatch = trimmedResponse.match(/element=\[(\d+),(\d+)\]/);
+                        if (!elementMatch) throw new Error(`Failed to extract element coordinates for Double Tap; raw="${trimmedResponse}"`);
+                        return {
+                            ...baseAction,
+                            action: 'Double Tap',
+                            element: [
+                                Number(elementMatch[1]),
+                                Number(elementMatch[2])
+                            ]
+                        };
+                    }
+                case 'Swipe':
+                    {
+                        const startMatch = trimmedResponse.match(/start=\[(\d+),(\d+)\]/);
+                        const endMatch = trimmedResponse.match(/end=\[(\d+),(\d+)\]/);
+                        if (!startMatch || !endMatch) throw new Error(`Failed to extract start/end coordinates for Swipe; raw="${trimmedResponse}"`);
+                        return {
+                            ...baseAction,
+                            action: 'Swipe',
+                            start: [
+                                Number(startMatch[1]),
+                                Number(startMatch[2])
+                            ],
+                            end: [
+                                Number(endMatch[1]),
+                                Number(endMatch[2])
+                            ]
+                        };
+                    }
+                case 'Long Press':
+                    {
+                        const elementMatch = trimmedResponse.match(/element=\[(\d+),(\d+)\]/);
+                        if (!elementMatch) throw new Error(`Failed to extract element coordinates for Long Press; raw="${trimmedResponse}"`);
+                        return {
+                            ...baseAction,
+                            action: 'Long Press',
+                            element: [
+                                Number(elementMatch[1]),
+                                Number(elementMatch[2])
+                            ]
+                        };
+                    }
+                case 'Launch':
+                    {
+                        const app = extractValueAfter(trimmedResponse, 'app="');
+                        return {
+                            ...baseAction,
+                            action: 'Launch',
+                            app
+                        };
+                    }
+                case 'Back':
+                    return {
+                        ...baseAction,
+                        action: 'Back'
+                    };
+                case 'Home':
+                    return {
+                        ...baseAction,
+                        action: 'Home'
+                    };
+                case 'Wait':
+                    {
+                        const durationMatch = trimmedResponse.match(/duration=(?:["\[])?(\d+)/);
+                        if (!durationMatch) throw new Error(`Failed to extract duration for Wait; raw="${trimmedResponse}"`);
+                        const seconds = Number.parseInt(durationMatch[1], 10);
+                        const durationMs = 1000 * seconds;
+                        return {
+                            ...baseAction,
+                            action: 'Wait',
+                            durationMs
+                        };
+                    }
+                case 'Interact':
+                    return {
+                        ...baseAction,
+                        action: 'Interact'
+                    };
+                case 'Call_API':
+                    {
+                        const instruction = extractValueAfter(trimmedResponse, 'instruction="');
+                        return {
+                            ...baseAction,
+                            action: 'Call_API',
+                            instruction
+                        };
+                    }
+                case 'Take_over':
+                    {
+                        const message = extractValueAfter(trimmedResponse, 'message="');
+                        return {
+                            ...baseAction,
+                            action: 'Take_over',
+                            message
+                        };
+                    }
+                case 'Note':
+                    {
+                        const message = extractValueAfter(trimmedResponse, 'message="');
+                        return {
+                            ...baseAction,
+                            action: 'Note',
+                            message
+                        };
+                    }
+                default:
+                    throw new Error(`Unknown action type: ${actionType}; raw="${trimmedResponse}"`);
+            }
+        }
+        throw new Error(`Failed to parse action: ${trimmedResponse}`);
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to parse action: ${errorMessage}; raw="${trimmedResponse}"`);
+    }
+}
+function parseAutoGLMResponse(content) {
+    if (content.includes('finish(message=')) {
+        const parts = content.split('finish(message=');
+        const think = parts[0].trim();
+        const actionContent = `finish(message=${parts[1]}`;
+        return {
+            think,
+            content: actionContent
+        };
+    }
+    if (content.includes('do(action=')) {
+        const parts = content.split('do(action=');
+        const think = parts[0].trim();
+        const actionContent = `do(action=${parts[1]}`;
+        return {
+            think,
+            content: actionContent
+        };
+    }
+    if (content.includes('<answer>')) {
+        const parts = content.split('<answer>');
+        const think = parts[0].replace(/<think>/g, '').replace(/<\/think>/g, '').trim();
+        const actionContent = parts[1].replace(/<\/answer>/g, '').trim();
+        return {
+            think,
+            content: actionContent
+        };
+    }
+    return {
+        think: '',
+        content
+    };
+}
+function parseAutoGLMLocateResponse(rawResponse) {
+    const { think, content: actionContent } = parseAutoGLMResponse(rawResponse);
+    if (!actionContent.startsWith('do(action="Tap"')) return {
+        think,
+        coordinates: null,
+        error: `Unexpected action type in auto-glm locate response: ${actionContent}`
+    };
+    try {
+        const elementMatch = actionContent.match(/element=\[(\d+),(\d+)\]/);
+        if (!elementMatch) return {
+            think,
+            coordinates: null,
+            error: `Failed to extract element coordinates from auto-glm response: ${actionContent}`
+        };
+        const x = Number(elementMatch[1]);
+        const y = Number(elementMatch[2]);
+        return {
+            think,
+            coordinates: {
+                x,
+                y
+            }
+        };
+    } catch (e) {
+        const errorMessage = e instanceof Error ? e.message : String(e);
+        return {
+            think,
+            coordinates: null,
+            error: `Failed to parse coordinates "${actionContent}" with errorMessage: ${errorMessage}`
+        };
+    }
+}
+export { extractValueAfter, parseAction, parseAutoGLMLocateResponse, parseAutoGLMResponse };