@rpascene/shared 0.30.8

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

@@ -0,0 +1,172 @@
+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 { getDebug } from "../logger.mjs";
+import { assert } from "../utils.mjs";
+import { createAssert, maskConfig, parseJson } from "./helper.mjs";
+import { initDebugConfig } from "./init-debug.mjs";
+import { parseVlModeAndUiTarsFromGlobalConfig, parseVlModeAndUiTarsModelVersionFromRawValue } from "./parse.mjs";
+const KEYS_MAP = {
+    VQA: VQA_MODEL_CONFIG_KEYS,
+    grounding: GROUNDING_MODEL_CONFIG_KEYS,
+    planning: PLANNING_MODEL_CONFIG_KEYS,
+    default: DEFAULT_MODEL_CONFIG_KEYS
+};
+const decideOpenaiSdkConfig = ({ keys, provider, valueAssert })=>{
+    initDebugConfig();
+    const debugLog = getDebug('ai:config');
+    const socksProxy = provider[keys.socksProxy];
+    const httpProxy = provider[keys.httpProxy];
+    const vlMode = provider[keys.vlMode];
+    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];
+        const openaiApiKey = provider[keys.openaiApiKey];
+        const openaiExtraConfig = parseJson(keys.openaiExtraConfig, provider[keys.openaiExtraConfig]);
+        valueAssert(openaiApiKey, keys.openaiApiKey, keys.openaiUseAzureDeprecated);
+        return {
+            socksProxy,
+            httpProxy,
+            vlModeRaw: vlMode,
+            openaiUseAzureDeprecated: true,
+            openaiApiKey,
+            openaiBaseURL,
+            openaiExtraConfig
+        };
+    }
+    if (provider[keys.useAzureOpenai]) {
+        debugLog(`provider has ${keys.useAzureOpenai} with value ${provider[keys.useAzureOpenai]}`);
+        const azureOpenaiScope = provider[keys.azureOpenaiScope];
+        const azureOpenaiKey = provider[keys.azureOpenaiKey];
+        const azureOpenaiEndpoint = provider[keys.azureOpenaiEndpoint];
+        const azureOpenaiDeployment = provider[keys.azureOpenaiDeployment];
+        const azureOpenaiApiVersion = provider[keys.azureOpenaiApiVersion];
+        const azureExtraConfig = parseJson(keys.azureExtraConfig, provider[keys.azureExtraConfig]);
+        const openaiExtraConfig = parseJson(keys.openaiExtraConfig, provider[keys.openaiExtraConfig]);
+        valueAssert(azureOpenaiKey, keys.azureOpenaiKey, keys.useAzureOpenai);
+        return {
+            socksProxy,
+            httpProxy,
+            vlModeRaw: vlMode,
+            useAzureOpenai: true,
+            azureOpenaiScope,
+            azureOpenaiKey,
+            azureOpenaiEndpoint,
+            azureOpenaiDeployment,
+            azureOpenaiApiVersion,
+            azureExtraConfig,
+            openaiExtraConfig
+        };
+    }
+    if (provider[keys.useAnthropicSdk]) {
+        debugLog(`provider has ${keys.useAnthropicSdk} with value ${provider[keys.useAnthropicSdk]}`);
+        const anthropicApiKey = provider[keys.anthropicApiKey];
+        valueAssert(anthropicApiKey, keys.anthropicApiKey, keys.useAnthropicSdk);
+        return {
+            socksProxy,
+            httpProxy,
+            useAnthropicSdk: true,
+            anthropicApiKey
+        };
+    }
+    {
+        debugLog('provider has no specific model SDK declared');
+        const openaiBaseURL = provider[keys.openaiBaseURL];
+        const openaiApiKey = provider[keys.openaiApiKey];
+        const openaiExtraConfig = parseJson(keys.openaiExtraConfig, provider[keys.openaiExtraConfig]);
+        valueAssert(openaiApiKey, keys.openaiApiKey);
+        return {
+            socksProxy,
+            httpProxy,
+            vlModeRaw: vlMode,
+            openaiBaseURL,
+            openaiApiKey,
+            openaiExtraConfig
+        };
+    }
+};
+const getModelDescription = (vlMode, uiTarsVersion)=>{
+    if (vlMode) if (uiTarsVersion) return `UI-TARS=${uiTarsVersion}`;
+    else return `${vlMode} mode`;
+    return '';
+};
+const decideModelConfigFromIntentConfig = (intent, intentConfig)=>{
+    const debugLog = getDebug('ai:config');
+    debugLog('decideModelConfig base on agent.modelConfig()');
+    const keysForFn = KEYS_MAP[intent];
+    const candidateModelNameFromConfig = intentConfig[keysForFn.modelName];
+    debugLog('Got modelName from modelConfigFn', candidateModelNameFromConfig);
+    const chosenKeys = (()=>{
+        if (candidateModelNameFromConfig) {
+            debugLog('query modelConfig from fn by intent got corresponding modelName, will get other corresponding keys');
+            return keysForFn;
+        }
+        debugLog('query modelConfig from fn by intent got no corresponding modelName, will get other keys by default');
+        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 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 = {
+        ...result,
+        modelName: intentConfig[chosenKeys.modelName],
+        vlMode,
+        uiTarsModelVersion: uiTarsVersion,
+        modelDescription,
+        from: 'modelConfig',
+        intent
+    };
+    debugLog(`decideModelConfig result by agent.modelConfig() with intent ${intent}:`, maskConfig(finalResult));
+    return finalResult;
+};
+const decideModelConfigFromEnv = (intent, allEnvConfig)=>{
+    initDebugConfig();
+    const debugLog = getDebug('ai:config');
+    const keysForEnv = 'default' === intent ? DEFAULT_MODEL_CONFIG_KEYS_LEGACY : KEYS_MAP[intent];
+    if ('default' !== intent && allEnvConfig[keysForEnv.modelName]) {
+        const modelName = allEnvConfig[keysForEnv.modelName];
+        debugLog(`Got intent ${intent} corresponding modelName ${modelName} by key ${keysForEnv.modelName} from globalConfig, will get other config by intent.`);
+        const result = decideOpenaiSdkConfig({
+            keys: keysForEnv,
+            provider: allEnvConfig,
+            valueAssert: createAssert(keysForEnv.modelName, 'process.env', modelName)
+        });
+        const { vlMode, uiTarsVersion } = parseVlModeAndUiTarsModelVersionFromRawValue(result.vlModeRaw);
+        const modelDescription = getModelDescription(vlMode, uiTarsVersion);
+        const finalResult = {
+            ...result,
+            modelName,
+            vlMode,
+            uiTarsModelVersion: uiTarsVersion,
+            modelDescription,
+            from: 'env',
+            intent
+        };
+        debugLog(`decideModelConfig result by process.env with intent ${intent}:`, maskConfig(finalResult));
+        return finalResult;
+    }
+    debugLog(`decideModelConfig as legacy logic with intent ${intent}.`);
+    const result = decideOpenaiSdkConfig({
+        keys: DEFAULT_MODEL_CONFIG_KEYS_LEGACY,
+        provider: allEnvConfig,
+        valueAssert: createAssert(DEFAULT_MODEL_CONFIG_KEYS_LEGACY.modelName, 'process.env')
+    });
+    const { vlMode, uiTarsVersion } = parseVlModeAndUiTarsFromGlobalConfig(allEnvConfig);
+    const modelDescription = getModelDescription(vlMode, uiTarsVersion);
+    const finalResult = {
+        ...result,
+        modelName: allEnvConfig[DEFAULT_MODEL_CONFIG_KEYS_LEGACY.modelName] || 'gpt-4o',
+        vlMode,
+        uiTarsModelVersion: uiTarsVersion,
+        modelDescription,
+        from: 'legacy-env',
+        intent
+    };
+    debugLog(`decideModelConfig result by legacy logic with intent ${intent}:`, maskConfig(finalResult));
+    return finalResult;
+};
+export { decideModelConfigFromEnv, decideModelConfigFromIntentConfig, decideOpenaiSdkConfig };

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

@@ -0,0 +1,82 @@
+import { initDebugConfig } from "./init-debug.mjs";
+import { ALL_ENV_KEYS, BOOLEAN_ENV_KEYS, MATCH_BY_POSITION, NUMBER_ENV_KEYS, STRING_ENV_KEYS } from "./types.mjs";
+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 = 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 (!STRING_ENV_KEYS.includes(key)) throw new Error(`getEnvConfigValue with key ${key} is not supported.`);
+        if (key === MATCH_BY_POSITION) throw new Error('MATCH_BY_POSITION is deprecated, use RPASCENE_USE_VL_MODEL instead');
+        const value = allConfig[key];
+        this.keysHaveBeenRead[key] = true;
+        if ('string' == typeof value) return value.trim();
+        return value;
+    }
+    getEnvConfigInNumber(key) {
+        const allConfig = this.getAllEnvConfig();
+        if (!NUMBER_ENV_KEYS.includes(key)) throw new Error(`getEnvConfigInNumber with key ${key} is not supported`);
+        const value = allConfig[key];
+        this.keysHaveBeenRead[key] = true;
+        return Number(value || '');
+    }
+    getEnvConfigInBoolean(key) {
+        const allConfig = this.getAllEnvConfig();
+        if (!BOOLEAN_ENV_KEYS.includes(key)) throw new Error(`getEnvConfigInBoolean with key ${key} is not supported`);
+        const value = allConfig[key];
+        this.keysHaveBeenRead[key] = true;
+        if (!value) return false;
+        if (/^(true|1)$/i.test(value)) return true;
+        if (/^(false|0)$/i.test(value)) return false;
+        return !!value.trim();
+    }
+    registerModelConfigManager(globalModelConfigManager) {
+        this.globalModelConfigManager = globalModelConfigManager;
+    }
+    overrideAIConfig(newConfig, extendMode = false) {
+        var _this_override;
+        const savedNewConfig = extendMode ? {
+            ...null == (_this_override = this.override) ? void 0 : _this_override.newConfig,
+            ...newConfig
+        } : newConfig;
+        this.override = {
+            newConfig: {
+                ...savedNewConfig
+            },
+            extendMode
+        };
+        if (!this.globalModelConfigManager) throw new Error('globalModelConfigManager is not registered, which should not happen');
+        this.globalModelConfigManager.clearModelConfigMap();
+    }
+    constructor(){
+        _define_property(this, "override", void 0);
+        _define_property(this, "keysHaveBeenRead", {});
+        _define_property(this, "globalModelConfigManager", void 0);
+        initDebugConfig();
+    }
+}
+export { GlobalConfigManager };

