@rpascene/shared 0.30.8

package/dist/lib/env/helper.js

@@ -0,0 +1,85 @@
+"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__, {
+    maskConfig: ()=>maskConfig,
+    createAssert: ()=>createAssert,
+    parseJson: ()=>parseJson
+});
+require("../utils.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])=>{
+        if ([
+            'openaiApiKey',
+            'azureOpenaiKey',
+            'anthropicApiKey'
+        ].includes(key)) return [
+            key,
+            maskKey(value)
+        ];
+        if ([
+            'openaiExtraConfig',
+            'azureExtraConfig'
+        ].includes(key)) return [
+            key,
+            maskKey(JSON.stringify(value))
+        ];
+        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
+        });
+    }
+};
+const createAssert = (modelNameKey, provider, modelName)=>(value, key, modelVendorFlag)=>{};
+exports.createAssert = __webpack_exports__.createAssert;
+exports.maskConfig = __webpack_exports__.maskConfig;
+exports.parseJson = __webpack_exports__.parseJson;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createAssert",
+    "maskConfig",
+    "parseJson"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/env/index.js

@@ -0,0 +1,94 @@
+"use strict";
+var __webpack_modules__ = {
+    "./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");
+    },
+    "./utils": function(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 ('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: ()=>_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",
+        "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__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _types__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./types");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _types__WEBPACK_IMPORTED_MODULE_1__)if ([
+        "default",
+        "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 _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.GlobalConfigManager = __webpack_exports__.GlobalConfigManager;
+exports.ModelConfigManager = __webpack_exports__.ModelConfigManager;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "GlobalConfigManager",
+    "ModelConfigManager"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_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 ('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
+});
+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.RPASCENE_DEBUG_AI_PROFILE);
+    let debugConfig = '';
+    if (shouldPrintTiming) {
+        console.warn('RPASCENE_DEBUG_AI_PROFILE is deprecated, use DEBUG=rpascene:ai:profile instead');
+        debugConfig = 'ai:profile';
+    }
+    const shouldPrintAIResponse = (0, external_basic_js_namespaceObject.getBasicEnvValue)(external_types_js_namespaceObject.RPASCENE_DEBUG_AI_RESPONSE);
+    if (shouldPrintAIResponse) {
+        console.warn('RPASCENE_DEBUG_AI_RESPONSE is deprecated, use DEBUG=rpascene:ai:response instead');
+        debugConfig = debugConfig ? 'ai:*' : 'ai:call';
+    }
+    if (debugConfig) (0, external_logger_js_namespaceObject.enableDebug)(debugConfig);
+};
+exports.initDebugConfig = __webpack_exports__.initDebugConfig;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "initDebugConfig"
+].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,133 @@
+"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;
+    }
+    throwErrorIfNonVLModel(intent = 'grounding') {
+        const modelConfig = this.getModelConfig(intent);
+        if (!modelConfig.vlMode) throw new Error('No visual language model (VL model) detected for the current scenario. Element localization may be inaccurate. Please verify your model configuration. Learn more: https://rpascenejs.com/choose-a-model');
+    }
+    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

@@ -0,0 +1,106 @@
+"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__, {
+    parseVlModeAndUiTarsFromGlobalConfig: ()=>parseVlModeAndUiTarsFromGlobalConfig,
+    parseVlModeAndUiTarsModelVersionFromRawValue: ()=>parseVlModeAndUiTarsModelVersionFromRawValue
+});
+const external_types_js_namespaceObject = require("./types.js");
+const parseVlModeAndUiTarsModelVersionFromRawValue = (vlModeRaw)=>{
+    if (!vlModeRaw) return {
+        vlMode: void 0,
+        uiTarsVersion: void 0
+    };
+    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: 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: external_types_js_namespaceObject.UITarsModelVersion.DOUBAO_1_5_20B
+    };
+    return {
+        vlMode: raw,
+        uiTarsVersion: void 0
+    };
+};
+const parseVlModeAndUiTarsFromGlobalConfig = (provider)=>{
+    const isDoubao = provider[external_types_js_namespaceObject.RPASCENE_USE_DOUBAO_VISION];
+    const isQwen = provider[external_types_js_namespaceObject.RPASCENE_USE_QWEN_VL];
+    const isQwen3 = provider[external_types_js_namespaceObject.RPASCENE_USE_QWEN3_VL];
+    const isUiTars = provider[external_types_js_namespaceObject.RPASCENE_USE_VLM_UI_TARS];
+    const isGemini = provider[external_types_js_namespaceObject.RPASCENE_USE_GEMINI];
+    const enabledModes = [
+        isDoubao && external_types_js_namespaceObject.RPASCENE_USE_DOUBAO_VISION,
+        isQwen && external_types_js_namespaceObject.RPASCENE_USE_QWEN_VL,
+        isQwen3 && external_types_js_namespaceObject.RPASCENE_USE_QWEN3_VL,
+        isUiTars && external_types_js_namespaceObject.RPASCENE_USE_VLM_UI_TARS,
+        isGemini && external_types_js_namespaceObject.RPASCENE_USE_GEMINI
+    ].filter(Boolean);
+    if (enabledModes.length > 1) throw new Error(`Only one vision mode can be enabled at a time. Currently enabled modes: ${enabledModes.join(', ')}. Please disable all but one mode.`);
+    if (isQwen3) return {
+        vlMode: 'qwen3-vl',
+        uiTarsVersion: void 0
+    };
+    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: external_types_js_namespaceObject.UITarsModelVersion.V1_0
+    };
+    else if ('DOUBAO' === isUiTars || 'DOUBAO-1.5' === isUiTars) return {
+        vlMode: 'vlm-ui-tars',
+        uiTarsVersion: external_types_js_namespaceObject.UITarsModelVersion.DOUBAO_1_5_20B
+    };
+    else return {
+        vlMode: 'vlm-ui-tars',
+        uiTarsVersion: `${isUiTars}`
+    };
+    return {
+        vlMode: void 0,
+        uiTarsVersion: void 0
+    };
+};
+exports.parseVlModeAndUiTarsFromGlobalConfig = __webpack_exports__.parseVlModeAndUiTarsFromGlobalConfig;
+exports.parseVlModeAndUiTarsModelVersionFromRawValue = __webpack_exports__.parseVlModeAndUiTarsModelVersionFromRawValue;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "parseVlModeAndUiTarsFromGlobalConfig",
+    "parseVlModeAndUiTarsModelVersionFromRawValue"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});