@godscene/shared 1.7.11

package/dist/es/constants/index.mjs

@@ -0,0 +1,124 @@
+import { PLAYWRIGHT_EXAMPLE_CODE, YAML_EXAMPLE_CODE } from "./example-code.mjs";
+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 SCRCPY_ADB_CONNECT_TIMEOUT_MS = 10000;
+const SCRCPY_PUSH_TIMEOUT_MS = 10000;
+const SCRCPY_START_TIMEOUT_MS = 15000;
+const SCRCPY_VIDEO_STREAM_TIMEOUT_MS = 15000;
+const SCRCPY_PREVIEW_METADATA_TIMEOUT_MS = SCRCPY_ADB_CONNECT_TIMEOUT_MS + SCRCPY_PUSH_TIMEOUT_MS + SCRCPY_START_TIMEOUT_MS + SCRCPY_VIDEO_STREAM_TIMEOUT_MS + 5000;
+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_CONCURRENCY = 2;
+const rpasceneCommand = {
+    Tap: 'Tap',
+    RightClick: 'RightClick',
+    DoubleClick: 'DoubleClick',
+    Hover: 'Hover',
+    Input: 'Input',
+    KeyboardPress: 'KeyboardPress',
+    Scroll: 'Scroll',
+    DragAndDrop: 'DragAndDrop',
+    ClearInput: 'ClearInput',
+    Sleep: 'Sleep',
+    LongPress: 'LongPress',
+    Swipe: 'Swipe',
+    Reload: 'Reload',
+    GoBack: 'GoBack',
+    Navigate: 'Navigate'
+};
+const rpastudioCommand = {
+    SeleniumClickCommand: 'SeleniumClickCommand',
+    SeleniumRightClickCommand: 'SeleniumRightClickCommand',
+    SeleniumDoubleClickCommand: 'SeleniumDoubleClickCommand',
+    SeleniumMouseHoverCommand: 'SeleniumMouseHoverCommand',
+    SeleniumSetValueCommand: 'SeleniumSetValueCommand',
+    SeleniumElementSendKeysCommand: 'SeleniumElementSendKeysCommand',
+    SeleniumSendKeysCommand: 'SeleniumSendKeysCommand',
+    SeleniumElementScrollCommand: 'SeleniumElementScrollCommand',
+    SeleniumWindowScrollCommand: 'SeleniumWindowScrollCommand',
+    SeleniumDragAndDropCommand: 'SeleniumDragAndDropCommand',
+    SeleniumClearValueCommand: 'SeleniumClearValueCommand',
+    PauseCommand: 'PauseCommand',
+    SeleniumBrowserRefreshCommand: 'SeleniumBrowserRefreshCommand',
+    SeleniumBrowserNavigateBackCommand: 'SeleniumBrowserNavigateBackCommand',
+    SeleniumBrowserNavigateCommand: 'SeleniumBrowserNavigateCommand'
+};
+const commandMap = {
+    [rpasceneCommand.Tap]: {
+        CommandName: rpastudioCommand.SeleniumClickCommand,
+        DisplayName: '元素点击'
+    },
+    [rpasceneCommand.RightClick]: {
+        CommandName: rpastudioCommand.SeleniumRightClickCommand,
+        DisplayName: '元素右键点击'
+    },
+    [rpasceneCommand.DoubleClick]: {
+        CommandName: rpastudioCommand.SeleniumDoubleClickCommand,
+        DisplayName: '元素双击'
+    },
+    [rpasceneCommand.Hover]: {
+        CommandName: rpastudioCommand.SeleniumMouseHoverCommand,
+        DisplayName: '鼠标悬停'
+    },
+    [rpasceneCommand.Input]: {
+        CommandName: rpastudioCommand.SeleniumSetValueCommand,
+        DisplayName: '设置文本'
+    },
+    [rpasceneCommand.KeyboardPress]: {
+        CommandName: rpastudioCommand.SeleniumElementSendKeysCommand,
+        DisplayName: '模拟按键'
+    },
+    [rpasceneCommand.Scroll]: {
+        CommandName: rpastudioCommand.SeleniumElementScrollCommand,
+        DisplayName: '元素滚动'
+    },
+    [rpasceneCommand.DragAndDrop]: {
+        CommandName: rpastudioCommand.SeleniumDragAndDropCommand,
+        DisplayName: '元素拖拽（至指定元素）'
+    },
+    [rpasceneCommand.ClearInput]: {
+        CommandName: rpastudioCommand.SeleniumClearValueCommand,
+        DisplayName: '清空文本'
+    },
+    [rpasceneCommand.Sleep]: {
+        CommandName: rpastudioCommand.PauseCommand,
+        DisplayName: '暂停脚本'
+    },
+    [rpasceneCommand.LongPress]: {
+        CommandName: '',
+        DisplayName: ''
+    },
+    [rpasceneCommand.Swipe]: {
+        CommandName: '',
+        DisplayName: ''
+    },
+    [rpasceneCommand.Reload]: {
+        CommandName: rpastudioCommand.SeleniumBrowserRefreshCommand,
+        DisplayName: '刷新'
+    },
+    [rpasceneCommand.GoBack]: {
+        CommandName: rpastudioCommand.SeleniumBrowserNavigateBackCommand,
+        DisplayName: '后退'
+    },
+    [rpasceneCommand.Navigate]: {
+        CommandName: rpastudioCommand.SeleniumBrowserNavigateCommand,
+        DisplayName: '打开页面'
+    }
+};
+export { CONTAINER_MINI_HEIGHT, CONTAINER_MINI_WIDTH, DEFAULT_WAIT_FOR_NAVIGATION_TIMEOUT, DEFAULT_WAIT_FOR_NETWORK_IDLE_CONCURRENCY, DEFAULT_WAIT_FOR_NETWORK_IDLE_TIMEOUT, DEFAULT_WDA_PORT, constants_NodeType as NodeType, PLAYGROUND_SERVER_PORT, PLAYWRIGHT_EXAMPLE_CODE, SCRCPY_ADB_CONNECT_TIMEOUT_MS, SCRCPY_PREVIEW_METADATA_TIMEOUT_MS, SCRCPY_PUSH_TIMEOUT_MS, SCRCPY_SERVER_PORT, SCRCPY_START_TIMEOUT_MS, SCRCPY_VIDEO_STREAM_TIMEOUT_MS, TEXT_MAX_SIZE, TEXT_SIZE_THRESHOLD, WEBDRIVER_ELEMENT_ID_KEY, YAML_EXAMPLE_CODE, commandMap, rpasceneCommand, rpastudioCommand };

