@jsonstudio/rcc 0.85.9 → 0.89.3

package/node_modules/@jsonstudio/llms/dist/conversion/shared/responses-request-adapter.js

@@ -0,0 +1,430 @@
+import { normalizeFunctionCallId, normalizeFunctionCallOutputId } from './responses-id-utils.js';
+import { ensureResponsesInstructions } from './responses-instructions.js';
+import { serializeToolArguments, coerceBridgeRole, serializeToolOutput } from './bridge-message-utils.js';
+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,
+        instructionsIsRaw: payload.instructions_is_raw === true,
+        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) {
+    const toolOutputs = Array.isArray(payload.tool_outputs)
+        ? payload.tool_outputs
+        : undefined;
+    const responseId = typeof payload.response_id === 'string' ? payload.response_id : undefined;
+    const hasInput = Array.isArray(payload.input) && payload.input.length > 0;
+    const submitOnlyMode = !!toolOutputs && !!responseId && !hasInput;
+    if (submitOnlyMode) {
+        return {
+            request: {
+                type: 'submit_tool_outputs',
+                model: payload.model,
+                response_id: responseId,
+                tool_outputs: toolOutputs,
+                stream: payload.stream === true
+            }
+        };
+    }
+    let toolsNormalized = Array.isArray(payload.tools)
+        ? normalizeTools(payload.tools)
+        : undefined;
+    // Inject MCP tools (CCR style) if enabled
+    try {
+        const enableMcp = String(process.env?.ROUTECODEX_MCP_ENABLE ?? '1') !== '0';
+        if (enableMcp) {
+            // Discover servers from prior inputs if present (best-effort; depends on client payload)
+            const discovered = new Set();
+            try {
+                const input = Array.isArray(payload.input) ? payload.input : [];
+                for (const it of input) {
+                    const t = (it && typeof it === 'object') ? it : {};
+                    const isToolCall = (t.type === 'function_call' || t.type === 'tool_call');
+                    const isToolMsg = (t.type === 'tool_message' || t.type === 'tool_result');
+                    if (isToolCall) {
+                        const args = typeof t.arguments === 'string' ? (() => { try {
+                            return JSON.parse(t.arguments);
+                        }
+                        catch {
+                            return {};
+                        } })() : (t.arguments || {});
+                        const sv = (args && typeof args === 'object') ? args.server : undefined;
+                        if (typeof sv === 'string' && sv.trim())
+                            discovered.add(sv.trim());
+                    }
+                    else if (isToolMsg) {
+                        const output = t?.output;
+                        const val = (typeof output === 'string') ? (() => { try {
+                            return JSON.parse(output);
+                        }
+                        catch {
+                            return null;
+                        } })() : (output || null);
+                        const args = (val && typeof val === 'object') ? val.arguments : undefined;
+                        const sv = (args && typeof args === 'object') ? args.server : undefined;
+                        if (typeof sv === 'string' && sv.trim())
+                            discovered.add(sv.trim());
+                    }
+                }
+            }
+            catch { /* ignore */ }
+            const list = toolsNormalized && Array.isArray(toolsNormalized) ? toolsNormalized : [];
+            const have = new Set(list.map((t) => (t?.function?.name || '').toString()));
+            const addTool = (def) => { if (!have.has(def.function.name)) {
+                list.push(def);
+                have.add(def.function.name);
+            } };
+            const obj = (props, req) => ({ type: 'object', properties: props, required: req, additionalProperties: false });
+            const serversRaw = String(process.env?.ROUTECODEX_MCP_SERVERS || '').trim();
+            const envServers = serversRaw ? serversRaw.split(',').map((s) => s.trim()).filter(Boolean) : [];
+            const merged = Array.from(new Set([...envServers, ...Array.from(discovered)]));
+            const serverProp = merged.length ? { type: 'string', enum: merged } : { type: 'string' };
+            // 初始仅注入 list_mcp_resources；有已知 server 后再注入其余 MCP 工具
+            // 与 Chat 路径保持一致：server 可选（不强制要求）
+            addTool({ type: 'function', function: { name: 'list_mcp_resources', strict: true, description: 'List resources from a given MCP server (arguments.server = server label).', parameters: obj({ server: serverProp, filter: { type: 'string' }, root: { type: 'string' } }, [] /* server optional */) } });
+            if (merged.length > 0) {
+                addTool({ type: 'function', function: { name: 'read_mcp_resource', strict: true, description: 'Read a resource via MCP server.', parameters: obj({ server: serverProp, uri: { type: 'string' } }, ['server', 'uri']) } });
+                addTool({ type: 'function', function: { name: 'list_mcp_resource_templates', strict: true, description: 'List resource templates via MCP server.', parameters: obj({ server: serverProp }, ['server']) } });
+            }
+            toolsNormalized = list;
+        }
+    }
+    catch { /* ignore MCP injection */ }
+    const mergedInput = mergeToolOutputsIntoInput(context.input, payload.tool_outputs);
+    let messages = mapResponsesInputToChat({
+        instructions: context.instructions,
+        input: mergedInput,
+        toolsNormalized
+    });
+    const preservedSystemMessages = Array.isArray(context.originalSystemMessages)
+        ? context.originalSystemMessages
+            .map((text) => (typeof text === 'string' ? text.trim() : ''))
+            .filter((text) => text.length > 0)
+            .map((text) => ({ role: 'system', content: text }))
+        : undefined;
+    if (preservedSystemMessages && preservedSystemMessages.length) {
+        const nonSystemMessages = messages.filter((msg) => String(msg?.role || '').toLowerCase() !== 'system');
+        messages = [...preservedSystemMessages, ...nonSystemMessages];
+    }
+    const request = {
+        model: payload.model || 'gpt-4.1-mini',
+        messages
+    };
+    for (const key of ['temperature', 'top_p', 'max_tokens', 'tool_choice', 'parallel_tool_calls', 'user', 'logit_bias', 'seed', 'response_format']) {
+        if (payload[key] !== undefined) {
+            request[key] = payload[key];
+        }
+    }
+    if (Array.isArray(toolsNormalized) && toolsNormalized.length) {
+        request.tools = toolsNormalized;
+    }
+    if (typeof payload.stream === 'boolean') {
+        request.stream = payload.stream;
+    }
+    return {
+        request,
+        toolsNormalized
+    };
+}
+function mergeToolOutputsIntoInput(input, toolOutputsRaw) {
+    const result = Array.isArray(input) ? [...input] : [];
+    if (!Array.isArray(toolOutputsRaw)) {
+        return result;
+    }
+    for (const entry of toolOutputsRaw) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const data = entry;
+        const callIdRaw = data.tool_call_id ?? data.call_id ?? data.id;
+        if (typeof callIdRaw !== 'string' || !callIdRaw.trim())
+            continue;
+        const outputRaw = data.output;
+        const outputText = normalizeToolOutputPayload(outputRaw);
+        const normalizedCallId = normalizeFunctionCallId({ callId: callIdRaw, fallback: callIdRaw });
+        const outputId = normalizeFunctionCallOutputId({ callId: normalizedCallId, fallback: normalizedCallId });
+        result.push({
+            type: 'function_call_output',
+            id: outputId,
+            call_id: normalizedCallId,
+            output: outputText
+        });
+    }
+    return result;
+}
+function normalizeToolOutputPayload(payload) {
+    if (typeof payload === 'string') {
+        return payload;
+    }
+    if (payload == null) {
+        return '';
+    }
+    try {
+        return JSON.stringify(payload);
+    }
+    catch {
+        return String(payload);
+    }
+}
+function mapResponsesInputToChat(options) {
+    const { instructions, input, toolsNormalized } = options;
+    const messages = [];
+    if (typeof instructions === 'string' && instructions.length) {
+        messages.push({ role: 'system', content: instructions });
+    }
+    if (!Array.isArray(input))
+        return messages;
+    const toolNameById = 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 = coerceBridgeRole(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') {
+                continue;
+            }
+            const args = entry.arguments ?? entry?.function?.arguments ?? {};
+            const parsedArgs = args;
+            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 = serializeToolArguments(parsedArgs, name, toolsNormalized).trim();
+            toolNameById.set(callId, name);
+            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 = serializeToolOutput(entry);
+            if (toolCallId) {
+                try {
+                    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;
+        }
+        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 = coerceBridgeRole((explicit.role ?? entry.role) || 'user');
+            if (typeof text === 'string' && text.trim().length) {
+                messages.push({ role: normalizedRole, content: text.trim() });
+            }
+            lastToolCallId = lastCallId;
+            handledViaExplicitMessage = true;
+        }
+        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 = coerceBridgeRole(entry.role || 'user');
+            if (typeof text === 'string' && text.trim().length) {
+                messages.push({ role: normalizedRole, content: text.trim() });
+            }
+            lastToolCallId = lastCallId;
+        }
+        try {
+            const t = String(entry.type || '').toLowerCase();
+            if ((t === 'input_text' || t === 'text' || t === 'output_text' || t === 'commentary') && typeof entry.text === 'string') {
+                const normalizedRole = coerceBridgeRole(entry.role || 'user');
+                const s = entry.text;
+                if (s && s.length)
+                    messages.push({ role: normalizedRole, content: s });
+            }
+        }
+        catch { /* ignore */ }
+    }
+    return messages;
+}
+function processMessageBlocks(blocks, toolsNormalized, toolNameById, toolCallIdAliases, lastToolCallId) {
+    const textParts = [];
+    const toolCalls = [];
+    const toolMessages = [];
+    let currentLastCall = lastToolCallId;
+    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()) {
+                currentLastCall = null;
+                continue;
+            }
+            const serialized = serializeToolArguments(parsedArgs, name, toolsNormalized).trim();
+            toolNameById.set(callId, name);
+            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 = serializeToolOutput(block);
+            if (toolCallId) {
+                try {
+                    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;
+        }
+    }
+    return {
+        text: textParts.length ? textParts.join('\n') : null,
+        toolCalls,
+        toolMessages,
+        lastCallId: currentLastCall
+    };
+}
+function normalizeTools(tools) {
+    const normalized = [];
+    for (const tool of tools) {
+        if (!tool || typeof tool !== 'object')
+            continue;
+        const originalType = typeof tool.type === 'string' ? tool.type : 'function';
+        const mappedType = ['function', 'custom'].includes(originalType.toLowerCase())
+            ? 'function'
+            : originalType;
+        const fn = (tool.function && typeof tool.function === 'object')
+            ? tool.function
+            : {};
+        const topName = typeof tool.name === 'string' ? tool.name : undefined;
+        const fnName = typeof fn.name === 'string' ? fn.name : undefined;
+        const name = (fnName || topName || '').trim();
+        if (!name)
+            continue;
+        const topDesc = typeof tool.description === 'string' ? tool.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(tool, 'parameters') ? tool.parameters : undefined;
+        const parameters = fnParams !== undefined ? fnParams : topParams;
+        const strict = typeof fn.strict === 'boolean' ? fn.strict :
+            typeof tool.strict === 'boolean' ? tool.strict :
+                undefined;
+        const fnOut = { name };
+        if (description)
+            fnOut.description = description;
+        if (parameters !== undefined)
+            fnOut.parameters = parameters;
+        if (strict !== undefined)
+            fnOut.strict = strict;
+        normalized.push({ type: mappedType, function: fnOut });
+    }
+    return normalized;
+}

