@godscene/core 1.7.11

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

@@ -0,0 +1,648 @@
+import { MIDSCENE_LANGFUSE_DEBUG, MIDSCENE_LANGSMITH_DEBUG, MIDSCENE_MODEL_MAX_TOKENS, OPENAI_MAX_TOKENS, globalConfigManager } from "@godscene/shared/env";
+import { getDebug } from "@godscene/shared/logger";
+import { assert, ifInBrowser } from "@godscene/shared/utils";
+import { jsonrepair } from "jsonrepair";
+import openai_0 from "openai";
+import { isAutoGLM, isUITars } from "../auto-glm/util.mjs";
+import { callAIWithCodexAppServer, isCodexAppServerProvider } from "./codex-app-server.mjs";
+import { shouldForceOriginalImageDetail } from "./image-detail.mjs";
+import { buildRequestAbortSignal, isHardTimeoutError, resolveEffectiveTimeoutMs } from "./request-timeout.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 AIResponseParseError extends Error {
+    constructor(message, rawResponse, usage){
+        super(message), _define_property(this, "usage", void 0), _define_property(this, "rawResponse", void 0);
+        this.name = 'AIResponseParseError';
+        this.rawResponse = rawResponse;
+        this.usage = usage;
+    }
+}
+const defaultYhtConfig = {
+    domain: 'APILink',
+    yht_access_token: '',
+    chatType: 14,
+    model: 'doubao-seed-1-6-vision-250815',
+    modelCategory: 2,
+    stream: 0,
+    temperature: 0.01,
+    top_p: 0.7,
+    baseURL: 'https://c2.yonyoucloud.com/iuap-aip-service/report/rest/api/aiService/chat',
+    traceId: '',
+    extraParams: {},
+    topic: ''
+};
+async function createChatClient({ modelConfig }) {
+    const { socksProxy, httpProxy, modelName, openaiBaseURL, openaiApiKey, openaiExtraConfig, modelDescription, uiTarsModelVersion, modelFamily, createOpenAIClient, timeout } = modelConfig;
+    let proxyAgent;
+    const warnClient = getDebug('ai:call', {
+        console: true
+    });
+    const debugProxy = getDebug('ai:call:proxy');
+    const warnProxy = getDebug('ai:call:proxy', {
+        console: true
+    });
+    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', sanitizeProxyUrl(httpProxy));
+        if (ifInBrowser) warnProxy('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', sanitizeProxyUrl(socksProxy));
+        if (ifInBrowser) warnProxy('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 || '')
+                } : {}
+            });
+            debugProxy('socks proxy configured successfully', {
+                type: socksType,
+                host: proxyUrl.hostname,
+                port: port
+            });
+        } catch (error) {
+            warnProxy('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 effectiveTimeoutMs = resolveEffectiveTimeoutMs({
+        timeout
+    });
+    const openAIOptions = {
+        baseURL: openaiBaseURL,
+        apiKey: openaiApiKey,
+        ...proxyAgent ? {
+            fetchOptions: {
+                dispatcher: proxyAgent
+            }
+        } : {},
+        ...openaiExtraConfig,
+        maxRetries: 0,
+        ...null !== effectiveTimeoutMs ? {
+            timeout: effectiveTimeoutMs
+        } : {},
+        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');
+        warnClient('DEBUGGING MODE: langsmith wrapper enabled');
+        const langsmithModule = 'langsmith/wrappers';
+        const { wrapOpenAI } = await import(langsmithModule);
+        openai = wrapOpenAI(openai);
+    }
+    if (openai && globalConfigManager.getEnvConfigInBoolean(MIDSCENE_LANGFUSE_DEBUG)) {
+        if (ifInBrowser) throw new Error('langfuse is not supported in browser');
+        warnClient('DEBUGGING MODE: langfuse wrapper enabled');
+        const langfuseModule = '@langfuse/openai';
+        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,
+        modelName,
+        modelDescription,
+        uiTarsModelVersion,
+        modelFamily
+    };
+}
+async function yhtCallAI(messages, modelConfig, options) {
+    const yhtConfig = {
+        domain: modelConfig.yht_domain || defaultYhtConfig.domain,
+        yht_access_token: modelConfig.yht_access_token || defaultYhtConfig.yht_access_token,
+        model: modelConfig.yht_model || defaultYhtConfig.model,
+        baseURL: modelConfig.yht_base_url || defaultYhtConfig.baseURL,
+        chatType: Number(modelConfig.yht_chat_type || defaultYhtConfig.chatType),
+        modelCategory: Number(modelConfig.yht_model_category || defaultYhtConfig.modelCategory),
+        stream: Number(modelConfig.yht_stream || defaultYhtConfig.stream),
+        temperature: Number(modelConfig.yht_temperature || defaultYhtConfig.temperature),
+        top_p: Number(modelConfig.yht_top_p || defaultYhtConfig.top_p),
+        traceId: modelConfig.yht_trace_id || defaultYhtConfig.traceId,
+        topic: defaultYhtConfig.topic,
+        extraParams: defaultYhtConfig.extraParams
+    };
+    const convertToYhtMessageFormat = (messages)=>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(' ') || '请分析图片内容'
+                    },
+                    ...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;
+        });
+    const debugCall = getDebug('ai:call:yht');
+    const debugProfileStats = getDebug('ai:profile:stats:yht');
+    const debugProfileDetail = getDebug('ai:profile:detail:yht');
+    const startTime = Date.now();
+    try {
+        debugCall(`准备调用AI服务，模型: ${yhtConfig.model}`);
+        const yhtMessages = convertToYhtMessageFormat(messages);
+        debugProfileDetail('转换后的消息格式:', JSON.stringify(yhtMessages));
+        const requestBody = {
+            domain: yhtConfig.domain,
+            messages: yhtMessages,
+            chatType: yhtConfig.chatType,
+            model: yhtConfig.model,
+            modelCategory: yhtConfig.modelCategory,
+            stream: yhtConfig.stream,
+            temperature: yhtConfig.temperature,
+            top_p: yhtConfig.top_p,
+            extraParams: yhtConfig.extraParams,
+            topic: yhtConfig.topic
+        };
+        debugCall('发送请求到AI服务');
+        const controller = new AbortController();
+        const { signal } = controller;
+        options?.abortSignal?.addEventListener('abort', ()=>{
+            controller.abort();
+        }, {
+            once: true
+        });
+        const timeout = 120000;
+        let response;
+        const timeoutPromise = (timeout)=>new Promise((_, reject)=>{
+                setTimeout(()=>{
+                    reject(new Error(`Request timeout after ${timeout}ms`));
+                }, timeout);
+            });
+        try {
+            response = await Promise.race([
+                fetch(yhtConfig.baseURL, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        yht_access_token: yhtConfig.yht_access_token || '',
+                        traceId: yhtConfig.traceId
+                    },
+                    body: JSON.stringify(requestBody),
+                    signal
+                }),
+                timeoutPromise(timeout)
+            ]).finally(()=>{
+                setTimeout(()=>{
+                    controller.abort();
+                }, 2000);
+            });
+        } catch (error) {
+            if ('AbortError' === error.name) console.log('Error1:', 'Request was aborted due to timeout');
+            else console.log('Error2:', error.message);
+            throw error;
+        }
+        if (!response.ok) {
+            const errorText = await response.text();
+            debugCall(`用友AI服务返回错误: ${response.status} ${errorText}`);
+            throw new Error(`用友AI服务返回错误: ${response.status} ${errorText}`);
+        }
+        const responseText = await response.text();
+        const result = JSON.parse(responseText);
+        const timeCost = Date.now() - startTime;
+        debugProfileStats(`用友模型调用完成，耗时: ${timeCost}ms, token使用: ${result.usage?.total_tokens || 'unknown'}`);
+        debugProfileDetail(`用友模型使用详情: ${JSON.stringify(result.usage)}`);
+        const content = result.result?.content || '';
+        debugCall(`用友AI服务响应内容: ${content}`);
+        const usage = {
+            prompt_tokens: result.usage?.prompt_tokens || 0,
+            completion_tokens: result.usage?.completion_tokens || 0,
+            total_tokens: result.usage?.total_tokens || 0,
+            cached_input: 0,
+            time_cost: timeCost,
+            model_name: yhtConfig.model,
+            model_description: `${yhtConfig.model} mode`,
+            intent: 'default',
+            request_id: result._request_id
+        };
+        const callAI_new = {
+            content: result.result?.content || '',
+            reasoning_content: result.result?.reasoning_content || '',
+            usage,
+            isStreamed: false
+        };
+        return callAI_new;
+    } catch (e) {
+        if ('AbortError' === e.name) throw new Error('请求取消');
+        console.error('用友AI调用错误:', e);
+        throw e;
+    }
+}
+async function callAI(messages, modelConfig, options) {
+    if (modelConfig.yht_access_token) return await yhtCallAI(messages, modelConfig, options);
+    if (isCodexAppServerProvider(modelConfig.openaiBaseURL)) return callAIWithCodexAppServer(messages, modelConfig, options);
+    const { completion, modelName, modelDescription, uiTarsModelVersion, modelFamily } = await createChatClient({
+        modelConfig
+    });
+    const effectiveTimeoutMs = resolveEffectiveTimeoutMs(modelConfig);
+    const extraBody = modelConfig.extraBody;
+    const maxTokens = globalConfigManager.getEnvConfigValueAsNumber(MIDSCENE_MODEL_MAX_TOKENS) ?? globalConfigManager.getEnvConfigValueAsNumber(OPENAI_MAX_TOKENS);
+    const debugCall = getDebug('ai:call');
+    const warnCall = getDebug('ai:call', {
+        console: true
+    });
+    const debugProfileStats = getDebug('ai:profile:stats');
+    const debugProfileDetail = getDebug('ai:profile:detail');
+    const startTime = Date.now();
+    const temperature = (()=>{
+        if ('gpt-5' === modelFamily) return void debugCall('temperature is ignored for gpt-5');
+        return modelConfig.temperature ?? 0;
+    })();
+    const isStreaming = options?.stream && options?.onChunk;
+    let content;
+    let accumulated = '';
+    let accumulatedReasoning = '';
+    let usage;
+    let timeCost;
+    let requestId;
+    const hasUsableText = (value)=>'string' == typeof value && value.trim().length > 0;
+    const buildUsageInfo = (usageData, requestId)=>{
+        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,
+            request_id: requestId ?? void 0
+        };
+    };
+    const commonConfig = {
+        temperature,
+        stream: !!isStreaming,
+        max_tokens: maxTokens,
+        ...'qwen2.5-vl' === modelFamily ? {
+            vl_high_resolution_images: true
+        } : {}
+    };
+    if (isAutoGLM(modelFamily)) {
+        commonConfig.top_p = 0.85;
+        commonConfig.frequency_penalty = 0.2;
+    }
+    const mergedEnableReasoning = (()=>{
+        const normalizedDeepThink = options?.deepThink === 'unset' ? void 0 : options?.deepThink;
+        if (true === normalizedDeepThink) return true;
+        if (false === normalizedDeepThink) return false;
+        return modelConfig.reasoningEnabled;
+    })();
+    const { config: reasoningEffortConfig, debugMessage: reasoningEffortDebugMessage, warningMessage } = resolveReasoningConfig({
+        reasoningEnabled: mergedEnableReasoning,
+        reasoningEffort: modelConfig.reasoningEffort,
+        reasoningBudget: modelConfig.reasoningBudget,
+        modelFamily
+    });
+    if (reasoningEffortDebugMessage) debugCall(reasoningEffortDebugMessage);
+    if (warningMessage) warnCall(warningMessage);
+    const shouldUseOriginalImageDetail = shouldForceOriginalImageDetail(modelConfig);
+    const messagesWithImageDetail = (()=>{
+        if (!shouldUseOriginalImageDetail) return messages;
+        return messages.map((msg)=>{
+            if (!Array.isArray(msg.content)) return msg;
+            const content = msg.content.map((part)=>{
+                if (part && 'image_url' === part.type && part.image_url?.url) return {
+                    ...part,
+                    image_url: {
+                        ...part.image_url,
+                        detail: 'original'
+                    }
+                };
+                return part;
+            });
+            return {
+                ...msg,
+                content
+            };
+        });
+    })();
+    try {
+        debugCall(`sending ${isStreaming ? 'streaming ' : ''}request to ${modelName}`);
+        if (isStreaming) {
+            const { signal: streamSignal, cleanup: cleanupStreamSignal } = buildRequestAbortSignal(effectiveTimeoutMs, options?.abortSignal);
+            try {
+                const stream = await completion.create({
+                    model: modelName,
+                    messages: messagesWithImageDetail,
+                    ...commonConfig,
+                    ...reasoningEffortConfig,
+                    ...extraBody
+                }, {
+                    stream: true,
+                    signal: streamSignal
+                });
+                requestId = stream._request_id;
+                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;
+                        accumulatedReasoning += reasoning_content;
+                        const chunkData = {
+                            content,
+                            reasoning_content,
+                            accumulated,
+                            isComplete: false,
+                            usage: void 0
+                        };
+                        options.onChunk(chunkData);
+                    }
+                    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
+                            };
+                        }
+                        const finalChunk = {
+                            content: '',
+                            accumulated,
+                            reasoning_content: '',
+                            isComplete: true,
+                            usage: buildUsageInfo(usage, requestId)
+                        };
+                        options.onChunk(finalChunk);
+                        break;
+                    }
+                }
+            } finally{
+                cleanupStreamSignal();
+            }
+            content = accumulated;
+            debugProfileStats(`streaming model, ${modelName}, mode, ${modelFamily || 'default'}, cost-ms, ${timeCost}, temperature, ${temperature ?? ''}`);
+        } else {
+            const retryCount = modelConfig.retryCount ?? 1;
+            const retryInterval = modelConfig.retryInterval ?? 2000;
+            const maxAttempts = retryCount + 1;
+            let lastError;
+            for(let attempt = 1; attempt <= maxAttempts; attempt++){
+                const { signal: attemptSignal, cleanup: cleanupAttemptSignal } = buildRequestAbortSignal(effectiveTimeoutMs, options?.abortSignal);
+                try {
+                    const result = await completion.create({
+                        model: modelName,
+                        messages: messagesWithImageDetail,
+                        ...commonConfig,
+                        ...reasoningEffortConfig,
+                        ...extraBody
+                    }, {
+                        signal: attemptSignal
+                    });
+                    timeCost = Date.now() - startTime;
+                    debugProfileStats(`model, ${modelName}, mode, ${modelFamily || 'default'}, ui-tars-version, ${uiTarsModelVersion}, 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 || ''}, temperature, ${temperature ?? ''}`);
+                    debugProfileDetail(`model usage detail: ${JSON.stringify(result.usage)}`);
+                    if (!result.choices) throw new Error(`invalid response from LLM service: ${JSON.stringify(result)}`);
+                    content = result.choices[0].message.content;
+                    accumulatedReasoning = result.choices[0].message?.reasoning_content || '';
+                    usage = result.usage;
+                    requestId = result._request_id;
+                    if (!hasUsableText(content) && hasUsableText(accumulatedReasoning)) {
+                        warnCall('empty content from AI model, using reasoning content');
+                        content = accumulatedReasoning;
+                    }
+                    if (!hasUsableText(content)) throw new AIResponseParseError('empty content from AI model', JSON.stringify(result), buildUsageInfo(usage, requestId));
+                    break;
+                } catch (error) {
+                    lastError = error;
+                    const wasHardTimeout = isHardTimeoutError(lastError);
+                    if (wasHardTimeout) warnCall(`AI call hit hard timeout (${effectiveTimeoutMs}ms, attempt ${attempt}/${maxAttempts}, model ${modelName}, intent ${modelConfig.intent})`);
+                    if (options?.abortSignal?.aborted) break;
+                    if (attempt < maxAttempts) {
+                        warnCall(`AI call failed (attempt ${attempt}/${maxAttempts}), retrying in ${retryInterval}ms... Error: ${lastError.message}`);
+                        await new Promise((resolve)=>setTimeout(resolve, retryInterval));
+                    }
+                } finally{
+                    cleanupAttemptSignal();
+                }
+            }
+            if (!content) throw lastError;
+        }
+        debugCall(`response reasoning content: ${accumulatedReasoning}`);
+        debugCall(`response content: ${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 || '',
+            reasoning_content: accumulatedReasoning || void 0,
+            usage: buildUsageInfo(usage, requestId),
+            isStreamed: !!isStreaming
+        };
+    } catch (e) {
+        warnCall('call AI error', e);
+        if (e instanceof AIResponseParseError) throw e;
+        const newError = new Error(`failed to call ${isStreaming ? 'streaming ' : ''}AI model service (${modelName}): ${e.message}\nTrouble shooting: https://midscenejs.com/model-provider.html`, {
+            cause: e
+        });
+        throw newError;
+    }
+}
+async function callAIWithObjectResponse(messages, modelConfig, options) {
+    const response = await callAI(messages, modelConfig, {
+        deepThink: options?.deepThink,
+        abortSignal: options?.abortSignal
+    });
+    assert(response, 'empty response');
+    const modelFamily = modelConfig.modelFamily;
+    const jsonContent = safeParseJson(response.content, modelFamily);
+    if ('object' != typeof jsonContent) throw new AIResponseParseError(`failed to parse json response from model (${modelConfig.modelName}): ${response.content}`, response.content, response.usage);
+    return {
+        content: jsonContent,
+        contentString: response.content,
+        usage: response.usage,
+        reasoning_content: response.reasoning_content
+    };
+}
+async function callAIWithStringResponse(msgs, modelConfig, options) {
+    const { content, usage } = await callAI(msgs, modelConfig, {
+        abortSignal: options?.abortSignal
+    });
+    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 resolveReasoningConfig({ reasoningEnabled, reasoningEffort, reasoningBudget, modelFamily }) {
+    if (void 0 === reasoningEnabled && !reasoningEffort && void 0 === reasoningBudget) return {
+        config: {}
+    };
+    const debugMessages = [];
+    const config = {};
+    if ('qwen3-vl' === modelFamily || 'qwen3.5' === modelFamily || 'qwen3.6' === modelFamily) {
+        if (void 0 !== reasoningEnabled) {
+            config.enable_thinking = reasoningEnabled;
+            debugMessages.push(`enable_thinking=${reasoningEnabled}`);
+        }
+        if (void 0 !== reasoningBudget) {
+            config.thinking_budget = reasoningBudget;
+            debugMessages.push(`thinking_budget=${reasoningBudget}`);
+        }
+    } else if ('doubao-vision' === modelFamily || 'doubao-seed' === modelFamily) {
+        if (void 0 !== reasoningEnabled) {
+            config.thinking = {
+                type: reasoningEnabled ? 'enabled' : 'disabled'
+            };
+            debugMessages.push(`thinking.type=${reasoningEnabled ? 'enabled' : 'disabled'}`);
+        }
+        if (reasoningEffort) {
+            config.reasoning_effort = reasoningEffort;
+            debugMessages.push(`reasoning_effort="${reasoningEffort}"`);
+        }
+    } else if ('glm-v' === modelFamily) {
+        if (void 0 !== reasoningEnabled) {
+            config.thinking = {
+                type: reasoningEnabled ? 'enabled' : 'disabled'
+            };
+            debugMessages.push(`thinking.type=${reasoningEnabled ? 'enabled' : 'disabled'}`);
+        }
+    } else if ('gpt-5' === modelFamily) {
+        config.reasoning = void 0;
+        debugMessages.push('reasoning config is ignored for gpt-5');
+    } else if (!modelFamily) return {
+        config: {},
+        debugMessage: 'reasoning config ignored: no model_family configured',
+        warningMessage: 'Reasoning config is set but no model_family is configured. Set MIDSCENE_MODEL_FAMILY to enable reasoning config pass-through.'
+    };
+    else if (reasoningEffort) {
+        config.reasoning_effort = reasoningEffort;
+        debugMessages.push(`reasoning_effort="${reasoningEffort}"`);
+    }
+    return {
+        config,
+        debugMessage: debugMessages.length ? `reasoning config for ${modelFamily}: ${debugMessages.join(', ')}` : void 0
+    };
+}
+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, modelFamily) {
+    const cleanJsonString = extractJSONFromCodeBlock(input);
+    if (cleanJsonString?.match(/\((\d+),(\d+)\)/)) return cleanJsonString.match(/\((\d+),(\d+)\)/)?.slice(1).map(Number);
+    let parsed;
+    let lastError;
+    try {
+        parsed = JSON.parse(cleanJsonString);
+        return normalizeJsonObject(parsed);
+    } catch (error) {
+        lastError = error;
+    }
+    try {
+        parsed = JSON.parse(jsonrepair(cleanJsonString));
+        return normalizeJsonObject(parsed);
+    } catch (error) {
+        lastError = error;
+    }
+    if ('doubao-vision' === modelFamily || 'doubao-seed' === modelFamily || isUITars(modelFamily)) {
+        const jsonString = preprocessDoubaoBboxJson(cleanJsonString);
+        try {
+            parsed = JSON.parse(jsonrepair(jsonString));
+            return normalizeJsonObject(parsed);
+        } catch (error) {
+            lastError = error;
+        }
+    }
+    throw Error(`failed to parse LLM response into JSON. Error - ${String(lastError ?? 'unknown error')}. Response - \n ${input}`);
+}
+export { AIResponseParseError, callAI, callAIWithObjectResponse, callAIWithStringResponse, extractJSONFromCodeBlock, preprocessDoubaoBboxJson, resolveReasoningConfig, safeParseJson, yhtCallAI };