@godscene/shared 1.7.11

package/dist/lib/env/constants.js

@@ -0,0 +1,153 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > 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__, {
+    INSIGHT_MODEL_CONFIG_KEYS: ()=>INSIGHT_MODEL_CONFIG_KEYS,
+    DEFAULT_MODEL_CONFIG_KEYS_LEGACY: ()=>DEFAULT_MODEL_CONFIG_KEYS_LEGACY,
+    DEFAULT_MODEL_CONFIG_KEYS: ()=>DEFAULT_MODEL_CONFIG_KEYS,
+    PLANNING_MODEL_CONFIG_KEYS: ()=>PLANNING_MODEL_CONFIG_KEYS
+});
+const external_types_js_namespaceObject = require("./types.js");
+const INSIGHT_MODEL_CONFIG_KEYS = {
+    modelName: external_types_js_namespaceObject.MIDSCENE_INSIGHT_MODEL_NAME,
+    socksProxy: external_types_js_namespaceObject.MIDSCENE_INSIGHT_MODEL_SOCKS_PROXY,
+    httpProxy: external_types_js_namespaceObject.MIDSCENE_INSIGHT_MODEL_HTTP_PROXY,
+    openaiBaseURL: external_types_js_namespaceObject.MIDSCENE_INSIGHT_MODEL_BASE_URL,
+    openaiApiKey: external_types_js_namespaceObject.MIDSCENE_INSIGHT_MODEL_API_KEY,
+    openaiExtraConfig: external_types_js_namespaceObject.MIDSCENE_INSIGHT_MODEL_INIT_CONFIG_JSON,
+    extraBody: external_types_js_namespaceObject.MIDSCENE_INSIGHT_MODEL_EXTRA_BODY_JSON,
+    modelFamily: external_types_js_namespaceObject.MIDSCENE_INSIGHT_MODEL_FAMILY,
+    timeout: external_types_js_namespaceObject.MIDSCENE_INSIGHT_MODEL_TIMEOUT,
+    temperature: external_types_js_namespaceObject.MIDSCENE_INSIGHT_MODEL_TEMPERATURE,
+    retryCount: external_types_js_namespaceObject.MIDSCENE_INSIGHT_MODEL_RETRY_COUNT,
+    retryInterval: external_types_js_namespaceObject.MIDSCENE_INSIGHT_MODEL_RETRY_INTERVAL,
+    reasoningEffort: external_types_js_namespaceObject.MIDSCENE_INSIGHT_MODEL_REASONING_EFFORT,
+    reasoningEnabled: external_types_js_namespaceObject.MIDSCENE_INSIGHT_MODEL_REASONING_ENABLED,
+    reasoningBudget: external_types_js_namespaceObject.MIDSCENE_INSIGHT_MODEL_REASONING_BUDGET,
+    yht_domain: external_types_js_namespaceObject.YHT_DOMAIN,
+    yht_access_token: external_types_js_namespaceObject.YHT_ACCESS_TOKEN,
+    yht_model: external_types_js_namespaceObject.YHT_MODEL,
+    yht_base_url: external_types_js_namespaceObject.YHT_BASE_URL,
+    yht_chat_type: external_types_js_namespaceObject.YHT_CHAT_TYPE,
+    yht_model_category: external_types_js_namespaceObject.YHT_MODEL_CATEGORY,
+    yht_stream: external_types_js_namespaceObject.YHT_STREAM,
+    yht_temperature: external_types_js_namespaceObject.YHT_TEMPERATURE,
+    yht_top_p: external_types_js_namespaceObject.YHT_TOP_P,
+    yht_trace_id: external_types_js_namespaceObject.YHT_TRACE_ID
+};
+const PLANNING_MODEL_CONFIG_KEYS = {
+    modelName: external_types_js_namespaceObject.MIDSCENE_PLANNING_MODEL_NAME,
+    socksProxy: external_types_js_namespaceObject.MIDSCENE_PLANNING_MODEL_SOCKS_PROXY,
+    httpProxy: external_types_js_namespaceObject.MIDSCENE_PLANNING_MODEL_HTTP_PROXY,
+    openaiBaseURL: external_types_js_namespaceObject.MIDSCENE_PLANNING_MODEL_BASE_URL,
+    openaiApiKey: external_types_js_namespaceObject.MIDSCENE_PLANNING_MODEL_API_KEY,
+    openaiExtraConfig: external_types_js_namespaceObject.MIDSCENE_PLANNING_MODEL_INIT_CONFIG_JSON,
+    extraBody: external_types_js_namespaceObject.MIDSCENE_PLANNING_MODEL_EXTRA_BODY_JSON,
+    modelFamily: external_types_js_namespaceObject.MIDSCENE_PLANNING_MODEL_FAMILY,
+    timeout: external_types_js_namespaceObject.MIDSCENE_PLANNING_MODEL_TIMEOUT,
+    temperature: external_types_js_namespaceObject.MIDSCENE_PLANNING_MODEL_TEMPERATURE,
+    retryCount: external_types_js_namespaceObject.MIDSCENE_PLANNING_MODEL_RETRY_COUNT,
+    retryInterval: external_types_js_namespaceObject.MIDSCENE_PLANNING_MODEL_RETRY_INTERVAL,
+    reasoningEffort: external_types_js_namespaceObject.MIDSCENE_PLANNING_MODEL_REASONING_EFFORT,
+    reasoningEnabled: external_types_js_namespaceObject.MIDSCENE_PLANNING_MODEL_REASONING_ENABLED,
+    reasoningBudget: external_types_js_namespaceObject.MIDSCENE_PLANNING_MODEL_REASONING_BUDGET,
+    yht_domain: external_types_js_namespaceObject.YHT_DOMAIN,
+    yht_access_token: external_types_js_namespaceObject.YHT_ACCESS_TOKEN,
+    yht_model: external_types_js_namespaceObject.YHT_MODEL,
+    yht_base_url: external_types_js_namespaceObject.YHT_BASE_URL,
+    yht_chat_type: external_types_js_namespaceObject.YHT_CHAT_TYPE,
+    yht_model_category: external_types_js_namespaceObject.YHT_MODEL_CATEGORY,
+    yht_stream: external_types_js_namespaceObject.YHT_STREAM,
+    yht_temperature: external_types_js_namespaceObject.YHT_TEMPERATURE,
+    yht_top_p: external_types_js_namespaceObject.YHT_TOP_P,
+    yht_trace_id: external_types_js_namespaceObject.YHT_TRACE_ID
+};
+const DEFAULT_MODEL_CONFIG_KEYS = {
+    modelName: external_types_js_namespaceObject.MIDSCENE_MODEL_NAME,
+    socksProxy: external_types_js_namespaceObject.MIDSCENE_MODEL_SOCKS_PROXY,
+    httpProxy: external_types_js_namespaceObject.MIDSCENE_MODEL_HTTP_PROXY,
+    openaiBaseURL: external_types_js_namespaceObject.MIDSCENE_MODEL_BASE_URL,
+    openaiApiKey: external_types_js_namespaceObject.MIDSCENE_MODEL_API_KEY,
+    openaiExtraConfig: external_types_js_namespaceObject.MIDSCENE_MODEL_INIT_CONFIG_JSON,
+    extraBody: external_types_js_namespaceObject.MIDSCENE_MODEL_EXTRA_BODY_JSON,
+    modelFamily: external_types_js_namespaceObject.MIDSCENE_MODEL_FAMILY,
+    timeout: external_types_js_namespaceObject.MIDSCENE_MODEL_TIMEOUT,
+    temperature: external_types_js_namespaceObject.MIDSCENE_MODEL_TEMPERATURE,
+    retryCount: external_types_js_namespaceObject.MIDSCENE_MODEL_RETRY_COUNT,
+    retryInterval: external_types_js_namespaceObject.MIDSCENE_MODEL_RETRY_INTERVAL,
+    reasoningEffort: external_types_js_namespaceObject.MIDSCENE_MODEL_REASONING_EFFORT,
+    reasoningEnabled: external_types_js_namespaceObject.MIDSCENE_MODEL_REASONING_ENABLED,
+    reasoningBudget: external_types_js_namespaceObject.MIDSCENE_MODEL_REASONING_BUDGET,
+    yht_domain: external_types_js_namespaceObject.YHT_DOMAIN,
+    yht_access_token: external_types_js_namespaceObject.YHT_ACCESS_TOKEN,
+    yht_model: external_types_js_namespaceObject.YHT_MODEL,
+    yht_base_url: external_types_js_namespaceObject.YHT_BASE_URL,
+    yht_chat_type: external_types_js_namespaceObject.YHT_CHAT_TYPE,
+    yht_model_category: external_types_js_namespaceObject.YHT_MODEL_CATEGORY,
+    yht_stream: external_types_js_namespaceObject.YHT_STREAM,
+    yht_temperature: external_types_js_namespaceObject.YHT_TEMPERATURE,
+    yht_top_p: external_types_js_namespaceObject.YHT_TOP_P,
+    yht_trace_id: external_types_js_namespaceObject.YHT_TRACE_ID
+};
+const DEFAULT_MODEL_CONFIG_KEYS_LEGACY = {
+    modelName: external_types_js_namespaceObject.MIDSCENE_MODEL_NAME,
+    socksProxy: external_types_js_namespaceObject.MIDSCENE_OPENAI_SOCKS_PROXY,
+    httpProxy: external_types_js_namespaceObject.MIDSCENE_OPENAI_HTTP_PROXY,
+    openaiBaseURL: external_types_js_namespaceObject.OPENAI_BASE_URL,
+    openaiApiKey: external_types_js_namespaceObject.OPENAI_API_KEY,
+    openaiExtraConfig: external_types_js_namespaceObject.MIDSCENE_OPENAI_INIT_CONFIG_JSON,
+    extraBody: external_types_js_namespaceObject.MIDSCENE_MODEL_EXTRA_BODY_JSON,
+    modelFamily: 'DEFAULT_MODEL_CONFIG_KEYS has no modelFamily key',
+    timeout: external_types_js_namespaceObject.MIDSCENE_MODEL_TIMEOUT,
+    temperature: external_types_js_namespaceObject.MIDSCENE_MODEL_TEMPERATURE,
+    retryCount: external_types_js_namespaceObject.MIDSCENE_MODEL_RETRY_COUNT,
+    retryInterval: external_types_js_namespaceObject.MIDSCENE_MODEL_RETRY_INTERVAL,
+    reasoningEffort: external_types_js_namespaceObject.MIDSCENE_MODEL_REASONING_EFFORT,
+    reasoningEnabled: external_types_js_namespaceObject.MIDSCENE_MODEL_REASONING_ENABLED,
+    reasoningBudget: external_types_js_namespaceObject.MIDSCENE_MODEL_REASONING_BUDGET,
+    yht_domain: external_types_js_namespaceObject.YHT_DOMAIN,
+    yht_access_token: external_types_js_namespaceObject.YHT_ACCESS_TOKEN,
+    yht_model: external_types_js_namespaceObject.YHT_MODEL,
+    yht_base_url: external_types_js_namespaceObject.YHT_BASE_URL,
+    yht_chat_type: external_types_js_namespaceObject.YHT_CHAT_TYPE,
+    yht_model_category: external_types_js_namespaceObject.YHT_MODEL_CATEGORY,
+    yht_stream: external_types_js_namespaceObject.YHT_STREAM,
+    yht_temperature: external_types_js_namespaceObject.YHT_TEMPERATURE,
+    yht_top_p: external_types_js_namespaceObject.YHT_TOP_P,
+    yht_trace_id: external_types_js_namespaceObject.YHT_TRACE_ID
+};
+exports.DEFAULT_MODEL_CONFIG_KEYS = __webpack_exports__.DEFAULT_MODEL_CONFIG_KEYS;
+exports.DEFAULT_MODEL_CONFIG_KEYS_LEGACY = __webpack_exports__.DEFAULT_MODEL_CONFIG_KEYS_LEGACY;
+exports.INSIGHT_MODEL_CONFIG_KEYS = __webpack_exports__.INSIGHT_MODEL_CONFIG_KEYS;
+exports.PLANNING_MODEL_CONFIG_KEYS = __webpack_exports__.PLANNING_MODEL_CONFIG_KEYS;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_MODEL_CONFIG_KEYS",
+    "DEFAULT_MODEL_CONFIG_KEYS_LEGACY",
+    "INSIGHT_MODEL_CONFIG_KEYS",
+    "PLANNING_MODEL_CONFIG_KEYS"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,128 @@
+"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 ("u" > 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 (key === external_types_js_namespaceObject.MATCH_BY_POSITION) throw new Error('MATCH_BY_POSITION is discarded, use MIDSCENE_MODEL_FAMILY instead');
+        if (!external_types_js_namespaceObject.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 (!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();
+    }
+    getEnvConfigValueAsNumber(key) {
+        if (!external_types_js_namespaceObject.STRING_ENV_KEYS.includes(key) && !external_types_js_namespaceObject.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 (![
+                ...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 ? {
+            ...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 __rspack_i in __webpack_exports__)if (-1 === [
+    "GlobalConfigManager"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/env/helper.js

@@ -0,0 +1,80 @@
+"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 ("u" > 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__, {
+    maskConfig: ()=>maskConfig,
+    parseJson: ()=>parseJson
+});
+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
+        });
+    }
+};
+exports.maskConfig = __webpack_exports__.maskConfig;
+exports.parseJson = __webpack_exports__.parseJson;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "maskConfig",
+    "parseJson"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/env/index.js

@@ -0,0 +1,90 @@
+"use strict";
+var __webpack_modules__ = {
+    "./global-config-manager" (module) {
+        module.exports = require("./global-config-manager.js");
+    },
+    "./model-config-manager" (module) {
+        module.exports = require("./model-config-manager.js");
+    },
+    "./types" (module) {
+        module.exports = require("./types.js");
+    },
+    "./utils" (module) {
+        module.exports = require("./utils.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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 ("u" > 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: ()=>_global_config_manager__rspack_import_3.GlobalConfigManager,
+        ModelConfigManager: ()=>_model_config_manager__rspack_import_2.ModelConfigManager
+    });
+    var _utils__rspack_import_0 = __webpack_require__("./utils");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _utils__rspack_import_0)if ([
+        "ModelConfigManager",
+        "GlobalConfigManager",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_utils__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _types__rspack_import_1 = __webpack_require__("./types");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _types__rspack_import_1)if ([
+        "ModelConfigManager",
+        "GlobalConfigManager",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _model_config_manager__rspack_import_2 = __webpack_require__("./model-config-manager");
+    var _global_config_manager__rspack_import_3 = __webpack_require__("./global-config-manager");
+})();
+exports.GlobalConfigManager = __webpack_exports__.GlobalConfigManager;
+exports.ModelConfigManager = __webpack_exports__.ModelConfigManager;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "GlobalConfigManager",
+    "ModelConfigManager"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/env/init-debug.js

@@ -0,0 +1,52 @@
+"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 ("u" > 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
+});
+const external_logger_js_namespaceObject = require("../logger.js");
+const external_basic_js_namespaceObject = require("./basic.js");
+const external_types_js_namespaceObject = require("./types.js");
+const initDebugConfig = ()=>{
+    const shouldPrintTiming = (0, external_basic_js_namespaceObject.getBasicEnvValue)(external_types_js_namespaceObject.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 = (0, external_basic_js_namespaceObject.getBasicEnvValue)(external_types_js_namespaceObject.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) (0, external_logger_js_namespaceObject.enableDebug)(debugConfig);
+};
+exports.initDebugConfig = __webpack_exports__.initDebugConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "initDebugConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,113 @@
+"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 ("u" > 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_parse_model_config_js_namespaceObject = require("./parse-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;
+}
+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 = (0, external_parse_model_config_js_namespaceObject.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 = (0, external_parse_model_config_js_namespaceObject.decideModelConfigFromIntentConfig)('insight', configMap);
+        const planningConfig = (0, external_parse_model_config_js_namespaceObject.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;
+    }
+}
+exports.ModelConfigManager = __webpack_exports__.ModelConfigManager;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ModelConfigManager"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});