package/dist/es/env/basic.mjs

@@ -0,0 +1,6 @@
+import { BASIC_ENV_KEYS } from "./types.mjs";
+const getBasicEnvValue = (key)=>{
+    if (!BASIC_ENV_KEYS.includes(key)) throw new Error(`getBasicEnvValue with key ${key} is not supported.`);
+    return process.env[key];
+};
+export { getBasicEnvValue };

package/dist/es/env/constants.mjs

@@ -0,0 +1,110 @@
+import { MIDSCENE_INSIGHT_MODEL_API_KEY, MIDSCENE_INSIGHT_MODEL_BASE_URL, MIDSCENE_INSIGHT_MODEL_EXTRA_BODY_JSON, MIDSCENE_INSIGHT_MODEL_FAMILY, MIDSCENE_INSIGHT_MODEL_HTTP_PROXY, MIDSCENE_INSIGHT_MODEL_INIT_CONFIG_JSON, MIDSCENE_INSIGHT_MODEL_NAME, MIDSCENE_INSIGHT_MODEL_REASONING_BUDGET, MIDSCENE_INSIGHT_MODEL_REASONING_EFFORT, MIDSCENE_INSIGHT_MODEL_REASONING_ENABLED, MIDSCENE_INSIGHT_MODEL_RETRY_COUNT, MIDSCENE_INSIGHT_MODEL_RETRY_INTERVAL, MIDSCENE_INSIGHT_MODEL_SOCKS_PROXY, MIDSCENE_INSIGHT_MODEL_TEMPERATURE, MIDSCENE_INSIGHT_MODEL_TIMEOUT, MIDSCENE_MODEL_API_KEY, MIDSCENE_MODEL_BASE_URL, MIDSCENE_MODEL_EXTRA_BODY_JSON, MIDSCENE_MODEL_FAMILY, MIDSCENE_MODEL_HTTP_PROXY, MIDSCENE_MODEL_INIT_CONFIG_JSON, MIDSCENE_MODEL_NAME, MIDSCENE_MODEL_REASONING_BUDGET, MIDSCENE_MODEL_REASONING_EFFORT, MIDSCENE_MODEL_REASONING_ENABLED, MIDSCENE_MODEL_RETRY_COUNT, MIDSCENE_MODEL_RETRY_INTERVAL, MIDSCENE_MODEL_SOCKS_PROXY, MIDSCENE_MODEL_TEMPERATURE, MIDSCENE_MODEL_TIMEOUT, MIDSCENE_OPENAI_HTTP_PROXY, MIDSCENE_OPENAI_INIT_CONFIG_JSON, MIDSCENE_OPENAI_SOCKS_PROXY, MIDSCENE_PLANNING_MODEL_API_KEY, MIDSCENE_PLANNING_MODEL_BASE_URL, MIDSCENE_PLANNING_MODEL_EXTRA_BODY_JSON, MIDSCENE_PLANNING_MODEL_FAMILY, MIDSCENE_PLANNING_MODEL_HTTP_PROXY, MIDSCENE_PLANNING_MODEL_INIT_CONFIG_JSON, MIDSCENE_PLANNING_MODEL_NAME, MIDSCENE_PLANNING_MODEL_REASONING_BUDGET, MIDSCENE_PLANNING_MODEL_REASONING_EFFORT, MIDSCENE_PLANNING_MODEL_REASONING_ENABLED, MIDSCENE_PLANNING_MODEL_RETRY_COUNT, MIDSCENE_PLANNING_MODEL_RETRY_INTERVAL, MIDSCENE_PLANNING_MODEL_SOCKS_PROXY, MIDSCENE_PLANNING_MODEL_TEMPERATURE, MIDSCENE_PLANNING_MODEL_TIMEOUT, OPENAI_API_KEY, OPENAI_BASE_URL, YHT_ACCESS_TOKEN, YHT_BASE_URL, YHT_CHAT_TYPE, YHT_DOMAIN, YHT_MODEL, YHT_MODEL_CATEGORY, YHT_STREAM, YHT_TEMPERATURE, YHT_TOP_P, YHT_TRACE_ID } from "./types.mjs";
+const INSIGHT_MODEL_CONFIG_KEYS = {
+    modelName: MIDSCENE_INSIGHT_MODEL_NAME,
+    socksProxy: MIDSCENE_INSIGHT_MODEL_SOCKS_PROXY,
+    httpProxy: MIDSCENE_INSIGHT_MODEL_HTTP_PROXY,
+    openaiBaseURL: MIDSCENE_INSIGHT_MODEL_BASE_URL,
+    openaiApiKey: MIDSCENE_INSIGHT_MODEL_API_KEY,
+    openaiExtraConfig: MIDSCENE_INSIGHT_MODEL_INIT_CONFIG_JSON,
+    extraBody: MIDSCENE_INSIGHT_MODEL_EXTRA_BODY_JSON,
+    modelFamily: MIDSCENE_INSIGHT_MODEL_FAMILY,
+    timeout: MIDSCENE_INSIGHT_MODEL_TIMEOUT,
+    temperature: MIDSCENE_INSIGHT_MODEL_TEMPERATURE,
+    retryCount: MIDSCENE_INSIGHT_MODEL_RETRY_COUNT,
+    retryInterval: MIDSCENE_INSIGHT_MODEL_RETRY_INTERVAL,
+    reasoningEffort: MIDSCENE_INSIGHT_MODEL_REASONING_EFFORT,
+    reasoningEnabled: MIDSCENE_INSIGHT_MODEL_REASONING_ENABLED,
+    reasoningBudget: MIDSCENE_INSIGHT_MODEL_REASONING_BUDGET,
+    yht_domain: YHT_DOMAIN,
+    yht_access_token: YHT_ACCESS_TOKEN,
+    yht_model: YHT_MODEL,
+    yht_base_url: YHT_BASE_URL,
+    yht_chat_type: YHT_CHAT_TYPE,
+    yht_model_category: YHT_MODEL_CATEGORY,
+    yht_stream: YHT_STREAM,
+    yht_temperature: YHT_TEMPERATURE,
+    yht_top_p: YHT_TOP_P,
+    yht_trace_id: YHT_TRACE_ID
+};
+const PLANNING_MODEL_CONFIG_KEYS = {
+    modelName: MIDSCENE_PLANNING_MODEL_NAME,
+    socksProxy: MIDSCENE_PLANNING_MODEL_SOCKS_PROXY,
+    httpProxy: MIDSCENE_PLANNING_MODEL_HTTP_PROXY,
+    openaiBaseURL: MIDSCENE_PLANNING_MODEL_BASE_URL,
+    openaiApiKey: MIDSCENE_PLANNING_MODEL_API_KEY,
+    openaiExtraConfig: MIDSCENE_PLANNING_MODEL_INIT_CONFIG_JSON,
+    extraBody: MIDSCENE_PLANNING_MODEL_EXTRA_BODY_JSON,
+    modelFamily: MIDSCENE_PLANNING_MODEL_FAMILY,
+    timeout: MIDSCENE_PLANNING_MODEL_TIMEOUT,
+    temperature: MIDSCENE_PLANNING_MODEL_TEMPERATURE,
+    retryCount: MIDSCENE_PLANNING_MODEL_RETRY_COUNT,
+    retryInterval: MIDSCENE_PLANNING_MODEL_RETRY_INTERVAL,
+    reasoningEffort: MIDSCENE_PLANNING_MODEL_REASONING_EFFORT,
+    reasoningEnabled: MIDSCENE_PLANNING_MODEL_REASONING_ENABLED,
+    reasoningBudget: MIDSCENE_PLANNING_MODEL_REASONING_BUDGET,
+    yht_domain: YHT_DOMAIN,
+    yht_access_token: YHT_ACCESS_TOKEN,
+    yht_model: YHT_MODEL,
+    yht_base_url: YHT_BASE_URL,
+    yht_chat_type: YHT_CHAT_TYPE,
+    yht_model_category: YHT_MODEL_CATEGORY,
+    yht_stream: YHT_STREAM,
+    yht_temperature: YHT_TEMPERATURE,
+    yht_top_p: YHT_TOP_P,
+    yht_trace_id: YHT_TRACE_ID
+};
+const DEFAULT_MODEL_CONFIG_KEYS = {
+    modelName: MIDSCENE_MODEL_NAME,
+    socksProxy: MIDSCENE_MODEL_SOCKS_PROXY,
+    httpProxy: MIDSCENE_MODEL_HTTP_PROXY,
+    openaiBaseURL: MIDSCENE_MODEL_BASE_URL,
+    openaiApiKey: MIDSCENE_MODEL_API_KEY,
+    openaiExtraConfig: MIDSCENE_MODEL_INIT_CONFIG_JSON,
+    extraBody: MIDSCENE_MODEL_EXTRA_BODY_JSON,
+    modelFamily: MIDSCENE_MODEL_FAMILY,
+    timeout: MIDSCENE_MODEL_TIMEOUT,
+    temperature: MIDSCENE_MODEL_TEMPERATURE,
+    retryCount: MIDSCENE_MODEL_RETRY_COUNT,
+    retryInterval: MIDSCENE_MODEL_RETRY_INTERVAL,
+    reasoningEffort: MIDSCENE_MODEL_REASONING_EFFORT,
+    reasoningEnabled: MIDSCENE_MODEL_REASONING_ENABLED,
+    reasoningBudget: MIDSCENE_MODEL_REASONING_BUDGET,
+    yht_domain: YHT_DOMAIN,
+    yht_access_token: YHT_ACCESS_TOKEN,
+    yht_model: YHT_MODEL,
+    yht_base_url: YHT_BASE_URL,
+    yht_chat_type: YHT_CHAT_TYPE,
+    yht_model_category: YHT_MODEL_CATEGORY,
+    yht_stream: YHT_STREAM,
+    yht_temperature: YHT_TEMPERATURE,
+    yht_top_p: YHT_TOP_P,
+    yht_trace_id: YHT_TRACE_ID
+};
+const DEFAULT_MODEL_CONFIG_KEYS_LEGACY = {
+    modelName: MIDSCENE_MODEL_NAME,
+    socksProxy: MIDSCENE_OPENAI_SOCKS_PROXY,
+    httpProxy: MIDSCENE_OPENAI_HTTP_PROXY,
+    openaiBaseURL: OPENAI_BASE_URL,
+    openaiApiKey: OPENAI_API_KEY,
+    openaiExtraConfig: MIDSCENE_OPENAI_INIT_CONFIG_JSON,
+    extraBody: MIDSCENE_MODEL_EXTRA_BODY_JSON,
+    modelFamily: 'DEFAULT_MODEL_CONFIG_KEYS has no modelFamily key',
+    timeout: MIDSCENE_MODEL_TIMEOUT,
+    temperature: MIDSCENE_MODEL_TEMPERATURE,
+    retryCount: MIDSCENE_MODEL_RETRY_COUNT,
+    retryInterval: MIDSCENE_MODEL_RETRY_INTERVAL,
+    reasoningEffort: MIDSCENE_MODEL_REASONING_EFFORT,
+    reasoningEnabled: MIDSCENE_MODEL_REASONING_ENABLED,
+    reasoningBudget: MIDSCENE_MODEL_REASONING_BUDGET,
+    yht_domain: YHT_DOMAIN,
+    yht_access_token: YHT_ACCESS_TOKEN,
+    yht_model: YHT_MODEL,
+    yht_base_url: YHT_BASE_URL,
+    yht_chat_type: YHT_CHAT_TYPE,
+    yht_model_category: YHT_MODEL_CATEGORY,
+    yht_stream: YHT_STREAM,
+    yht_temperature: YHT_TEMPERATURE,
+    yht_top_p: YHT_TOP_P,
+    yht_trace_id: YHT_TRACE_ID
+};
+export { DEFAULT_MODEL_CONFIG_KEYS, DEFAULT_MODEL_CONFIG_KEYS_LEGACY, INSIGHT_MODEL_CONFIG_KEYS, PLANNING_MODEL_CONFIG_KEYS };

