@godscene/core 1.7.11

package/dist/lib/ai-model/llm-planning.js

@@ -0,0 +1,268 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    parseXMLPlanningResponse: ()=>parseXMLPlanningResponse,
+    plan: ()=>plan
+});
+const img_namespaceObject = require("@godscene/shared/img");
+const logger_namespaceObject = require("@godscene/shared/logger");
+const utils_namespaceObject = require("@godscene/shared/utils");
+const external_common_js_namespaceObject = require("../common.js");
+const llm_planning_js_namespaceObject = require("./prompt/llm-planning.js");
+const util_js_namespaceObject = require("./prompt/util.js");
+const index_js_namespaceObject = require("./service-caller/index.js");
+const debug = (0, logger_namespaceObject.getDebug)('planning');
+const warnLog = (0, logger_namespaceObject.getDebug)('planning', {
+    console: true
+});
+function parseXMLPlanningResponse(xmlString, modelFamily) {
+    const thought = (0, util_js_namespaceObject.extractXMLTag)(xmlString, 'thought');
+    const memory = (0, util_js_namespaceObject.extractXMLTag)(xmlString, 'memory');
+    const log = (0, util_js_namespaceObject.extractXMLTag)(xmlString, 'log') || '';
+    const error = (0, util_js_namespaceObject.extractXMLTag)(xmlString, 'error');
+    const actionType = (0, util_js_namespaceObject.extractXMLTag)(xmlString, 'action-type');
+    const actionParamStr = (0, util_js_namespaceObject.extractXMLTag)(xmlString, 'action-param-json');
+    const completeGoalRegex = /<complete\s+success="(true|false)">([\s\S]*?)<\/complete>/i;
+    const completeGoalMatch = xmlString.match(completeGoalRegex);
+    let finalizeMessage;
+    let finalizeSuccess;
+    if (completeGoalMatch) {
+        finalizeSuccess = 'true' === completeGoalMatch[1];
+        finalizeMessage = completeGoalMatch[2]?.trim() || void 0;
+    }
+    const updatePlanContent = (0, util_js_namespaceObject.extractXMLTag)(xmlString, 'update-plan-content');
+    const markSubGoalDone = (0, util_js_namespaceObject.extractXMLTag)(xmlString, 'mark-sub-goal-done');
+    const updateSubGoals = updatePlanContent ? (0, util_js_namespaceObject.parseSubGoalsFromXML)(updatePlanContent) : void 0;
+    const markFinishedIndexes = markSubGoalDone ? (0, util_js_namespaceObject.parseMarkFinishedIndexes)(markSubGoalDone) : void 0;
+    let action = null;
+    if (actionType && 'null' !== actionType.toLowerCase()) {
+        const type = actionType.split('<')[0].trim();
+        let param;
+        if (actionParamStr) try {
+            param = (0, index_js_namespaceObject.safeParseJson)(actionParamStr, modelFamily);
+        } catch (e) {
+            throw new Error(`Failed to parse action-param-json: ${e}`);
+        }
+        action = {
+            type,
+            ...void 0 !== param ? {
+                param
+            } : {}
+        };
+    }
+    return {
+        ...thought ? {
+            thought
+        } : {},
+        ...memory ? {
+            memory
+        } : {},
+        log,
+        ...error ? {
+            error
+        } : {},
+        action,
+        ...void 0 !== finalizeMessage ? {
+            finalizeMessage
+        } : {},
+        ...void 0 !== finalizeSuccess ? {
+            finalizeSuccess
+        } : {},
+        ...updateSubGoals?.length ? {
+            updateSubGoals
+        } : {},
+        ...markFinishedIndexes?.length ? {
+            markFinishedIndexes
+        } : {}
+    };
+}
+async function plan(userInstruction, opts) {
+    const { context, modelConfig, conversationHistory } = opts;
+    const { shotSize } = context;
+    const screenshotBase64 = context.screenshot.base64;
+    const { modelFamily } = modelConfig;
+    const includeSubGoals = true === opts.deepThink;
+    const systemPrompt = await (0, llm_planning_js_namespaceObject.systemPromptToTaskPlanning)({
+        actionSpace: opts.actionSpace,
+        modelFamily,
+        includeBbox: opts.includeBbox,
+        includeThought: true,
+        includeSubGoals
+    });
+    let imagePayload = screenshotBase64;
+    let imageWidth = shotSize.width;
+    let imageHeight = shotSize.height;
+    if ('qwen2.5-vl' === modelFamily) {
+        const paddedResult = await (0, img_namespaceObject.paddingToMatchBlockByBase64)(imagePayload);
+        imageWidth = paddedResult.width;
+        imageHeight = paddedResult.height;
+        imagePayload = paddedResult.imageBase64;
+    }
+    const actionContext = opts.actionContext ? `<high_priority_knowledge>${opts.actionContext}</high_priority_knowledge>\n` : '';
+    const instruction = [
+        {
+            role: 'user',
+            content: [
+                {
+                    type: 'text',
+                    text: `${actionContext}<user_instruction>${userInstruction}</user_instruction>`
+                }
+            ]
+        }
+    ];
+    let latestFeedbackMessage;
+    const subGoalsText = includeSubGoals ? conversationHistory.subGoalsToText() : conversationHistory.historicalLogsToText();
+    const subGoalsSection = subGoalsText ? `\n\n${subGoalsText}` : '';
+    const memoriesText = conversationHistory.memoriesToText();
+    const memoriesSection = memoriesText ? `\n\n${memoriesText}` : '';
+    if (conversationHistory.pendingFeedbackMessage) {
+        latestFeedbackMessage = {
+            role: 'user',
+            content: [
+                {
+                    type: 'text',
+                    text: `${conversationHistory.pendingFeedbackMessage}. The previous action has been executed, here is the latest screenshot. Please continue according to the instruction.${memoriesSection}${subGoalsSection}`
+                },
+                {
+                    type: 'image_url',
+                    image_url: {
+                        url: imagePayload,
+                        detail: 'high'
+                    }
+                }
+            ]
+        };
+        conversationHistory.resetPendingFeedbackMessageIfExists();
+    } else latestFeedbackMessage = {
+        role: 'user',
+        content: [
+            {
+                type: 'text',
+                text: `this is the latest screenshot${memoriesSection}${subGoalsSection}`
+            },
+            {
+                type: 'image_url',
+                image_url: {
+                    url: imagePayload,
+                    detail: 'high'
+                }
+            }
+        ]
+    };
+    conversationHistory.append(latestFeedbackMessage);
+    conversationHistory.compressHistory(50, 20);
+    const historyLog = conversationHistory.snapshot(opts.imagesIncludeCount);
+    const msgs = [
+        {
+            role: 'system',
+            content: systemPrompt
+        },
+        ...instruction,
+        ...historyLog
+    ];
+    let { content: rawResponse, usage, reasoning_content } = await (0, index_js_namespaceObject.callAI)(msgs, modelConfig, {
+        deepThink: 'unset' === opts.deepThink ? void 0 : opts.deepThink,
+        abortSignal: opts.abortSignal
+    });
+    let planFromAI;
+    try {
+        try {
+            planFromAI = parseXMLPlanningResponse(rawResponse, modelFamily);
+        } catch  {
+            const retry = await (0, index_js_namespaceObject.callAI)(msgs, modelConfig, {
+                deepThink: 'unset' === opts.deepThink ? void 0 : opts.deepThink,
+                abortSignal: opts.abortSignal
+            });
+            rawResponse = retry.content;
+            usage = retry.usage;
+            reasoning_content = retry.reasoning_content;
+            planFromAI = parseXMLPlanningResponse(rawResponse, modelFamily);
+        }
+        if (planFromAI.action && void 0 !== planFromAI.finalizeSuccess) {
+            warnLog('Planning response included both an action and <complete>; ignoring <complete> output.');
+            planFromAI.finalizeMessage = void 0;
+            planFromAI.finalizeSuccess = void 0;
+        }
+        const actions = planFromAI.action ? [
+            planFromAI.action
+        ] : [];
+        let shouldContinuePlanning = true;
+        if (void 0 !== planFromAI.finalizeSuccess) {
+            debug('task completed via <complete> tag, stop planning');
+            shouldContinuePlanning = false;
+            if (includeSubGoals) conversationHistory.markAllSubGoalsFinished();
+        }
+        const returnValue = {
+            ...planFromAI,
+            actions,
+            rawResponse,
+            usage,
+            reasoning_content,
+            yamlFlow: (0, external_common_js_namespaceObject.buildYamlFlowFromPlans)(actions, opts.actionSpace),
+            shouldContinuePlanning
+        };
+        (0, utils_namespaceObject.assert)(planFromAI, "can't get plans from AI");
+        actions.forEach((action)=>{
+            const type = action.type;
+            const actionInActionSpace = opts.actionSpace.find((action)=>action.name === type);
+            debug('actionInActionSpace matched', actionInActionSpace);
+            const locateFields = actionInActionSpace ? (0, external_common_js_namespaceObject.findAllMidsceneLocatorField)(actionInActionSpace.paramSchema) : [];
+            debug('locateFields', locateFields);
+            locateFields.forEach((field)=>{
+                const locateResult = action.param[field];
+                if (locateResult && void 0 !== modelFamily) action.param[field] = (0, external_common_js_namespaceObject.fillBboxParam)(locateResult, imageWidth, imageHeight, modelFamily);
+            });
+        });
+        if (includeSubGoals) {
+            if (planFromAI.updateSubGoals?.length) conversationHistory.mergeSubGoals(planFromAI.updateSubGoals);
+            if (planFromAI.markFinishedIndexes?.length) for (const index of planFromAI.markFinishedIndexes)conversationHistory.markSubGoalFinished(index);
+            if (planFromAI.log) conversationHistory.appendSubGoalLog(planFromAI.log);
+        } else if (planFromAI.log) conversationHistory.appendHistoricalLog(planFromAI.log);
+        if (planFromAI.memory) conversationHistory.appendMemory(planFromAI.memory);
+        conversationHistory.append({
+            role: 'assistant',
+            content: [
+                {
+                    type: 'text',
+                    text: rawResponse
+                }
+            ]
+        });
+        return returnValue;
+    } catch (parseError) {
+        const errorMessage = parseError instanceof Error ? parseError.message : String(parseError);
+        throw new index_js_namespaceObject.AIResponseParseError(`XML parse error: ${errorMessage}`, rawResponse, usage);
+    }
+}
+exports.parseXMLPlanningResponse = __webpack_exports__.parseXMLPlanningResponse;
+exports.plan = __webpack_exports__.plan;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "parseXMLPlanningResponse",
+    "plan"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/ai-model/prompt/common.js

