@jsonstudio/llms 0.4.2

package/dist/conversion/responses/responses-openai-bridge.js

@@ -0,0 +1,1330 @@
+import { normalizeFunctionCallId, normalizeFunctionCallOutputId } from '../shared/responses-id-utils.js';
+import { ensureResponsesInstructions } from '../shared/responses-instructions.js';
+// --- Utilities (ported strictly) ---
+import { canonicalizeChatResponseTools } from '../shared/tool-canonicalizer.js';
+function isObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+// tryParseJson now shared in ../shared/jsonish.ts
+// splitCommandString now unified in ../shared/tooling.ts
+// parseLenient now shared in ../shared/jsonish.ts
+function defaultObjectSchema() { return { type: 'object', properties: {}, additionalProperties: true }; }
+// normalizeTools unified in ../shared/args-mapping.ts
+// --- Structured self-repair helpers for tool failures (Responses path) ---
+// use shared isImagePath
+// NOTE: 自修复提示已移除（统一标准：不做模糊兜底）。
+function getExpectedType(schema, key) {
+    if (!schema || !isObject(schema))
+        return { kind: 'any' };
+    const props = isObject(schema.properties) ? schema.properties : undefined;
+    const s = props && isObject(props[key]) ? props[key] : undefined;
+    if (!s)
+        return { kind: 'any' };
+    const t = s.type;
+    if (t === 'string')
+        return { kind: 'string' };
+    if (t === 'object')
+        return { kind: 'object' };
+    if (t === 'array') {
+        const items = s.items;
+        const it = items && isObject(items) ? items.type : undefined;
+        if (it === 'string')
+            return { kind: 'arrayString' };
+        return { kind: 'any' };
+    }
+    return { kind: 'any' };
+}
+function normalizeArgumentsBySchema(argsStringOrObj, _functionName, _tools) {
+    // 只做最小字符串化：字符串原样透传；对象仅 stringify 一次；不做 parse/修复
+    if (typeof argsStringOrObj === 'string')
+        return argsStringOrObj;
+    try {
+        return JSON.stringify(argsStringOrObj ?? {});
+    }
+    catch {
+        return String(argsStringOrObj);
+    }
+}
+function parseFunctionArguments(args) {
+    if (typeof args === 'string') {
+        try {
+            const obj = JSON.parse(args);
+            return isObject(obj) ? obj : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    if (isObject(args))
+        return args;
+    return {};
+}
+// Responses-only: 保持“只映射，不解析/不修复”。
+function normalizeToolOutput(entry) {
+    const out = entry?.output;
+    if (typeof out === 'string')
+        return out;
+    if (out && typeof out === 'object') {
+        try {
+            return JSON.stringify(out);
+        }
+        catch {
+            return String(out);
+        }
+    }
+    return null;
+}
+// --- Public bridge functions ---
+export function captureResponsesContext(payload, dto) {
+    ensureResponsesInstructions(payload);
+    const context = {
+        requestId: dto?.route?.requestId,
+        instructions: typeof payload.instructions === 'string' ? payload.instructions : undefined,
+        input: Array.isArray(payload.input) ? payload.input : undefined,
+        include: payload.include,
+        store: payload.store,
+        toolChoice: payload.tool_choice,
+        parallelToolCalls: typeof payload.parallel_tool_calls === 'boolean' ? payload.parallel_tool_calls : undefined,
+        metadata: (payload.metadata && typeof payload.metadata === 'object') ? { ...payload.metadata } : undefined,
+        responseFormat: payload.response_format,
+        stream: typeof payload.stream === 'boolean' ? payload.stream : undefined,
+        isChatPayload: Array.isArray(payload.messages)
+    };
+    if (Array.isArray(payload.tools)) {
+        context.toolsRaw = payload.tools;
+    }
+    context.isResponsesPayload = !context.isChatPayload && Array.isArray(context.input);
+    return context;
+}
+export function buildChatRequestFromResponses(payload, context) {
+    // V3: 对 Responses 路径仅做“形状转换”，不做参数解析/修复。
+    // 将顶层 { type,name,description,parameters,strict } 归一为 OpenAI Chat tools 形状：
+    // { type:'function', function:{ name,description,parameters,strict? } }
+    const mapToolToChatShape = (t) => {
+        if (!t || typeof t !== 'object')
+            return null;
+        const anyT = t;
+        const originalType = typeof anyT.type === 'string' ? anyT.type : 'function';
+        const mappedType = ['function', 'custom'].includes(originalType.toLowerCase()) ? 'function' : originalType;
+        const fn = (anyT.function && typeof anyT.function === 'object') ? anyT.function : {};
+        const topName = typeof anyT.name === 'string' ? anyT.name : undefined;
+        const fnName = typeof fn.name === 'string' ? fn.name : undefined;
+        const name = (fnName || topName || '').trim();
+        if (!name)
+            return null;
+        const topDesc = typeof anyT.description === 'string' ? anyT.description : undefined;
+        const fnDesc = typeof fn.description === 'string' ? fn.description : undefined;
+        const description = fnDesc || topDesc;
+        const fnParams = Object.prototype.hasOwnProperty.call(fn, 'parameters') ? fn.parameters : undefined;
+        const topParams = Object.prototype.hasOwnProperty.call(anyT, 'parameters') ? anyT.parameters : undefined;
+        // 不解析/修复参数；保留原始 schema
+        const parameters = fnParams !== undefined ? fnParams : topParams;
+        const strict = typeof fn.strict === 'boolean' ? fn.strict :
+            typeof anyT.strict === 'boolean' ? anyT.strict :
+                undefined;
+        const fnOut = { name };
+        if (description)
+            fnOut.description = description;
+        if (parameters !== undefined)
+            fnOut.parameters = parameters;
+        if (strict !== undefined)
+            fnOut.strict = strict;
+        return { type: mappedType, function: fnOut };
+    };
+    const toolsNormalized = Array.isArray(payload.tools)
+        ? payload.tools.map(mapToolToChatShape).filter(Boolean)
+        : undefined;
+    // 不在 Responses 路径进行 MCP 工具注入；统一由 Chat 后半段治理注入
+    let messages = mapResponsesInputToChat({
+        instructions: context.instructions,
+        input: context.input,
+        toolsNormalized
+    });
+    if (Array.isArray(context.originalSystemMessages) && context.originalSystemMessages.length) {
+        const preservedSystems = context.originalSystemMessages
+            .map(text => ({ role: 'system', content: text }))
+            .filter(message => typeof message.content === 'string');
+        if (preservedSystems.length) {
+            const nonSystemMessages = messages.filter((msg) => String(msg?.role).toLowerCase() !== 'system');
+            messages = [...preservedSystems, ...nonSystemMessages];
+        }
+    }
+    // 不在 Responses 路径做工具治理；统一在 Chat 后半段处理
+    // No system tips for MCP on OpenAI Responses path (avoid leaking tool names)
+    if (!messages.length) {
+        // Fallback: if there is genuine user text in input blocks, inject a user message (align with Anthropic)
+        try {
+            const input = Array.isArray(context.input) ? context.input : [];
+            for (const entry of input) {
+                if (!entry || typeof entry !== 'object')
+                    continue;
+                const role = normalizeResponseRole(entry.role || 'user');
+                if (role !== 'user')
+                    continue;
+                const blocks = Array.isArray(entry.content) ? entry.content : [];
+                const parts = [];
+                for (const b of blocks) {
+                    if (!b || typeof b !== 'object')
+                        continue;
+                    const t = String(b.type || '').toLowerCase();
+                    if ((t === 'input_text' || t === 'text' || t === 'commentary') && typeof b.text === 'string') {
+                        parts.push(b.text);
+                    }
+                }
+                const txt = parts.join('\n').trim();
+                if (txt) {
+                    messages.push({ role: 'user', content: txt });
+                    break;
+                }
+            }
+        }
+        catch { /* ignore */ }
+        if (!messages.length) {
+            // 最小兜底：若存在 instructions，则用作一条 user 消息（部分上游要求至少一条 user）
+            if (typeof context.instructions === 'string' && context.instructions.trim().length > 0) {
+                const s = context.instructions.trim();
+                messages.push({ role: 'user', content: s });
+            }
+            else {
+                throw new Error('Responses payload produced no chat messages');
+            }
+        }
+    }
+    // 如果只有 system 消息且无 user/assistant/tool，则将 instructions 重用为一条 user 消息，保证最小可用
+    try {
+        const hasNonSystem = messages.some((m) => (m && typeof m === 'object' && (m.role === 'user' || m.role === 'assistant' || m.role === 'tool')));
+        if (!hasNonSystem && typeof context.instructions === 'string' && context.instructions.trim().length > 0) {
+            messages.push({ role: 'user', content: context.instructions.trim() });
+        }
+    }
+    catch { /* ignore */ }
+    const result = { model: payload.model, messages };
+    if (typeof payload.stream === 'boolean') {
+        result.stream = payload.stream;
+    }
+    for (const key of ['top_p', 'tool_choice', 'parallel_tool_calls', 'user', 'logit_bias', 'seed', 'response_format']) {
+        if (payload[key] !== undefined)
+            result[key] = payload[key];
+    }
+    if (typeof payload.max_tokens === 'number' && payload.max_output_tokens === undefined) {
+        payload.max_output_tokens = payload.max_tokens;
+    }
+    if (payload.max_output_tokens !== undefined) {
+        result.max_output_tokens = payload.max_output_tokens;
+    }
+    if (Array.isArray(toolsNormalized) && toolsNormalized.length)
+        result.tools = toolsNormalized;
+    return { request: result, toolsNormalized };
+}
+/**
+ * Chat 请求 → Responses 请求（非流），用于 V3 process=chat 且 providerWire=responses 的请求编码。
+ *
+ * 设计目标：
+ *  - 保留 model / tools / tool_choice / parallel_tool_calls 等字段；
+ *  - 将 system 消息折叠到 instructions；
+ *  - 将 user/assistant/tool 消息编码为 input[] 中的 message 块，使得 mapResponsesInputToChat 能够还原为等价 Chat 请求。
+ */
+export function buildResponsesRequestFromChat(payload, ctx) {
+    const chat = unwrapData(payload);
+    const out = {};
+    // 基本字段
+    out.model = chat.model;
+    // tools: 反向映射为 ResponsesToolDefinition 形状
+    const toolsArr = Array.isArray(chat.tools) ? chat.tools : [];
+    if (toolsArr.length) {
+        out.tools = toolsArr.map(t => {
+            const anyT = t || {};
+            if (anyT.type === 'function' && anyT.function && typeof anyT.function === 'object') {
+                const fn = anyT.function;
+                const base = { type: 'function' };
+                if (typeof fn.name === 'string')
+                    base.name = fn.name;
+                if (typeof fn.description === 'string')
+                    base.description = fn.description;
+                if (Object.prototype.hasOwnProperty.call(fn, 'parameters'))
+                    base.parameters = fn.parameters;
+                if (typeof fn.strict === 'boolean')
+                    base.strict = fn.strict;
+                return base;
+            }
+            return anyT;
+        });
+    }
+    const passthroughKeys = [
+        'tool_choice',
+        'parallel_tool_calls',
+        'response_format',
+        'user',
+        'top_p',
+        'max_output_tokens',
+        'logit_bias',
+        'seed'
+    ];
+    for (const key of passthroughKeys) {
+        if (chat[key] !== undefined)
+            out[key] = chat[key];
+    }
+    if (typeof chat.max_tokens === 'number' && chat.max_output_tokens === undefined) {
+        out.max_output_tokens = chat.max_tokens;
+    }
+    const messages = Array.isArray(chat.messages) ? chat.messages : [];
+    const input = [];
+    const collectText = (val) => {
+        if (!val)
+            return '';
+        if (typeof val === 'string')
+            return val;
+        if (Array.isArray(val))
+            return val.map(collectText).join('');
+        if (typeof val === 'object') {
+            if (typeof val.text === 'string')
+                return String(val.text);
+            if (Array.isArray(val.content))
+                return collectText(val.content);
+            if (typeof val.content === 'string')
+                return String(val.content);
+        }
+        return '';
+    };
+    const extractUserTextFromEntry = (entry) => {
+        if (!entry || typeof entry !== 'object')
+            return '';
+        const directContent = entry.content ?? entry.message?.content;
+        if (typeof directContent === 'string')
+            return directContent.trim();
+        if (Array.isArray(directContent)) {
+            return directContent.map(block => collectText(block)).join('').trim();
+        }
+        const text = entry.text ?? entry.message?.text;
+        if (typeof text === 'string')
+            return text.trim();
+        return '';
+    };
+    const systemParts = [];
+    const originalSystemMessages = [];
+    let latestUserInstruction = null;
+    const pendingToolCallIds = [];
+    const knownToolCallIds = new Set();
+    const toolCallIdAliases = new Map();
+    // 将 system 消息折叠到 instructions，其余 role 映射到 input[].message.content 中
+    for (const m of messages) {
+        if (!m || typeof m !== 'object')
+            continue;
+        const role = String(m.role || '').toLowerCase();
+        const content = m.content;
+        const collectedText = collectText(content);
+        const text = role === 'system' ? collectedText : collectedText.trim();
+        if (role === 'system') {
+            if (collectedText && collectedText.length) {
+                originalSystemMessages.push(collectedText);
+                systemParts.push(collectedText);
+            }
+            continue;
+        }
+        // tool 结果消息：Chat 中 role='tool' 的消息，应回写为 Responses 的 function_call_output 输入块，
+        // 以便 FC 等上游识别为工具结果，而不是普通 message（其 role 不接受 'tool'）。
+        if (role === 'tool') {
+            const rawToolId = m.tool_call_id ||
+                m.call_id ||
+                m.tool_use_id ||
+                m.id ||
+                undefined;
+            let callId = typeof rawToolId === 'string' ? rawToolId : undefined;
+            if (callId && toolCallIdAliases.has(callId)) {
+                callId = toolCallIdAliases.get(callId);
+            }
+            if (!callId || !knownToolCallIds.has(callId)) {
+                const fallbackId = pendingToolCallIds.length ? pendingToolCallIds.shift() : undefined;
+                if (fallbackId) {
+                    if (callId && callId !== fallbackId) {
+                        toolCallIdAliases.set(callId, fallbackId);
+                    }
+                    callId = fallbackId;
+                }
+            }
+            else if (callId) {
+                const idx = pendingToolCallIds.indexOf(callId);
+                if (idx >= 0)
+                    pendingToolCallIds.splice(idx, 1);
+            }
+            const normalizedCallId = normalizeFunctionCallId({
+                callId,
+                fallback: `fc_call_${input.length + 1}`
+            });
+            if (callId && callId !== normalizedCallId) {
+                toolCallIdAliases.set(callId, normalizedCallId);
+            }
+            const normalizedId = normalizeFunctionCallOutputId({
+                callId: normalizedCallId,
+                fallback: `fc_tool_${input.length + 1}`
+            });
+            const entry = {
+                type: 'function_call_output',
+                id: normalizedId,
+                call_id: normalizedCallId,
+                output: text || undefined
+            };
+            input.push(entry);
+            continue;
+        }
+        // tool_calls: 将 Chat 中的 tool_calls 归一为 function_call/tool_call 输入块。
+        // Responses V3 要求 call_id 稳定并与 Chat payload 完全一致，以便多轮工具结果匹配。
+        // 因此这里不再改写 id，仅在缺失时生成随机 call_id。
+        const toolCalls = Array.isArray(m.tool_calls) ? m.tool_calls : [];
+        if (toolCalls.length) {
+            for (const tc of toolCalls) {
+                try {
+                    const rawId = typeof tc?.id === 'string' && tc.id
+                        ? String(tc.id)
+                        : `call_${Math.random().toString(36).slice(2, 8)}`;
+                    const normalizedCallId = normalizeFunctionCallId({
+                        callId: rawId,
+                        fallback: `fc_call_${input.length + 1}`
+                    });
+                    if (rawId !== normalizedCallId) {
+                        toolCallIdAliases.set(rawId, normalizedCallId);
+                    }
+                    const fn = tc?.function || {};
+                    const name = typeof fn?.name === 'string' ? String(fn.name) : 'tool';
+                    const argsRaw = fn?.arguments;
+                    const args = typeof argsRaw === 'string' ? argsRaw : normalizeArgumentsBySchema(argsRaw, name, out.tools);
+                    const entry = {
+                        type: 'function_call',
+                        id: normalizedCallId,
+                        call_id: normalizedCallId,
+                        name,
+                        arguments: args
+                    };
+                    input.push(entry);
+                    knownToolCallIds.add(normalizedCallId);
+                    pendingToolCallIds.push(normalizedCallId);
+                }
+                catch {
+                    // ignore single tool_call
+                }
+            }
+            continue;
+        }
+        // 普通 user/assistant/tool 消息 → message 块
+        // FC 在 user 输入块上要求 content[*].type 是 input_text/input_image/input_file，
+        // 在 assistant 历史消息上要求 output_text/refusal。
+        if (text) {
+            const tRole = role === 'assistant' ? 'output_text' : 'input_text';
+            const entry = {
+                type: 'message',
+                role,
+                content: [{ type: tRole, text }]
+            };
+            input.push(entry);
+            if (role === 'user' && text) {
+                latestUserInstruction = text;
+            }
+        }
+    }
+    if (!latestUserInstruction) {
+        for (let i = input.length - 1; i >= 0; i -= 1) {
+            const entry = input[i];
+            const roleSource = entry?.role ?? entry?.message?.role;
+            const role = typeof roleSource === 'string' ? roleSource.toLowerCase() : '';
+            if (role !== 'user')
+                continue;
+            const text = extractUserTextFromEntry(entry);
+            if (text) {
+                latestUserInstruction = text;
+                break;
+            }
+        }
+    }
+    const combinedSystemInstruction = systemParts.join('\n\n').trim();
+    if (combinedSystemInstruction.length > 0) {
+        out.instructions = combinedSystemInstruction;
+    }
+    else if (typeof ctx?.instructions === 'string' && ctx.instructions.trim().length) {
+        out.instructions = ctx.instructions.trim();
+    }
+    if (!out.instructions && typeof latestUserInstruction === 'string' && latestUserInstruction.trim().length) {
+        out.instructions = latestUserInstruction.trim();
+    }
+    if (ctx?.instructionsIsRaw === true) {
+        out.instructions_is_raw = true;
+    }
+    else if ('instructions_is_raw' in out) {
+        delete out.instructions_is_raw;
+    }
+    // 不追加 metadata，以便 roundtrip 与原始 payload 对齐；系统提示直接写入 instructions。
+    if (input.length) {
+        out.input = input;
+    }
+    const streamFromChat = typeof chat.stream === 'boolean' ? chat.stream : undefined;
+    const streamFromParameters = chat?.parameters && typeof chat.parameters?.stream === 'boolean'
+        ? chat.parameters.stream
+        : undefined;
+    const resolvedStream = typeof ctx?.stream === 'boolean'
+        ? ctx.stream
+        : (streamFromChat !== undefined ? streamFromChat : streamFromParameters);
+    if (resolvedStream === true) {
+        out.stream = true;
+    }
+    else if (resolvedStream === false) {
+        out.stream = false;
+    }
+    ensureResponsesInstructions(out);
+    return { request: out, originalSystemMessages };
+}
+export function buildResponsesPayloadFromChat(payload, context) {
+    if (!payload || typeof payload !== 'object')
+        return payload;
+    const response = unwrapData(payload);
+    if (!response || typeof response !== 'object')
+        return payload;
+    // If provider already returned Responses shape, sanitize textual output to remove tool result envelopes
+    if (response.object === 'response' && Array.isArray(response.output)) {
+        try {
+            const outArr = response.output;
+            for (const item of outArr) {
+                if (!item || typeof item !== 'object')
+                    continue;
+                const t = String(item.type || '').toLowerCase();
+                if (t === 'message' && item.message && typeof item.message === 'object') {
+                    const msg = item.message;
+                    const content = msg.content;
+                    if (Array.isArray(content)) {
+                        for (const part of content) {
+                            if (part && typeof part === 'object' && String(part.type || '').toLowerCase() === 'output_text' && typeof part.text === 'string') {
+                                // rcc.tool.v1 剥离已移除
+                            }
+                        }
+                    }
+                    else if (typeof content === 'string') {
+                        // rcc.tool.v1 剥离已移除
+                    }
+                }
+                if (t === 'reasoning' && Array.isArray(item.content)) {
+                    for (const part of item.content) {
+                        if (part && typeof part === 'object' && String(part.type || '').toLowerCase() === 'output_text' && typeof part.text === 'string') {
+                            // rcc.tool.v1 剥离已移除
+                        }
+                    }
+                }
+            }
+            if (typeof response.output_text === 'string') {
+                // rcc.tool.v1 剥离已移除
+            }
+        }
+        catch { /* ignore sanitize errors */ }
+        return response;
+    }
+    // 如果响应本身是 Anthropic-style message（type:'message'+content[]），先归一为 Chat completion，
+    // 再走统一的 Chat→Responses 映射路径，避免“带 tool_use 的 message”直接被当作 Chat completion。
+    let responseForBridge = response;
+    try {
+        const maybeType = String(response.type || '').toLowerCase();
+        if (maybeType === 'message' && Array.isArray(response.content) && !Array.isArray(response.choices)) {
+            const msg = response;
+            const contentArr = Array.isArray(msg.content) ? msg.content : [];
+            const textParts = [];
+            const toolCalls = [];
+            for (const b of contentArr) {
+                if (!b || typeof b !== 'object')
+                    continue;
+                const t = String(b.type || '').toLowerCase();
+                if (t === 'text' && typeof b.text === 'string') {
+                    const s = b.text;
+                    if (s && s.trim().length)
+                        textParts.push(s);
+                }
+                else if (t === 'tool_use') {
+                    const name = typeof b.name === 'string' ? String(b.name) : '';
+                    const id = typeof b.id === 'string' ? String(b.id) : `call_${Math.random().toString(36).slice(2, 10)}`;
+                    let args = '';
+                    const input = b.input;
+                    if (typeof input === 'string')
+                        args = input;
+                    else {
+                        try {
+                            args = JSON.stringify(input ?? {});
+                        }
+                        catch {
+                            args = '{}';
+                        }
+                    }
+                    if (name)
+                        toolCalls.push({ id, name, args });
+                }
+            }
+            const mapStopToFinish = (sr) => {
+                const v = String(sr || '');
+                if (v === 'tool_use')
+                    return 'tool_calls';
+                if (v === 'max_tokens')
+                    return 'length';
+                if (v === 'stop_sequence')
+                    return 'content_filter';
+                return 'stop';
+            };
+            const finish_reason = mapStopToFinish(msg.stop_reason);
+            const chatMsg = {
+                role: msg.role || 'assistant',
+                content: textParts.join('\n')
+            };
+            if (toolCalls.length) {
+                chatMsg.tool_calls = toolCalls.map(tc => ({
+                    id: tc.id,
+                    type: 'function',
+                    function: { name: tc.name, arguments: tc.args }
+                }));
+            }
+            const usageIn = msg.usage || {};
+            responseForBridge = {
+                id: msg.id || `chatcmpl_${Date.now()}`,
+                object: 'chat.completion',
+                model: msg.model || 'unknown',
+                choices: [
+                    {
+                        index: 0,
+                        finish_reason,
+                        message: chatMsg
+                    }
+                ],
+                usage: usageIn
+            };
+        }
+    }
+    catch {
+        responseForBridge = response;
+    }
+    // Canonicalize response tools (Responses-style) before mapping to Responses blocks
+    const canonical = canonicalizeChatResponseTools(responseForBridge);
+    const choices = Array.isArray(canonical?.choices) ? canonical.choices : [];
+    const primaryChoice = choices[0] && typeof choices[0] === 'object' ? choices[0] : undefined;
+    const message = primaryChoice && typeof primaryChoice.message === 'object' ? primaryChoice.message : undefined;
+    const role = message?.role || 'assistant';
+    const content = message?.content;
+    const reasoningText = typeof message?.reasoning_content === 'string' && message.reasoning_content.trim().length
+        ? String(message.reasoning_content).trim() : undefined;
+    const outputItems = [];
+    const allocateOutputId = (prefix) => `${prefix}_${context?.requestId ?? Date.now()}_${outputItems.length + 1}`;
+    if (reasoningText) {
+        outputItems.push({
+            id: allocateOutputId('reasoning'),
+            type: 'reasoning',
+            status: 'completed',
+            summary: [],
+            content: [{ type: 'reasoning_text', text: reasoningText }]
+        });
+    }
+    const convertedContent = convertChatContentToResponses(content);
+    if (convertedContent.length > 0) {
+        outputItems.push({
+            id: allocateOutputId('message'),
+            type: 'message',
+            status: 'completed',
+            role,
+            content: convertedContent
+        });
+    }
+    let toolCalls = Array.isArray(message?.tool_calls) ? message.tool_calls : [];
+    const toolCallIdMap = new Map();
+    // 过滤无效函数调用（name 缺失或为空）
+    try {
+        toolCalls = toolCalls.filter((it) => {
+            const nm = (it && typeof it === 'object') ? (it?.function?.name || it.name) : undefined;
+            return typeof nm === 'string' && nm.trim().length > 0 && nm.toLowerCase() !== 'tool';
+        });
+    }
+    catch { /* ignore */ }
+    for (const call of toolCalls) {
+        try {
+            const fn = call?.function || {};
+            const callName = typeof fn?.name === 'string' && fn.name.trim().length
+                ? fn.name
+                : (typeof call.name === 'string' ? call.name : 'tool');
+            if (!callName || callName.toLowerCase() === 'tool')
+                continue;
+            const rawArgs = fn?.arguments ?? call.arguments ?? {};
+            const argsStr = typeof rawArgs === 'string'
+                ? rawArgs
+                : (() => {
+                    try {
+                        return JSON.stringify(rawArgs ?? {});
+                    }
+                    catch {
+                        return '{}';
+                    }
+                })();
+            const originalCallId = typeof call.id === 'string' && call.id.trim().length
+                ? String(call.id)
+                : (typeof call.call_id === 'string' && call.call_id.trim().length
+                    ? String(call.call_id)
+                    : allocateOutputId('tool_call'));
+            const callId = normalizeFunctionCallId({
+                callId: originalCallId,
+                fallback: `fc_call_${outputItems.length + 1}`
+            });
+            if (originalCallId && originalCallId !== callId) {
+                toolCallIdMap.set(originalCallId, callId);
+            }
+            toolCallIdMap.set(callId, callId);
+            outputItems.push({
+                id: allocateOutputId('function_call'),
+                type: 'function_call',
+                status: 'in_progress',
+                name: callName,
+                call_id: callId,
+                arguments: argsStr
+            });
+        }
+        catch {
+            // ignore malformed tool call
+        }
+    }
+    const usageRaw = response.usage;
+    let usage = undefined;
+    if (usageRaw && typeof usageRaw === 'object') {
+        usage = { ...usageRaw };
+        if (usage.input_tokens != null && usage.prompt_tokens == null) {
+            usage.prompt_tokens = usage.input_tokens;
+        }
+        if (usage.output_tokens != null && usage.completion_tokens == null) {
+            usage.completion_tokens = usage.output_tokens;
+        }
+        if (usage.prompt_tokens != null && usage.completion_tokens != null && usage.total_tokens == null) {
+            const total = Number(usage.prompt_tokens) + Number(usage.completion_tokens);
+            if (!Number.isNaN(total))
+                usage.total_tokens = total;
+        }
+        try {
+            delete usage.input_tokens;
+            delete usage.output_tokens;
+        }
+        catch { /* ignore */ }
+    }
+    else if (usageRaw !== undefined) {
+        usage = usageRaw;
+    }
+    const outputText = extractOutputText(convertedContent, toolCalls);
+    const hasToolCalls = toolCalls.length > 0;
+    const status = hasToolCalls ? 'requires_action' : 'completed';
+    if (hasToolCalls) {
+        for (const item of outputItems) {
+            if (item.type === 'message') {
+                item.status = 'in_progress';
+            }
+        }
+    }
+    const out = {
+        id: response.id || `resp-${Date.now()}`,
+        object: 'response',
+        created_at: response.created_at || response.created || Math.floor(Date.now() / 1000),
+        model: response.model,
+        status,
+        output: outputItems,
+        output_text: outputText || ''
+    };
+    if (usage !== undefined)
+        out.usage = usage;
+    // Synthesize required_action for non-stream JSON when tool_calls exist
+    try {
+        if (toolCalls.length > 0) {
+            const toStringJson = (v) => { if (typeof v === 'string')
+                return v; try {
+                return JSON.stringify(v ?? {});
+            }
+            catch {
+                return '{}';
+            } };
+            const callsAll = toolCalls.filter((it) => {
+                const nm = (it && typeof it === 'object') ? (it?.function?.name || it.name) : undefined;
+                return typeof nm === 'string' && nm.trim().length > 0 && nm.toLowerCase() !== 'tool';
+            }).map((it) => {
+                const rawId = typeof it.id === 'string' ? it.id : (typeof it.call_id === 'string' ? it.call_id : `call_${Math.random().toString(36).slice(2, 8)}`);
+                const id = toolCallIdMap.get(rawId) ?? normalizeFunctionCallId({ callId: rawId, fallback: `fc_call_${outputItems.length + 1}` });
+                const nm = typeof it?.function?.name === 'string' ? it.function.name : (typeof it.name === 'string' ? it.name : 'tool');
+                const rawArgs = it?.function?.arguments ?? it.arguments ?? {};
+                const argsStr = toStringJson(rawArgs);
+                return { id, type: 'function', function: { name: String(nm), arguments: String(argsStr) } };
+            });
+            // 仅做最小形状映射：不进行校验与归一，仅透传（字符串化）。
+            const calls = callsAll;
+            const required_action = { type: 'submit_tool_outputs', submit_tool_outputs: { tool_calls: calls } };
+            out.required_action = required_action;
+        }
+    }
+    catch { /* ignore */ }
+    // Do not inject captured tool results here; keep Chat back-half behavior standard.
+    if (context) {
+        for (const k of ['metadata', 'instructions', 'parallel_tool_calls', 'tool_choice', 'include', 'store']) {
+            if (context[k] !== undefined)
+                out[k] = context[k];
+        }
+    }
+    return out;
+}
+function mapResponsesInputToChat(options) {
+    const { instructions, input, toolsNormalized } = options;
+    const messages = [];
+    if (typeof instructions === 'string') {
+        const trimmed = instructions.trim();
+        if (trimmed.length) {
+            messages.push({ role: 'system', content: trimmed });
+        }
+    }
+    if (!Array.isArray(input))
+        return messages;
+    const toolNameById = new Map();
+    const toolArgsById = new Map();
+    const toolCallIdAliases = new Map();
+    let lastToolCallId = null;
+    for (const entry of input) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const entryType = typeof entry.type === 'string' ? entry.type.toLowerCase() : 'message';
+        if (typeof entry.content === 'string') {
+            const directText = (entry.content || '').toString().trim();
+            if (directText.length) {
+                const normalizedRole = normalizeResponseRole(entry.role || 'user');
+                messages.push({ role: normalizedRole, content: directText });
+                continue;
+            }
+        }
+        if (entryType === 'function_call' || entryType === 'tool_call') {
+            const rawName = typeof entry.name === 'string' ? entry.name : (typeof entry?.function?.name === 'string' ? entry.function.name : undefined);
+            const name = (typeof rawName === 'string' && rawName.includes('.')) ? rawName.slice(rawName.indexOf('.') + 1).trim() : rawName;
+            if (typeof name !== 'string' || !name.trim() || name.toLowerCase() === 'tool') {
+                // 无效函数名：不生成 tool_calls，避免污染会话
+                continue;
+            }
+            const args = entry.arguments ?? entry?.function?.arguments ?? {};
+            const parsedArgs = args; // 不解析，原样透传（对象在后续 stringify）
+            const callIdRaw = typeof entry.id === 'string' ? entry.id : (typeof entry.call_id === 'string' ? entry.call_id : `call_${Math.random().toString(36).slice(2, 8)}`);
+            const callId = normalizeFunctionCallId({
+                callId: callIdRaw,
+                fallback: `fc_call_${messages.length + 1}`
+            });
+            if (callIdRaw && callIdRaw !== callId) {
+                toolCallIdAliases.set(callIdRaw, callId);
+            }
+            const serialized = normalizeArgumentsBySchema(parsedArgs, name, toolsNormalized).trim();
+            toolNameById.set(callId, name);
+            toolArgsById.set(callId, serialized);
+            messages.push({ role: 'assistant', tool_calls: [{ id: callId, type: 'function', function: { name, arguments: serialized } }] });
+            lastToolCallId = callId;
+            continue;
+        }
+        if (entryType === 'function_call_output' || entryType === 'tool_result' || entryType === 'tool_message') {
+            let toolCallId = entry.tool_call_id || entry.call_id || entry.tool_use_id || entry.id || lastToolCallId;
+            if (toolCallId && toolCallIdAliases.has(String(toolCallId))) {
+                toolCallId = toolCallIdAliases.get(String(toolCallId)) || toolCallId;
+            }
+            else if (typeof toolCallId === 'string' && toolCallId.trim().length) {
+                const normalized = normalizeFunctionCallId({ callId: toolCallId, fallback: toolCallId });
+                if (normalized !== toolCallId) {
+                    toolCallIdAliases.set(toolCallId, normalized);
+                }
+                toolCallId = normalized;
+            }
+            const output = normalizeToolOutput(entry);
+            if (toolCallId) {
+                try {
+                    // Emit a standard tool role message so downstream Chat back-half can govern correctly
+                    let contentStr = output != null ? String(output) : '';
+                    if (!contentStr || contentStr.trim().length === 0) {
+                        contentStr = 'Command succeeded (no output).';
+                    }
+                    const nm = toolNameById.get(String(toolCallId));
+                    const toolMsg = { role: 'tool', tool_call_id: String(toolCallId), content: contentStr };
+                    if (typeof nm === 'string' && nm.trim().length)
+                        toolMsg.name = nm;
+                    messages.push(toolMsg);
+                }
+                catch {
+                    const fallback = (output ?? '');
+                    const nm = toolNameById.get(String(toolCallId));
+                    const toolMsg = { role: 'tool', tool_call_id: String(toolCallId), content: String(fallback) };
+                    if (typeof nm === 'string' && nm.trim().length)
+                        toolMsg.name = nm;
+                    messages.push(toolMsg);
+                }
+                lastToolCallId = null;
+            }
+            continue;
+        }
+        // Prefer explicit message shape when present: entry.message.{role,content[]}
+        let handledViaExplicitMessage = false;
+        if (entry && typeof entry.message === 'object' && Array.isArray(entry.message?.content)) {
+            const explicit = entry.message;
+            const { text, toolCalls, toolMessages, lastCallId } = processMessageBlocks(Array.isArray(explicit.content) ? explicit.content : [], toolsNormalized, toolNameById, toolCallIdAliases, lastToolCallId);
+            if (toolCalls.length)
+                messages.push({ role: 'assistant', tool_calls: toolCalls });
+            for (const msg of toolMessages)
+                messages.push(msg);
+            const normalizedRole = normalizeResponseRole((explicit.role ?? entry.role) || 'user');
+            if (typeof text === 'string' && text.trim().length) {
+                messages.push({ role: normalizedRole, content: text.trim() });
+            }
+            lastToolCallId = lastCallId;
+            handledViaExplicitMessage = true;
+        }
+        // Otherwise, consume entry.content[] if present
+        if (!handledViaExplicitMessage) {
+            const { text, toolCalls, toolMessages, lastCallId } = processMessageBlocks(Array.isArray(entry.content) ? entry.content : [], toolsNormalized, toolNameById, toolCallIdAliases, lastToolCallId);
+            if (toolCalls.length)
+                messages.push({ role: 'assistant', tool_calls: toolCalls });
+            for (const msg of toolMessages)
+                messages.push(msg);
+            const normalizedRole = normalizeResponseRole(entry.role || 'user');
+            if (typeof text === 'string' && text.trim().length) {
+                messages.push({ role: normalizedRole, content: text.trim() });
+            }
+            lastToolCallId = lastCallId;
+        }
+        // Finally, handle top-level text items (e.g., { type: 'input_text', text: '...' })
+        try {
+            const t = String(entry.type || '').toLowerCase();
+            if ((t === 'input_text' || t === 'text' || t === 'output_text' || t === 'commentary') && typeof entry.text === 'string') {
+                const normalizedRole = normalizeResponseRole(entry.role || 'user');
+                const s = entry.text;
+                if (s && s.length)
+                    messages.push({ role: normalizedRole, content: s });
+            }
+        }
+        catch { /* ignore */ }
+    }
+    return messages;
+}
+function normalizeResponseRole(role) {
+    if (typeof role === 'string') {
+        const normalized = role.toLowerCase();
+        if (normalized === 'system' || normalized === 'assistant' || normalized === 'user' || normalized === 'tool')
+            return normalized;
+    }
+    return 'user';
+}
+function processMessageBlocks(blocks, toolsNormalized, toolNameById, toolCallIdAliases, lastToolCallId) {
+    const textParts = [];
+    const toolCalls = [];
+    const toolMessages = [];
+    let currentLastCall = lastToolCallId;
+    const toolArgsByIdLocal = new Map();
+    for (const block of blocks) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const type = typeof block.type === 'string' ? block.type.toLowerCase() : '';
+        if (type === 'input_text' || type === 'output_text' || type === 'text' || type === 'commentary') {
+            if (typeof block.text === 'string')
+                textParts.push(block.text);
+            else if (typeof block.content === 'string')
+                textParts.push(block.content);
+            continue;
+        }
+        if (type === 'message' && Array.isArray(block.content)) {
+            const nested = processMessageBlocks(block.content, toolsNormalized, toolNameById, toolCallIdAliases, currentLastCall);
+            if (nested.text)
+                textParts.push(nested.text);
+            for (const tc of nested.toolCalls)
+                toolCalls.push(tc);
+            for (const tm of nested.toolMessages)
+                toolMessages.push(tm);
+            currentLastCall = nested.lastCallId;
+            continue;
+        }
+        if (type === 'function_call') {
+            const rawName = typeof block.name === 'string' ? block.name : (typeof block?.function?.name === 'string' ? block.function.name : undefined);
+            const name = (typeof rawName === 'string' && rawName.includes('.')) ? rawName.slice(rawName.indexOf('.') + 1).trim() : rawName;
+            const args = block.arguments ?? block?.function?.arguments ?? {};
+            const parsedArgs = args; // 不解析
+            const callIdRaw = typeof block.id === 'string' ? block.id : (typeof block.call_id === 'string' ? block.call_id : `call_${Math.random().toString(36).slice(2, 8)}`);
+            const callId = normalizeFunctionCallId({ callId: callIdRaw, fallback: `fc_call_${toolCalls.length + 1}` });
+            if (callIdRaw && callIdRaw !== callId) {
+                toolCallIdAliases.set(callIdRaw, callId);
+            }
+            if (typeof name !== 'string' || !name.trim()) {
+                // 缺少函数名：不生成 function_call，避免 downstream 进入错误循环
+                // 将内容留给文本路径或后续消息拼接处理
+                currentLastCall = null;
+                continue;
+            }
+            const serialized = normalizeArgumentsBySchema(parsedArgs, name, toolsNormalized).trim();
+            toolNameById.set(callId, name);
+            toolArgsByIdLocal.set(callId, serialized);
+            toolCalls.push({ id: callId, type: 'function', function: { name, arguments: serialized } });
+            currentLastCall = callId;
+            continue;
+        }
+        if (type === 'function_call_output' || type === 'tool_result' || type === 'tool_message') {
+            let toolCallId = block.tool_call_id || block.call_id || block.tool_use_id || block.id || currentLastCall;
+            if (toolCallId && toolCallIdAliases.has(String(toolCallId))) {
+                toolCallId = toolCallIdAliases.get(String(toolCallId)) || toolCallId;
+            }
+            else if (typeof toolCallId === 'string' && toolCallId.trim().length) {
+                const normalized = normalizeFunctionCallId({ callId: toolCallId, fallback: toolCallId });
+                if (normalized !== toolCallId) {
+                    toolCallIdAliases.set(toolCallId, normalized);
+                }
+                toolCallId = normalized;
+            }
+            const output = normalizeToolOutput(block);
+            if (toolCallId) {
+                try {
+                    // No rcc envelope: emit plain tool role message with text content (fallback message on empty)
+                    let contentStr = output != null ? String(output) : '';
+                    if (!contentStr || contentStr.trim().length === 0) {
+                        contentStr = 'Command succeeded (no output).';
+                    }
+                    const nm = toolNameById.get(String(toolCallId));
+                    const toolMsg = { role: 'tool', tool_call_id: String(toolCallId), content: contentStr };
+                    if (typeof nm === 'string' && nm.trim().length)
+                        toolMsg.name = nm;
+                    toolMessages.push(toolMsg);
+                }
+                catch {
+                    const fallback = (output ?? '');
+                    const nm = toolNameById.get(String(toolCallId));
+                    const toolMsg = { role: 'tool', tool_call_id: String(toolCallId), content: String(fallback) };
+                    if (typeof nm === 'string' && nm.trim().length)
+                        toolMsg.name = nm;
+                    toolMessages.push(toolMsg);
+                }
+                currentLastCall = null;
+            }
+            continue;
+        }
+    }
+    const text = textParts.length ? textParts.join('\n').trim() : null;
+    return { text, toolCalls, toolMessages, lastCallId: currentLastCall };
+}
+function sanitizeThink(s) {
+    try {
+        let out = s.replace(/<think>[\s\S]*?<\/think>/gi, '');
+        out = out.replace(/```\s*think[\s\S]*?```/gi, '');
+        out = out.replace(/\n{3,}/g, '\n\n');
+        return out.trim();
+    }
+    catch {
+        return s;
+    }
+}
+function convertChatContentToResponses(content) {
+    if (content == null)
+        return [];
+    if (typeof content === 'string')
+        return [{ type: 'output_text', text: content }];
+    if (Array.isArray(content)) {
+        return content.map((part) => {
+            if (typeof part === 'string')
+                return { type: 'output_text', text: sanitizeThink(part) };
+            if (part && typeof part === 'object') {
+                if (typeof part.text === 'string')
+                    return { type: 'output_text', text: sanitizeThink(part.text) };
+                return { type: part.type || 'output_text', text: sanitizeThink(part.text ?? '') };
+            }
+            return { type: 'output_text', text: sanitizeThink(String(part)) };
+        });
+    }
+    if (typeof content === 'object') {
+        try {
+            return [{ type: 'output_text', text: JSON.stringify(content) }];
+        }
+        catch {
+            return [{ type: 'output_text', text: String(content) }];
+        }
+    }
+    return [{ type: 'output_text', text: '' }];
+}
+function extractOutputText(parts, _toolCalls) {
+    if (parts.length > 0) {
+        const text = parts
+            .filter(p => typeof p.text === 'string')
+            .map(p => sanitizeThink(p.text))
+            .join('\n')
+            .trim();
+        if (text.length)
+            return text;
+    }
+    return '';
+}
+function unwrapData(value) {
+    let current = value;
+    const seen = new Set();
+    while (current && typeof current === 'object' && !Array.isArray(current) && !seen.has(current)) {
+        seen.add(current);
+        if ('choices' in current || 'message' in current)
+            break;
+        if ('data' in current && typeof current.data === 'object') {
+            current = current.data;
+            continue;
+        }
+        break;
+    }
+    return current;
+}
+export function extractRequestIdFromResponse(response) {
+    if (response && typeof response === 'object' && 'metadata' in response && response.metadata && typeof response.metadata === 'object') {
+        const meta = response.metadata;
+        if (typeof meta.requestId === 'string')
+            return meta.requestId;
+    }
+    return undefined;
+}
+// (imports moved to top)
+function unwrapResponsesResponse(payload) {
+    if (!payload || typeof payload !== 'object')
+        return undefined;
+    if (typeof payload.object === 'string' && payload.object === 'response') {
+        return payload;
+    }
+    if (Array.isArray(payload.output) ||
+        typeof payload.status === 'string' ||
+        payload.required_action) {
+        return payload;
+    }
+    let current = payload;
+    const visited = new Set();
+    while (current && typeof current === 'object' && !Array.isArray(current)) {
+        if (visited.has(current))
+            break;
+        visited.add(current);
+        if (typeof current.object === 'string' && current.object === 'response') {
+            return current;
+        }
+        if (current.response && typeof current.response === 'object') {
+            current = current.response;
+            continue;
+        }
+        if (current.data && typeof current.data === 'object') {
+            current = current.data;
+            continue;
+        }
+        break;
+    }
+    return undefined;
+}
+function collectMessageTexts(blocks) {
+    const parts = [];
+    const pushText = (value) => {
+        if (typeof value === 'string' && value.trim().length) {
+            parts.push(sanitizeThink(value));
+        }
+    };
+    if (typeof blocks === 'string') {
+        pushText(blocks);
+        return parts;
+    }
+    if (!Array.isArray(blocks))
+        return parts;
+    for (const block of blocks) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const type = typeof block.type === 'string' ? String(block.type).toLowerCase() : '';
+        if (type === 'text' || type === 'input_text' || type === 'output_text' || type === 'commentary') {
+            pushText(block.text ?? block.content);
+            continue;
+        }
+        if (Array.isArray(block.content)) {
+            parts.push(...collectMessageTexts(block.content));
+            continue;
+        }
+        if (typeof block.text === 'string') {
+            pushText(block.text);
+        }
+    }
+    return parts;
+}
+function collectResponseOutput(response) {
+    const textParts = [];
+    const reasoningParts = [];
+    const outputItems = Array.isArray(response.output) ? response.output : [];
+    for (const item of outputItems) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const type = typeof item.type === 'string' ? String(item.type).toLowerCase() : '';
+        if (type === 'message') {
+            const message = item.message && typeof item.message === 'object'
+                ? item.message
+                : item;
+            const content = Array.isArray(message.content) ? message.content : [];
+            textParts.push(...collectMessageTexts(content));
+            continue;
+        }
+        if (type === 'output_text') {
+            if (typeof item.text === 'string') {
+                textParts.push(sanitizeThink(item.text));
+            }
+            continue;
+        }
+        if (type === 'reasoning') {
+            const content = Array.isArray(item.content) ? item.content : [];
+            for (const block of content) {
+                if (block && typeof block === 'object' && typeof block.text === 'string') {
+                    const sanitized = sanitizeThink(block.text);
+                    if (sanitized.length)
+                        reasoningParts.push(sanitized);
+                }
+            }
+        }
+    }
+    return { textParts, reasoningParts };
+}
+function normalizeToolCallName(rawName) {
+    if (typeof rawName !== 'string' || !rawName.trim().length)
+        return undefined;
+    if (!rawName.includes('.'))
+        return rawName.trim();
+    return rawName.slice(rawName.indexOf('.') + 1).trim() || undefined;
+}
+function selectCallId(entry) {
+    const candidates = [
+        entry?.call_id,
+        entry?.tool_call_id,
+        entry?.tool_use_id,
+        entry?.id
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'string' && candidate.trim().length > 0) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function normalizeToolCall(entry, fallbackPrefix) {
+    if (!entry || typeof entry !== 'object')
+        return null;
+    const fn = entry.function || {};
+    const rawName = normalizeToolCallName(fn.name ?? entry.name);
+    if (!rawName)
+        return null;
+    const argsRaw = fn.arguments ?? entry.arguments ?? {};
+    const argsStr = typeof argsRaw === 'string'
+        ? argsRaw
+        : (() => { try {
+            return JSON.stringify(argsRaw ?? {});
+        }
+        catch {
+            return '{}';
+        } })();
+    const callIdRaw = selectCallId(entry);
+    const callId = normalizeFunctionCallId({
+        callId: callIdRaw,
+        fallback: `${fallbackPrefix}_${Math.random().toString(36).slice(2, 10)}`
+    });
+    return {
+        id: callId,
+        type: 'function',
+        function: {
+            name: rawName,
+            arguments: argsStr
+        }
+    };
+}
+function collectToolCallsFromResponses(response) {
+    const collected = [];
+    const seenIds = new Set();
+    const pushCall = (call, source) => {
+        if (!call)
+            return;
+        const key = typeof call.id === 'string' ? call.id : `${source}_${collected.length}`;
+        if (key && seenIds.has(key))
+            return;
+        if (key)
+            seenIds.add(key);
+        collected.push(call);
+    };
+    const required = response?.required_action?.submit_tool_outputs?.tool_calls;
+    if (Array.isArray(required)) {
+        for (const call of required) {
+            pushCall(normalizeToolCall(call, 'req_call'), 'req_call');
+        }
+    }
+    const outputItems = Array.isArray(response.output) ? response.output : [];
+    for (const item of outputItems) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const type = typeof item.type === 'string' ? String(item.type).toLowerCase() : '';
+        if (type !== 'function_call')
+            continue;
+        pushCall(normalizeToolCall(item, 'output_call'), 'output_call');
+    }
+    return collected;
+}
+function resolveFinishReason(response, toolCalls) {
+    const meta = response.metadata && typeof response.metadata === 'object'
+        ? response.metadata
+        : undefined;
+    if (meta && typeof meta.finish_reason === 'string') {
+        return meta.finish_reason;
+    }
+    if (toolCalls.length > 0) {
+        return 'tool_calls';
+    }
+    const status = typeof response.status === 'string' ? response.status.toLowerCase() : '';
+    if (status === 'requires_action')
+        return 'tool_calls';
+    if (status === 'in_progress' || status === 'streaming')
+        return 'length';
+    if (status === 'cancelled')
+        return 'cancelled';
+    if (status === 'failed')
+        return 'error';
+    return 'stop';
+}
+/**
+ * 将非流式 ResponsesResponse 形状还原为等价的 ChatResponse 形状（用于闭环测试）。
+ *
+ *  - id / model / created(_at) / usage → 直接透传
+ *  - output_text / output[] → choices[0].message.content
+ *  - required_action.submit_tool_outputs.tool_calls → choices[0].message.tool_calls
+ *  - finish_reason：metadata.finish_reason 优先，其次 status/tool_calls 推断
+ *
+ * 若 payload 已是 ChatCompletion 形状，则直接返回。
+ */
+export function buildChatResponseFromResponses(payload) {
+    if (!payload || typeof payload !== 'object')
+        return payload;
+    const response = unwrapResponsesResponse(payload);
+    if (!response) {
+        if (Array.isArray(payload.choices))
+            return payload;
+        return payload;
+    }
+    const id = typeof response.id === 'string' ? response.id : `resp_${Date.now()}`;
+    const model = response.model;
+    const created = typeof response.created_at === 'number'
+        ? response.created_at
+        : (response.created ?? Math.floor(Date.now() / 1000));
+    const usage = response.usage;
+    const toolCalls = collectToolCallsFromResponses(response);
+    const { textParts, reasoningParts } = collectResponseOutput(response);
+    const explicitOutput = typeof response.output_text === 'string' && response.output_text.trim().length
+        ? sanitizeThink(response.output_text)
+        : undefined;
+    const messageContentText = explicitOutput || textParts.join('\n').trim();
+    const messageContent = messageContentText || '';
+    const message = {
+        role: 'assistant',
+        content: messageContent
+    };
+    if (toolCalls.length) {
+        message.tool_calls = toolCalls;
+    }
+    if (reasoningParts.length) {
+        message.reasoning_content = reasoningParts.join('\n');
+    }
+    const finishReason = resolveFinishReason(response, toolCalls);
+    const chat = {
+        id,
+        object: 'chat.completion',
+        created,
+        model,
+        choices: [
+            {
+                index: 0,
+                finish_reason: finishReason,
+                message
+            }
+        ]
+    };
+    if (usage !== undefined) {
+        chat.usage = usage;
+    }
+    return chat;
+}