package/dist/es/env/global-config-manager.mjs

@@ -0,0 +1,94 @@
+import { initDebugConfig } from "./init-debug.mjs";
+import { ALL_ENV_KEYS, BOOLEAN_ENV_KEYS, GLOBAL_ENV_KEYS, MATCH_BY_POSITION, MODEL_ENV_KEYS, NUMBER_ENV_KEYS, STRING_ENV_KEYS } from "./types.mjs";
+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 = 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 (key === MATCH_BY_POSITION) throw new Error('MATCH_BY_POSITION is discarded, use MIDSCENE_MODEL_FAMILY instead');
+        if (!STRING_ENV_KEYS.includes(key)) throw new Error(`getEnvConfigValue with key ${key} is not supported.`);
+        const value = allConfig[key];
+        this.keysHaveBeenRead[key] = true;
+        if ('string' == typeof value) return value.trim();
+        return value;
+    }
+    getEnvConfigInBoolean(key) {
+        const allConfig = this.getAllEnvConfig();
+        if (!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();
+    }
+    getEnvConfigValueAsNumber(key) {
+        if (!STRING_ENV_KEYS.includes(key) && !NUMBER_ENV_KEYS.includes(key)) throw new Error(`getEnvConfigValueAsNumber with key ${key} is not supported.`);
+        const allConfig = this.getAllEnvConfig();
+        const value = allConfig[key];
+        this.keysHaveBeenRead[key] = true;
+        if ('string' != typeof value) return;
+        const trimmed = value.trim();
+        if (!trimmed) return;
+        const numValue = Number(trimmed);
+        return Number.isNaN(numValue) ? void 0 : numValue;
+    }
+    registerModelConfigManager(globalModelConfigManager) {
+        this.globalModelConfigManager = globalModelConfigManager;
+    }
+    overrideAIConfig(newConfig, extendMode = false) {
+        for(const key in newConfig){
+            if (![
+                ...GLOBAL_ENV_KEYS,
+                ...MODEL_ENV_KEYS
+            ].includes(key)) throw new Error(`Failed to override AI config, invalid key: ${key}`);
+            const value = newConfig[key];
+            if ('string' != typeof value) throw new Error(`Failed to override AI config, value for key ${key} must be a string, but got with type ${typeof value}`);
+            if (this.keysHaveBeenRead[key]) console.warn(`Warning: try to override AI config with key ${key} ,but it has been read.`);
+        }
+        const savedNewConfig = extendMode ? {
+            ...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);
+        initDebugConfig();
+    }
+}
+export { GlobalConfigManager };