package/dist/es/env/helper.mjs

@@ -0,0 +1,45 @@
+import "../utils.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])=>{
+        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)=>{};
+export { createAssert, maskConfig, parseJson };

package/dist/es/env/index.mjs

@@ -0,0 +1,5 @@
+import { ModelConfigManager } from "./model-config-manager.mjs";
+import { GlobalConfigManager } from "./global-config-manager.mjs";
+export * from "./utils.mjs";
+export * from "./types.mjs";
+export { GlobalConfigManager, ModelConfigManager };

package/dist/es/env/init-debug.mjs

@@ -0,0 +1,18 @@
+import { enableDebug } from "../logger.mjs";
+import { getBasicEnvValue } from "./basic.mjs";
+import { RPASCENE_DEBUG_AI_PROFILE, RPASCENE_DEBUG_AI_RESPONSE } from "./types.mjs";
+const initDebugConfig = ()=>{
+    const shouldPrintTiming = getBasicEnvValue(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 = getBasicEnvValue(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) enableDebug(debugConfig);
+};
+export { initDebugConfig };

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

@@ -0,0 +1,99 @@
+import { decideModelConfigFromEnv, decideModelConfigFromIntentConfig } from "./decide-model-config.mjs";
+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 = 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 = 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);
+        }
+    }
+}
+export { ModelConfigManager };