package/node_modules/@jsonstudio/llms/dist/conversion/shared/responses-response-utils.d.ts

@@ -0,0 +1,3 @@
+export declare function collectToolCallsFromResponses(response: Record<string, unknown>): Array<Record<string, unknown>>;
+export declare function resolveFinishReason(response: Record<string, unknown>, toolCalls: Array<Record<string, unknown>>): string;
+export declare function buildChatResponseFromResponses(payload: unknown): Record<string, unknown> | unknown;

package/node_modules/@jsonstudio/llms/dist/conversion/shared/responses-response-utils.js

@@ -0,0 +1,239 @@
+import { sanitizeResponsesFunctionName } from './responses-tool-utils.js';
+import { normalizeFunctionCallId } from './bridge-id-utils.js';
+import { extractOutputSegments } from './output-content-normalizer.js';
+import { sanitizeReasoningTaggedText } from './reasoning-utils.js';
+import { createBridgeActionState, runBridgeActionPipeline } from './bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from './bridge-policies.js';
+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.trim();
+        }
+    }
+    return undefined;
+}
+function normalizeToolCall(entry, fallbackPrefix) {
+    if (!entry || typeof entry !== 'object')
+        return null;
+    const fn = entry.function || {};
+    const rawName = sanitizeResponsesFunctionName(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 = typeof callIdRaw === 'string' && callIdRaw.length
+        ? callIdRaw
+        : normalizeFunctionCallId({
+            callId: callIdRaw,
+            fallback: `${fallbackPrefix}_${Math.random().toString(36).slice(2, 10)}`
+        });
+    return {
+        id: callId,
+        type: 'function',
+        function: {
+            name: rawName,
+            arguments: argsStr
+        }
+    };
+}
+export 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;
+}
+export 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';
+}
+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 collectRawReasoningSegments(response) {
+    const segments = [];
+    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 !== 'reasoning')
+            continue;
+        const content = Array.isArray(item.content) ? item.content : [];
+        for (const part of content) {
+            if (part && typeof part === 'object' && typeof part.text === 'string') {
+                segments.push(part.text);
+            }
+        }
+    }
+    return segments;
+}
+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 } = extractOutputSegments(response);
+    const rawReasoningSegments = collectRawReasoningSegments(response);
+    const explicitOutput = typeof response.output_text === 'string' && response.output_text.trim().length
+        ? sanitizeReasoningTaggedText(response.output_text)
+        : undefined;
+    const messageContentText = explicitOutput || textParts.join('\n').trim();
+    const messageContent = messageContentText || '';
+    const message = {
+        role: 'assistant',
+        content: messageContent
+    };
+    try {
+        const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-responses', moduleType: 'openai-responses' });
+        const policyActions = resolvePolicyActions(bridgePolicy, 'response_inbound');
+        if (policyActions?.length) {
+            const actionState = createBridgeActionState({
+                messages: [message],
+                rawResponse: response
+            });
+            runBridgeActionPipeline({
+                stage: 'response_inbound',
+                actions: policyActions,
+                protocol: bridgePolicy?.protocol ?? 'openai-responses',
+                moduleType: bridgePolicy?.moduleType ?? 'openai-responses',
+                requestId: typeof response?.id === 'string' ? response.id : undefined,
+                state: actionState
+            });
+        }
+    }
+    catch {
+        // Ignore policy errors
+    }
+    if (toolCalls.length) {
+        message.tool_calls = toolCalls;
+    }
+    const reasoningSegments = rawReasoningSegments.length ? rawReasoningSegments : reasoningParts;
+    if (reasoningSegments.length) {
+        message.reasoning_content = reasoningSegments.join('\n');
+    }
+    const finishReason = resolveFinishReason(response, toolCalls);
+    const chat = {
+        id,
+        object: 'chat.completion',
+        created,
+        model,
+        choices: [
+            {
+                index: 0,
+                finish_reason: finishReason,
+                message
+            }
+        ]
+    };
+    const hasOutputTextField = Object.prototype.hasOwnProperty.call(response, 'output_text');
+    if (rawReasoningSegments.length) {
+        chat.__responses_reasoning = rawReasoningSegments;
+    }
+    chat.__responses_output_text_meta = {
+        hasField: hasOutputTextField,
+        value: hasOutputTextField && typeof response.output_text === 'string'
+            ? sanitizeReasoningTaggedText(response.output_text)
+            : undefined
+    };
+    if (usage !== undefined) {
+        chat.usage = usage;
+    }
+    return chat;
+}