package/dist/es/env/helper.mjs

@@ -0,0 +1,43 @@
+const maskKey = (key, maskChar = '*')=>{
+    if ('string' != typeof key || 0 === key.length) return key;
+    const prefixLen = 3;
+    const suffixLen = 3;
+    const keepLength = prefixLen + suffixLen;
+    if (key.length <= keepLength) return key;
+    const prefix = key.substring(0, prefixLen);
+    const suffix = key.substring(key.length - suffixLen);
+    const maskLength = key.length - keepLength;
+    const mask = maskChar.repeat(maskLength);
+    return `${prefix}${mask}${suffix}`;
+};
+const maskConfig = (config)=>Object.fromEntries(Object.entries(config).map(([key, value])=>{
+        if (!value) return [
+            key,
+            value
+        ];
+        if ('string' == typeof value && /key/i.test(key)) return [
+            key,
+            maskKey(value)
+        ];
+        if ('object' == typeof value) {
+            const valueStr = JSON.stringify(value);
+            if (/key/i.test(valueStr)) return [
+                key,
+                maskKey(valueStr)
+            ];
+        }
+        return [
+            key,
+            value
+        ];
+    }));
+const parseJson = (key, value)=>{
+    if (value) try {
+        return JSON.parse(value);
+    } catch (e) {
+        throw new Error(`Failed to parse ${key} as a JSON. ${e.message}`, {
+            cause: e
+        });
+    }
+};
+export { maskConfig, parseJson };

