@rpascene/shared 0.30.8

package/dist/lib/constants/index.js

@@ -0,0 +1,153 @@
+"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 ('undefined' != 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__, {
+    PLAYGROUND_SERVER_PORT: ()=>PLAYGROUND_SERVER_PORT,
+    DEFAULT_WAIT_FOR_NETWORK_IDLE_TIMEOUT: ()=>DEFAULT_WAIT_FOR_NETWORK_IDLE_TIMEOUT,
+    SCRCPY_SERVER_PORT: ()=>SCRCPY_SERVER_PORT,
+    TEXT_SIZE_THRESHOLD: ()=>TEXT_SIZE_THRESHOLD,
+    commandMap: ()=>commandMap,
+    YAML_EXAMPLE_CODE: ()=>external_example_code_js_namespaceObject.YAML_EXAMPLE_CODE,
+    DEFAULT_WAIT_FOR_NETWORK_IDLE_CONCURRENCY: ()=>DEFAULT_WAIT_FOR_NETWORK_IDLE_CONCURRENCY,
+    DEFAULT_WAIT_FOR_NAVIGATION_TIMEOUT: ()=>DEFAULT_WAIT_FOR_NAVIGATION_TIMEOUT,
+    CONTAINER_MINI_WIDTH: ()=>CONTAINER_MINI_WIDTH,
+    CONTAINER_MINI_HEIGHT: ()=>CONTAINER_MINI_HEIGHT,
+    TEXT_MAX_SIZE: ()=>TEXT_MAX_SIZE,
+    NodeType: ()=>constants_NodeType,
+    WEBDRIVER_ELEMENT_ID_KEY: ()=>WEBDRIVER_ELEMENT_ID_KEY,
+    DEFAULT_WDA_PORT: ()=>DEFAULT_WDA_PORT,
+    DEFAULT_WAIT_FOR_NETWORK_IDLE_TIME: ()=>DEFAULT_WAIT_FOR_NETWORK_IDLE_TIME,
+    PLAYWRIGHT_EXAMPLE_CODE: ()=>external_example_code_js_namespaceObject.PLAYWRIGHT_EXAMPLE_CODE
+});
+const external_example_code_js_namespaceObject = require("./example-code.js");
+const TEXT_SIZE_THRESHOLD = 9;
+const TEXT_MAX_SIZE = 40;
+const CONTAINER_MINI_HEIGHT = 3;
+const CONTAINER_MINI_WIDTH = 3;
+var constants_NodeType = /*#__PURE__*/ function(NodeType) {
+    NodeType["CONTAINER"] = "CONTAINER Node";
+    NodeType["FORM_ITEM"] = "FORM_ITEM Node";
+    NodeType["BUTTON"] = "BUTTON Node";
+    NodeType["A"] = "Anchor Node";
+    NodeType["IMG"] = "IMG Node";
+    NodeType["TEXT"] = "TEXT Node";
+    NodeType["POSITION"] = "POSITION Node";
+    return NodeType;
+}({});
+const PLAYGROUND_SERVER_PORT = 5800;
+const SCRCPY_SERVER_PORT = 5700;
+const WEBDRIVER_ELEMENT_ID_KEY = 'element-6066-11e4-a52e-4f735466cecf';
+const DEFAULT_WDA_PORT = 8100;
+const DEFAULT_WAIT_FOR_NAVIGATION_TIMEOUT = 5000;
+const DEFAULT_WAIT_FOR_NETWORK_IDLE_TIMEOUT = 2000;
+const DEFAULT_WAIT_FOR_NETWORK_IDLE_TIME = 300;
+const DEFAULT_WAIT_FOR_NETWORK_IDLE_CONCURRENCY = 2;
+const commandMap = {
+    Tap: {
+        CommandName: "SeleniumClickCommand",
+        DisplayName: "\u5143\u7D20\u70B9\u51FB"
+    },
+    RightClick: {
+        CommandName: "SeleniumRightClickCommand",
+        DisplayName: "\u5143\u7D20\u53F3\u952E\u70B9\u51FB"
+    },
+    DoubleClick: {
+        CommandName: "SeleniumDoubleClickCommand",
+        DisplayName: "\u5143\u7D20\u53CC\u51FB"
+    },
+    Hover: {
+        CommandName: "SeleniumMouseHoverCommand",
+        DisplayName: "\u9F20\u6807\u60AC\u505C"
+    },
+    Input: {
+        CommandName: "SeleniumSetTextCommand",
+        DisplayName: "\u8BBE\u7F6E\u6587\u672C"
+    },
+    KeyboardPress: {
+        CommandName: "SeleniumSendKeysCommand",
+        DisplayName: "\u6A21\u62DF\u6309\u952E"
+    },
+    Scroll: {
+        CommandName: "SeleniumElementScrollCommand",
+        DisplayName: "\u5143\u7D20\u6EDA\u52A8"
+    },
+    DragAndDrop: {
+        CommandName: "SeleniumDragDropCommand",
+        DisplayName: "\u5143\u7D20\u62D6\u62FD\uFF08\u81F3\u6307\u5B9A\u5143\u7D20\uFF09"
+    },
+    ClearInput: {
+        CommandName: "SeleniumClearTextCommand",
+        DisplayName: "\u6E05\u7A7A\u6587\u672C"
+    },
+    Sleep: {
+        CommandName: "SeleniumPauseCommand",
+        DisplayName: "\u6682\u505C\u811A\u672C"
+    },
+    LongPress: {
+        CommandName: "SeleniumSendKeysCommand",
+        DisplayName: "\u6A21\u62DF\u6309\u952E"
+    },
+    Swipe: {
+        CommandName: "SeleniumClickCommand",
+        DisplayName: "\u5143\u7D20\u70B9\u51FB"
+    }
+};
+exports.CONTAINER_MINI_HEIGHT = __webpack_exports__.CONTAINER_MINI_HEIGHT;
+exports.CONTAINER_MINI_WIDTH = __webpack_exports__.CONTAINER_MINI_WIDTH;
+exports.DEFAULT_WAIT_FOR_NAVIGATION_TIMEOUT = __webpack_exports__.DEFAULT_WAIT_FOR_NAVIGATION_TIMEOUT;
+exports.DEFAULT_WAIT_FOR_NETWORK_IDLE_CONCURRENCY = __webpack_exports__.DEFAULT_WAIT_FOR_NETWORK_IDLE_CONCURRENCY;
+exports.DEFAULT_WAIT_FOR_NETWORK_IDLE_TIME = __webpack_exports__.DEFAULT_WAIT_FOR_NETWORK_IDLE_TIME;
+exports.DEFAULT_WAIT_FOR_NETWORK_IDLE_TIMEOUT = __webpack_exports__.DEFAULT_WAIT_FOR_NETWORK_IDLE_TIMEOUT;
+exports.DEFAULT_WDA_PORT = __webpack_exports__.DEFAULT_WDA_PORT;
+exports.NodeType = __webpack_exports__.NodeType;
+exports.PLAYGROUND_SERVER_PORT = __webpack_exports__.PLAYGROUND_SERVER_PORT;
+exports.PLAYWRIGHT_EXAMPLE_CODE = __webpack_exports__.PLAYWRIGHT_EXAMPLE_CODE;
+exports.SCRCPY_SERVER_PORT = __webpack_exports__.SCRCPY_SERVER_PORT;
+exports.TEXT_MAX_SIZE = __webpack_exports__.TEXT_MAX_SIZE;
+exports.TEXT_SIZE_THRESHOLD = __webpack_exports__.TEXT_SIZE_THRESHOLD;
+exports.WEBDRIVER_ELEMENT_ID_KEY = __webpack_exports__.WEBDRIVER_ELEMENT_ID_KEY;
+exports.YAML_EXAMPLE_CODE = __webpack_exports__.YAML_EXAMPLE_CODE;
+exports.commandMap = __webpack_exports__.commandMap;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "CONTAINER_MINI_HEIGHT",
+    "CONTAINER_MINI_WIDTH",
+    "DEFAULT_WAIT_FOR_NAVIGATION_TIMEOUT",
+    "DEFAULT_WAIT_FOR_NETWORK_IDLE_CONCURRENCY",
+    "DEFAULT_WAIT_FOR_NETWORK_IDLE_TIME",
+    "DEFAULT_WAIT_FOR_NETWORK_IDLE_TIMEOUT",
+    "DEFAULT_WDA_PORT",
+    "NodeType",
+    "PLAYGROUND_SERVER_PORT",
+    "PLAYWRIGHT_EXAMPLE_CODE",
+    "SCRCPY_SERVER_PORT",
+    "TEXT_MAX_SIZE",
+    "TEXT_SIZE_THRESHOLD",
+    "WEBDRIVER_ELEMENT_ID_KEY",
+    "YAML_EXAMPLE_CODE",
+    "commandMap"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/env/basic.js

