@midscene/core 0.30.10 → 1.0.0

package/dist/es/ai-model/service-caller/index.mjs

@@ -1,282 +1,207 @@
-import { AIResponseFormat } from "../../types.mjs";
-import { Anthropic } from "@anthropic-ai/sdk";
-import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
-import { MIDSCENE_API_TYPE, MIDSCENE_LANGSMITH_DEBUG, OPENAI_MAX_TOKENS, globalConfigManager } from "@midscene/shared/env";
-import { parseBase64 } from "@midscene/shared/img";
+import { MIDSCENE_LANGFUSE_DEBUG, MIDSCENE_LANGSMITH_DEBUG, MIDSCENE_MODEL_MAX_TOKENS, OPENAI_MAX_TOKENS, globalConfigManager } from "@midscene/shared/env";
 import { getDebug } from "@midscene/shared/logger";
 import { assert, ifInBrowser } from "@midscene/shared/utils";
-import { HttpsProxyAgent } from "https-proxy-agent";
 import { jsonrepair } from "jsonrepair";
-import openai_0, { AzureOpenAI } from "openai";
-import { SocksProxyAgent } from "socks-proxy-agent";
-import { AIActionType } from "../common.mjs";
-import { assertSchema } from "../prompt/assertion.mjs";
-import { locatorSchema } from "../prompt/llm-locator.mjs";
-import { planSchema } from "../prompt/llm-planning.mjs";
+import openai_0 from "openai";
 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;
+    const { socksProxy, httpProxy, modelName, openaiBaseURL, openaiApiKey, openaiExtraConfig, modelDescription, uiTarsModelVersion: uiTarsVersion, vlMode, createOpenAIClient, timeout } = modelConfig;
     let proxyAgent;
     const debugProxy = getDebug('ai:call:proxy');