package/dist/es/env/index.mjs

@@ -0,0 +1,5 @@
+import { ModelConfigManager } from "./model-config-manager.mjs";
+import { GlobalConfigManager } from "./global-config-manager.mjs";
+export * from "./utils.mjs";
+export * from "./types.mjs";
+export { GlobalConfigManager, ModelConfigManager };

package/dist/es/env/init-debug.mjs

@@ -0,0 +1,18 @@
+import { enableDebug } from "../logger.mjs";
+import { getBasicEnvValue } from "./basic.mjs";
+import { MIDSCENE_DEBUG_MODEL_PROFILE, MIDSCENE_DEBUG_MODEL_RESPONSE } from "./types.mjs";
+const initDebugConfig = ()=>{
+    const shouldPrintTiming = getBasicEnvValue(MIDSCENE_DEBUG_MODEL_PROFILE);
+    let debugConfig = '';
+    if (shouldPrintTiming) {
+        console.warn('MIDSCENE_DEBUG_MODEL_PROFILE is deprecated, use DEBUG=midscene:ai:profile instead');
+        debugConfig = 'ai:profile';
+    }
+    const shouldPrintModelResponse = getBasicEnvValue(MIDSCENE_DEBUG_MODEL_RESPONSE);
+    if (shouldPrintModelResponse) {
+        console.warn('MIDSCENE_DEBUG_MODEL_RESPONSE is deprecated, use DEBUG=midscene:ai:response instead');
+        debugConfig = debugConfig ? 'ai:*' : 'ai:call';
+    }
+    if (debugConfig) enableDebug(debugConfig);
+};
+export { initDebugConfig };

