@midscene/shared 0.26.7-beta-20250821134240.0 → 0.27.0

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

@@ -16,7 +16,12 @@ const allConfigFromEnv = ()=>ENV_KEYS.reduce((p, name)=>({
 class GlobalConfigManager {
     reset() {
         this.override = void 0;
-        this.modelConfigFn = void 0;
+        this.modelConfigByIntent = {
+            VQA: void 0,
+            default: void 0,
+            grounding: void 0,
+            planning: void 0
+        };
     }
     getAllConfig() {
         const envConfig = allConfigFromEnv();
@@ -69,28 +74,34 @@ class GlobalConfigManager {
             extendMode
         };
     }
-    getModelConfig(intent) {
-        if (this.modelConfigFn) {
-            const result = this.modelConfigFn({
-                intent
-            });
-            return {
-                hasModelConfigFn: true,
-                result
-            };
-        }
-        return {
-            hasModelConfigFn: false,
-            result: void 0
-        };
+    getModelConfigFromFn(intent) {
+        return this.modelConfigByIntent[intent];
     }
     registerModelConfigFn(modelConfigFn) {
         if ('function' != typeof modelConfigFn) throw new Error(`modelConfigFn must be a function when registerModelConfigFn, but got with type ${typeof modelConfigFn}`);
-        this.modelConfigFn = modelConfigFn;
+        const intents = [
+            'VQA',
+            'default',
+            'grounding',
+            'planning'
+        ];
+        for (const i of 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.`);
+            this.modelConfigByIntent[i] = result;
+        }
     }
     constructor(){
         _define_property(this, "override", void 0);
-        _define_property(this, "modelConfigFn", void 0);
+        _define_property(this, "modelConfigByIntent", void 0);
+        this.modelConfigByIntent = {
+            VQA: void 0,
+            default: void 0,
+            grounding: void 0,
+            planning: void 0
+        };
     }
 }
 const globalConfigManger = new GlobalConfigManager();

package/dist/es/env/helper.mjs

@@ -0,0 +1,52 @@
+import { enableDebug } from "../logger.mjs";
+import { assert } from "../utils.mjs";
+import { globalConfigManger } from "./global-config.mjs";
+import { MIDSCENE_DEBUG_AI_PROFILE, MIDSCENE_DEBUG_AI_RESPONSE } from "./types.mjs";
+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])=>[
+            key,
+            [
+                'openaiApiKey',
+                'azureOpenaiKey',
+                'anthropicApiKey'
+            ].includes(key) ? maskKey(value) : value
+        ]));
+const initDebugConfig = ()=>{
+    const shouldPrintTiming = globalConfigManger.getConfigValueInBoolean(MIDSCENE_DEBUG_AI_PROFILE);
+    let debugConfig = '';
+    if (shouldPrintTiming) {
+        console.warn('MIDSCENE_DEBUG_AI_PROFILE is deprecated, use DEBUG=midscene:ai:profile instead');
+        debugConfig = 'ai:profile';
+    }
+    const shouldPrintAIResponse = globalConfigManger.getConfigValueInBoolean(MIDSCENE_DEBUG_AI_RESPONSE);
+    if (shouldPrintAIResponse) {
+        console.warn('MIDSCENE_DEBUG_AI_RESPONSE is deprecated, use DEBUG=midscene:ai:response instead');
+        debugConfig = debugConfig ? 'ai:*' : 'ai:call';
+    }
+    if (debugConfig) enableDebug(debugConfig);
+};
+const parseJson = (key, value)=>{
+    if (void 0 !== value) try {
+        return JSON.parse(value);
+    } catch (e) {
+        throw new Error(`Failed to parse ${key} as a JSON. ${e.message}`, {
+            cause: e
+        });
+    }
+};
+const createAssert = (modelNameKey, provider, modelName)=>(value, key, modelVendorFlag)=>{
+        if (modelName) modelVendorFlag ? assert(value, `The ${key} must be a non-empty string because of the ${modelNameKey} is declared as ${modelName} and ${modelVendorFlag} has also been specified in ${provider}, but got: ${value}. Please check your config.`) : assert(value, `The ${key} must be a non-empty string because of the ${modelNameKey} is declared as ${modelName} in ${provider}, but got: ${value}. Please check your config.`);
+        else assert(value, `The ${key} must be a non-empty string, but got: ${value}. Please check your config.`);
+    };
+export { createAssert, initDebugConfig, maskConfig, parseJson };

package/dist/es/env/index.mjs

@@ -1,5 +1,6 @@
 import { globalConfigManger } from "./global-config.mjs";
 import { decideModelConfig } from "./model-config.mjs";
+import { UITarsModelVersion } from "./parse.mjs";
 export * from "./utils.mjs";
 export * from "./types.mjs";
-export { decideModelConfig, globalConfigManger };
+export { UITarsModelVersion, decideModelConfig, globalConfigManger };

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

@@ -1,35 +1,9 @@
 import { globalConfigManger } from "./global-config.mjs";
-import { MIDSCENE_DEBUG_AI_PROFILE, MIDSCENE_DEBUG_AI_RESPONSE, MIDSCENE_USE_DOUBAO_VISION, MIDSCENE_USE_GEMINI, MIDSCENE_USE_QWEN_VL, MIDSCENE_USE_VLM_UI_TARS } from "./types.mjs";
 import { DEFAULT_MODEL_CONFIG_KEYS, DEFAULT_MODEL_CONFIG_KEYS_LEGACY, GROUNDING_MODEL_CONFIG_KEYS, PLANNING_MODEL_CONFIG_KEYS, VQA_MODEL_CONFIG_KEYS } from "./constants.mjs";
-import { enableDebug, getDebug } from "../logger.mjs";
+import { getDebug } from "../logger.mjs";
 import { assert } from "../utils.mjs";
-const initDebugConfig = ()=>{
-    const shouldPrintTiming = globalConfigManger.getConfigValueInBoolean(MIDSCENE_DEBUG_AI_PROFILE);
-    let debugConfig = '';
-    if (shouldPrintTiming) {
-        console.warn('MIDSCENE_DEBUG_AI_PROFILE is deprecated, use DEBUG=midscene:ai:profile instead');
-        debugConfig = 'ai:profile';
-    }
-    const shouldPrintAIResponse = globalConfigManger.getConfigValueInBoolean(MIDSCENE_DEBUG_AI_RESPONSE);
-    if (shouldPrintAIResponse) {
-        console.warn('MIDSCENE_DEBUG_AI_RESPONSE is deprecated, use DEBUG=midscene:ai:response instead');
-        debugConfig = debugConfig ? 'ai:*' : 'ai:call';
-    }
-    if (debugConfig) enableDebug(debugConfig);
-};
-const createAssert = (modelNameKey, provider, modelName)=>(value, key, modelVendorFlag)=>{
-        if (modelName) modelVendorFlag ? assert(value, `The ${key} must be a non-empty string because of the ${modelNameKey} is declared as ${modelName} and ${modelVendorFlag} has also been specified in ${provider}, but got: ${value}. Please check your config.`) : assert(value, `The ${key} must be a non-empty string because of the ${modelNameKey} is declared as ${modelName} in ${provider}, but got: ${value}. Please check your config.`);
-        else assert(value, `The ${key} must be a non-empty string, but got: ${value}. Please check your config.`);
-    };
-const parseJson = (key, value)=>{
-    if (void 0 !== value) try {
-        return JSON.parse(value);
-    } catch (e) {
-        throw new Error(`Failed to parse ${key} as a JSON. ${e.message}`, {
-            cause: e
-        });
-    }
-};
+import { createAssert, initDebugConfig, maskConfig, parseJson } from "./helper.mjs";
+import { parseVlModeAndUiTarsFromGlobalConfig, parseVlModeAndUiTarsFromRaw } from "./parse.mjs";
 const KEYS_MAP = {
     VQA: VQA_MODEL_CONFIG_KEYS,
     grounding: GROUNDING_MODEL_CONFIG_KEYS,
@@ -37,11 +11,12 @@ const KEYS_MAP = {
     default: DEFAULT_MODEL_CONFIG_KEYS
 };
 const decideOpenaiSdkConfig = ({ keys, provider, valueAssert })=>{
+    initDebugConfig();
+    const debugLog = getDebug('ai:decideModel');
     const socksProxy = provider[keys.socksProxy];
     const httpProxy = provider[keys.httpProxy];
     const vlMode = provider[keys.vlMode];
-    const debugLog = getDebug('ai:decideModel');
-    debugLog('enter decideOpenaiSdkConfig', provider, keys);
+    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];
@@ -52,7 +27,7 @@ const decideOpenaiSdkConfig = ({ keys, provider, valueAssert })=>{
         return {
             socksProxy,
             httpProxy,
-            vlMode,
+            vlModeRaw: vlMode,
             openaiUseAzureDeprecated: true,
             openaiApiKey,
             openaiBaseURL,
@@ -72,7 +47,7 @@ const decideOpenaiSdkConfig = ({ keys, provider, valueAssert })=>{
         return {
             socksProxy,
             httpProxy,
-            vlMode,
+            vlModeRaw: vlMode,
             useAzureOpenai: true,
             azureOpenaiScope,
             azureOpenaiKey,
@@ -104,41 +79,27 @@ const decideOpenaiSdkConfig = ({ keys, provider, valueAssert })=>{
         return {
             socksProxy,
             httpProxy,
-            vlMode,
+            vlModeRaw: vlMode,
             openaiBaseURL,
             openaiApiKey,
             openaiExtraConfig
         };
     }
 };
-const decideVlModelValueFromGlobalConfig = ()=>{
-    const isDoubao = globalConfigManger.getConfigValueInBoolean(MIDSCENE_USE_DOUBAO_VISION);
-    const isQwen = globalConfigManger.getConfigValueInBoolean(MIDSCENE_USE_QWEN_VL);
-    const isUiTars = globalConfigManger.getConfigValueInBoolean(MIDSCENE_USE_VLM_UI_TARS);
-    const isGemini = globalConfigManger.getConfigValueInBoolean(MIDSCENE_USE_GEMINI);
-    const enabledModes = [
-        isDoubao && MIDSCENE_USE_DOUBAO_VISION,
-        isQwen && MIDSCENE_USE_QWEN_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 (isQwen) return 'qwen-vl';
-    if (isDoubao) return 'doubao-vision';
-    if (isGemini) return 'gemini';
-    if (isUiTars) return 'vlm-ui-tars';
+const getModelDescription = (vlMode, uiTarsVersion)=>{
+    if (vlMode) if (uiTarsVersion) return `UI-TARS=${uiTarsVersion}`;
+    else return `${vlMode} mode`;
+    return '';
 };
 const decideModelConfig = (modelPreferences, withAssert)=>{
     initDebugConfig();
     const debugLog = getDebug('ai:decideModel');
     debugLog('modelPreferences', modelPreferences);
     const { intent } = modelPreferences;
-    const { hasModelConfigFn, result: modelConfigFromFn } = globalConfigManger.getModelConfig(intent);
-    debugLog('The return value of agent.modelConfig()', modelConfigFromFn);
-    if (hasModelConfigFn) {
-        if (!modelConfigFromFn) throw new Error(`The agent has an option named modelConfig is a function, but it return ${modelConfigFromFn} when call with intent ${intent}, which should be a object.`);
+    const modelConfigFromFn = globalConfigManger.getModelConfigFromFn(intent);
+    if (modelConfigFromFn) {
+        debugLog('decideModelConfig base on agent.modelConfig()');
         const keysForFn = KEYS_MAP[intent];
-        debugLog('ChooseOpenaiSdkConfig base on agent.modelConfig()');
         const candidateModelNameFromConfig = modelConfigFromFn[keysForFn.modelName];
         debugLog('Got modelName from modelConfigFn', candidateModelNameFromConfig);
         const chosenKeys = (()=>{
@@ -155,49 +116,61 @@ const decideModelConfig = (modelPreferences, withAssert)=>{
             provider: modelConfigFromFn,
             valueAssert: withAssert ? createAssert(chosenKeys.modelName, 'modelConfig', candidateModelNameFromConfig) : ()=>{}
         });
+        const { vlMode, uiTarsVersion } = parseVlModeAndUiTarsFromRaw(result.vlModeRaw);
+        const modelDescription = getModelDescription(vlMode, uiTarsVersion);
         const finalResult = {
             ...result,
             modelName: modelConfigFromFn[chosenKeys.modelName],
+            vlMode,
+            uiTarsVersion,
+            modelDescription,
             from: 'modelConfig'
         };
-        debugLog('ChooseOpenaiSdkConfig result:', finalResult);
+        debugLog('decideModelConfig result by agent.modelConfig():', maskConfig(finalResult));
         return finalResult;
     }
     const allConfig = globalConfigManger.getAllConfig();
     const keysForEnv = 'default' === intent ? DEFAULT_MODEL_CONFIG_KEYS_LEGACY : KEYS_MAP[intent];
     const candidateModelNameFromEnv = allConfig[keysForEnv.modelName];
     debugLog(`Get value of ${keysForEnv.modelName} from globalConfig`, candidateModelNameFromEnv);
-    if (candidateModelNameFromEnv) {
-        debugLog('ChooseOpenaiSdkConfig base on global env config with intent.');
+    if ('default' !== intent && allConfig[keysForEnv.modelName]) {
+        const modelName = allConfig[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,
-            valueAssert: withAssert ? createAssert(keysForEnv.modelName, 'process.env', candidateModelNameFromEnv) : ()=>{}
+            valueAssert: withAssert ? createAssert(keysForEnv.modelName, 'process.env', modelName) : ()=>{}
         });
+        const { vlMode, uiTarsVersion } = parseVlModeAndUiTarsFromRaw(result.vlModeRaw);
+        const modelDescription = getModelDescription(vlMode, uiTarsVersion);
         const finalResult = {
             ...result,
-            modelName: candidateModelNameFromEnv,
-            from: 'env'
-        };
-        debugLog('ChooseOpenaiSdkConfig result:', finalResult);
-        return finalResult;
-    }
-    {
-        debugLog('ChooseOpenaiSdkConfig base on global env config without intent.');
-        const result = decideOpenaiSdkConfig({
-            keys: DEFAULT_MODEL_CONFIG_KEYS_LEGACY,
-            provider: allConfig,
-            valueAssert: withAssert ? createAssert(DEFAULT_MODEL_CONFIG_KEYS_LEGACY.modelName, 'process.env') : ()=>{}
-        });
-        const vlMode = decideVlModelValueFromGlobalConfig();
-        const finalResult = {
-            ...result,
-            modelName: allConfig[DEFAULT_MODEL_CONFIG_KEYS_LEGACY.modelName] || 'gpt-4o',
+            modelName,
             vlMode,
-            from: 'legacy-env'
+            uiTarsVersion,
+            modelDescription,
+            from: 'env'
         };
-        debugLog('ChooseOpenaiSdkConfig result:', finalResult);
+        debugLog('decideModelConfig result by process.env with intent:', maskConfig(finalResult));
         return finalResult;
     }
+    debugLog(`decideModelConfig as legacy logic with intent ${intent}.`);
+    const result = decideOpenaiSdkConfig({
+        keys: DEFAULT_MODEL_CONFIG_KEYS_LEGACY,
+        provider: allConfig,
+        valueAssert: withAssert ? createAssert(DEFAULT_MODEL_CONFIG_KEYS_LEGACY.modelName, 'process.env') : ()=>{}
+    });
+    const { vlMode, uiTarsVersion } = parseVlModeAndUiTarsFromGlobalConfig(allConfig);
+    const modelDescription = getModelDescription(vlMode, uiTarsVersion);
+    const finalResult = {
+        ...result,
+        modelName: allConfig[DEFAULT_MODEL_CONFIG_KEYS_LEGACY.modelName] || 'gpt-4o',
+        vlMode,
+        uiTarsVersion,
+        modelDescription,
+        from: 'legacy-env'
+    };
+    debugLog('decideModelConfig result by legacy logic:', maskConfig(finalResult));
+    return finalResult;
 };
-export { createAssert, decideModelConfig, decideOpenaiSdkConfig, parseJson };
+export { decideModelConfig, decideOpenaiSdkConfig };

package/dist/es/env/parse.mjs

@@ -0,0 +1,78 @@
+import { MIDSCENE_USE_DOUBAO_VISION, MIDSCENE_USE_GEMINI, MIDSCENE_USE_QWEN_VL, MIDSCENE_USE_VLM_UI_TARS } from "./types.mjs";
+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)=>{
+    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}`);
+    const raw = vlModeRaw;
+    if ('vlm-ui-tars' === raw) return {
+        vlMode: 'vlm-ui-tars',
+        uiTarsVersion: "1.0"
+    };
+    if ('vlm-ui-tars-doubao' === raw || 'vlm-ui-tars-doubao-1.5' === raw) return {
+        vlMode: 'vlm-ui-tars',
+        uiTarsVersion: "doubao-1.5-20B"
+    };
+    return {
+        vlMode: raw,
+        uiTarsVersion: void 0
+    };
+};
+const parseVlModeAndUiTarsFromGlobalConfig = (provider)=>{
+    const isDoubao = provider[MIDSCENE_USE_DOUBAO_VISION];
+    const isQwen = provider[MIDSCENE_USE_QWEN_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,
+        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 (isQwen) return {
+        vlMode: 'qwen-vl',
+        uiTarsVersion: void 0
+    };
+    if (isDoubao) return {
+        vlMode: 'doubao-vision',
+        uiTarsVersion: void 0
+    };
+    if (isGemini) return {
+        vlMode: 'gemini',
+        uiTarsVersion: void 0
+    };
+    if (isUiTars) if ('1' === isUiTars) return {
+        vlMode: 'vlm-ui-tars',
+        uiTarsVersion: "1.0"
+    };
+    else if ('DOUBAO' === isUiTars || 'DOUBAO-1.5' === isUiTars) return {
+        vlMode: 'vlm-ui-tars',
+        uiTarsVersion: "doubao-1.5-20B"
+    };
+    else return {
+        vlMode: 'vlm-ui-tars',
+        uiTarsVersion: `${isUiTars}`
+    };
+    return {
+        vlMode: void 0,
+        uiTarsVersion: void 0
+    };
+};
+export { parse_UITarsModelVersion as UITarsModelVersion, parseVlModeAndUiTarsFromGlobalConfig, parseVlModeAndUiTarsFromRaw };

package/dist/es/env/utils.mjs

@@ -1,41 +1,12 @@
 import { globalConfigManger } from "./global-config.mjs";
 import { decideModelConfig } from "./model-config.mjs";
-import { MIDSCENE_OPENAI_INIT_CONFIG_JSON, MIDSCENE_PREFERRED_LANGUAGE, MIDSCENE_USE_VLM_UI_TARS } from "./types.mjs";
-var utils_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;
-}({});
+import { MIDSCENE_OPENAI_INIT_CONFIG_JSON, MIDSCENE_PREFERRED_LANGUAGE } from "./types.mjs";
 const uiTarsModelVersion = (modelPreferences)=>{
-    if ('vlm-ui-tars' !== vlLocateMode(modelPreferences)) return false;
-    const modelConfig = decideModelConfig(modelPreferences, false);
-    const { vlMode } = modelConfig;
-    if ('legacy-env' === modelConfig.from) {
-        const versionConfig = globalConfigManger.getConfigValue(MIDSCENE_USE_VLM_UI_TARS);
-        if ('1' === versionConfig) return "1.0";
-        if ('DOUBAO' === versionConfig || 'DOUBAO-1.5' === versionConfig) return "doubao-1.5-20B";
-        return `${versionConfig}`;
-    }
-    if ('vlm-ui-tars' === vlMode) return "1.0";
-    if ('vlm-ui-tars-doubao' === vlMode || 'vlm-ui-tars-doubao-1.5' === vlMode) return "doubao-1.5-20B";
-    throw new Error(`vlMode ${vlMode} is not a expected value.`);
+    const { uiTarsVersion } = decideModelConfig(modelPreferences, false);
+    return uiTarsVersion;
 };
-const validModeNames = [
-    'doubao-vision',
-    'gemini',
-    'qwen-vl',
-    'vlm-ui-tars',
-    'vlm-ui-tars-doubao',
-    'vlm-ui-tars-doubao-1.5'
-];
 const vlLocateMode = (modelPreferences)=>{
-    const modelConfig = decideModelConfig(modelPreferences, false);
-    if (void 0 === modelConfig.vlMode) return false;
-    const { vlMode } = modelConfig;
-    if (!validModeNames.includes(vlMode)) throw new Error(`VL_MODE value ${vlMode} is not a valid VL_MODE value, must be one of ${validModeNames}`);
-    if ('vlm-ui-tars-doubao' === vlMode || 'vlm-ui-tars-doubao-1.5' === vlMode) return 'vlm-ui-tars';
+    const { vlMode } = decideModelConfig(modelPreferences, false);
     return vlMode;
 };
 const getIsUseQwenVl = (modelPreferences)=>{
@@ -69,4 +40,4 @@ const overrideAIConfig = (newConfig, extendMode = false)=>{
     }
     globalConfigManger.registerOverride(newConfig, extendMode);
 };
-export { utils_UITarsModelVersion as UITarsModelVersion, getAIConfig, getAIConfigInBoolean, getAIConfigInNumber, getIsUseQwenVl, getModelName, getPreferredLanguage, getUploadTestServerUrl, overrideAIConfig, uiTarsModelVersion, vlLocateMode };
+export { getAIConfig, getAIConfigInBoolean, getAIConfigInNumber, getIsUseQwenVl, getModelName, getPreferredLanguage, getUploadTestServerUrl, overrideAIConfig, uiTarsModelVersion, vlLocateMode };

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

@@ -44,7 +44,12 @@ const allConfigFromEnv = ()=>external_types_js_namespaceObject.ENV_KEYS.reduce((
 class GlobalConfigManager {
     reset() {
         this.override = void 0;
-        this.modelConfigFn = void 0;
+        this.modelConfigByIntent = {
+            VQA: void 0,
+            default: void 0,
+            grounding: void 0,
+            planning: void 0
+        };
     }
     getAllConfig() {
         const envConfig = allConfigFromEnv();
@@ -97,28 +102,34 @@ class GlobalConfigManager {
             extendMode
         };
     }
-    getModelConfig(intent) {
-        if (this.modelConfigFn) {
-            const result = this.modelConfigFn({
-                intent
-            });
-            return {
-                hasModelConfigFn: true,
-                result
-            };
-        }
-        return {
-            hasModelConfigFn: false,
-            result: void 0
-        };
+    getModelConfigFromFn(intent) {
+        return this.modelConfigByIntent[intent];
     }
     registerModelConfigFn(modelConfigFn) {
         if ('function' != typeof modelConfigFn) throw new Error(`modelConfigFn must be a function when registerModelConfigFn, but got with type ${typeof modelConfigFn}`);
-        this.modelConfigFn = modelConfigFn;
+        const intents = [
+            'VQA',
+            'default',
+            'grounding',
+            'planning'
+        ];
+        for (const i of 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.`);
+            this.modelConfigByIntent[i] = result;
+        }
     }
     constructor(){
         _define_property(this, "override", void 0);
-        _define_property(this, "modelConfigFn", void 0);
+        _define_property(this, "modelConfigByIntent", void 0);
+        this.modelConfigByIntent = {
+            VQA: void 0,
+            default: void 0,
+            grounding: void 0,
+            planning: void 0
+        };
     }
 }
 const globalConfigManger = new GlobalConfigManager();

package/dist/lib/env/helper.js

@@ -0,0 +1,96 @@
+"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__, {
+    initDebugConfig: ()=>initDebugConfig,
+    maskConfig: ()=>maskConfig,
+    createAssert: ()=>createAssert,
+    parseJson: ()=>parseJson
+});
+const external_logger_js_namespaceObject = require("../logger.js");
+const external_utils_js_namespaceObject = require("../utils.js");
+const external_global_config_js_namespaceObject = require("./global-config.js");
+const external_types_js_namespaceObject = require("./types.js");
+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])=>[
+            key,
+            [
+                'openaiApiKey',
+                'azureOpenaiKey',
+                'anthropicApiKey'
+            ].includes(key) ? maskKey(value) : value
+        ]));
+const initDebugConfig = ()=>{
+    const shouldPrintTiming = external_global_config_js_namespaceObject.globalConfigManger.getConfigValueInBoolean(external_types_js_namespaceObject.MIDSCENE_DEBUG_AI_PROFILE);
+    let debugConfig = '';
+    if (shouldPrintTiming) {
+        console.warn('MIDSCENE_DEBUG_AI_PROFILE is deprecated, use DEBUG=midscene:ai:profile instead');
+        debugConfig = 'ai:profile';
+    }
+    const shouldPrintAIResponse = external_global_config_js_namespaceObject.globalConfigManger.getConfigValueInBoolean(external_types_js_namespaceObject.MIDSCENE_DEBUG_AI_RESPONSE);
+    if (shouldPrintAIResponse) {
+        console.warn('MIDSCENE_DEBUG_AI_RESPONSE is deprecated, use DEBUG=midscene:ai:response instead');
+        debugConfig = debugConfig ? 'ai:*' : 'ai:call';
+    }
+    if (debugConfig) (0, external_logger_js_namespaceObject.enableDebug)(debugConfig);
+};
+const parseJson = (key, value)=>{
+    if (void 0 !== value) try {
+        return JSON.parse(value);
+    } catch (e) {
+        throw new Error(`Failed to parse ${key} as a JSON. ${e.message}`, {
+            cause: e
+        });
+    }
+};
+const createAssert = (modelNameKey, provider, modelName)=>(value, key, modelVendorFlag)=>{
+        if (modelName) if (modelVendorFlag) (0, external_utils_js_namespaceObject.assert)(value, `The ${key} must be a non-empty string because of the ${modelNameKey} is declared as ${modelName} and ${modelVendorFlag} has also been specified in ${provider}, but got: ${value}. Please check your config.`);
+        else (0, external_utils_js_namespaceObject.assert)(value, `The ${key} must be a non-empty string because of the ${modelNameKey} is declared as ${modelName} in ${provider}, but got: ${value}. Please check your config.`);
+        else (0, external_utils_js_namespaceObject.assert)(value, `The ${key} must be a non-empty string, but got: ${value}. Please check your config.`);
+    };
+exports.createAssert = __webpack_exports__.createAssert;
+exports.initDebugConfig = __webpack_exports__.initDebugConfig;
+exports.maskConfig = __webpack_exports__.maskConfig;
+exports.parseJson = __webpack_exports__.parseJson;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createAssert",
+    "initDebugConfig",
+    "maskConfig",
+    "parseJson"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});