@@ -0,0 +1,39 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    bboxDescription: ()=>bboxDescription
+});
+function bboxDescription(modelFamily) {
+    if ('gemini' === modelFamily) return 'box_2d bounding box for the target element, should be [ymin, xmin, ymax, xmax] normalized to 0-1000.';
+    return '2d bounding box as [xmin, ymin, xmax, ymax]';
+}
+exports.bboxDescription = __webpack_exports__.bboxDescription;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "bboxDescription"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/ai-model/prompt/describe.js

@@ -0,0 +1,98 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    elementDescriberInstruction: ()=>elementDescriberInstruction
+});
+const env_namespaceObject = require("@godscene/shared/env");
+const examplesMap = {
+    Chinese: [
+        '"登录表单中的"登录"按钮"',
+        '"搜索输入框，placeholder 为"请输入关键词""',
+        '"顶部导航栏中文字为"首页"的链接"',
+        '"联系表单中的提交按钮"',
+        '"aria-label 为"打开菜单"的菜单图标"'
+    ],
+    English: [
+        '"Login button with text \'Sign In\'"',
+        '"Search input with placeholder \'Enter keywords\'"',
+        '"Navigation link with text \'Home\' in header"',
+        '"Submit button in contact form"',
+        '"Menu icon with aria-label \'Open menu\'"'
+    ]
+};
+const getExamples = (language)=>{
+    const examples = examplesMap[language] || examplesMap.English;
+    return examples.map((e)=>`- ${e}`).join('\n');
+};
+const elementDescriberInstruction = ()=>{
+    const preferredLanguage = (0, env_namespaceObject.getPreferredLanguage)();
+    return `
+Describe the element in the red rectangle for precise identification.
+
+IMPORTANT: You MUST write the description in ${preferredLanguage}.
+
+CRITICAL REQUIREMENTS:
+1. UNIQUENESS: The description must uniquely identify this element on the current page
+2. UNIVERSALITY: Use generic, reusable selectors that work across different contexts
+3. PRECISION: Be specific enough to distinguish from similar elements
+
+DESCRIPTION STRUCTURE:
+1. Element type (button, input, link, div, etc.)
+2. Primary identifier (in order of preference):
+   - Unique text content: "with text 'Login'"
+   - Unique attribute: "with aria-label 'Search'"
+   - Unique class/ID: "with class 'primary-button'"
+   - Unique position: "in header navigation"
+3. Secondary identifiers (if needed for uniqueness):
+   - Visual features: "blue background", "with icon"
+   - Relative position: "below search bar", "in sidebar"
+   - Parent context: "in login form", "in main menu"
+
+GUIDELINES:
+- Keep description under 25 words
+- Prioritize semantic identifiers over visual ones
+- Use consistent terminology across similar elements
+- Avoid page-specific or temporary content
+- Don't mention the red rectangle or selection box
+- Focus on stable, reusable characteristics
+- **Write the description in ${preferredLanguage}**
+
+EXAMPLES:
+${getExamples(preferredLanguage)}
+
+Return JSON:
+{
+  "description": "unique element identifier",
+  "error"?: "error message if any"
+}`;
+};
+exports.elementDescriberInstruction = __webpack_exports__.elementDescriberInstruction;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "elementDescriberInstruction"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/ai-model/prompt/extraction.js