package/dist/es/env/model-config-manager.mjs

@@ -0,0 +1,79 @@
+import { decideModelConfigFromIntentConfig } from "./parse-model-config.mjs";
+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 ModelConfigManager {
+    initialize() {
+        if (this.isInitialized) return;
+        let configMap;
+        if (this.modelConfig) {
+            this.isolatedMode = true;
+            configMap = this.normalizeModelConfig(this.modelConfig);
+        } else configMap = this.globalConfigManager?.getAllEnvConfig() || {};
+        const defaultConfig = decideModelConfigFromIntentConfig('default', configMap);
+        if (!defaultConfig) throw new Error('Model configuration is incomplete: model name (MIDSCENE_MODEL_NAME) is required. See https://midscenejs.com/model-strategy.html');
+        const insightConfig = decideModelConfigFromIntentConfig('insight', configMap);
+        const planningConfig = decideModelConfigFromIntentConfig('planning', configMap);
+        this.modelConfigMap = {
+            default: {
+                ...defaultConfig,
+                createOpenAIClient: this.createOpenAIClientFn
+            },
+            insight: {
+                ...insightConfig || defaultConfig,
+                createOpenAIClient: this.createOpenAIClientFn
+            },
+            planning: {
+                ...planningConfig || defaultConfig,
+                createOpenAIClient: this.createOpenAIClientFn
+            }
+        };
+        this.isInitialized = true;
+    }
+    normalizeModelConfig(config) {
+        return Object.entries(config).reduce((acc, [key, value])=>{
+            if (null == value) return acc;
+            acc[key] = String(value);
+            return acc;
+        }, Object.create(null));
+    }
+    clearModelConfigMap() {
+        if (this.isolatedMode) throw new Error('ModelConfigManager work in isolated mode, so clearModelConfigMap should not be called');
+        this.isInitialized = false;
+    }
+    getModelConfig(intent) {
+        if (!this.isInitialized) this.initialize();
+        if (!this.modelConfigMap) throw new Error('modelConfigMap is not initialized, which should not happen');
+        return this.modelConfigMap[intent];
+    }
+    getUploadTestServerUrl() {
+        const { openaiExtraConfig } = this.getModelConfig('default');
+        const serverUrl = openaiExtraConfig?.REPORT_SERVER_URL;
+        return serverUrl;
+    }
+    registerGlobalConfigManager(globalConfigManager) {
+        this.globalConfigManager = globalConfigManager;
+    }
+    throwErrorIfNonVLModel() {
+        const modelConfig = this.getModelConfig('default');
+        if (!modelConfig.modelFamily) throw new Error('MIDSCENE_MODEL_FAMILY is not set to a visual language model (VL model), the element localization can not be achieved. Check your model configuration. See https://midscenejs.com/model-strategy.html');
+    }
+    constructor(modelConfig, createOpenAIClientFn){
+        _define_property(this, "modelConfigMap", void 0);
+        _define_property(this, "isInitialized", false);
+        _define_property(this, "isolatedMode", false);
+        _define_property(this, "globalConfigManager", void 0);
+        _define_property(this, "modelConfig", void 0);
+        _define_property(this, "createOpenAIClientFn", void 0);
+        this.modelConfig = modelConfig;
+        this.createOpenAIClientFn = createOpenAIClientFn;
+    }
+}
+export { ModelConfigManager };

package/dist/es/env/parse-model-config.mjs