@@ -0,0 +1,40 @@
+"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 ('undefined' != 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__, {
+    getBasicEnvValue: ()=>getBasicEnvValue
+});
+const external_types_js_namespaceObject = require("./types.js");
+const getBasicEnvValue = (key)=>{
+    if (!external_types_js_namespaceObject.BASIC_ENV_KEYS.includes(key)) throw new Error(`getBasicEnvValue with key ${key} is not supported.`);
+    return process.env[key];
+};
+exports.getBasicEnvValue = __webpack_exports__.getBasicEnvValue;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "getBasicEnvValue"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/env/constants.js

@@ -0,0 +1,143 @@
+"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 ('undefined' != 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__, {
+    DEFAULT_MODEL_CONFIG_KEYS_LEGACY: ()=>DEFAULT_MODEL_CONFIG_KEYS_LEGACY,
+    VQA_MODEL_CONFIG_KEYS: ()=>VQA_MODEL_CONFIG_KEYS,
+    DEFAULT_MODEL_CONFIG_KEYS: ()=>DEFAULT_MODEL_CONFIG_KEYS,
+    PLANNING_MODEL_CONFIG_KEYS: ()=>PLANNING_MODEL_CONFIG_KEYS,
+    GROUNDING_MODEL_CONFIG_KEYS: ()=>GROUNDING_MODEL_CONFIG_KEYS
+});
+const external_types_js_namespaceObject = require("./types.js");
+const VQA_MODEL_CONFIG_KEYS = {
+    modelName: external_types_js_namespaceObject.RPASCENE_VQA_MODEL_NAME,
+    socksProxy: external_types_js_namespaceObject.RPASCENE_VQA_OPENAI_SOCKS_PROXY,
+    httpProxy: external_types_js_namespaceObject.RPASCENE_VQA_OPENAI_HTTP_PROXY,
+    openaiBaseURL: external_types_js_namespaceObject.RPASCENE_VQA_OPENAI_BASE_URL,
+    openaiApiKey: external_types_js_namespaceObject.RPASCENE_VQA_OPENAI_API_KEY,
+    openaiExtraConfig: external_types_js_namespaceObject.RPASCENE_VQA_OPENAI_INIT_CONFIG_JSON,
+    openaiUseAzureDeprecated: external_types_js_namespaceObject.RPASCENE_VQA_OPENAI_USE_AZURE,
+    useAzureOpenai: external_types_js_namespaceObject.RPASCENE_VQA_USE_AZURE_OPENAI,
+    azureOpenaiScope: external_types_js_namespaceObject.RPASCENE_VQA_AZURE_OPENAI_SCOPE,
+    azureOpenaiKey: external_types_js_namespaceObject.RPASCENE_VQA_AZURE_OPENAI_KEY,
+    azureOpenaiEndpoint: external_types_js_namespaceObject.RPASCENE_VQA_AZURE_OPENAI_ENDPOINT,
+    azureOpenaiApiVersion: external_types_js_namespaceObject.RPASCENE_VQA_AZURE_OPENAI_API_VERSION,
+    azureOpenaiDeployment: external_types_js_namespaceObject.RPASCENE_VQA_AZURE_OPENAI_DEPLOYMENT,
+    azureExtraConfig: external_types_js_namespaceObject.RPASCENE_VQA_AZURE_OPENAI_INIT_CONFIG_JSON,
+    useAnthropicSdk: external_types_js_namespaceObject.RPASCENE_VQA_USE_ANTHROPIC_SDK,
+    anthropicApiKey: external_types_js_namespaceObject.RPASCENE_VQA_ANTHROPIC_API_KEY,
+    vlMode: external_types_js_namespaceObject.RPASCENE_VQA_VL_MODE
+};
+const GROUNDING_MODEL_CONFIG_KEYS = {
+    modelName: external_types_js_namespaceObject.RPASCENE_GROUNDING_MODEL_NAME,
+    socksProxy: external_types_js_namespaceObject.RPASCENE_GROUNDING_OPENAI_SOCKS_PROXY,
+    httpProxy: external_types_js_namespaceObject.RPASCENE_GROUNDING_OPENAI_HTTP_PROXY,
+    openaiBaseURL: external_types_js_namespaceObject.RPASCENE_GROUNDING_OPENAI_BASE_URL,
+    openaiApiKey: external_types_js_namespaceObject.RPASCENE_GROUNDING_OPENAI_API_KEY,
+    openaiExtraConfig: external_types_js_namespaceObject.RPASCENE_GROUNDING_OPENAI_INIT_CONFIG_JSON,
+    openaiUseAzureDeprecated: external_types_js_namespaceObject.RPASCENE_GROUNDING_OPENAI_USE_AZURE,
+    useAzureOpenai: external_types_js_namespaceObject.RPASCENE_GROUNDING_USE_AZURE_OPENAI,
+    azureOpenaiScope: external_types_js_namespaceObject.RPASCENE_GROUNDING_AZURE_OPENAI_SCOPE,
+    azureOpenaiKey: external_types_js_namespaceObject.RPASCENE_GROUNDING_AZURE_OPENAI_KEY,
+    azureOpenaiEndpoint: external_types_js_namespaceObject.RPASCENE_GROUNDING_AZURE_OPENAI_ENDPOINT,
+    azureOpenaiApiVersion: external_types_js_namespaceObject.RPASCENE_GROUNDING_AZURE_OPENAI_API_VERSION,
+    azureOpenaiDeployment: external_types_js_namespaceObject.RPASCENE_GROUNDING_AZURE_OPENAI_DEPLOYMENT,
+    azureExtraConfig: external_types_js_namespaceObject.RPASCENE_GROUNDING_AZURE_OPENAI_INIT_CONFIG_JSON,
+    useAnthropicSdk: external_types_js_namespaceObject.RPASCENE_GROUNDING_USE_ANTHROPIC_SDK,
+    anthropicApiKey: external_types_js_namespaceObject.RPASCENE_GROUNDING_ANTHROPIC_API_KEY,
+    vlMode: external_types_js_namespaceObject.RPASCENE_GROUNDING_VL_MODE
+};
+const PLANNING_MODEL_CONFIG_KEYS = {
+    modelName: external_types_js_namespaceObject.RPASCENE_PLANNING_MODEL_NAME,
+    socksProxy: external_types_js_namespaceObject.RPASCENE_PLANNING_OPENAI_SOCKS_PROXY,
+    httpProxy: external_types_js_namespaceObject.RPASCENE_PLANNING_OPENAI_HTTP_PROXY,
+    openaiBaseURL: external_types_js_namespaceObject.RPASCENE_PLANNING_OPENAI_BASE_URL,
+    openaiApiKey: external_types_js_namespaceObject.RPASCENE_PLANNING_OPENAI_API_KEY,
+    openaiExtraConfig: external_types_js_namespaceObject.RPASCENE_PLANNING_OPENAI_INIT_CONFIG_JSON,
+    openaiUseAzureDeprecated: external_types_js_namespaceObject.RPASCENE_PLANNING_OPENAI_USE_AZURE,
+    useAzureOpenai: external_types_js_namespaceObject.RPASCENE_PLANNING_USE_AZURE_OPENAI,
+    azureOpenaiScope: external_types_js_namespaceObject.RPASCENE_PLANNING_AZURE_OPENAI_SCOPE,
+    azureOpenaiKey: external_types_js_namespaceObject.RPASCENE_PLANNING_AZURE_OPENAI_KEY,
+    azureOpenaiEndpoint: external_types_js_namespaceObject.RPASCENE_PLANNING_AZURE_OPENAI_ENDPOINT,
+    azureOpenaiApiVersion: external_types_js_namespaceObject.RPASCENE_PLANNING_AZURE_OPENAI_API_VERSION,
+    azureOpenaiDeployment: external_types_js_namespaceObject.RPASCENE_PLANNING_AZURE_OPENAI_DEPLOYMENT,
+    azureExtraConfig: external_types_js_namespaceObject.RPASCENE_PLANNING_AZURE_OPENAI_INIT_CONFIG_JSON,
+    useAnthropicSdk: external_types_js_namespaceObject.RPASCENE_PLANNING_USE_ANTHROPIC_SDK,
+    anthropicApiKey: external_types_js_namespaceObject.RPASCENE_PLANNING_ANTHROPIC_API_KEY,
+    vlMode: external_types_js_namespaceObject.RPASCENE_PLANNING_VL_MODE
+};
+const DEFAULT_MODEL_CONFIG_KEYS = {
+    modelName: external_types_js_namespaceObject.RPASCENE_MODEL_NAME,
+    socksProxy: external_types_js_namespaceObject.RPASCENE_OPENAI_SOCKS_PROXY,
+    httpProxy: external_types_js_namespaceObject.RPASCENE_OPENAI_HTTP_PROXY,
+    openaiBaseURL: external_types_js_namespaceObject.RPASCENE_OPENAI_BASE_URL,
+    openaiApiKey: external_types_js_namespaceObject.RPASCENE_OPENAI_API_KEY,
+    openaiExtraConfig: external_types_js_namespaceObject.RPASCENE_OPENAI_INIT_CONFIG_JSON,
+    openaiUseAzureDeprecated: external_types_js_namespaceObject.RPASCENE_OPENAI_USE_AZURE,
+    useAzureOpenai: external_types_js_namespaceObject.RPASCENE_USE_AZURE_OPENAI,
+    azureOpenaiScope: external_types_js_namespaceObject.RPASCENE_AZURE_OPENAI_SCOPE,
+    azureOpenaiKey: external_types_js_namespaceObject.RPASCENE_AZURE_OPENAI_KEY,
+    azureOpenaiEndpoint: external_types_js_namespaceObject.RPASCENE_AZURE_OPENAI_ENDPOINT,
+    azureOpenaiApiVersion: external_types_js_namespaceObject.RPASCENE_AZURE_OPENAI_API_VERSION,
+    azureOpenaiDeployment: external_types_js_namespaceObject.RPASCENE_AZURE_OPENAI_DEPLOYMENT,
+    azureExtraConfig: external_types_js_namespaceObject.RPASCENE_AZURE_OPENAI_INIT_CONFIG_JSON,
+    useAnthropicSdk: external_types_js_namespaceObject.RPASCENE_USE_ANTHROPIC_SDK,
+    anthropicApiKey: external_types_js_namespaceObject.RPASCENE_ANTHROPIC_API_KEY,
+    vlMode: external_types_js_namespaceObject.RPASCENE_VL_MODE
+};
+const DEFAULT_MODEL_CONFIG_KEYS_LEGACY = {
+    modelName: external_types_js_namespaceObject.RPASCENE_MODEL_NAME,
+    socksProxy: external_types_js_namespaceObject.RPASCENE_OPENAI_SOCKS_PROXY,
+    httpProxy: external_types_js_namespaceObject.RPASCENE_OPENAI_HTTP_PROXY,
+    openaiBaseURL: external_types_js_namespaceObject.OPENAI_BASE_URL,
+    openaiApiKey: external_types_js_namespaceObject.OPENAI_API_KEY,
+    openaiExtraConfig: external_types_js_namespaceObject.RPASCENE_OPENAI_INIT_CONFIG_JSON,
+    openaiUseAzureDeprecated: external_types_js_namespaceObject.OPENAI_USE_AZURE,
+    useAzureOpenai: external_types_js_namespaceObject.RPASCENE_USE_AZURE_OPENAI,
+    azureOpenaiScope: external_types_js_namespaceObject.RPASCENE_AZURE_OPENAI_SCOPE,
+    azureOpenaiKey: external_types_js_namespaceObject.AZURE_OPENAI_KEY,
+    azureOpenaiEndpoint: external_types_js_namespaceObject.AZURE_OPENAI_ENDPOINT,
+    azureOpenaiApiVersion: external_types_js_namespaceObject.AZURE_OPENAI_API_VERSION,
+    azureOpenaiDeployment: external_types_js_namespaceObject.AZURE_OPENAI_DEPLOYMENT,
+    azureExtraConfig: external_types_js_namespaceObject.RPASCENE_AZURE_OPENAI_INIT_CONFIG_JSON,
+    useAnthropicSdk: external_types_js_namespaceObject.RPASCENE_USE_ANTHROPIC_SDK,
+    anthropicApiKey: external_types_js_namespaceObject.ANTHROPIC_API_KEY,
+    vlMode: 'DEFAULT_MODEL_CONFIG_KEYS has no vlMode key'
+};
+exports.DEFAULT_MODEL_CONFIG_KEYS = __webpack_exports__.DEFAULT_MODEL_CONFIG_KEYS;
+exports.DEFAULT_MODEL_CONFIG_KEYS_LEGACY = __webpack_exports__.DEFAULT_MODEL_CONFIG_KEYS_LEGACY;
+exports.GROUNDING_MODEL_CONFIG_KEYS = __webpack_exports__.GROUNDING_MODEL_CONFIG_KEYS;
+exports.PLANNING_MODEL_CONFIG_KEYS = __webpack_exports__.PLANNING_MODEL_CONFIG_KEYS;
+exports.VQA_MODEL_CONFIG_KEYS = __webpack_exports__.VQA_MODEL_CONFIG_KEYS;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "DEFAULT_MODEL_CONFIG_KEYS",
+    "DEFAULT_MODEL_CONFIG_KEYS_LEGACY",
+    "GROUNDING_MODEL_CONFIG_KEYS",
+    "PLANNING_MODEL_CONFIG_KEYS",
+    "VQA_MODEL_CONFIG_KEYS"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/env/decide-model-config.js