@@ -0,0 +1,169 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    parseXMLExtractionResponse: ()=>parseXMLExtractionResponse,
+    systemPromptToExtract: ()=>systemPromptToExtract,
+    extractDataQueryPrompt: ()=>extractDataQueryPrompt
+});
+const env_namespaceObject = require("@godscene/shared/env");
+const index_js_namespaceObject = require("../service-caller/index.js");
+const external_util_js_namespaceObject = require("./util.js");
+function parseXMLExtractionResponse(xmlString) {
+    const thought = (0, external_util_js_namespaceObject.extractXMLTag)(xmlString, 'thought');
+    const dataJsonStr = (0, external_util_js_namespaceObject.extractXMLTag)(xmlString, 'data-json');
+    const errorsStr = (0, external_util_js_namespaceObject.extractXMLTag)(xmlString, 'errors');
+    if (!dataJsonStr) throw new Error('Missing required field: data-json');
+    let data;
+    try {
+        data = (0, index_js_namespaceObject.safeParseJson)(dataJsonStr, void 0);
+    } catch (e) {
+        throw new Error(`Failed to parse data-json: ${e}`);
+    }
+    let errors;
+    if (errorsStr) try {
+        const parsedErrors = (0, index_js_namespaceObject.safeParseJson)(errorsStr, void 0);
+        if (Array.isArray(parsedErrors)) errors = parsedErrors;
+    } catch (e) {}
+    return {
+        ...thought ? {
+            thought
+        } : {},
+        data,
+        ...errors && errors.length > 0 ? {
+            errors
+        } : {}
+    };
+}
+function systemPromptToExtract() {
+    const preferredLanguage = (0, env_namespaceObject.getPreferredLanguage)();
+    return `
+You are a versatile professional in software UI design and testing. Your outstanding contributions will impact the user experience of billions of users.
+
+The user will give you a screenshot, the contents of it (optional), and some data requirements in <DATA_DEMAND>. You need to understand the user's requirements and extract the data satisfying the <DATA_DEMAND>.
+
+If a key specifies a JSON data type (such as Number, String, Boolean, Object, Array), ensure the returned value strictly matches that data type.
+
+When DATA_DEMAND is a JSON object, the keys in your response must exactly match the keys in DATA_DEMAND. Do not rename, translate, or substitute any key.
+
+If the user provides multiple reference images, please carefully review the reference images with the screenshot and provide the correct answer for <DATA_DEMAND>.
+
+
+Return in the following XML format:
+<thought>the thinking process of the extraction, less than 300 words. Use ${preferredLanguage} in this field.</thought>
+<data-json>the extracted data as JSON. Make sure both the value and scheme meet the DATA_DEMAND. If you want to write some description in this field, use the same language as the DATA_DEMAND.</data-json>
+<errors>optional error messages as JSON array, e.g., ["error1", "error2"]</errors>
+
+# Example 1
+For example, if the DATA_DEMAND is:
+
+<DATA_DEMAND>
+{
+  "name": "name shows on the left panel, string",
+  "age": "age shows on the right panel, number",
+  "isAdmin": "if the user is admin, boolean"
+}
+</DATA_DEMAND>
+
+By viewing the screenshot and page contents, you can extract the following data:
+
+<thought>According to the screenshot, i can see ...</thought>
+<data-json>
+{
+  "name": "John",
+  "age": 30,
+  "isAdmin": true
+}
+</data-json>
+
+# Example 2
+If the DATA_DEMAND is:
+
+<DATA_DEMAND>
+the todo items list, string[]
+</DATA_DEMAND>
+
+By viewing the screenshot and page contents, you can extract the following data:
+
+<thought>According to the screenshot, i can see ...</thought>
+<data-json>
+["todo 1", "todo 2", "todo 3"]
+</data-json>
+
+# Example 3
+If the DATA_DEMAND is:
+
+<DATA_DEMAND>
+the page title, string
+</DATA_DEMAND>
+
+By viewing the screenshot and page contents, you can extract the following data:
+
+<thought>According to the screenshot, i can see ...</thought>
+<data-json>
+"todo list"
+</data-json>
+
+# Example 4
+If the DATA_DEMAND is:
+
+<DATA_DEMAND>
+{
+  "StatementIsTruthy": "Boolean, is it currently the SMS page?"
+}
+</DATA_DEMAND>
+
+By viewing the screenshot and page contents, you can extract the following data:
+
+<thought>According to the screenshot, i can see ...</thought>
+<data-json>
+{ "StatementIsTruthy": true }
+</data-json>
+`;
+}
+const extractDataQueryPrompt = (pageDescription, dataQuery)=>{
+    let dataQueryText = '';
+    dataQueryText = 'string' == typeof dataQuery ? dataQuery : JSON.stringify(dataQuery, null, 2);
+    return `
+<PageDescription>
+${pageDescription}
+</PageDescription>
+
+<DATA_DEMAND>
+${dataQueryText}
+</DATA_DEMAND>
+  `;
+};
+exports.extractDataQueryPrompt = __webpack_exports__.extractDataQueryPrompt;
+exports.parseXMLExtractionResponse = __webpack_exports__.parseXMLExtractionResponse;
+exports.systemPromptToExtract = __webpack_exports__.systemPromptToExtract;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "extractDataQueryPrompt",
+    "parseXMLExtractionResponse",
+    "systemPromptToExtract"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/ai-model/prompt/llm-locator.js

