@midscene/shared 0.28.2 → 0.28.3

package/dist/lib/env/{model-config.js → decide-model-config.js}

@@ -24,8 +24,9 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    decideOpenaiSdkConfig: ()=>decideOpenaiSdkConfig,
-    decideModelConfig: ()=>decideModelConfig
+    decideModelConfigFromEnv: ()=>decideModelConfigFromEnv,
+    decideModelConfigFromIntentConfig: ()=>decideModelConfigFromIntentConfig,
+    decideOpenaiSdkConfig: ()=>decideOpenaiSdkConfig
 });
 const external_constants_js_namespaceObject = require("./constants.js");
 const external_logger_js_namespaceObject = require("../logger.js");
@@ -41,7 +42,7 @@ const KEYS_MAP = {
 };
 const decideOpenaiSdkConfig = ({ keys, provider, valueAssert })=>{
     (0, external_init_debug_js_namespaceObject.initDebugConfig)();
-    const debugLog = (0, external_logger_js_namespaceObject.getDebug)('ai:global:config');
+    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];
@@ -118,61 +119,62 @@ const getModelDescription = (vlMode, uiTarsVersion)=>{
     else return `${vlMode} mode`;
     return '';
 };
-const decideModelConfig = ({ intent, modelConfigFromFn, allConfig })=>{
+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:globalConfig');
-    if (modelConfigFromFn) {
-        debugLog('decideModelConfig base on agent.modelConfig()');
-        const keysForFn = KEYS_MAP[intent];
-        const candidateModelNameFromConfig = modelConfigFromFn[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)(modelConfigFromFn[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: modelConfigFromFn,
-            valueAssert: (0, external_helper_js_namespaceObject.createAssert)(chosenKeys.modelName, 'modelConfig', candidateModelNameFromConfig)
-        });
-        const { vlMode, uiTarsVersion } = (0, external_parse_js_namespaceObject.parseVlModeAndUiTarsFromRaw)(result.vlModeRaw);
-        const modelDescription = getModelDescription(vlMode, uiTarsVersion);
-        const finalResult = {
-            ...result,
-            modelName: modelConfigFromFn[chosenKeys.modelName],
-            vlMode,
-            uiTarsVersion,
-            modelDescription,
-            from: 'modelConfig'
-        };
-        debugLog(`decideModelConfig result by agent.modelConfig() with intent ${intent}:`, (0, external_helper_js_namespaceObject.maskConfig)(finalResult));
-        return finalResult;
-    }
+    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];
-    const candidateModelNameFromEnv = allConfig[keysForEnv.modelName];
-    debugLog(`Get value of ${keysForEnv.modelName} from globalConfig`, candidateModelNameFromEnv);
-    if ('default' !== intent && allConfig[keysForEnv.modelName]) {
-        const modelName = allConfig[keysForEnv.modelName];
+    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: allConfig,
+            provider: allEnvConfig,
             valueAssert: (0, external_helper_js_namespaceObject.createAssert)(keysForEnv.modelName, 'process.env', modelName)
         });
-        const { vlMode, uiTarsVersion } = (0, external_parse_js_namespaceObject.parseVlModeAndUiTarsFromRaw)(result.vlModeRaw);
+        const { vlMode, uiTarsVersion } = (0, external_parse_js_namespaceObject.parseVlModeAndUiTarsModelVersionFromRawValue)(result.vlModeRaw);
         const modelDescription = getModelDescription(vlMode, uiTarsVersion);
         const finalResult = {
             ...result,
             modelName,
             vlMode,
-            uiTarsVersion,
+            uiTarsModelVersion: uiTarsVersion,
             modelDescription,
-            from: 'env'
+            from: 'env',
+            intent
         };
         debugLog(`decideModelConfig result by process.env with intent ${intent}:`, (0, external_helper_js_namespaceObject.maskConfig)(finalResult));
         return finalResult;