@@ -0,0 +1,212 @@
+"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 ('undefined' != 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__, {
+    decideModelConfigFromEnv: ()=>decideModelConfigFromEnv,
+    decideModelConfigFromIntentConfig: ()=>decideModelConfigFromIntentConfig,
+    decideOpenaiSdkConfig: ()=>decideOpenaiSdkConfig
+});
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_logger_js_namespaceObject = require("../logger.js");
+const external_utils_js_namespaceObject = require("../utils.js");
+const external_helper_js_namespaceObject = require("./helper.js");
+const external_init_debug_js_namespaceObject = require("./init-debug.js");
+const external_parse_js_namespaceObject = require("./parse.js");
+const KEYS_MAP = {
+    VQA: external_constants_js_namespaceObject.VQA_MODEL_CONFIG_KEYS,
+    grounding: external_constants_js_namespaceObject.GROUNDING_MODEL_CONFIG_KEYS,
+    planning: external_constants_js_namespaceObject.PLANNING_MODEL_CONFIG_KEYS,
+    default: external_constants_js_namespaceObject.DEFAULT_MODEL_CONFIG_KEYS
+};
+const decideOpenaiSdkConfig = ({ keys, provider, valueAssert })=>{
+    (0, external_init_debug_js_namespaceObject.initDebugConfig)();
+    const debugLog = (0, external_logger_js_namespaceObject.getDebug)('ai:config');
+    const socksProxy = provider[keys.socksProxy];
+    const httpProxy = provider[keys.httpProxy];
+    const vlMode = provider[keys.vlMode];
+    debugLog('enter decideOpenaiSdkConfig with keys:', keys);
+    if (provider[keys.openaiUseAzureDeprecated]) {
+        debugLog(`provider has ${keys.openaiUseAzureDeprecated} with value${provider[keys.openaiUseAzureDeprecated]}`);
+        const openaiBaseURL = provider[keys.openaiBaseURL];
+        const openaiApiKey = provider[keys.openaiApiKey];
+        const openaiExtraConfig = (0, external_helper_js_namespaceObject.parseJson)(keys.openaiExtraConfig, provider[keys.openaiExtraConfig]);
+        valueAssert(openaiApiKey, keys.openaiApiKey, keys.openaiUseAzureDeprecated);
+        return {
+            socksProxy,
+            httpProxy,
+            vlModeRaw: vlMode,
+            openaiUseAzureDeprecated: true,
+            openaiApiKey,
+            openaiBaseURL,
+            openaiExtraConfig
+        };
+    }
+    if (provider[keys.useAzureOpenai]) {
+        debugLog(`provider has ${keys.useAzureOpenai} with value ${provider[keys.useAzureOpenai]}`);
+        const azureOpenaiScope = provider[keys.azureOpenaiScope];
+        const azureOpenaiKey = provider[keys.azureOpenaiKey];
+        const azureOpenaiEndpoint = provider[keys.azureOpenaiEndpoint];
+        const azureOpenaiDeployment = provider[keys.azureOpenaiDeployment];
+        const azureOpenaiApiVersion = provider[keys.azureOpenaiApiVersion];
+        const azureExtraConfig = (0, external_helper_js_namespaceObject.parseJson)(keys.azureExtraConfig, provider[keys.azureExtraConfig]);
+        const openaiExtraConfig = (0, external_helper_js_namespaceObject.parseJson)(keys.openaiExtraConfig, provider[keys.openaiExtraConfig]);
+        valueAssert(azureOpenaiKey, keys.azureOpenaiKey, keys.useAzureOpenai);
+        return {
+            socksProxy,
+            httpProxy,
+            vlModeRaw: vlMode,
+            useAzureOpenai: true,
+            azureOpenaiScope,
+            azureOpenaiKey,
+            azureOpenaiEndpoint,
+            azureOpenaiDeployment,
+            azureOpenaiApiVersion,
+            azureExtraConfig,
+            openaiExtraConfig
+        };
+    }
+    if (provider[keys.useAnthropicSdk]) {
+        debugLog(`provider has ${keys.useAnthropicSdk} with value ${provider[keys.useAnthropicSdk]}`);
+        const anthropicApiKey = provider[keys.anthropicApiKey];
+        valueAssert(anthropicApiKey, keys.anthropicApiKey, keys.useAnthropicSdk);
+        return {
+            socksProxy,
+            httpProxy,
+            useAnthropicSdk: true,
+            anthropicApiKey
+        };
+    }
+    {
+        debugLog('provider has no specific model SDK declared');
+        const openaiBaseURL = provider[keys.openaiBaseURL];
+        const openaiApiKey = provider[keys.openaiApiKey];
+        const openaiExtraConfig = (0, external_helper_js_namespaceObject.parseJson)(keys.openaiExtraConfig, provider[keys.openaiExtraConfig]);
+        valueAssert(openaiApiKey, keys.openaiApiKey);
+        return {
+            socksProxy,
+            httpProxy,
+            vlModeRaw: vlMode,
+            openaiBaseURL,
+            openaiApiKey,
+            openaiExtraConfig
+        };
+    }
+};
+const getModelDescription = (vlMode, uiTarsVersion)=>{
+    if (vlMode) if (uiTarsVersion) return `UI-TARS=${uiTarsVersion}`;
+    else return `${vlMode} mode`;
+    return '';
+};
+const decideModelConfigFromIntentConfig = (intent, intentConfig)=>{
+    const debugLog = (0, external_logger_js_namespaceObject.getDebug)('ai:config');
+    debugLog('decideModelConfig base on agent.modelConfig()');
+    const keysForFn = KEYS_MAP[intent];
+    const candidateModelNameFromConfig = intentConfig[keysForFn.modelName];
+    debugLog('Got modelName from modelConfigFn', candidateModelNameFromConfig);
+    const chosenKeys = (()=>{
+        if (candidateModelNameFromConfig) {
+            debugLog('query modelConfig from fn by intent got corresponding modelName, will get other corresponding keys');
+            return keysForFn;
+        }
+        debugLog('query modelConfig from fn by intent got no corresponding modelName, will get other keys by default');
+        (0, external_utils_js_namespaceObject.assert)(intentConfig[external_constants_js_namespaceObject.DEFAULT_MODEL_CONFIG_KEYS.modelName], `The return value of agent.modelConfig do not have a valid value with key ${external_constants_js_namespaceObject.DEFAULT_MODEL_CONFIG_KEYS.modelName}.`);
+        return external_constants_js_namespaceObject.DEFAULT_MODEL_CONFIG_KEYS;
+    })();
+    const result = decideOpenaiSdkConfig({
+        keys: chosenKeys,
+        provider: intentConfig,
+        valueAssert: (0, external_helper_js_namespaceObject.createAssert)(chosenKeys.modelName, 'modelConfig', candidateModelNameFromConfig)
+    });
+    const { vlMode, uiTarsVersion } = (0, external_parse_js_namespaceObject.parseVlModeAndUiTarsModelVersionFromRawValue)(result.vlModeRaw);
+    const modelDescription = getModelDescription(vlMode, uiTarsVersion);
+    const finalResult = {
+        ...result,
+        modelName: intentConfig[chosenKeys.modelName],
+        vlMode,
+        uiTarsModelVersion: uiTarsVersion,
+        modelDescription,
+        from: 'modelConfig',
+        intent
+    };
+    debugLog(`decideModelConfig result by agent.modelConfig() with intent ${intent}:`, (0, external_helper_js_namespaceObject.maskConfig)(finalResult));
+    return finalResult;
+};
+const decideModelConfigFromEnv = (intent, allEnvConfig)=>{
+    (0, external_init_debug_js_namespaceObject.initDebugConfig)();
+    const debugLog = (0, external_logger_js_namespaceObject.getDebug)('ai:config');
+    const keysForEnv = 'default' === intent ? external_constants_js_namespaceObject.DEFAULT_MODEL_CONFIG_KEYS_LEGACY : KEYS_MAP[intent];
+    if ('default' !== intent && allEnvConfig[keysForEnv.modelName]) {
+        const modelName = allEnvConfig[keysForEnv.modelName];
+        debugLog(`Got intent ${intent} corresponding modelName ${modelName} by key ${keysForEnv.modelName} from globalConfig, will get other config by intent.`);
+        const result = decideOpenaiSdkConfig({
+            keys: keysForEnv,
+            provider: allEnvConfig,
+            valueAssert: (0, external_helper_js_namespaceObject.createAssert)(keysForEnv.modelName, 'process.env', modelName)
+        });
+        const { vlMode, uiTarsVersion } = (0, external_parse_js_namespaceObject.parseVlModeAndUiTarsModelVersionFromRawValue)(result.vlModeRaw);
+        const modelDescription = getModelDescription(vlMode, uiTarsVersion);
+        const finalResult = {
+            ...result,
+            modelName,
+            vlMode,
+            uiTarsModelVersion: uiTarsVersion,
+            modelDescription,
+            from: 'env',
+            intent
+        };
+        debugLog(`decideModelConfig result by process.env with intent ${intent}:`, (0, external_helper_js_namespaceObject.maskConfig)(finalResult));
+        return finalResult;
+    }
+    debugLog(`decideModelConfig as legacy logic with intent ${intent}.`);
+    const result = decideOpenaiSdkConfig({
+        keys: external_constants_js_namespaceObject.DEFAULT_MODEL_CONFIG_KEYS_LEGACY,
+        provider: allEnvConfig,
+        valueAssert: (0, external_helper_js_namespaceObject.createAssert)(external_constants_js_namespaceObject.DEFAULT_MODEL_CONFIG_KEYS_LEGACY.modelName, 'process.env')
+    });
+    const { vlMode, uiTarsVersion } = (0, external_parse_js_namespaceObject.parseVlModeAndUiTarsFromGlobalConfig)(allEnvConfig);
+    const modelDescription = getModelDescription(vlMode, uiTarsVersion);
+    const finalResult = {
+        ...result,
+        modelName: allEnvConfig[external_constants_js_namespaceObject.DEFAULT_MODEL_CONFIG_KEYS_LEGACY.modelName] || 'gpt-4o',
+        vlMode,
+        uiTarsModelVersion: uiTarsVersion,
+        modelDescription,
+        from: 'legacy-env',
+        intent
+    };
+    debugLog(`decideModelConfig result by legacy logic with intent ${intent}:`, (0, external_helper_js_namespaceObject.maskConfig)(finalResult));
+    return finalResult;
+};
+exports.decideModelConfigFromEnv = __webpack_exports__.decideModelConfigFromEnv;
+exports.decideModelConfigFromIntentConfig = __webpack_exports__.decideModelConfigFromIntentConfig;
+exports.decideOpenaiSdkConfig = __webpack_exports__.decideOpenaiSdkConfig;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "decideModelConfigFromEnv",
+    "decideModelConfigFromIntentConfig",
+    "decideOpenaiSdkConfig"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/env/global-config-manager.js