+    const sanitizeProxyUrl = (url)=>{
+        try {
+            const parsed = new URL(url);
+            if (parsed.username) {
+                parsed.password = '****';
+                return parsed.href;
+            }
+            return url;
+        } catch  {
+            return url;
+        }
+    };
     if (httpProxy) {
-        debugProxy('using http proxy', httpProxy);
-        proxyAgent = new HttpsProxyAgent(httpProxy);
+        debugProxy('using http proxy', sanitizeProxyUrl(httpProxy));
+        if (ifInBrowser) console.warn('HTTP proxy is configured but not supported in browser environment');
+        else {
+            const moduleName = 'undici';
+            const { ProxyAgent } = await import(moduleName);
+            proxyAgent = new ProxyAgent({
+                uri: httpProxy
+            });
+        }
     } else if (socksProxy) {
-        debugProxy('using socks proxy', socksProxy);
-        proxyAgent = new SocksProxyAgent(socksProxy);
-    }
-    if (openaiUseAzureDeprecated) openai = new AzureOpenAI({
-        baseURL: openaiBaseURL,
-        apiKey: openaiApiKey,
-        httpAgent: proxyAgent,
-        ...openaiExtraConfig,
-        dangerouslyAllowBrowser: true
-    });
-    else if (useAzureOpenai) {
-        let tokenProvider;
-        if (azureOpenaiScope) {
-            assert(!ifInBrowser, 'Azure OpenAI is not supported in browser with Midscene.');
-            const credential = new DefaultAzureCredential();
-            tokenProvider = getBearerTokenProvider(credential, azureOpenaiScope);
-            openai = new AzureOpenAI({
-                azureADTokenProvider: tokenProvider,
-                endpoint: azureOpenaiEndpoint,
-                apiVersion: azureOpenaiApiVersion,
-                deployment: azureOpenaiDeployment,
-                ...openaiExtraConfig,
-                ...azureExtraConfig
+        debugProxy('using socks proxy', sanitizeProxyUrl(socksProxy));
+        if (ifInBrowser) console.warn('SOCKS proxy is configured but not supported in browser environment');
+        else try {
+            const moduleName = 'fetch-socks';
+            const { socksDispatcher } = await import(moduleName);
+            const proxyUrl = new URL(socksProxy);
+            if (!proxyUrl.hostname) throw new Error('SOCKS proxy URL must include a valid hostname');
+            const port = Number.parseInt(proxyUrl.port, 10);
+            if (!proxyUrl.port || Number.isNaN(port)) throw new Error('SOCKS proxy URL must include a valid port');
+            const protocol = proxyUrl.protocol.replace(':', '');
+            const socksType = 'socks4' === protocol ? 4 : 'socks5' === protocol ? 5 : 5;
+            proxyAgent = socksDispatcher({
+                type: socksType,
+                host: proxyUrl.hostname,
+                port,
+                ...proxyUrl.username ? {
+                    userId: decodeURIComponent(proxyUrl.username),
+                    password: decodeURIComponent(proxyUrl.password || '')
+                } : {}
             });
-        } else openai = new AzureOpenAI({
-            apiKey: azureOpenaiKey,
-            endpoint: azureOpenaiEndpoint,
-            apiVersion: azureOpenaiApiVersion,
-            deployment: azureOpenaiDeployment,
-            dangerouslyAllowBrowser: true,
-            ...openaiExtraConfig,
-            ...azureExtraConfig
-        });
-    } else if (!useAnthropicSdk) openai = new openai_0({
+            debugProxy('socks proxy configured successfully', {
+                type: socksType,
+                host: proxyUrl.hostname,
+                port: port
+            });
+        } catch (error) {
+            console.error('Failed to configure SOCKS proxy:', error);
+            throw new Error(`Invalid SOCKS proxy URL: ${socksProxy}. Expected format: socks4://host:port, socks5://host:port, or with authentication: socks5://user:pass@host:port`);
+        }
+    }
+    const openAIOptions = {
         baseURL: openaiBaseURL,
         apiKey: openaiApiKey,
-        httpAgent: proxyAgent,
+        ...proxyAgent ? {
+            fetchOptions: {
+                dispatcher: proxyAgent
+            }
+        } : {},
         ...openaiExtraConfig,
-        defaultHeaders: {
-            ...(null == openaiExtraConfig ? void 0 : openaiExtraConfig.defaultHeaders) || {},
-            [MIDSCENE_API_TYPE]: AIActionTypeValue.toString()
-        },
+        ...'number' == typeof timeout ? {
+            timeout
+        } : {},
         dangerouslyAllowBrowser: true
-    });
+    };
+    const baseOpenAI = new openai_0(openAIOptions);
+    let openai = baseOpenAI;
     if (openai && globalConfigManager.getEnvConfigInBoolean(MIDSCENE_LANGSMITH_DEBUG)) {
         if (ifInBrowser) throw new Error('langsmith is not supported in browser');
         console.log('DEBUGGING MODE: langsmith wrapper enabled');
-        const { wrapOpenAI } = await import("langsmith/wrappers");
+        const langsmithModule = 'langsmith/wrappers';
+        const { wrapOpenAI } = await import(langsmithModule);
         openai = wrapOpenAI(openai);
     }
-    if (void 0 !== openai) return {
+    if (openai && globalConfigManager.getEnvConfigInBoolean(MIDSCENE_LANGFUSE_DEBUG)) {
+        if (ifInBrowser) throw new Error('langfuse is not supported in browser');
+        console.log('DEBUGGING MODE: langfuse wrapper enabled');
+        const langfuseModule = 'langfuse';
+        const { observeOpenAI } = await import(langfuseModule);
+        openai = observeOpenAI(openai);
+    }
+    if (createOpenAIClient) {
+        const wrappedClient = await createOpenAIClient(baseOpenAI, openAIOptions);
+        if (wrappedClient) openai = wrappedClient;
+    }
+    return {
         completion: openai.chat.completions,
-        style: 'openai',
-        modelName,
-        modelDescription,
-        uiTarsVersion,
-        vlMode
-    };
-    if (useAnthropicSdk) openai = new 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 callAI(messages, AIActionTypeValue, modelConfig, options) {
-    const { completion, style, modelName, modelDescription, uiTarsVersion, vlMode } = await createChatClient({
+    const { completion, modelName, modelDescription, uiTarsVersion, vlMode } = await createChatClient({
         AIActionTypeValue,
         modelConfig
     });
-    const responseFormat = getResponseFormat(modelName, AIActionTypeValue);
-    const maxTokens = globalConfigManager.getEnvConfigValue(OPENAI_MAX_TOKENS);
+    const maxTokens = globalConfigManager.getEnvConfigValue(MIDSCENE_MODEL_MAX_TOKENS) ?? globalConfigManager.getEnvConfigValue(OPENAI_MAX_TOKENS);
     const debugCall = getDebug('ai:call');
     const debugProfileStats = getDebug('ai:profile:stats');
     const debugProfileDetail = getDebug('ai:profile:detail');
     const startTime = Date.now();
-    const isStreaming = (null == options ? void 0 : options.stream) && (null == options ? void 0 : options.onChunk);
+    const isStreaming = options?.stream && options?.onChunk;
     let content;
     let accumulated = '';
     let usage;
     let timeCost;
+    const buildUsageInfo = (usageData)=>{
+        if (!usageData) return;
+        const cachedInputTokens = usageData?.prompt_tokens_details?.cached_tokens;
+        return {
+            prompt_tokens: usageData.prompt_tokens ?? 0,
+            completion_tokens: usageData.completion_tokens ?? 0,
+            total_tokens: usageData.total_tokens ?? 0,
+            cached_input: cachedInputTokens ?? 0,
+            time_cost: timeCost ?? 0,
+            model_name: modelName,
+            model_description: modelDescription,
+            intent: modelConfig.intent
+        };
+    };
     const commonConfig = {
-        temperature: 'vlm-ui-tars' === vlMode ? 0.0 : 0.1,
+        temperature: 'vlm-ui-tars' === vlMode ? 0.0 : void 0,
         stream: !!isStreaming,
-        max_tokens: 'number' == typeof maxTokens ? maxTokens : Number.parseInt(maxTokens || '2048', 10),
-        ...'qwen-vl' === vlMode || 'qwen3-vl' === vlMode ? {
+        max_tokens: 'number' == typeof maxTokens ? maxTokens : void 0,
+        ...'qwen2.5-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)}`);
-                assert(result.choices, `invalid response from LLM service: ${JSON.stringify(result)}`);
-                content = result.choices[0].message.content;
-                usage = result.usage;
-            }
-            debugCall(`response: ${content}`);
-            assert(content, 'empty content');
-        } else if ('anthropic' === style) {
-            const convertImageContent = (content)=>{
-                if ('image_url' === content.type) {
-                    const imgBase64 = content.image_url.url;
-                    assert(imgBase64, 'image_url is required');
-                    const { mimeType, body } = parseBase64(content.image_url.url);
-                    return {
-                        source: {
-                            type: 'base64',
-                            media_type: mimeType,
-                            data: body
-                        },
-                        type: 'image'
+        debugCall(`sending ${isStreaming ? 'streaming ' : ''}request to ${modelName}`);
+        if (isStreaming) {
+            const stream = await completion.create({
+                model: modelName,
+                messages,
+                ...commonConfig
+            }, {
+                stream: true
+            });
+            for await (const chunk of stream){
+                const content = chunk.choices?.[0]?.delta?.content || '';
+                const reasoning_content = chunk.choices?.[0]?.delta?.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);
                 }
-                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
+                if (chunk.choices?.[0]?.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
                         };
-                        options.onChunk(finalChunk);
-                        break;
                     }
+                    const finalChunk = {
+                        content: '',
+                        accumulated,
+                        reasoning_content: '',
+                        isComplete: true,
+                        usage: buildUsageInfo(usage)
+                    };
+                    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;
             }
-            assert(content, 'empty content');
+            content = accumulated;
+            debugProfileStats(`streaming model, ${modelName}, mode, ${vlMode || 'default'}, cost-ms, ${timeCost}`);
+        } else {
+            const result = await completion.create({
+                model: modelName,
+                messages,
+                ...commonConfig
+            });
+            timeCost = Date.now() - startTime;
+            debugProfileStats(`model, ${modelName}, mode, ${vlMode || 'default'}, ui-tars-version, ${uiTarsVersion}, prompt-tokens, ${result.usage?.prompt_tokens || ''}, completion-tokens, ${result.usage?.completion_tokens || ''}, total-tokens, ${result.usage?.total_tokens || ''}, cost-ms, ${timeCost}, requestId, ${result._request_id || ''}`);
+            debugProfileDetail(`model usage detail: ${JSON.stringify(result.usage)}`);
+            assert(result.choices, `invalid response from LLM service: ${JSON.stringify(result)}`);
+            content = result.choices[0].message.content;
+            usage = result.usage;
         }
+        debugCall(`response: ${content}`);
+        assert(content, 'empty content');
         if (isStreaming && !usage) {
             const estimatedTokens = Math.max(1, Math.floor((content || '').length / 4));
             usage = {
@@ -287,52 +212,17 @@ async function callAI(messages, AIActionTypeValue, modelConfig, options) {
         }
         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,
+            usage: buildUsageInfo(usage),
             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://midscenejs.com/model-provider.html`, {
+        const newError = new Error(`failed to call ${isStreaming ? 'streaming ' : ''}AI model service (${modelName}): ${e.message}. Trouble shooting: https://midscenejs.com/model-provider.html`, {
             cause: e
         });
         throw newError;
     }
 }
-const getResponseFormat = (modelName, AIActionTypeValue)=>{
-    let responseFormat;
-    if (modelName.includes('gpt-4')) switch(AIActionTypeValue){
-        case AIActionType.ASSERT:
-            responseFormat = assertSchema;
-            break;
-        case AIActionType.INSPECT_ELEMENT:
-            responseFormat = locatorSchema;
-            break;
-        case AIActionType.PLAN:
-            responseFormat = planSchema;
-            break;
-        case AIActionType.EXTRACT_DATA:
-        case AIActionType.DESCRIBE_ELEMENT:
-            responseFormat = {
-                type: AIResponseFormat.JSON
-            };
-            break;
-        case AIActionType.TEXT:
-            responseFormat = void 0;
-            break;
-    }
-    if ('gpt-4o-2024-05-13' === modelName && AIActionTypeValue !== AIActionType.TEXT) responseFormat = {
-        type: AIResponseFormat.JSON
-    };
-    return responseFormat;
-};
 async function callAIWithObjectResponse(messages, AIActionTypeValue, modelConfig) {
     const response = await callAI(messages, AIActionTypeValue, modelConfig);
     assert(response, 'empty response');
@@ -340,6 +230,7 @@ async function callAIWithObjectResponse(messages, AIActionTypeValue, modelConfig
     const jsonContent = safeParseJson(response.content, vlMode);
     return {
         content: jsonContent,
+        contentString: response.content,
         usage: response.usage
     };
 }
@@ -365,24 +256,41 @@ 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 normalizeJsonObject(obj) {
+    if (null == obj) return obj;
+    if (Array.isArray(obj)) return obj.map((item)=>normalizeJsonObject(item));
+    if ('object' == typeof obj) {
+        const normalized = {};
+        for (const [key, value] of Object.entries(obj)){
+            const trimmedKey = key.trim();
+            let normalizedValue = normalizeJsonObject(value);
+            if ('string' == typeof normalizedValue) normalizedValue = normalizedValue.trim();
+            normalized[trimmedKey] = normalizedValue;
+        }
+        return normalized;
+    }
+    if ('string' == typeof obj) return obj.trim();
+    return obj;
+}
 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);
-    }
+    if (cleanJsonString?.match(/\((\d+),(\d+)\)/)) return cleanJsonString.match(/\((\d+),(\d+)\)/)?.slice(1).map(Number);
+    let parsed;
     try {
-        return JSON.parse(cleanJsonString);
+        parsed = JSON.parse(cleanJsonString);
+        return normalizeJsonObject(parsed);
     } catch  {}
     try {
-        return JSON.parse(jsonrepair(cleanJsonString));
+        parsed = JSON.parse(jsonrepair(cleanJsonString));
+        return normalizeJsonObject(parsed);
     } catch (e) {}
     if ('doubao-vision' === vlMode || 'vlm-ui-tars' === vlMode) {
         const jsonString = preprocessDoubaoBboxJson(cleanJsonString);
-        return JSON.parse(jsonrepair(jsonString));
+        parsed = JSON.parse(jsonrepair(jsonString));
+        return normalizeJsonObject(parsed);
     }
     throw Error(`failed to parse json response: ${input}`);
 }
-export { callAI, callAIWithObjectResponse, callAIWithStringResponse, extractJSONFromCodeBlock, getResponseFormat, preprocessDoubaoBboxJson, safeParseJson };
+export { callAI, callAIWithObjectResponse, callAIWithStringResponse, extractJSONFromCodeBlock, preprocessDoubaoBboxJson, safeParseJson };
 
 //# sourceMappingURL=index.mjs.map