@@ -180,26 +182,29 @@ const decideModelConfig = ({ intent, modelConfigFromFn, allConfig })=>{
     debugLog(`decideModelConfig as legacy logic with intent ${intent}.`);
     const result = decideOpenaiSdkConfig({
         keys: external_constants_js_namespaceObject.DEFAULT_MODEL_CONFIG_KEYS_LEGACY,
-        provider: allConfig,
+        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)(allConfig);
+    const { vlMode, uiTarsVersion } = (0, external_parse_js_namespaceObject.parseVlModeAndUiTarsFromGlobalConfig)(allEnvConfig);
     const modelDescription = getModelDescription(vlMode, uiTarsVersion);
     const finalResult = {
         ...result,
-        modelName: allConfig[external_constants_js_namespaceObject.DEFAULT_MODEL_CONFIG_KEYS_LEGACY.modelName] || 'gpt-4o',
+        modelName: allEnvConfig[external_constants_js_namespaceObject.DEFAULT_MODEL_CONFIG_KEYS_LEGACY.modelName] || 'gpt-4o',
         vlMode,
-        uiTarsVersion,
+        uiTarsModelVersion: uiTarsVersion,
         modelDescription,
-        from: 'legacy-env'
+        from: 'legacy-env',
+        intent
     };
     debugLog(`decideModelConfig result by legacy logic with intent ${intent}:`, (0, external_helper_js_namespaceObject.maskConfig)(finalResult));
     return finalResult;
 };
-exports.decideModelConfig = __webpack_exports__.decideModelConfig;
+exports.decideModelConfigFromEnv = __webpack_exports__.decideModelConfigFromEnv;
+exports.decideModelConfigFromIntentConfig = __webpack_exports__.decideModelConfigFromIntentConfig;
 exports.decideOpenaiSdkConfig = __webpack_exports__.decideOpenaiSdkConfig;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "decideModelConfig",
+    "decideModelConfigFromEnv",
+    "decideModelConfigFromIntentConfig",
     "decideOpenaiSdkConfig"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {

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

@@ -0,0 +1,125 @@
+"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 MIDSCENE_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;
+        for(const key in newConfig){
+            if (![
+                ...external_types_js_namespaceObject.GLOBAL_ENV_KEYS,
+                ...external_types_js_namespaceObject.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 ? {
+            ...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
+});

package/dist/lib/env/index.js

@@ -1,7 +1,10 @@
 "use strict";
 var __webpack_modules__ = {
-    "./parse": function(module) {
-        module.exports = require("./parse.js");
+    "./global-config-manager": function(module) {
+        module.exports = require("./global-config-manager.js");
+    },
+    "./model-config-manager": function(module) {
+        module.exports = require("./model-config-manager.js");
     },
     "./types": function(module) {
         module.exports = require("./types.js");
@@ -54,13 +57,15 @@ var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
     __webpack_require__.d(__webpack_exports__, {
-        UITarsModelVersion: ()=>_parse__WEBPACK_IMPORTED_MODULE_2__.UITarsModelVersion
+        GlobalConfigManager: ()=>_global_config_manager__WEBPACK_IMPORTED_MODULE_3__.GlobalConfigManager,
+        ModelConfigManager: ()=>_model_config_manager__WEBPACK_IMPORTED_MODULE_2__.ModelConfigManager
     });
     var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./utils");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
     for(var __WEBPACK_IMPORT_KEY__ in _utils__WEBPACK_IMPORTED_MODULE_0__)if ([
         "default",
-        "UITarsModelVersion"
+        "GlobalConfigManager",
+        "ModelConfigManager"
     ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
         return _utils__WEBPACK_IMPORTED_MODULE_0__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
@@ -69,16 +74,20 @@ var __webpack_exports__ = {};
     var __WEBPACK_REEXPORT_OBJECT__ = {};
     for(var __WEBPACK_IMPORT_KEY__ in _types__WEBPACK_IMPORTED_MODULE_1__)if ([
         "default",
-        "UITarsModelVersion"
+        "GlobalConfigManager",
+        "ModelConfigManager"
     ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
         return _types__WEBPACK_IMPORTED_MODULE_1__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _parse__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./parse");
+    var _model_config_manager__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./model-config-manager");
+    var _global_config_manager__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./global-config-manager");
 })();
-exports.UITarsModelVersion = __webpack_exports__.UITarsModelVersion;
+exports.GlobalConfigManager = __webpack_exports__.GlobalConfigManager;
+exports.ModelConfigManager = __webpack_exports__.ModelConfigManager;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "UITarsModelVersion"
+    "GlobalConfigManager",
+    "ModelConfigManager"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true

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

@@ -0,0 +1,129 @@
+"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__, {
+    ModelConfigManager: ()=>ModelConfigManager
+});
+const external_decide_model_config_js_namespaceObject = require("./decide-model-config.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;
+}
+const ALL_INTENTS = [
+    'VQA',
+    'default',
+    'grounding',
+    'planning'
+];
+class ModelConfigManager {
+    calcIntentConfigMap(modelConfigFn) {
+        const intentConfigMap = {
+            VQA: void 0,
+            default: void 0,
+            grounding: void 0,
+            planning: void 0
+        };
+        for (const i of ALL_INTENTS){
+            const result = modelConfigFn({
+                intent: i
+            });
+            if (!result) throw new Error(`The agent has an option named modelConfig is a function, but it return ${result} when call with intent ${i}, which should be a object.`);
+            intentConfigMap[i] = result;
+        }
+        return intentConfigMap;
+    }
+    calcModelConfigMapBaseOnIntent(intentConfigMap) {
+        const modelConfigMap = {
+            VQA: void 0,
+            default: void 0,
+            grounding: void 0,
+            planning: void 0
+        };
+        for (const i of ALL_INTENTS){
+            const result = (0, external_decide_model_config_js_namespaceObject.decideModelConfigFromIntentConfig)(i, intentConfigMap[i]);
+            modelConfigMap[i] = result;
+        }
+        return modelConfigMap;
+    }
+    calcModelConfigMapBaseOnEnv(allEnvConfig) {
+        const modelConfigMap = {
+            VQA: void 0,
+            default: void 0,
+            grounding: void 0,
+            planning: void 0
+        };
+        for (const i of ALL_INTENTS){
+            const result = (0, external_decide_model_config_js_namespaceObject.decideModelConfigFromEnv)(i, allEnvConfig);
+            modelConfigMap[i] = result;
+        }
+        return modelConfigMap;
+    }
+    clearModelConfigMap() {
+        if (this.isolatedMode) throw new Error('ModelConfigManager work in isolated mode, so clearModelConfigMap should not be called');
+        this.modelConfigMap = void 0;
+    }
+    getModelConfig(intent) {
+        if (this.isolatedMode) {
+            if (!this.modelConfigMap) throw new Error('modelConfigMap is not initialized in isolated mode, which should not happen');
+            return this.modelConfigMap[intent];
+        }
+        if (!this.modelConfigMap) {
+            if (!this.globalConfigManager) throw new Error('globalConfigManager is not registered, which should not happen');
+            this.modelConfigMap = this.calcModelConfigMapBaseOnEnv(this.globalConfigManager.getAllEnvConfig());
+        }
+        return this.modelConfigMap[intent];
+    }
+    getUploadTestServerUrl() {
+        const { openaiExtraConfig } = this.getModelConfig('default');
+        const serverUrl = null == openaiExtraConfig ? void 0 : openaiExtraConfig.REPORT_SERVER_URL;
+        return serverUrl;
+    }
+    registerGlobalConfigManager(globalConfigManager) {
+        this.globalConfigManager = globalConfigManager;
+    }
+    constructor(modelConfigFn){
+        _define_property(this, "modelConfigMap", void 0);
+        _define_property(this, "isolatedMode", false);
+        _define_property(this, "globalConfigManager", void 0);
+        if (modelConfigFn) {
+            this.isolatedMode = true;
+            const intentConfigMap = this.calcIntentConfigMap(modelConfigFn);
+            this.modelConfigMap = this.calcModelConfigMapBaseOnIntent(intentConfigMap);
+        }
+    }
+}
+exports.ModelConfigManager = __webpack_exports__.ModelConfigManager;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "ModelConfigManager"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/env/parse.js

@@ -24,40 +24,24 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    parseVlModeAndUiTarsFromRaw: ()=>parseVlModeAndUiTarsFromRaw,
     parseVlModeAndUiTarsFromGlobalConfig: ()=>parseVlModeAndUiTarsFromGlobalConfig,
-    UITarsModelVersion: ()=>parse_UITarsModelVersion
+    parseVlModeAndUiTarsModelVersionFromRawValue: ()=>parseVlModeAndUiTarsModelVersionFromRawValue
 });
 const external_types_js_namespaceObject = require("./types.js");
-var parse_UITarsModelVersion = /*#__PURE__*/ function(UITarsModelVersion) {
-    UITarsModelVersion["V1_0"] = "1.0";
-    UITarsModelVersion["V1_5"] = "1.5";
-    UITarsModelVersion["DOUBAO_1_5_15B"] = "doubao-1.5-15B";
-    UITarsModelVersion["DOUBAO_1_5_20B"] = "doubao-1.5-20B";
-    return UITarsModelVersion;
-}({});
-const vlModeRawValidValues = [
-    'doubao-vision',
-    'gemini',
-    'qwen-vl',
-    'vlm-ui-tars',
-    'vlm-ui-tars-doubao',
-    'vlm-ui-tars-doubao-1.5'
-];
-const parseVlModeAndUiTarsFromRaw = (vlModeRaw)=>{
+const parseVlModeAndUiTarsModelVersionFromRawValue = (vlModeRaw)=>{
     if (!vlModeRaw) return {
         vlMode: void 0,
         uiTarsVersion: void 0
     };
-    if (!vlModeRawValidValues.includes(vlModeRaw)) throw new Error(`the value ${vlModeRaw} is not a valid VL_MODE value, must be one of ${vlModeRawValidValues}`);
+    if (!external_types_js_namespaceObject.VL_MODE_RAW_VALID_VALUES.includes(vlModeRaw)) throw new Error(`the value ${vlModeRaw} is not a valid VL_MODE value, must be one of ${external_types_js_namespaceObject.VL_MODE_RAW_VALID_VALUES}`);
     const raw = vlModeRaw;
     if ('vlm-ui-tars' === raw) return {
         vlMode: 'vlm-ui-tars',
-        uiTarsVersion: "1.0"
+        uiTarsVersion: external_types_js_namespaceObject.UITarsModelVersion.V1_0
     };
     if ('vlm-ui-tars-doubao' === raw || 'vlm-ui-tars-doubao-1.5' === raw) return {
         vlMode: 'vlm-ui-tars',
-        uiTarsVersion: "doubao-1.5-20B"
+        uiTarsVersion: external_types_js_namespaceObject.UITarsModelVersion.DOUBAO_1_5_20B
     };
     return {
         vlMode: raw,
@@ -90,11 +74,11 @@ const parseVlModeAndUiTarsFromGlobalConfig = (provider)=>{
     };
     if (isUiTars) if ('1' === isUiTars) return {
         vlMode: 'vlm-ui-tars',
-        uiTarsVersion: "1.0"
+        uiTarsVersion: external_types_js_namespaceObject.UITarsModelVersion.V1_0
     };
     else if ('DOUBAO' === isUiTars || 'DOUBAO-1.5' === isUiTars) return {
         vlMode: 'vlm-ui-tars',
-        uiTarsVersion: "doubao-1.5-20B"
+        uiTarsVersion: external_types_js_namespaceObject.UITarsModelVersion.DOUBAO_1_5_20B
     };
     else return {
         vlMode: 'vlm-ui-tars',
@@ -105,13 +89,11 @@ const parseVlModeAndUiTarsFromGlobalConfig = (provider)=>{
         uiTarsVersion: void 0
     };
 };
-exports.UITarsModelVersion = __webpack_exports__.UITarsModelVersion;
 exports.parseVlModeAndUiTarsFromGlobalConfig = __webpack_exports__.parseVlModeAndUiTarsFromGlobalConfig;
-exports.parseVlModeAndUiTarsFromRaw = __webpack_exports__.parseVlModeAndUiTarsFromRaw;
+exports.parseVlModeAndUiTarsModelVersionFromRawValue = __webpack_exports__.parseVlModeAndUiTarsModelVersionFromRawValue;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "UITarsModelVersion",
     "parseVlModeAndUiTarsFromGlobalConfig",
-    "parseVlModeAndUiTarsFromRaw"
+    "parseVlModeAndUiTarsModelVersionFromRawValue"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/lib/env/types.js

@@ -135,7 +135,9 @@ __webpack_require__.d(__webpack_exports__, {
     OPENAI_MAX_TOKENS: ()=>OPENAI_MAX_TOKENS,
     OPENAI_USE_AZURE: ()=>OPENAI_USE_AZURE,
     STRING_ENV_KEYS: ()=>STRING_ENV_KEYS,
-    UNUSED_ENV_KEYS: ()=>UNUSED_ENV_KEYS
+    UITarsModelVersion: ()=>UITarsModelVersion,
+    UNUSED_ENV_KEYS: ()=>UNUSED_ENV_KEYS,
+    VL_MODE_RAW_VALID_VALUES: ()=>VL_MODE_RAW_VALID_VALUES
 });
 const MIDSCENE_OPENAI_INIT_CONFIG_JSON = 'MIDSCENE_OPENAI_INIT_CONFIG_JSON';
 const MIDSCENE_MODEL_NAME = 'MIDSCENE_MODEL_NAME';
@@ -367,6 +369,21 @@ const ALL_ENV_KEYS = [
     ...GLOBAL_ENV_KEYS,
     ...MODEL_ENV_KEYS
 ];
+var UITarsModelVersion = /*#__PURE__*/ function(UITarsModelVersion) {
+    UITarsModelVersion["V1_0"] = "1.0";
+    UITarsModelVersion["V1_5"] = "1.5";
+    UITarsModelVersion["DOUBAO_1_5_15B"] = "doubao-1.5-15B";
+    UITarsModelVersion["DOUBAO_1_5_20B"] = "doubao-1.5-20B";
+    return UITarsModelVersion;
+}({});
+const VL_MODE_RAW_VALID_VALUES = [
+    'doubao-vision',
+    'gemini',
+    'qwen-vl',
+    'vlm-ui-tars',
+    'vlm-ui-tars-doubao',
+    'vlm-ui-tars-doubao-1.5'
+];
 exports.ALL_ENV_KEYS = __webpack_exports__.ALL_ENV_KEYS;
 exports.ANTHROPIC_API_KEY = __webpack_exports__.ANTHROPIC_API_KEY;
 exports.AZURE_OPENAI_API_VERSION = __webpack_exports__.AZURE_OPENAI_API_VERSION;
@@ -478,7 +495,9 @@ exports.OPENAI_BASE_URL = __webpack_exports__.OPENAI_BASE_URL;
 exports.OPENAI_MAX_TOKENS = __webpack_exports__.OPENAI_MAX_TOKENS;
 exports.OPENAI_USE_AZURE = __webpack_exports__.OPENAI_USE_AZURE;
 exports.STRING_ENV_KEYS = __webpack_exports__.STRING_ENV_KEYS;
+exports.UITarsModelVersion = __webpack_exports__.UITarsModelVersion;
 exports.UNUSED_ENV_KEYS = __webpack_exports__.UNUSED_ENV_KEYS;
+exports.VL_MODE_RAW_VALID_VALUES = __webpack_exports__.VL_MODE_RAW_VALID_VALUES;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "ALL_ENV_KEYS",
     "ANTHROPIC_API_KEY",
@@ -591,7 +610,9 @@ for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "OPENAI_MAX_TOKENS",
     "OPENAI_USE_AZURE",
     "STRING_ENV_KEYS",
-    "UNUSED_ENV_KEYS"
+    "UITarsModelVersion",
+    "UNUSED_ENV_KEYS",
+    "VL_MODE_RAW_VALID_VALUES"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true