@@ -0,0 +1,116 @@
+"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 ('undefined' != 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__, {
+    GlobalConfigManager: ()=>GlobalConfigManager
+});
+const external_init_debug_js_namespaceObject = require("./init-debug.js");
+const external_types_js_namespaceObject = require("./types.js");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class GlobalConfigManager {
+    getAllEnvConfig() {
+        const envConfig = external_types_js_namespaceObject.ALL_ENV_KEYS.reduce((p, name)=>{
+            p[name] = process.env[name];
+            return p;
+        }, Object.create(null));
+        if (!this.override) return envConfig;
+        {
+            const { newConfig, extendMode } = this.override;
+            if (extendMode) return {
+                ...envConfig,
+                ...newConfig
+            };
+            return {
+                ...newConfig
+            };
+        }
+    }
+    getEnvConfigValue(key) {
+        const allConfig = this.getAllEnvConfig();
+        if (!external_types_js_namespaceObject.STRING_ENV_KEYS.includes(key)) throw new Error(`getEnvConfigValue with key ${key} is not supported.`);
+        if (key === external_types_js_namespaceObject.MATCH_BY_POSITION) throw new Error('MATCH_BY_POSITION is deprecated, use RPASCENE_USE_VL_MODEL instead');
+        const value = allConfig[key];
+        this.keysHaveBeenRead[key] = true;
+        if ('string' == typeof value) return value.trim();
+        return value;
+    }
+    getEnvConfigInNumber(key) {
+        const allConfig = this.getAllEnvConfig();
+        if (!external_types_js_namespaceObject.NUMBER_ENV_KEYS.includes(key)) throw new Error(`getEnvConfigInNumber with key ${key} is not supported`);
+        const value = allConfig[key];
+        this.keysHaveBeenRead[key] = true;
+        return Number(value || '');
+    }
+    getEnvConfigInBoolean(key) {
+        const allConfig = this.getAllEnvConfig();
+        if (!external_types_js_namespaceObject.BOOLEAN_ENV_KEYS.includes(key)) throw new Error(`getEnvConfigInBoolean with key ${key} is not supported`);
+        const value = allConfig[key];
+        this.keysHaveBeenRead[key] = true;
+        if (!value) return false;
+        if (/^(true|1)$/i.test(value)) return true;
+        if (/^(false|0)$/i.test(value)) return false;
+        return !!value.trim();
+    }
+    registerModelConfigManager(globalModelConfigManager) {
+        this.globalModelConfigManager = globalModelConfigManager;
+    }
+    overrideAIConfig(newConfig, extendMode = false) {
+        var _this_override;
+        const savedNewConfig = extendMode ? {
+            ...null == (_this_override = this.override) ? void 0 : _this_override.newConfig,
+            ...newConfig
+        } : newConfig;
+        this.override = {
+            newConfig: {
+                ...savedNewConfig
+            },
+            extendMode
+        };
+        if (!this.globalModelConfigManager) throw new Error('globalModelConfigManager is not registered, which should not happen');
+        this.globalModelConfigManager.clearModelConfigMap();
+    }
+    constructor(){
+        _define_property(this, "override", void 0);
+        _define_property(this, "keysHaveBeenRead", {});
+        _define_property(this, "globalModelConfigManager", void 0);
+        (0, external_init_debug_js_namespaceObject.initDebugConfig)();
+    }
+}
+exports.GlobalConfigManager = __webpack_exports__.GlobalConfigManager;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "GlobalConfigManager"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});