@@ -0,0 +1,165 @@
+import { DEFAULT_MODEL_CONFIG_KEYS, INSIGHT_MODEL_CONFIG_KEYS, PLANNING_MODEL_CONFIG_KEYS } from "./constants.mjs";
+import { MIDSCENE_OPENAI_HTTP_PROXY, MIDSCENE_OPENAI_INIT_CONFIG_JSON, MIDSCENE_OPENAI_SOCKS_PROXY, MIDSCENE_USE_DOUBAO_VISION, MIDSCENE_USE_GEMINI, MIDSCENE_USE_QWEN3_VL, MIDSCENE_USE_QWEN_VL, MIDSCENE_USE_VLM_UI_TARS, MODEL_FAMILY_VALUES, OPENAI_API_KEY, OPENAI_BASE_URL, UITarsModelVersion } from "./types.mjs";
+import { getDebug } from "../logger.mjs";
+import { assert } from "../utils.mjs";
+import { maskConfig, parseJson } from "./helper.mjs";
+import { initDebugConfig } from "./init-debug.mjs";
+const MODEL_CONFIG_DOC_URL = 'https://midscenejs.com/model-common-config.html';
+const getCurrentVersion = ()=>"1.7.10";
+const getInvalidModelFamilyMessage = (modelFamily)=>`Invalid MIDSCENE_MODEL_FAMILY value: ${modelFamily}. Current version v${getCurrentVersion()} accepts the following model families: ${MODEL_FAMILY_VALUES.join(', ')}. You can also visit ${MODEL_CONFIG_DOC_URL} for the latest configuration information.`;
+const KEYS_MAP = {
+    insight: INSIGHT_MODEL_CONFIG_KEYS,
+    planning: PLANNING_MODEL_CONFIG_KEYS,
+    default: DEFAULT_MODEL_CONFIG_KEYS
+};
+const getUITarsModelVersion = (modelFamily)=>{
+    if ('vlm-ui-tars' === modelFamily) return UITarsModelVersion.V1_0;
+    if ('vlm-ui-tars-doubao' === modelFamily || 'vlm-ui-tars-doubao-1.5' === modelFamily) return UITarsModelVersion.DOUBAO_1_5_20B;
+};
+const validateModelFamily = (modelFamily)=>{
+    if (modelFamily && !MODEL_FAMILY_VALUES.includes(modelFamily)) throw new Error(getInvalidModelFamilyMessage(modelFamily));
+};
+const legacyConfigToModelFamily = (provider)=>{
+    const isDoubao = provider[MIDSCENE_USE_DOUBAO_VISION];
+    const isQwen = provider[MIDSCENE_USE_QWEN_VL];
+    const isQwen3 = provider[MIDSCENE_USE_QWEN3_VL];
+    const isUiTars = provider[MIDSCENE_USE_VLM_UI_TARS];
+    const isGemini = provider[MIDSCENE_USE_GEMINI];
+    const enabledModes = [
+        isDoubao && MIDSCENE_USE_DOUBAO_VISION,
+        isQwen && MIDSCENE_USE_QWEN_VL,
+        isQwen3 && MIDSCENE_USE_QWEN3_VL,
+        isUiTars && MIDSCENE_USE_VLM_UI_TARS,
+        isGemini && MIDSCENE_USE_GEMINI
+    ].filter(Boolean);
+    if (enabledModes.length > 1) throw new Error(`Only one vision mode can be enabled at a time. Currently enabled modes: ${enabledModes.join(', ')}. Please disable all but one mode.`);
+    if (isQwen3) return 'qwen3-vl';
+    if (isQwen) return 'qwen2.5-vl';
+    if (isDoubao) return 'doubao-vision';
+    if (isGemini) return 'gemini';
+    if (isUiTars) if ('1' === isUiTars) return 'vlm-ui-tars';
+    else if ('DOUBAO' === isUiTars || 'DOUBAO-1.5' === isUiTars) return 'vlm-ui-tars-doubao-1.5';
+    else return 'vlm-ui-tars-doubao';
+};
+const getModelDescription = (modelFamily, uiTarsModelVersion)=>{
+    if (uiTarsModelVersion) return `UI-TARS=${uiTarsModelVersion}`;
+    if (modelFamily) return `${modelFamily} mode`;
+    return '';
+};
+const normalizeOpenaiExtraConfig = (config)=>{
+    if (!config || 'object' != typeof config || Array.isArray(config)) return;
+    const { defaultHeaders, extra_headers, extraHeaders, ...rest } = config;
+    const headers = defaultHeaders ?? extra_headers ?? extraHeaders;
+    if (void 0 !== headers) return {
+        ...rest,
+        defaultHeaders: headers
+    };
+    return rest;
+};
+const parseOpenaiSdkConfig = ({ keys, provider, useLegacyLogic = false })=>{
+    initDebugConfig();
+    const debugLog = getDebug('ai:config');
+    debugLog('enter parseOpenaiSdkConfig with keys:', keys);
+    const legacyAPIKey = useLegacyLogic ? provider[OPENAI_API_KEY] : void 0;
+    const legacyBaseURL = useLegacyLogic ? provider[OPENAI_BASE_URL] : void 0;
+    const legacySocksProxy = useLegacyLogic ? provider[MIDSCENE_OPENAI_SOCKS_PROXY] : void 0;
+    const legacyHttpProxy = useLegacyLogic ? provider[MIDSCENE_OPENAI_HTTP_PROXY] : void 0;
+    const legacyOpenaiExtraConfig = useLegacyLogic ? provider[MIDSCENE_OPENAI_INIT_CONFIG_JSON] : void 0;
+    const legacyModelFamily = useLegacyLogic ? legacyConfigToModelFamily(provider) : void 0;
+    const modelFamilyRaw = provider[keys.modelFamily] || legacyModelFamily;
+    const openaiApiKey = provider[keys.openaiApiKey] || legacyAPIKey;
+    const openaiBaseURL = provider[keys.openaiBaseURL] || legacyBaseURL;
+    const socksProxy = provider[keys.socksProxy] || legacySocksProxy;
+    const httpProxy = provider[keys.httpProxy] || legacyHttpProxy;
+    const modelName = provider[keys.modelName];
+    const yht_domain = provider[keys.yht_domain];
+    const yht_access_token = provider[keys.yht_access_token];
+    const yht_model = provider[keys.yht_model];
+    const yht_base_url = provider[keys.yht_base_url];
+    const yht_chat_type = provider[keys.yht_chat_type];
+    const yht_model_category = provider[keys.yht_model_category];
+    const yht_stream = provider[keys.yht_stream];
+    const yht_temperature = provider[keys.yht_temperature];
+    const yht_top_p = provider[keys.yht_top_p];
+    const yht_trace_id = provider[keys.yht_trace_id];
+    const openaiExtraConfigStr = provider[keys.openaiExtraConfig];
+    const openaiExtraConfig = parseJson(keys.openaiExtraConfig, openaiExtraConfigStr || legacyOpenaiExtraConfig);
+    const extraBodyStr = provider[keys.extraBody];
+    const extraBody = parseJson(keys.extraBody, extraBodyStr);
+    const temperature = provider[keys.temperature] ? Number(provider[keys.temperature]) : 0;
+    const modelFamily = modelFamilyRaw;
+    validateModelFamily(modelFamily);
+    const uiTarsModelVersion = getUITarsModelVersion(modelFamily);
+    const modelDescription = getModelDescription(modelFamily, uiTarsModelVersion);
+    return {
+        yht_domain,
+        yht_access_token,
+        yht_model,
+        yht_base_url,
+        yht_chat_type,
+        yht_model_category,
+        yht_stream,
+        yht_temperature,
+        yht_top_p,
+        yht_trace_id,
+        socksProxy,
+        httpProxy,
+        openaiBaseURL,
+        openaiApiKey,
+        openaiExtraConfig: normalizeOpenaiExtraConfig(openaiExtraConfig),
+        extraBody,
+        modelFamily,
+        uiTarsModelVersion,
+        modelName: modelName,
+        modelDescription,
+        intent: '-',
+        timeout: provider[keys.timeout] ? Number(provider[keys.timeout]) : void 0,
+        temperature,
+        retryCount: (()=>{
+            if (!provider[keys.retryCount]) return 1;
+            const val = Number(provider[keys.retryCount]);
+            if (!Number.isFinite(val)) return 1;
+            if (val < 0) throw new Error(`${keys.retryCount} must be non-negative, got ${val}`);
+            return val;
+        })(),
+        retryInterval: (()=>{
+            if (!provider[keys.retryInterval]) return 2000;
+            const val = Number(provider[keys.retryInterval]);
+            if (!Number.isFinite(val)) return 2000;
+            if (val < 0) throw new Error(`${keys.retryInterval} must be non-negative, got ${val}`);
+            return val;
+        })(),
+        reasoningEffort: provider[keys.reasoningEffort]?.trim() || void 0,
+        reasoningEnabled: (()=>{
+            const val = provider[keys.reasoningEnabled]?.trim()?.toLowerCase();
+            if ('true' === val || '1' === val) return true;
+            if ('false' === val || '0' === val) return false;
+        })(),
+        reasoningBudget: (()=>{
+            const val = provider[keys.reasoningBudget]?.trim();
+            if (!val) return;
+            const num = Number(val);
+            return Number.isFinite(num) ? num : void 0;
+        })()
+    };
+};
+const decideModelConfigFromIntentConfig = (intent, configMap)=>{
+    const debugLog = getDebug('ai:config');
+    debugLog('will decideModelConfig base on agent.modelConfig()', intent, maskConfig(configMap));
+    const keysForFn = KEYS_MAP[intent];
+    const modelName = configMap[keysForFn.modelName];
+    if (!modelName) return void debugLog('no modelName found for intent', intent);
+    const finalResult = parseOpenaiSdkConfig({
+        keys: keysForFn,
+        provider: configMap,
+        useLegacyLogic: 'default' === intent
+    });
+    finalResult.intent = intent;
+    debugLog('decideModelConfig result by agent.modelConfig() with intent', intent, maskConfig({
+        ...finalResult
+    }));
+    assert(finalResult.openaiBaseURL, `failed to get base URL of model (intent=${intent}). See https://midscenejs.com/model-strategy`);
+    if (!finalResult.modelName) console.warn(`modelName is not set for intent ${intent}, this may cause unexpected behavior. See https://midscenejs.com/model-strategy`);
+    return finalResult;
+};
+export { decideModelConfigFromIntentConfig, getUITarsModelVersion, legacyConfigToModelFamily, parseOpenaiSdkConfig, validateModelFamily };