@midscene/shared 0.28.2 → 0.28.3

package/dist/lib/env/utils.js

@@ -24,57 +24,18 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    getIsUseQwenVl: ()=>getIsUseQwenVl,
-    uiTarsModelVersion: ()=>uiTarsModelVersion,
-    overrideAIConfig: ()=>overrideAIConfig,
-    vlLocateMode: ()=>vlLocateMode,
-    getUploadTestServerUrl: ()=>getUploadTestServerUrl,
     globalConfigManager: ()=>globalConfigManager,
+    globalModelConfigManager: ()=>globalModelConfigManager,
     getPreferredLanguage: ()=>getPreferredLanguage,
-    getModelName: ()=>getModelName
+    overrideAIConfig: ()=>overrideAIConfig
 });
-const external_global_config_js_namespaceObject = require("./global-config.js");
+const external_global_config_manager_js_namespaceObject = require("./global-config-manager.js");
+const external_model_config_manager_js_namespaceObject = require("./model-config-manager.js");
 const external_types_js_namespaceObject = require("./types.js");
-const globalConfigManager = new external_global_config_js_namespaceObject.GlobalConfigManager();
-const uiTarsModelVersion = (modelPreferences)=>{
-    try {
-        const result = globalConfigManager.getModelConfigByIntent(modelPreferences.intent);
-        return result.uiTarsVersion;
-    } catch (e) {
-        if (null == e ? void 0 : e[external_global_config_js_namespaceObject.GLOBAL_CONFIG_MANAGER_UNINITIALIZED_FLAG]) return void console.warn("Call uiTarsModelVersion before globalConfig init, will return undefined. This warning should only appear in midscene's own unit tests.");
-        throw e;
-    }
-};
-const vlLocateMode = (modelPreferences)=>{
-    try {
-        const result = globalConfigManager.getModelConfigByIntent(modelPreferences.intent);
-        return result.vlMode;
-    } catch (e) {
-        if (null == e ? void 0 : e[external_global_config_js_namespaceObject.GLOBAL_CONFIG_MANAGER_UNINITIALIZED_FLAG]) return void console.warn("Call vlLocateMode before globalConfig init, will return undefined. This warning should only appear in midscene's own unit tests.");
-        throw e;
-    }
-};
-const getIsUseQwenVl = (modelPreferences)=>{
-    try {
-        const result = globalConfigManager.getModelConfigByIntent(modelPreferences.intent);
-        return 'qwen-vl' === result.vlMode;
-    } catch (e) {
-        if (null == e ? void 0 : e[external_global_config_js_namespaceObject.GLOBAL_CONFIG_MANAGER_UNINITIALIZED_FLAG]) {
-            console.warn("Call getIsUseQwenVl before globalConfig init, will return false. This warning should only appear in midscene's own unit tests.");
-            return false;
-        }
-        throw e;
-    }
-};
-function getModelName(modelPreferences) {
-    try {
-        const result = globalConfigManager.getModelConfigByIntent(modelPreferences.intent);
-        return null == result ? void 0 : result.modelName;
-    } catch (e) {
-        if (null == e ? void 0 : e[external_global_config_js_namespaceObject.GLOBAL_CONFIG_MANAGER_UNINITIALIZED_FLAG]) return void console.warn("Call getModelName before globalConfig init, will return undefined. This warning should only appear in midscene's own unit tests.");
-        throw e;
-    }
-}
+const globalModelConfigManager = new external_model_config_manager_js_namespaceObject.ModelConfigManager();
+const globalConfigManager = new external_global_config_manager_js_namespaceObject.GlobalConfigManager();
+globalConfigManager.registerModelConfigManager(globalModelConfigManager);
+globalModelConfigManager.registerGlobalConfigManager(globalConfigManager);
 const getPreferredLanguage = ()=>{
     const prefer = globalConfigManager.getEnvConfigValue(external_types_js_namespaceObject.MIDSCENE_PREFERRED_LANGUAGE);
     if (prefer) return prefer;
@@ -82,36 +43,18 @@ const getPreferredLanguage = ()=>{
     const isChina = 'Asia/Shanghai' === timeZone;
     return isChina ? 'Chinese' : 'English';
 };
-const getUploadTestServerUrl = ()=>{
-    try {
-        const { openaiExtraConfig } = globalConfigManager.getModelConfigByIntent('default');
-        const serverUrl = null == openaiExtraConfig ? void 0 : openaiExtraConfig.REPORT_SERVER_URL;
-        return serverUrl;
-    } catch (e) {
-        if (null == e ? void 0 : e[external_global_config_js_namespaceObject.GLOBAL_CONFIG_MANAGER_UNINITIALIZED_FLAG]) return void console.warn("Call getUploadTestServerUrl before globalConfig init, will return undefined. This warning should only appear in midscene's own unit tests.");
-        throw e;
-    }
-};
 const overrideAIConfig = (newConfig, extendMode = false)=>{
-    globalConfigManager.registerOverride(newConfig, extendMode);
+    globalConfigManager.overrideAIConfig(newConfig, extendMode);
 };
-exports.getIsUseQwenVl = __webpack_exports__.getIsUseQwenVl;
-exports.getModelName = __webpack_exports__.getModelName;
 exports.getPreferredLanguage = __webpack_exports__.getPreferredLanguage;
-exports.getUploadTestServerUrl = __webpack_exports__.getUploadTestServerUrl;
 exports.globalConfigManager = __webpack_exports__.globalConfigManager;
+exports.globalModelConfigManager = __webpack_exports__.globalModelConfigManager;
 exports.overrideAIConfig = __webpack_exports__.overrideAIConfig;
-exports.uiTarsModelVersion = __webpack_exports__.uiTarsModelVersion;
-exports.vlLocateMode = __webpack_exports__.vlLocateMode;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "getIsUseQwenVl",
-    "getModelName",
     "getPreferredLanguage",
-    "getUploadTestServerUrl",
     "globalConfigManager",
-    "overrideAIConfig",
-    "uiTarsModelVersion",
-    "vlLocateMode"
+    "globalModelConfigManager",
+    "overrideAIConfig"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/types/env/decide-model-config.d.ts

@@ -0,0 +1,14 @@
+import type { IModelConfig, TIntent } from './types';
+import { DEFAULT_MODEL_CONFIG_KEYS, DEFAULT_MODEL_CONFIG_KEYS_LEGACY, GROUNDING_MODEL_CONFIG_KEYS, PLANNING_MODEL_CONFIG_KEYS, VQA_MODEL_CONFIG_KEYS } from './constants';
+type TModelConfigKeys = typeof VQA_MODEL_CONFIG_KEYS | typeof GROUNDING_MODEL_CONFIG_KEYS | typeof PLANNING_MODEL_CONFIG_KEYS | typeof DEFAULT_MODEL_CONFIG_KEYS | typeof DEFAULT_MODEL_CONFIG_KEYS_LEGACY;
+/**
+ * Choose OpenAI SDK config, such as OpenAI, AzureOpenAI, AnthropicSDK, etc.
+ */
+export declare const decideOpenaiSdkConfig: ({ keys, provider, valueAssert, }: {
+    keys: TModelConfigKeys;
+    provider: Record<string, string | undefined>;
+    valueAssert: (value: string | undefined, key: string, modelVendorFlag?: string) => void;
+}) => Omit<IModelConfig, "modelName" | "from" | "vlMode" | "uiTarsVersion" | "modelDescription" | "intent">;
+export declare const decideModelConfigFromIntentConfig: (intent: TIntent, intentConfig: Record<string, string | undefined>) => IModelConfig;
+export declare const decideModelConfigFromEnv: (intent: TIntent, allEnvConfig: Record<string, string | undefined>) => IModelConfig;
+export {};

package/dist/types/env/global-config-manager.d.ts

@@ -0,0 +1,32 @@
+import type { ModelConfigManager } from './model-config-manager';
+import { BOOLEAN_ENV_KEYS, GLOBAL_ENV_KEYS, NUMBER_ENV_KEYS, STRING_ENV_KEYS } from './types';
+import { MODEL_ENV_KEYS } from './types';
+/**
+ * Collect global configs from process.env, overrideAIConfig, etc.
+ * And provider methods to get merged config value
+ */
+export declare class GlobalConfigManager {
+    private override;
+    private keysHaveBeenRead;
+    private globalModelConfigManager;
+    constructor();
+    /**
+     * recalculate allEnvConfig every time because process.env can be updated any time
+     */
+    getAllEnvConfig(): Record<string, string | undefined>;
+    getEnvConfigValue(key: (typeof STRING_ENV_KEYS)[number]): string | undefined;
+    /**
+     * read number only from process.env
+     */
+    getEnvConfigInNumber(key: (typeof NUMBER_ENV_KEYS)[number]): number;
+    /**
+     * read boolean only from process.env
+     */
+    getEnvConfigInBoolean(key: (typeof BOOLEAN_ENV_KEYS)[number]): boolean;
+    registerModelConfigManager(globalModelConfigManager: ModelConfigManager): void;
+    /**
+     * for overrideAIConfig
+     * can only override keys in MODEL_ENV_KEYS
+     */
+    overrideAIConfig(newConfig: Partial<Record<(typeof GLOBAL_ENV_KEYS)[number] | (typeof MODEL_ENV_KEYS)[number], string>>, extendMode?: boolean): void;
+}

package/dist/types/env/helper.d.ts

@@ -1,4 +1,4 @@
-import type { IModelConfig } from './model-config';
+import type { IModelConfig } from './types';
 export declare const maskConfig: (config: IModelConfig) => {
     [k: string]: any;
 };

package/dist/types/env/index.d.ts

@@ -1,3 +1,4 @@
 export * from './utils';
 export * from './types';
-export { UITarsModelVersion } from './parse';
+export { ModelConfigManager } from './model-config-manager';
+export { GlobalConfigManager } from './global-config-manager';

package/dist/types/env/model-config-manager.d.ts

@@ -0,0 +1,23 @@
+import type { GlobalConfigManager } from './global-config-manager';
+import type { IModelConfig, TIntent, TModelConfigFn } from './types';
+export type TIntentConfigMap = Record<TIntent, ReturnType<TModelConfigFn> | undefined>;
+export declare class ModelConfigManager {
+    private modelConfigMap;
+    private isolatedMode;
+    private globalConfigManager;
+    constructor(modelConfigFn?: TModelConfigFn);
+    private calcIntentConfigMap;
+    private calcModelConfigMapBaseOnIntent;
+    private calcModelConfigMapBaseOnEnv;
+    /**
+     * should only be called by GlobalConfigManager
+     */
+    clearModelConfigMap(): void;
+    /**
+     * if isolatedMode is true, modelConfigMap was initialized in constructor and can't be changed
+     * if isolatedMode is false, modelConfigMap can be changed by process.env so we need to recalculate it when it's undefined
+     */
+    getModelConfig(intent: TIntent): IModelConfig;
+    getUploadTestServerUrl(): string | undefined;
+    registerGlobalConfigManager(globalConfigManager: GlobalConfigManager): void;
+}

package/dist/types/env/parse.d.ts

@@ -1,16 +1,5 @@
-import { type TVlModeTypes } from './types';
-export declare enum UITarsModelVersion {
-    V1_0 = "1.0",
-    V1_5 = "1.5",
-    DOUBAO_1_5_15B = "doubao-1.5-15B",
-    DOUBAO_1_5_20B = "doubao-1.5-20B"
-}
-/**
- *
- * @param vlModeRaw
- * @returns
- */
-export declare const parseVlModeAndUiTarsFromRaw: (vlModeRaw?: string) => {
+import { type TVlModeTypes, UITarsModelVersion } from './types';
+export declare const parseVlModeAndUiTarsModelVersionFromRawValue: (vlModeRaw?: string) => {
     vlMode?: TVlModeTypes;
     uiTarsVersion?: UITarsModelVersion;
 };

package/dist/types/env/types.d.ts

@@ -235,7 +235,57 @@ export interface IModelConfigForDefaultLegacy {
 export type TIntent = 'VQA' | 'planning' | 'grounding' | 'default';
 export type TModelConfigFn = (options: {
     intent: TIntent;
-}) => IModelConfigForVQA | IModelConfigForPlanning | IModeConfigForGrounding | IModelConfigForDefault | IModelConfigForDefaultLegacy;
-export interface IModelPreferences {
+}) => IModelConfigForVQA | IModelConfigForPlanning | IModeConfigForGrounding | IModelConfigForDefault;
+export declare enum UITarsModelVersion {
+    V1_0 = "1.0",
+    V1_5 = "1.5",
+    DOUBAO_1_5_15B = "doubao-1.5-15B",
+    DOUBAO_1_5_20B = "doubao-1.5-20B"
+}
+export declare const VL_MODE_RAW_VALID_VALUES: TVlModeValues[];
+export interface IModelConfig {
+    /**
+     * proxy
+     */
+    socksProxy?: string;
+    httpProxy?: string;
+    /**
+     * model
+     */
+    modelName: string;
+    /**
+     * OpenAI
+     */
+    openaiBaseURL?: string;
+    openaiApiKey?: string;
+    openaiExtraConfig?: Record<string, unknown>;
+    /**
+     * Azure
+     */
+    openaiUseAzureDeprecated?: boolean;
+    useAzureOpenai?: boolean;
+    azureOpenaiScope?: string;
+    azureOpenaiKey?: string;
+    azureOpenaiEndpoint?: string;
+    azureOpenaiApiVersion?: string;
+    azureOpenaiDeployment?: string;
+    azureExtraConfig?: Record<string, unknown>;
+    /**
+     * Anthropic
+     */
+    useAnthropicSdk?: boolean;
+    anthropicApiKey?: string;
+    /**
+     * - vlModeRaw: exists only in non-legacy logic. value can be 'doubao-vision', 'gemini', 'qwen-vl', 'vlm-ui-tars', 'vlm-ui-tars-doubao', 'vlm-ui-tars-doubao-1.5'
+     * - vlMode: based on the results of the vlModoRaw classification，value can be 'doubao-vision', 'gemini', 'qwen-vl', 'vlm-ui-tars'
+     */
+    vlModeRaw?: string;
+    vlMode?: TVlModeTypes;
+    uiTarsModelVersion?: UITarsModelVersion;
+    modelDescription: string;
+    /**
+     * for debug
+     */
     intent: TIntent;
+    from: 'modelConfig' | 'env' | 'legacy-env';
 }

package/dist/types/env/utils.d.ts

@@ -1,11 +1,7 @@
-import { GlobalConfigManager } from './global-config';
-import type { UITarsModelVersion } from './parse';
-import { type GLOBAL_ENV_KEYS, type IModelPreferences, type MODEL_ENV_KEYS, type TVlModeTypes } from './types';
+import { GlobalConfigManager } from './global-config-manager';
+import { ModelConfigManager } from './model-config-manager';
+import { type GLOBAL_ENV_KEYS, type MODEL_ENV_KEYS } from './types';
+export declare const globalModelConfigManager: ModelConfigManager;
 export declare const globalConfigManager: GlobalConfigManager;
-export declare const uiTarsModelVersion: (modelPreferences: IModelPreferences) => UITarsModelVersion | undefined;
-export declare const vlLocateMode: (modelPreferences: IModelPreferences) => TVlModeTypes | undefined;
-export declare const getIsUseQwenVl: (modelPreferences: IModelPreferences) => boolean;
-export declare function getModelName(modelPreferences: IModelPreferences): string | undefined;
 export declare const getPreferredLanguage: () => string;
-export declare const getUploadTestServerUrl: () => string | undefined;
 export declare const overrideAIConfig: (newConfig: Partial<Record<(typeof GLOBAL_ENV_KEYS)[number] | (typeof MODEL_ENV_KEYS)[number], string>>, extendMode?: boolean) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midscene/shared",
-  "version": "0.28.2",
+  "version": "0.28.3",
   "repository": "https://github.com/web-infra-dev/midscene",
   "homepage": "https://midscenejs.com/",
   "types": "./dist/types/index.d.ts",

package/src/env/{model-config.ts → decide-model-config.ts}

@@ -1,4 +1,9 @@
-import type { TIntent, TVlModeTypes } from './types';
+import type {
+  IModelConfig,
+  TIntent,
+  TVlModeTypes,
+  UITarsModelVersion,
+} from './types';
 
 import {
   DEFAULT_MODEL_CONFIG_KEYS,
@@ -13,57 +18,10 @@ import { assert } from '../utils';
 import { createAssert, maskConfig, parseJson } from './helper';
 import { initDebugConfig } from './init-debug';
 import {
-  type UITarsModelVersion,
   parseVlModeAndUiTarsFromGlobalConfig,
-  parseVlModeAndUiTarsFromRaw,
+  parseVlModeAndUiTarsModelVersionFromRawValue,
 } from './parse';
 
-export interface IModelConfig {
-  /**
-   * proxy
-   */
-  socksProxy?: string;
-  httpProxy?: string;
-  /**
-   * model
-   */
-  modelName: string;
-  /**
-   * OpenAI
-   */
-  openaiBaseURL?: string;
-  openaiApiKey?: string;
-  openaiExtraConfig?: Record<string, unknown>;
-  /**
-   * Azure
-   */
-  openaiUseAzureDeprecated?: boolean;
-  useAzureOpenai?: boolean;
-  azureOpenaiScope?: string;
-  azureOpenaiKey?: string;
-  azureOpenaiEndpoint?: string;
-  azureOpenaiApiVersion?: string;
-  azureOpenaiDeployment?: string;
-  azureExtraConfig?: Record<string, unknown>;
-  /**
-   * Anthropic
-   */
-  useAnthropicSdk?: boolean;
-  anthropicApiKey?: string;
-  /**
-   * - vlModeRaw: exists only in non-legacy logic. value can be 'doubao-vision', 'gemini', 'qwen-vl', 'vlm-ui-tars', 'vlm-ui-tars-doubao', 'vlm-ui-tars-doubao-1.5'
-   * - vlMode: based on the results of the vlModoRaw classification，value can be 'doubao-vision', 'gemini', 'qwen-vl', 'vlm-ui-tars'
-   */
-  vlModeRaw?: string;
-  vlMode?: string;
-  uiTarsVersion?: UITarsModelVersion;
-  modelDescription: string;
-  /**
-   * for debug
-   */
-  from: 'modelConfig' | 'env' | 'legacy-env';
-}
-
 type TModelConfigKeys =
   | typeof VQA_MODEL_CONFIG_KEYS
   | typeof GROUNDING_MODEL_CONFIG_KEYS
@@ -95,10 +53,15 @@ export const decideOpenaiSdkConfig = ({
   ) => void;
 }): Omit<
   IModelConfig,
-  'modelName' | 'from' | 'vlMode' | 'uiTarsVersion' | 'modelDescription'
+  | 'modelName'
+  | 'from'
+  | 'vlMode'
+  | 'uiTarsVersion'
+  | 'modelDescription'
+  | 'intent'
 > => {
   initDebugConfig();
-  const debugLog = getDebug('ai:global:config');
+  const debugLog = getDebug('ai:config');
 
   const socksProxy = provider[keys.socksProxy];
   const httpProxy = provider[keys.httpProxy];
@@ -211,95 +174,82 @@ const getModelDescription = (
   return '';
 };
 
-/**
- * get and validate model config for model client
- * priority order:
- * - modelConfigFn result
- * - process.env.MIDSCENE_${intent}_MODEL_NAME
- * - PROCESS.ENV.MIDSCENE_MODEL_NAME
- */
-export const decideModelConfig = ({
-  intent,
-  modelConfigFromFn,
-  allConfig,
-}: {
-  intent: TIntent;
-  modelConfigFromFn: Record<string, string | undefined> | undefined;
-  allConfig: Record<string, string | undefined>;
-}): IModelConfig => {
-  initDebugConfig();
-  const debugLog = 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;
-      } else {
-        debugLog(
-          'query modelConfig from fn by intent got no corresponding modelName, will get other keys by default',
-        );
-        assert(
-          modelConfigFromFn[DEFAULT_MODEL_CONFIG_KEYS.modelName],
-          `The return value of agent.modelConfig do not have a valid value with key ${DEFAULT_MODEL_CONFIG_KEYS.modelName}.`,
-        );
-        return DEFAULT_MODEL_CONFIG_KEYS;
-      }
-    })();
+export const decideModelConfigFromIntentConfig = (
+  intent: TIntent,
+  intentConfig: Record<string, string | undefined>,
+): IModelConfig => {
+  const debugLog = getDebug('ai:config');
 
-    const result = decideOpenaiSdkConfig({
-      keys: chosenKeys,
-      provider: modelConfigFromFn,
-      valueAssert: createAssert(
-        chosenKeys.modelName,
-        'modelConfig',
-        candidateModelNameFromConfig,
-      ),
-    });
+  debugLog('decideModelConfig base on agent.modelConfig()');
 
-    const { vlMode, uiTarsVersion } = parseVlModeAndUiTarsFromRaw(
-      result.vlModeRaw,
-    );
-    const modelDescription = getModelDescription(vlMode, uiTarsVersion);
+  const keysForFn = KEYS_MAP[intent];
 
-    const finalResult: IModelConfig = {
-      ...result,
-      modelName: modelConfigFromFn[chosenKeys.modelName]!,
-      vlMode,
-      uiTarsVersion,
-      modelDescription,
-      from: 'modelConfig',
-    };
+  const candidateModelNameFromConfig = intentConfig[keysForFn.modelName];
 
-    debugLog(
-      `decideModelConfig result by agent.modelConfig() with intent ${intent}:`,
-      maskConfig(finalResult),
-    );
-    return finalResult;
-  }
+  debugLog('Got modelName from modelConfigFn', candidateModelNameFromConfig);
 
-  const keysForEnv =
-    intent === 'default' ? DEFAULT_MODEL_CONFIG_KEYS_LEGACY : KEYS_MAP[intent];
+  const chosenKeys = (() => {
+    if (candidateModelNameFromConfig) {
+      debugLog(
+        'query modelConfig from fn by intent got corresponding modelName, will get other corresponding keys',
+      );
+      return keysForFn;
+    } else {
+      debugLog(
+        'query modelConfig from fn by intent got no corresponding modelName, will get other keys by default',
+      );
+      assert(
+        intentConfig[DEFAULT_MODEL_CONFIG_KEYS.modelName],
+        `The return value of agent.modelConfig do not have a valid value with key ${DEFAULT_MODEL_CONFIG_KEYS.modelName}.`,
+      );
+      return DEFAULT_MODEL_CONFIG_KEYS;
+    }
+  })();
 
-  const candidateModelNameFromEnv = allConfig[keysForEnv.modelName];
+  const result = decideOpenaiSdkConfig({
+    keys: chosenKeys,
+    provider: intentConfig,
+    valueAssert: createAssert(
+      chosenKeys.modelName,
+      'modelConfig',
+      candidateModelNameFromConfig,
+    ),
+  });
+
+  const { vlMode, uiTarsVersion } =
+    parseVlModeAndUiTarsModelVersionFromRawValue(result.vlModeRaw);
+
+  const modelDescription = getModelDescription(vlMode, uiTarsVersion);
+
+  const finalResult: IModelConfig = {
+    ...result,
+    modelName: intentConfig[chosenKeys.modelName]!,
+    vlMode,
+    uiTarsModelVersion: uiTarsVersion,
+    modelDescription,
+    from: 'modelConfig',
+    intent,
+  };
 
   debugLog(
-    `Get value of ${keysForEnv.modelName} from globalConfig`,
-    candidateModelNameFromEnv,
+    `decideModelConfig result by agent.modelConfig() with intent ${intent}:`,
+    maskConfig(finalResult),
   );
+  return finalResult;
+};
 