package/dist/es/env/parse.mjs

@@ -0,0 +1,69 @@
+import { RPASCENE_USE_DOUBAO_VISION, RPASCENE_USE_GEMINI, RPASCENE_USE_QWEN3_VL, RPASCENE_USE_QWEN_VL, RPASCENE_USE_VLM_UI_TARS, UITarsModelVersion, VL_MODE_RAW_VALID_VALUES } from "./types.mjs";
+const parseVlModeAndUiTarsModelVersionFromRawValue = (vlModeRaw)=>{
+    if (!vlModeRaw) return {
+        vlMode: void 0,
+        uiTarsVersion: void 0
+    };
+    if (!VL_MODE_RAW_VALID_VALUES.includes(vlModeRaw)) throw new Error(`the value ${vlModeRaw} is not a valid VL_MODE value, must be one of ${VL_MODE_RAW_VALID_VALUES}`);
+    const raw = vlModeRaw;
+    if ('vlm-ui-tars' === raw) return {
+        vlMode: 'vlm-ui-tars',
+        uiTarsVersion: UITarsModelVersion.V1_0
+    };
+    if ('vlm-ui-tars-doubao' === raw || 'vlm-ui-tars-doubao-1.5' === raw) return {
+        vlMode: 'vlm-ui-tars',
+        uiTarsVersion: UITarsModelVersion.DOUBAO_1_5_20B
+    };
+    return {
+        vlMode: raw,
+        uiTarsVersion: void 0
+    };
+};
+const parseVlModeAndUiTarsFromGlobalConfig = (provider)=>{
+    const isDoubao = provider[RPASCENE_USE_DOUBAO_VISION];
+    const isQwen = provider[RPASCENE_USE_QWEN_VL];
+    const isQwen3 = provider[RPASCENE_USE_QWEN3_VL];
+    const isUiTars = provider[RPASCENE_USE_VLM_UI_TARS];
+    const isGemini = provider[RPASCENE_USE_GEMINI];
+    const enabledModes = [
+        isDoubao && RPASCENE_USE_DOUBAO_VISION,
+        isQwen && RPASCENE_USE_QWEN_VL,
+        isQwen3 && RPASCENE_USE_QWEN3_VL,
+        isUiTars && RPASCENE_USE_VLM_UI_TARS,
+        isGemini && 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: UITarsModelVersion.V1_0
+    };
+    else if ('DOUBAO' === isUiTars || 'DOUBAO-1.5' === isUiTars) return {
+        vlMode: 'vlm-ui-tars',
+        uiTarsVersion: UITarsModelVersion.DOUBAO_1_5_20B
+    };
+    else return {
+        vlMode: 'vlm-ui-tars',
+        uiTarsVersion: `${isUiTars}`
+    };
+    return {
+        vlMode: void 0,
+        uiTarsVersion: void 0
+    };
+};
+export { parseVlModeAndUiTarsFromGlobalConfig, parseVlModeAndUiTarsModelVersionFromRawValue };