@rpascene/core 0.30.8

package/dist/lib/ai-model/service-caller/index.js

@@ -0,0 +1,623 @@
+"use strict";
+var __webpack_modules__ = {
+    "langsmith/wrappers": function(module) {
+        module.exports = import("langsmith/wrappers").then(function(module) {
+            return module;
+        });
+    }
+};
+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__, {
+        preprocessDoubaoBboxJson: ()=>preprocessDoubaoBboxJson,
+        callAIWithObjectResponse: ()=>callAIWithObjectResponse,
+        getResponseFormat: ()=>getResponseFormat,
+        safeParseJson: ()=>safeParseJson,
+        callAI: ()=>callAI,
+        extractJSONFromCodeBlock: ()=>extractJSONFromCodeBlock,
+        callAIWithStringResponse: ()=>callAIWithStringResponse,
+        defaultYhtConfig: ()=>defaultYhtConfig,
+        callAIOld: ()=>callAIOld
+    });
+    const external_types_js_namespaceObject = require("../../types.js");
+    const sdk_namespaceObject = require("@anthropic-ai/sdk");
+    const identity_namespaceObject = require("@azure/identity");
+    const env_namespaceObject = require("@rpascene/shared/env");
+    const img_namespaceObject = require("@rpascene/shared/img");
+    const logger_namespaceObject = require("@rpascene/shared/logger");
+    const utils_namespaceObject = require("@rpascene/shared/utils");
+    const external_https_proxy_agent_namespaceObject = require("https-proxy-agent");
+    const external_jsonrepair_namespaceObject = require("jsonrepair");
+    const external_openai_namespaceObject = require("openai");
+    var external_openai_default = /*#__PURE__*/ __webpack_require__.n(external_openai_namespaceObject);
+    const external_socks_proxy_agent_namespaceObject = require("socks-proxy-agent");
+    const external_common_js_namespaceObject = require("../common.js");
+    const assertion_js_namespaceObject = require("../prompt/assertion.js");
+    const llm_locator_js_namespaceObject = require("../prompt/llm-locator.js");
+    const llm_planning_js_namespaceObject = require("../prompt/llm-planning.js");
+    const defaultYhtConfig = {
+        domain: 'APILink',
+        yht_access_token: '',
+        chatType: 14,
+        model: 'doubao-seed-1-6-vision-250815',
+        modelCategory: 2,
+        stream: 0,
+        temperature: 0.95,
+        top_p: 0.7,
+        baseURL: 'https://c2.yonyoucloud.com/iuap-aip-service/report/rest/api/aiService/chat'
+    };
+    async function createChatClient({ AIActionTypeValue, modelConfig }) {
+        const { socksProxy, httpProxy, modelName, openaiBaseURL, openaiApiKey, openaiExtraConfig, openaiUseAzureDeprecated, useAzureOpenai, azureOpenaiScope, azureOpenaiKey, azureOpenaiEndpoint, azureOpenaiApiVersion, azureOpenaiDeployment, azureExtraConfig, useAnthropicSdk, anthropicApiKey, modelDescription, uiTarsModelVersion: uiTarsVersion, vlMode } = modelConfig;
+        let openai;
+        let proxyAgent;
+        const debugProxy = (0, logger_namespaceObject.getDebug)('ai:call:proxy');
+        if (httpProxy) {
+            debugProxy('using http proxy', httpProxy);
+            proxyAgent = new external_https_proxy_agent_namespaceObject.HttpsProxyAgent(httpProxy);
+        } else if (socksProxy) {
+            debugProxy('using socks proxy', socksProxy);
+            proxyAgent = new external_socks_proxy_agent_namespaceObject.SocksProxyAgent(socksProxy);
+        }
+        if (openaiUseAzureDeprecated) openai = new external_openai_namespaceObject.AzureOpenAI({
+            baseURL: openaiBaseURL,
+            apiKey: openaiApiKey,
+            httpAgent: proxyAgent,
+            ...openaiExtraConfig,
+            dangerouslyAllowBrowser: true
+        });
+        else if (useAzureOpenai) {
+            let tokenProvider;
+            if (azureOpenaiScope) {
+                (0, utils_namespaceObject.assert)(!utils_namespaceObject.ifInBrowser, 'Azure OpenAI is not supported in browser with Rpascene.');
+                const credential = new identity_namespaceObject.DefaultAzureCredential();
+                tokenProvider = (0, identity_namespaceObject.getBearerTokenProvider)(credential, azureOpenaiScope);
+                openai = new external_openai_namespaceObject.AzureOpenAI({
+                    azureADTokenProvider: tokenProvider,
+                    endpoint: azureOpenaiEndpoint,
+                    apiVersion: azureOpenaiApiVersion,
+                    deployment: azureOpenaiDeployment,
+                    ...openaiExtraConfig,
+                    ...azureExtraConfig
+                });
+            } else openai = new external_openai_namespaceObject.AzureOpenAI({
+                apiKey: azureOpenaiKey,
+                endpoint: azureOpenaiEndpoint,
+                apiVersion: azureOpenaiApiVersion,
+                deployment: azureOpenaiDeployment,
+                dangerouslyAllowBrowser: true,
+                ...openaiExtraConfig,
+                ...azureExtraConfig
+            });
+        } else if (!useAnthropicSdk) openai = new (external_openai_default())({
+            baseURL: openaiBaseURL,
+            apiKey: openaiApiKey,
+            httpAgent: proxyAgent,
+            ...openaiExtraConfig,
+            defaultHeaders: {
+                ...(null == openaiExtraConfig ? void 0 : openaiExtraConfig.defaultHeaders) || {},
+                [env_namespaceObject.RPASCENE_API_TYPE]: AIActionTypeValue.toString()
+            },
+            dangerouslyAllowBrowser: true
+        });
+        if (openai && env_namespaceObject.globalConfigManager.getEnvConfigInBoolean(env_namespaceObject.RPASCENE_LANGSMITH_DEBUG)) {
+            if (utils_namespaceObject.ifInBrowser) throw new Error('langsmith is not supported in browser');
+            console.log('DEBUGGING MODE: langsmith wrapper enabled');
+            const { wrapOpenAI } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "langsmith/wrappers"));
+            openai = wrapOpenAI(openai);
+        }
+        if (void 0 !== openai) return {
+            completion: openai.chat.completions,
+            style: 'openai',
+            modelName,
+            modelDescription,
+            uiTarsVersion,
+            vlMode
+        };
+        if (useAnthropicSdk) openai = new sdk_namespaceObject.Anthropic({
+            apiKey: anthropicApiKey,
+            httpAgent: proxyAgent,
+            dangerouslyAllowBrowser: true
+        });
+        if (void 0 !== openai && openai.messages) return {
+            completion: openai.messages,
+            style: 'anthropic',
+            modelName,
+            modelDescription,
+            uiTarsVersion,
+            vlMode
+        };
+        throw new Error('Openai SDK or Anthropic SDK is not initialized');
+    }
+    async function callAIOld(messages, AIActionTypeValue, modelConfig, options) {
+        const { completion, style, modelName, modelDescription, uiTarsVersion, vlMode } = await createChatClient({
+            AIActionTypeValue,
+            modelConfig
+        });
+        const responseFormat = getResponseFormat(modelName, AIActionTypeValue);
+        const maxTokens = env_namespaceObject.globalConfigManager.getEnvConfigValue(env_namespaceObject.OPENAI_MAX_TOKENS);
+        const debugCall = (0, logger_namespaceObject.getDebug)('ai:call');
+        const debugProfileStats = (0, logger_namespaceObject.getDebug)('ai:profile:stats');
+        const debugProfileDetail = (0, logger_namespaceObject.getDebug)('ai:profile:detail');
+        const startTime = Date.now();
+        const isStreaming = (null == options ? void 0 : options.stream) && (null == options ? void 0 : options.onChunk);
+        let content;
+        let accumulated = '';
+        let usage;
+        let timeCost;
+        const commonConfig = {
+            temperature: 'vlm-ui-tars' === vlMode ? 0.0 : 0.1,
+            stream: !!isStreaming,
+            max_tokens: 'number' == typeof maxTokens ? maxTokens : Number.parseInt(maxTokens || '2048', 10),
+            ...'qwen-vl' === vlMode || 'qwen3-vl' === vlMode ? {
+                vl_high_resolution_images: true
+            } : {}
+        };
+        try {
+            if ('openai' === style) {
+                debugCall(`sending ${isStreaming ? 'streaming ' : ''}request to ${modelName}`);
+                if (isStreaming) {
+                    const stream = await completion.create({
+                        model: modelName,
+                        messages,
+                        response_format: responseFormat,
+                        ...commonConfig
+                    }, {
+                        stream: true
+                    });
+                    for await (const chunk of stream){
+                        var _chunk_choices__delta, _chunk_choices_, _chunk_choices, _chunk_choices__delta1, _chunk_choices_1, _chunk_choices1, _chunk_choices_2, _chunk_choices2;
+                        const content = (null == (_chunk_choices = chunk.choices) ? void 0 : null == (_chunk_choices_ = _chunk_choices[0]) ? void 0 : null == (_chunk_choices__delta = _chunk_choices_.delta) ? void 0 : _chunk_choices__delta.content) || '';
+                        const reasoning_content = (null == (_chunk_choices1 = chunk.choices) ? void 0 : null == (_chunk_choices_1 = _chunk_choices1[0]) ? void 0 : null == (_chunk_choices__delta1 = _chunk_choices_1.delta) ? void 0 : _chunk_choices__delta1.reasoning_content) || '';
+                        if (chunk.usage) usage = chunk.usage;
+                        if (content || reasoning_content) {
+                            accumulated += content;
+                            const chunkData = {
+                                content,
+                                reasoning_content,
+                                accumulated,
+                                isComplete: false,
+                                usage: void 0
+                            };
+                            options.onChunk(chunkData);
+                        }
+                        if (null == (_chunk_choices2 = chunk.choices) ? void 0 : null == (_chunk_choices_2 = _chunk_choices2[0]) ? void 0 : _chunk_choices_2.finish_reason) {
+                            timeCost = Date.now() - startTime;
+                            if (!usage) {
+                                const estimatedTokens = Math.max(1, Math.floor(accumulated.length / 4));
+                                usage = {
+                                    prompt_tokens: estimatedTokens,
+                                    completion_tokens: estimatedTokens,
+                                    total_tokens: 2 * estimatedTokens
+                                };
+                            }
+                            const finalChunk = {
+                                content: '',
+                                accumulated,
+                                reasoning_content: '',
+                                isComplete: true,
+                                usage: {
+                                    prompt_tokens: usage.prompt_tokens ?? 0,
+                                    completion_tokens: usage.completion_tokens ?? 0,
+                                    total_tokens: usage.total_tokens ?? 0,
+                                    time_cost: timeCost ?? 0,
+                                    model_name: modelName,
+                                    model_description: modelDescription,
+                                    intent: modelConfig.intent
+                                }
+                            };
+                            options.onChunk(finalChunk);
+                            break;
+                        }
+                    }
+                    content = accumulated;
+                    debugProfileStats(`streaming model, ${modelName}, mode, ${vlMode || 'default'}, cost-ms, ${timeCost}`);
+                } else {
+                    var _result_usage, _result_usage1, _result_usage2;
+                    const result = await completion.create({
+                        model: modelName,
+                        messages,
+                        response_format: responseFormat,
+                        ...commonConfig
+                    });
+                    timeCost = Date.now() - startTime;
+                    debugProfileStats(`model, ${modelName}, mode, ${vlMode || 'default'}, ui-tars-version, ${uiTarsVersion}, prompt-tokens, ${(null == (_result_usage = result.usage) ? void 0 : _result_usage.prompt_tokens) || ''}, completion-tokens, ${(null == (_result_usage1 = result.usage) ? void 0 : _result_usage1.completion_tokens) || ''}, total-tokens, ${(null == (_result_usage2 = result.usage) ? void 0 : _result_usage2.total_tokens) || ''}, cost-ms, ${timeCost}, requestId, ${result._request_id || ''}`);
+                    debugProfileDetail(`model usage detail: ${JSON.stringify(result.usage)}`);
+                    (0, utils_namespaceObject.assert)(result.choices, `invalid response from LLM service: ${JSON.stringify(result)}`);
+                    content = result.choices[0].message.content;
+                    usage = result.usage;
+                }
+                debugCall(`response: ${content}`);
+                (0, utils_namespaceObject.assert)(content, 'empty content');
+            } else if ('anthropic' === style) {
+                const convertImageContent = (content)=>{
+                    if ('image_url' === content.type) {
+                        const imgBase64 = content.image_url.url;
+                        (0, utils_namespaceObject.assert)(imgBase64, 'image_url is required');
+                        const { mimeType, body } = (0, img_namespaceObject.parseBase64)(content.image_url.url);
+                        return {
+                            source: {
+                                type: 'base64',
+                                media_type: mimeType,
+                                data: body
+                            },
+                            type: 'image'
+                        };
+                    }
+                    return content;
+                };
+                if (isStreaming) {
+                    const stream = await completion.create({
+                        model: modelName,
+                        system: 'You are a versatile professional in software UI automation',
+                        messages: messages.map((m)=>({
+                                role: 'user',
+                                content: Array.isArray(m.content) ? m.content.map(convertImageContent) : m.content
+                            })),
+                        response_format: responseFormat,
+                        ...commonConfig
+                    });
+                    for await (const chunk of stream){
+                        var _chunk_delta;
+                        const content = (null == (_chunk_delta = chunk.delta) ? void 0 : _chunk_delta.text) || '';
+                        if (content) {
+                            accumulated += content;
+                            const chunkData = {
+                                content,
+                                accumulated,
+                                reasoning_content: '',
+                                isComplete: false,
+                                usage: void 0
+                            };
+                            options.onChunk(chunkData);
+                        }
+                        if ('message_stop' === chunk.type) {
+                            timeCost = Date.now() - startTime;
+                            const anthropicUsage = chunk.usage;
+                            const finalChunk = {
+                                content: '',
+                                accumulated,
+                                reasoning_content: '',
+                                isComplete: true,
+                                usage: anthropicUsage ? {
+                                    prompt_tokens: anthropicUsage.input_tokens ?? 0,
+                                    completion_tokens: anthropicUsage.output_tokens ?? 0,
+                                    total_tokens: (anthropicUsage.input_tokens ?? 0) + (anthropicUsage.output_tokens ?? 0),
+                                    time_cost: timeCost ?? 0,
+                                    model_name: modelName,
+                                    model_description: modelDescription,
+                                    intent: modelConfig.intent
+                                } : void 0
+                            };
+                            options.onChunk(finalChunk);
+                            break;
+                        }
+                    }
+                    content = accumulated;
+                } else {
+                    const result = await completion.create({
+                        model: modelName,
+                        system: 'You are a versatile professional in software UI automation',
+                        messages: messages.map((m)=>({
+                                role: 'user',
+                                content: Array.isArray(m.content) ? m.content.map(convertImageContent) : m.content
+                            })),
+                        response_format: responseFormat,
+                        ...commonConfig
+                    });
+                    timeCost = Date.now() - startTime;
+                    content = result.content[0].text;
+                    usage = result.usage;
+                }
+                (0, utils_namespaceObject.assert)(content, 'empty content');
+            }
+            if (isStreaming && !usage) {
+                const estimatedTokens = Math.max(1, Math.floor((content || '').length / 4));
+                usage = {
+                    prompt_tokens: estimatedTokens,
+                    completion_tokens: estimatedTokens,
+                    total_tokens: 2 * estimatedTokens
+                };
+            }
+            return {
+                content: content || '',
+                usage: usage ? {
+                    prompt_tokens: usage.prompt_tokens ?? 0,
+                    completion_tokens: usage.completion_tokens ?? 0,
+                    total_tokens: usage.total_tokens ?? 0,
+                    time_cost: timeCost ?? 0,
+                    model_name: modelName,
+                    model_description: modelDescription,
+                    intent: modelConfig.intent
+                } : void 0,
+                isStreamed: !!isStreaming
+            };
+        } catch (e) {
+            console.error(' call AI error', e);
+            const newError = new Error(`failed to call ${isStreaming ? 'streaming ' : ''}AI model service: ${e.message}. Trouble shooting: https://rpascenejs.com/model-provider.html`, {
+                cause: e
+            });
+            throw newError;
+        }
+    }
+    const getResponseFormat = (modelName, AIActionTypeValue)=>{
+        let responseFormat;
+        if (modelName.includes('gpt-4')) switch(AIActionTypeValue){
+            case external_common_js_namespaceObject.AIActionType.ASSERT:
+                responseFormat = assertion_js_namespaceObject.assertSchema;
+                break;
+            case external_common_js_namespaceObject.AIActionType.INSPECT_ELEMENT:
+                responseFormat = llm_locator_js_namespaceObject.locatorSchema;
+                break;
+            case external_common_js_namespaceObject.AIActionType.PLAN:
+                responseFormat = llm_planning_js_namespaceObject.planSchema;
+                break;
+            case external_common_js_namespaceObject.AIActionType.EXTRACT_DATA:
+            case external_common_js_namespaceObject.AIActionType.DESCRIBE_ELEMENT:
+                responseFormat = {
+                    type: external_types_js_namespaceObject.AIResponseFormat.JSON
+                };
+                break;
+            case external_common_js_namespaceObject.AIActionType.TEXT:
+                responseFormat = void 0;
+                break;
+        }
+        if ('gpt-4o-2024-05-13' === modelName && AIActionTypeValue !== external_common_js_namespaceObject.AIActionType.TEXT) responseFormat = {
+            type: external_types_js_namespaceObject.AIResponseFormat.JSON
+        };
+        return responseFormat;
+    };
+    async function callAIWithObjectResponse(messages, AIActionTypeValue, modelConfig) {
+        const response = await callAI(messages, AIActionTypeValue, modelConfig);
+        (0, utils_namespaceObject.assert)(response, 'empty response');
+        const vlMode = modelConfig.vlMode;
+        const jsonContent = safeParseJson(response.content, vlMode);
+        return {
+            content: jsonContent,
+            usage: response.usage
+        };
+    }
+    async function callAIWithStringResponse(msgs, AIActionTypeValue, modelConfig) {
+        const { content, usage } = await callAI(msgs, AIActionTypeValue, modelConfig);
+        return {
+            content,
+            usage
+        };
+    }
+    function extractJSONFromCodeBlock(response) {
+        try {
+            const jsonMatch = response.match(/^\s*(\{[\s\S]*\})\s*$/);
+            if (jsonMatch) return jsonMatch[1];
+            const codeBlockMatch = response.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
+            if (codeBlockMatch) return codeBlockMatch[1];
+            const jsonLikeMatch = response.match(/\{[\s\S]*\}/);
+            if (jsonLikeMatch) return jsonLikeMatch[0];
+        } catch  {}
+        return response;
+    }
+    function preprocessDoubaoBboxJson(input) {
+        if (input.includes('bbox')) while(/\d+\s+\d+/.test(input))input = input.replace(/(\d+)\s+(\d+)/g, '$1,$2');
+        return input;
+    }
+    function safeParseJson(input, vlMode) {
+        const cleanJsonString = extractJSONFromCodeBlock(input);
+        if (null == cleanJsonString ? void 0 : cleanJsonString.match(/\((\d+),(\d+)\)/)) {
+            var _cleanJsonString_match;
+            return null == (_cleanJsonString_match = cleanJsonString.match(/\((\d+),(\d+)\)/)) ? void 0 : _cleanJsonString_match.slice(1).map(Number);
+        }
+        try {
+            return JSON.parse(cleanJsonString);
+        } catch  {}
+        try {
+            return JSON.parse((0, external_jsonrepair_namespaceObject.jsonrepair)(cleanJsonString));
+        } catch (e) {}
+        if ('doubao-vision' === vlMode || 'vlm-ui-tars' === vlMode) {
+            const jsonString = preprocessDoubaoBboxJson(cleanJsonString);
+            return JSON.parse((0, external_jsonrepair_namespaceObject.jsonrepair)(jsonString));
+        }
+        throw Error(`failed to parse json response: ${input}`);
+    }
+    async function callAI(messages, AIActionTypeValue, modelConfig, options) {
+        const allEnvConfig = env_namespaceObject.globalConfigManager.getAllEnvConfig();
+        const YhtConfig = allEnvConfig || defaultYhtConfig;
+        const debugCall = (0, logger_namespaceObject.getDebug)('ai:call:yht');
+        const debugProfileStats = (0, logger_namespaceObject.getDebug)('ai:profile:stats:yht');
+        const debugProfileDetail = (0, logger_namespaceObject.getDebug)('ai:profile:detail:yht');
+        const startTime = Date.now();
+        const config = YhtConfig;
+        const isStreaming = (null == options ? void 0 : options.stream) && (null == options ? void 0 : options.onChunk);
+        try {
+            var _result_usage, _result_result, _result_usage1, _result_usage2, _result_usage3;
+            debugCall(`\u{51C6}\u{5907}\u{8C03}\u{7528}AI\u{670D}\u{52A1}\u{FF0C}\u{6A21}\u{578B}: ${config.model}, \u{52A8}\u{4F5C}\u{7C7B}\u{578B}: ${AIActionTypeValue}`);
+            const yhtMessages = convertToYhtMessageFormat(messages);
+            debugProfileDetail("\u8F6C\u6362\u540E\u7684\u6D88\u606F\u683C\u5F0F:", JSON.stringify(yhtMessages));
+            const requestBody = {
+                domain: config.domain,
+                messages: yhtMessages,
+                chatType: config.chatType,
+                model: config.model,
+                modelCategory: config.modelCategory,
+                stream: isStreaming ? 1 : config.stream,
+                temperature: config.temperature,
+                top_p: config.top_p,
+                extraParams: config.extraParams,
+                topic: config.topic
+            };
+            debugCall("\u53D1\u9001\u8BF7\u6C42\u5230AI\u670D\u52A1");
+            const response = await fetch(config.baseURL || defaultYhtConfig.baseURL, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    yht_access_token: config.yht_access_token
+                },
+                body: JSON.stringify(requestBody)
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                debugCall(`\u{7528}\u{53CB}AI\u{670D}\u{52A1}\u{8FD4}\u{56DE}\u{9519}\u{8BEF}: ${response.status} ${errorText}`);
+                throw new Error(`\u{7528}\u{53CB}AI\u{670D}\u{52A1}\u{8FD4}\u{56DE}\u{9519}\u{8BEF}: ${response.status} ${errorText}`);
+            }
+            const responseText = await response.text();
+            debugProfileDetail("\u7528\u53CBAI\u670D\u52A1\u539F\u59CB\u54CD\u5E94:", responseText);
+            let result;
+            try {
+                result = JSON.parse(responseText);
+            } catch (parseError) {
+                debugCall("JSON\u89E3\u6790\u5931\u8D25\uFF0C\u5C1D\u8BD5\u68C0\u67E5\u662F\u5426\u4E3AXML\u683C\u5F0F");
+                const processedContent = extractContentFromResponse(responseText);
+                result = {
+                    result: {
+                        content: processedContent
+                    },
+                    usage: void 0
+                };
+            }
+            const timeCost = Date.now() - startTime;
+            debugProfileStats(`\u{7528}\u{53CB}\u{6A21}\u{578B}\u{8C03}\u{7528}\u{5B8C}\u{6210}\u{FF0C}\u{8017}\u{65F6}: ${timeCost}ms, token\u{4F7F}\u{7528}: ${(null == (_result_usage = result.usage) ? void 0 : _result_usage.total_tokens) || 'unknown'}`);
+            debugProfileDetail(`\u{7528}\u{53CB}\u{6A21}\u{578B}\u{4F7F}\u{7528}\u{8BE6}\u{60C5}: ${JSON.stringify(result.usage)}`);
+            let content = (null == (_result_result = result.result) ? void 0 : _result_result.content) || '';
+            content = extractContentFromResponse(content);
+            debugCall(`\u{7528}\u{53CB}AI\u{670D}\u{52A1}\u{54CD}\u{5E94}\u{5185}\u{5BB9}: ${content}`);
+            (0, utils_namespaceObject.assert)(content, "\u7528\u53CBAI\u670D\u52A1\u8FD4\u56DE\u7A7A\u5185\u5BB9");
+            const usage = {
+                prompt_tokens: (null == (_result_usage1 = result.usage) ? void 0 : _result_usage1.prompt_tokens) || 0,
+                completion_tokens: (null == (_result_usage2 = result.usage) ? void 0 : _result_usage2.completion_tokens) || 0,
+                total_tokens: (null == (_result_usage3 = result.usage) ? void 0 : _result_usage3.total_tokens) || 0,
+                time_cost: timeCost,
+                model_name: config.model || '',
+                model_description: "\u7528\u53CBAI\u670D\u52A1",
+                intent: modelConfig.intent
+            };
+            return {
+                content,
+                usage,
+                isStreamed: false
+            };
+        } catch (e) {
+            const errorMsg = e.message || "\u672A\u77E5\u9519\u8BEF";
+            debugCall(`\u{7528}\u{53CB}AI\u{8C03}\u{7528}\u{9519}\u{8BEF}: ${errorMsg}`);
+            console.error("\u7528\u53CBAI\u8C03\u7528\u9519\u8BEF:", e);
+            let enhancedErrorMsg = `\u{7528}\u{53CB}AI\u{670D}\u{52A1}\u{8C03}\u{7528}\u{5931}\u{8D25}: ${errorMsg}`;
+            if (errorMsg.includes('fetch')) enhancedErrorMsg += "\u3002\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u6216API\u5730\u5740\u662F\u5426\u6B63\u786E\u3002";
+            else if (errorMsg.includes('token')) enhancedErrorMsg += "\u3002\u8BF7\u68C0\u67E5\u7528\u53CB\u8BBF\u95EE\u4EE4\u724C\u662F\u5426\u6709\u6548\u3002";
+            const newError = new Error(enhancedErrorMsg, {
+                cause: e
+            });
+            throw newError;
+        }
+    }
+    function extractContentFromResponse(response) {
+        try {
+            if (response.includes('<json>') && response.includes('</json>')) {
+                const xmlMatch = response.match(/<json>([\s\S]*?)<\/json>/);
+                if (xmlMatch && xmlMatch[1]) return xmlMatch[1].trim();
+            }
+            return extractJSONFromCodeBlock(response);
+        } catch (error) {
+            console.warn("\u4ECE\u54CD\u5E94\u4E2D\u63D0\u53D6\u5185\u5BB9\u65F6\u51FA\u9519:", error);
+            return response;
+        }
+    }
+    function convertToYhtMessageFormat(messages) {
+        return messages.map((msg)=>{
+            const yhtMessage = {
+                role: 'system' === msg.role ? 'system' : 'user'
+            };
+            if ('string' == typeof msg.content) yhtMessage.vlContent = [
+                {
+                    type: 'text',
+                    text: msg.content
+                }
+            ];
+            else if (Array.isArray(msg.content)) {
+                const textParts = msg.content.filter((part)=>'text' === part.type);
+                const imageParts = msg.content.filter((part)=>'image_url' === part.type);
+                if (imageParts.length > 0) yhtMessage.vlContent = [
+                    {
+                        type: 'text',
+                        text: textParts.map((part)=>part.text).join(' ') || "\u8BF7\u5206\u6790\u56FE\u7247\u5185\u5BB9"
+                    },
+                    ...imageParts.map((part)=>({
+                            type: 'image_url',
+                            image_url: {
+                                url: part.image_url.url,
+                                detail: 'high'
+                            }
+                        }))
+                ];
+                else if (textParts.length > 0) yhtMessage.vlContent = [
+                    {
+                        type: 'text',
+                        text: textParts.map((part)=>part.text).join(' ')
+                    }
+                ];
+            }
+            return yhtMessage;
+        });
+    }
+})();
+exports.callAI = __webpack_exports__.callAI;
+exports.callAIOld = __webpack_exports__.callAIOld;
+exports.callAIWithObjectResponse = __webpack_exports__.callAIWithObjectResponse;
+exports.callAIWithStringResponse = __webpack_exports__.callAIWithStringResponse;
+exports.defaultYhtConfig = __webpack_exports__.defaultYhtConfig;
+exports.extractJSONFromCodeBlock = __webpack_exports__.extractJSONFromCodeBlock;
+exports.getResponseFormat = __webpack_exports__.getResponseFormat;
+exports.preprocessDoubaoBboxJson = __webpack_exports__.preprocessDoubaoBboxJson;
+exports.safeParseJson = __webpack_exports__.safeParseJson;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "callAI",
+    "callAIOld",
+    "callAIWithObjectResponse",
+    "callAIWithStringResponse",
+    "defaultYhtConfig",
+    "extractJSONFromCodeBlock",
+    "getResponseFormat",
+    "preprocessDoubaoBboxJson",
+    "safeParseJson"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+//# sourceMappingURL=index.js.map