-  if (intent !== 'default' && allConfig[keysForEnv.modelName]) {
-    const modelName = allConfig[keysForEnv.modelName]!;
+export const decideModelConfigFromEnv = (
+  intent: TIntent,
+  allEnvConfig: Record<string, string | undefined>,
+): IModelConfig => {
+  initDebugConfig();
+  const debugLog = getDebug('ai:config');
+
+  const keysForEnv =
+    intent === 'default' ? DEFAULT_MODEL_CONFIG_KEYS_LEGACY : KEYS_MAP[intent];
+
+  if (intent !== 'default' && 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.`,
@@ -307,22 +257,22 @@ export const decideModelConfig = ({
 
     const result = decideOpenaiSdkConfig({
       keys: keysForEnv,
-      provider: allConfig,
+      provider: allEnvConfig,
       valueAssert: createAssert(keysForEnv.modelName, 'process.env', modelName),
     });
 
-    const { vlMode, uiTarsVersion } = parseVlModeAndUiTarsFromRaw(
-      result.vlModeRaw,
-    );
+    const { vlMode, uiTarsVersion } =
+      parseVlModeAndUiTarsModelVersionFromRawValue(result.vlModeRaw);
     const modelDescription = getModelDescription(vlMode, uiTarsVersion);
 
     const finalResult: IModelConfig = {
       ...result,
       modelName,
       vlMode,
-      uiTarsVersion,
+      uiTarsModelVersion: uiTarsVersion,
       modelDescription,
       from: 'env',
+      intent,
     };
 
     debugLog(
@@ -334,9 +284,10 @@ export const decideModelConfig = ({
 
   debugLog(`decideModelConfig as legacy logic with intent ${intent}.`);
 
+  // TODO: when fallback to legacy logic, prefer to read MIDSCENE_OPENAI_API_KEY rather than OPENAI_API_KEY
   const result = decideOpenaiSdkConfig({
     keys: DEFAULT_MODEL_CONFIG_KEYS_LEGACY,
-    provider: allConfig,
+    provider: allEnvConfig,
     valueAssert: createAssert(
       DEFAULT_MODEL_CONFIG_KEYS_LEGACY.modelName,
       'process.env',
@@ -344,7 +295,7 @@ export const decideModelConfig = ({
   });
 
   const { vlMode, uiTarsVersion } =
-    parseVlModeAndUiTarsFromGlobalConfig(allConfig);
+    parseVlModeAndUiTarsFromGlobalConfig(allEnvConfig);
 
   const modelDescription = getModelDescription(vlMode, uiTarsVersion);
 
@@ -352,11 +303,12 @@ export const decideModelConfig = ({
     ...result,
     // In the legacy logic, GPT-4o is the default model.
     modelName:
-      allConfig[DEFAULT_MODEL_CONFIG_KEYS_LEGACY.modelName] || 'gpt-4o',
+      allEnvConfig[DEFAULT_MODEL_CONFIG_KEYS_LEGACY.modelName] || 'gpt-4o',
     vlMode,
-    uiTarsVersion,
+    uiTarsModelVersion: uiTarsVersion,
     modelDescription,
     from: 'legacy-env',
+    intent,
   };
 
   debugLog(