@@ -0,0 +1,86 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    systemPromptToLocateElement: ()=>systemPromptToLocateElement,
+    findElementPrompt: ()=>findElementPrompt
+});
+const env_namespaceObject = require("@godscene/shared/env");
+const external_common_js_namespaceObject = require("./common.js");
+function systemPromptToLocateElement(modelFamily) {
+    const preferredLanguage = (0, env_namespaceObject.getPreferredLanguage)();
+    const bboxComment = (0, external_common_js_namespaceObject.bboxDescription)(modelFamily);
+    return `
+## Role:
+You are an AI assistant that helps identify UI elements.
+
+## Objective:
+- Identify elements in screenshots that match the user's description.
+- Provide the coordinates of the element that matches the user's description.
+
+## Important Notes for Locating Elements:
+- When the user describes an element that contains text (such as buttons, input fields, dropdown options, radio buttons, etc.), you should locate ONLY the text region of that element, not the entire element boundary.
+- For example: If an input field is large (both wide and tall) with a placeholder text "Please enter your comment", you should locate only the area where the placeholder text appears, not the entire input field.
+- This principle applies to all text-containing elements: focus on the visible text region rather than the full element container.
+
+## Output Format:
+\`\`\`json
+{
+  "bbox": [number, number, number, number],  // ${bboxComment}
+  "errors"?: string[]
+}
+\`\`\`
+
+Fields:
+* \`bbox\` is the bounding box of the element that matches the user's description
+* \`errors\` is an optional array of error messages (if any)
+
+For example, when an element is found:
+\`\`\`json
+{
+  "bbox": [100, 100, 200, 200],
+  "errors": []
+}
+\`\`\`
+
+When no element is found:
+\`\`\`json
+{
+  "bbox": [],
+  "errors": ["I can see ..., but {some element} is not found. Use ${preferredLanguage}."]
+}
+\`\`\`
+`;
+}
+const findElementPrompt = (targetElementDescription)=>`Find: ${targetElementDescription}`;
+exports.findElementPrompt = __webpack_exports__.findElementPrompt;
+exports.systemPromptToLocateElement = __webpack_exports__.systemPromptToLocateElement;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "findElementPrompt",
+    "systemPromptToLocateElement"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});