@jsonstudio/llms 0.6.230 → 0.6.467

package/dist/conversion/hub/response/provider-response.js

@@ -1,3 +1,4 @@
+import { recordStage } from '../pipeline/stages/utils.js';
 import { ChatFormatAdapter } from '../format-adapters/chat-format-adapter.js';
 import { ResponsesFormatAdapter } from '../format-adapters/responses-format-adapter.js';
 import { AnthropicFormatAdapter } from '../format-adapters/anthropic-format-adapter.js';
@@ -12,45 +13,36 @@ import { runRespProcessStage2Finalize } from '../pipeline/stages/resp_process/re
 import { runRespOutboundStage1ClientRemap } from '../pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js';
 import { runRespOutboundStage2SseStream } from '../pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.js';
 import { recordResponsesResponse } from '../../shared/responses-conversation-store.js';
-import { runServerSideToolEngine } from './server-side-tools.js';
-function resolveChatReasoningMode(entryEndpoint) {
-    const envRaw = (process.env.ROUTECODEX_CHAT_REASONING_MODE || process.env.RCC_CHAT_REASONING_MODE || '').trim().toLowerCase();
-    const map = {
-        keep: 'keep',
-        drop: 'drop',
-        discard: 'drop',
-        text: 'append_to_content',
-        append: 'append_to_content',
-        append_text: 'append_to_content',
-        append_to_content: 'append_to_content'
-    };
-    if (envRaw && map[envRaw]) {
-        return map[envRaw];
-    }
-    return 'keep';
-}
+import { runServerToolOrchestration } from '../../../servertool/engine.js';
 const PROVIDER_RESPONSE_REGISTRY = {
     'openai-chat': {
-        protocol: 'openai-chat',
         createFormatAdapter: () => new ChatFormatAdapter(),
         createMapper: () => new OpenAIChatResponseMapper()
     },
     'openai-responses': {
-        protocol: 'openai-responses',
         createFormatAdapter: () => new ResponsesFormatAdapter(),
         createMapper: () => new ResponsesResponseMapper()
     },
     'anthropic-messages': {
-        protocol: 'anthropic-messages',
         createFormatAdapter: () => new AnthropicFormatAdapter(),
         createMapper: () => new AnthropicResponseMapper()
     },
     'gemini-chat': {
-        protocol: 'gemini-chat',
         createFormatAdapter: () => new GeminiFormatAdapter(),
         createMapper: () => new GeminiResponseMapper()
     }
 };
+function isServerToolFollowup(context) {
+    const raw = context.serverToolFollowup;
+    if (raw === true) {
+        return true;
+    }
+    if (typeof raw === 'string') {
+        const v = raw.trim().toLowerCase();
+        return v === '1' || v === 'true';
+    }
+    return false;
+}
 function resolveClientProtocol(entryEndpoint) {
     const lowered = (entryEndpoint || '').toLowerCase();
     if (lowered.includes('/v1/responses'))
@@ -86,8 +78,28 @@ function applyModelOverride(payload, model) {
         /* ignore */
     }
 }
+function resolveChatReasoningMode(_entryEndpoint) {
+    // 当前保持默认策略：保留 reasoning_content 字段，不做额外拼接或删除。
+    return 'keep';
+}
 export async function convertProviderResponse(options) {
     const clientProtocol = resolveClientProtocol(options.entryEndpoint);
+    const hasServerToolSupport = Boolean(options.providerInvoker) || Boolean(options.reenterPipeline);
+    const skipServerTools = isServerToolFollowup(options.context) || !hasServerToolSupport;
+    // 对于由 server-side 工具触发的内部跳转（二跳/三跳），统一禁用 SSE 聚合输出，
+    // 始终返回完整的 ChatCompletion JSON，便于在 llms 内部直接解析，而不是拿到
+    // __sse_responses 可读流。
+    const wantsStream = isServerToolFollowup(options.context) ? false : options.wantsStream;
+    try {
+        // eslint-disable-next-line no-console
+        console.log(`\x1b[38;5;33m[servertool][orchestrator][debug] requestId=${options.context.requestId} ` +
+            `protocol=${options.providerProtocol} endpoint=${options.entryEndpoint} ` +
+            `skipServerTools=${skipServerTools} hasInvoker=${Boolean(options.providerInvoker)} ` +
+            `hasReenter=${Boolean(options.reenterPipeline)}\x1b[0m`);
+    }
+    catch {
+        /* logging best-effort */
+    }
     const displayModel = extractDisplayModel(options.context);
     const plan = PROVIDER_RESPONSE_REGISTRY[options.providerProtocol];
     if (!plan) {
@@ -97,7 +109,7 @@ export async function convertProviderResponse(options) {
         providerProtocol: options.providerProtocol,
         payload: options.providerResponse,
         adapterContext: options.context,
-        wantsStream: options.wantsStream,
+        wantsStream,
         stageRecorder: options.stageRecorder
     });
     const formatAdapter = plan.createFormatAdapter();
@@ -138,18 +150,55 @@ export async function convertProviderResponse(options) {
         mapper,
         stageRecorder: options.stageRecorder
     });
-    // Server-side tool orchestration hook (web_search, etc.).
-    const serverSideResult = await runServerSideToolEngine({
-        chatResponse,
-        adapterContext: options.context,
-        entryEndpoint: options.entryEndpoint,
-        requestId: options.context.requestId,
-        providerProtocol: options.providerProtocol,
-        providerInvoker: options.providerInvoker
-    });
-    const chatForGovernance = serverSideResult.finalChatResponse;
+    // 记录语义映射后的 ChatCompletion，便于回放 server-side 工具流程。
+    recordStage(options.stageRecorder, 'resp_inbound_stage3_semantic_map.chat', chatResponse);
+    // 检查是否需要进行 ServerTool 编排
+    // 使用新的 ChatEnvelope 级别的 servertool 实现
+    let effectiveChatResponse = chatResponse;
+    if (!skipServerTools && options.reenterPipeline) {
+        try {
+            // eslint-disable-next-line no-console
+            console.log(`\x1b[38;5;33m[servertool][orchestrator] start requestId=${options.context.requestId} ` +
+                `protocol=${options.providerProtocol} endpoint=${options.entryEndpoint}\x1b[0m`);
+        }
+        catch {
+            /* logging best-effort */
+        }
+        const orchestration = await runServerToolOrchestration({
+            chat: chatResponse,
+            adapterContext: options.context,
+            requestId: options.context.requestId,
+            entryEndpoint: options.entryEndpoint,
+            providerProtocol: options.providerProtocol,
+            providerInvoker: options.providerInvoker,
+            reenterPipeline: options.reenterPipeline
+        });
+        if (orchestration.executed) {
+            const flowLabel = orchestration.flowId ?? 'servertool_flow';
+            try {
+                // eslint-disable-next-line no-console
+                console.log(`\x1b[38;5;33m[servertool][orchestrator] completed requestId=${options.context.requestId} ` +
+                    `mode=${flowLabel}\x1b[0m`);
+            }
+            catch {
+                /* logging best-effort */
+            }
+            effectiveChatResponse = orchestration.chat;
+        }
+        else {
+            try {
+                // eslint-disable-next-line no-console
+                console.log(`\x1b[38;5;33m[servertool][orchestrator] skipped requestId=${options.context.requestId} ` +
+                    'reason=no_servertool_match\x1b[0m');
+            }
+            catch {
+                /* logging best-effort */
+            }
+        }
+    }
+    // 如果没有执行 servertool，继续原来的处理流程
     const governanceResult = await runRespProcessStage1ToolGovernance({
-        payload: chatForGovernance,
+        payload: effectiveChatResponse,
         entryEndpoint: options.entryEndpoint,
         requestId: options.context.requestId,
         clientProtocol,
@@ -159,7 +208,7 @@ export async function convertProviderResponse(options) {
         payload: governanceResult.governedPayload,
         entryEndpoint: options.entryEndpoint,
         requestId: options.context.requestId,
-        wantsStream: options.wantsStream,
+        wantsStream,
         reasoningMode: resolveChatReasoningMode(options.entryEndpoint),
         stageRecorder: options.stageRecorder
     });
@@ -176,7 +225,7 @@ export async function convertProviderResponse(options) {
         clientPayload,
         clientProtocol,
         requestId: options.context.requestId,
-        wantsStream: options.wantsStream,
+        wantsStream,
         stageRecorder: options.stageRecorder
     });
     if (outbound.stream) {

package/dist/conversion/hub/response/server-side-tools.js

@@ -32,7 +32,28 @@ function extractToolCalls(chatResponse) {
     return calls;
 }
 function extractTextFromChatLike(payload) {
-    const choices = getArray(payload.choices);
+    // 1) 解包常见包装层：data / response 节点
+    let current = payload;
+    const visited = new Set();
+    while (current && typeof current === 'object' && !Array.isArray(current) && !visited.has(current)) {
+        visited.add(current);
+        if (Array.isArray(current.choices) || Array.isArray(current.output)) {
+            break;
+        }
+        const data = current.data;
+        if (data && typeof data === 'object' && !Array.isArray(data)) {
+            current = data;
+            continue;
+        }
+        const response = current.response;
+        if (response && typeof response === 'object' && !Array.isArray(response)) {
+            current = response;
+            continue;
+        }
+        break;
+    }
+    // 2) 优先从 choices[].message.content 提取（OpenAI/GLM 兼容）
+    const choices = getArray(current.choices);
     if (!choices.length)
         return '';
     const first = asObject(choices[0]);
@@ -43,7 +64,7 @@ function extractTextFromChatLike(payload) {
         return '';
     const content = message.content;
     if (typeof content === 'string')
-        return content;
+        return content.trim();
     const parts = getArray(content);
     const texts = [];
     for (const part of parts) {
@@ -55,9 +76,45 @@ function extractTextFromChatLike(payload) {
             if (typeof record.text === 'string') {
                 texts.push(record.text);
             }
+            else if (typeof record.content === 'string') {
+                texts.push(record.content);
+            }
+        }
+    }
+    const joinedFromChoices = texts.join('\n').trim();
+    if (joinedFromChoices) {
+        return joinedFromChoices;
+    }
+    // 3) 回退：从 output[].content[] 中提取（部分 Responses/自定义后端）
+    const output = current.output;
+    if (Array.isArray(output)) {
+        const altTexts = [];
+        for (const entry of output) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const blocks = entry.content;
+            const blockArray = Array.isArray(blocks) ? blocks : [];
+            for (const block of blockArray) {
+                if (!block || typeof block !== 'object')
+                    continue;
+                const record = block;
+                if (typeof record.text === 'string') {
+                    altTexts.push(record.text);
+                }
+                else if (typeof record.output_text === 'string') {
+                    altTexts.push(record.output_text);
+                }
+                else if (typeof record.content === 'string') {
+                    altTexts.push(record.content);
+                }
+            }
+        }
+        const joined = altTexts.join('\n').trim();
+        if (joined) {
+            return joined;
         }
     }
-    return texts.join('\n').trim();
+    return '';
 }
 function getWebSearchConfig(ctx) {
     const raw = ctx.webSearch;
@@ -131,7 +188,7 @@ function resolveEnvServerSideToolsEnabled() {
         return false;
     if (raw === '1' || raw === 'true' || raw === 'yes')
         return true;
-    if (raw === 'web_search' || raw === 'websearch')
+    if (raw === 'web_search')
         return true;
     return false;
 }

package/dist/conversion/hub/semantic-mappers/gemini-mapper.js

@@ -171,6 +171,117 @@ function collectParameters(payload) {
     }
     return Object.keys(params).length ? params : undefined;
 }
+function appendChatContentToGeminiParts(message, targetParts) {
+    const content = message.content;
+    if (typeof content === 'string') {
+        const text = content.trim();
+        if (text.length) {
+            targetParts.push({ text });
+        }
+        return;
+    }
+    if (!Array.isArray(content)) {
+        return;
+    }
+    const items = content;
+    for (const block of items) {
+        if (block == null)
+            continue;
+        if (typeof block === 'string') {
+            const text = block.trim();
+            if (text.length) {
+                targetParts.push({ text });
+            }
+            continue;
+        }
+        if (typeof block !== 'object') {
+            const text = String(block);
+            if (text.trim().length) {
+                targetParts.push({ text: text.trim() });
+            }
+            continue;
+        }
+        const record = block;
+        const rawType = record.type;
+        const type = typeof rawType === 'string' ? rawType.toLowerCase() : '';
+        // Text-style blocks
+        if (!type || type === 'text') {
+            const textValue = typeof record.text === 'string'
+                ? record.text
+                : typeof record.content === 'string'
+                    ? record.content
+                    : '';
+            const text = textValue.trim();
+            if (text.length) {
+                targetParts.push({ text });
+            }
+            continue;
+        }
+        // Image-style blocks -> Gemini inlineData
+        if (type === 'image' || type === 'image_url') {
+            // Prefer OpenAI-style image_url.url, but also accept uri/url/data.
+            let url;
+            const imageUrlRaw = record.image_url;
+            if (typeof imageUrlRaw === 'string') {
+                url = imageUrlRaw;
+            }
+            else if (imageUrlRaw && typeof imageUrlRaw === 'object' && typeof imageUrlRaw.url === 'string') {
+                url = imageUrlRaw.url;
+            }
+            else if (typeof record.uri === 'string') {
+                url = record.uri;
+            }
+            else if (typeof record.url === 'string') {
+                url = record.url;
+            }
+            else if (typeof record.data === 'string') {
+                url = record.data;
+            }
+            const trimmed = (url ?? '').trim();
+            if (!trimmed.length) {
+                // Fallback: at least emit a textual marker so内容不会完全丢失
+                targetParts.push({ text: '[image]' });
+                continue;
+            }
+            let mimeType;
+            let data;
+            // data:URL → inlineData { mimeType, data }
+            if (trimmed.startsWith('data:')) {
+                const match = /^data:([^;,]+)?(?:;base64)?,(.*)$/s.exec(trimmed);
+                if (match) {
+                    mimeType = (match[1] || '').trim() || undefined;
+                    data = match[2] || '';
+                }
+            }
+            if (data && data.trim().length) {
+                const inline = {
+                    inlineData: {
+                        data: data.trim()
+                    }
+                };
+                if (mimeType && mimeType.length) {
+                    inline.inlineData.mimeType = mimeType;
+                }
+                targetParts.push(inline);
+            }
+            else {
+                // 非 data: URL 暂时作为文本 URL 传递，保持语义可见
+                targetParts.push({ text: trimmed });
+            }
+            continue;
+        }
+        // 默认：回退为文本 JSON 表示，避免静默丢失内容
+        try {
+            const jsonText = JSON.stringify(record);
+            if (jsonText.trim().length) {
+                targetParts.push({ text: jsonText });
+            }
+        }
+        catch {
+            // ignore malformed block
+        }
+    }
+}
 function buildGeminiRequestFromChat(chat, metadata) {
     const contents = [];
     const emittedToolOutputs = new Set();
@@ -191,9 +302,7 @@ function buildGeminiRequestFromChat(chat, metadata) {
             role: mapChatRoleToGemini(message.role),
             parts: []
         };
-        if (typeof message.content === 'string' && message.content.trim().length) {
-            entry.parts.push({ text: message.content });
-        }
+        appendChatContentToGeminiParts(message, entry.parts);
         const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
         for (const tc of toolCalls) {
             if (!tc || typeof tc !== 'object')
@@ -335,7 +444,18 @@ function safeParseJson(value) {
     }
 }
 function ensureFunctionResponsePayload(value) {
+    // Gemini function_response.response 字段在 CloudCode/Gemini CLI 协议里对应的是
+    // protobuf Struct（JSON object），而不是顶层数组。
+    // 这里做一层规范化：
+    // - 对象：直接透传；
+    // - 数组：包一层 { result: [...] } 避免把数组作为 Struct 根节点；
+    // - 原始值：包一层 { result: value }，并把 undefined 映射为 null。
     if (value && typeof value === 'object') {
+        if (Array.isArray(value)) {
+            return {
+                result: value
+            };
+        }
         return value;
     }
     return {

package/dist/conversion/hub/semantic-mappers/responses-mapper.js

@@ -148,6 +148,20 @@ function serializeSystemContent(message) {
     }
     return undefined;
 }
+function mergeMetadata(a, b) {
+    if (!a && !b) {
+        return undefined;
+    }
+    if (!a && b) {
+        return jsonClone(b);
+    }
+    if (a && !b) {
+        return jsonClone(a);
+    }
+    const left = jsonClone(a);
+    const right = jsonClone(b);
+    return { ...left, ...right };
+}
 export class ResponsesSemanticMapper {
     async toChat(format, ctx) {
         const payload = format.payload || {};
@@ -209,13 +223,15 @@ export class ResponsesSemanticMapper {
             .map(message => serializeSystemContent(message))
             .filter((content) => typeof content === 'string' && content.length > 0);
         const capturedContext = chat.metadata?.responsesContext;
+        const envelopeMetadata = chat.metadata && isJsonObject(chat.metadata) ? chat.metadata : undefined;
         const responsesContext = isJsonObject(capturedContext)
             ? {
                 ...capturedContext,
+                metadata: mergeMetadata(capturedContext.metadata, envelopeMetadata),
                 originalSystemMessages
             }
             : {
-                metadata: (chat.metadata && isJsonObject(chat.metadata) ? chat.metadata : undefined),
+                metadata: envelopeMetadata,
                 originalSystemMessages
             };
         const responsesResult = buildResponsesRequestFromChat(requestShape, responsesContext);

package/dist/conversion/hub/standardized-bridge.js

@@ -60,6 +60,20 @@ export function standardizedToChatEnvelope(request, options) {
     const metadata = {
         context: adapterContext
     };
+    const sourceMeta = (request.metadata && typeof request.metadata === 'object'
+        ? request.metadata
+        : undefined);
+    if (sourceMeta) {
+        if (sourceMeta.webSearch && typeof sourceMeta.webSearch === 'object') {
+            metadata.webSearch = sourceMeta.webSearch;
+        }
+        if (sourceMeta.forceWebSearch === true) {
+            metadata.forceWebSearch = true;
+        }
+        if (sourceMeta.forceVision === true) {
+            metadata.forceVision = true;
+        }
+    }
     if (typeof adapterContext.toolCallIdStyle === 'string' && adapterContext.toolCallIdStyle.length) {
         metadata.toolCallIdStyle = adapterContext.toolCallIdStyle;
     }

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

@@ -3,6 +3,7 @@ import { evaluateResponsesHostPolicy } from './responses-host-policy.js';
 import { convertMessagesToBridgeInput, convertBridgeInputToChatMessages } from '../shared/bridge-message-utils.js';
 import { createToolCallIdTransformer, enforceToolCallIdStyle, resolveToolCallIdStyle, stripInternalToolingMetadata, sanitizeResponsesFunctionName } from '../shared/responses-tool-utils.js';
 import { mapBridgeToolsToChat, mapChatToolsToBridge } from '../shared/tool-mapping.js';
+import { ProviderProtocolError } from '../shared/errors.js';
 // --- Utilities (ported strictly) ---
 import { canonicalizeChatResponseTools } from '../shared/tool-canonicalizer.js';
 import { normalizeMessageReasoningTools } from '../shared/reasoning-tool-normalizer.js';
@@ -95,7 +96,16 @@ export function buildChatRequestFromResponses(payload, context) {
     // 不在 Responses 路径做工具治理；统一在 Chat 后半段处理
     // No system tips for MCP on OpenAI Responses path (avoid leaking tool names)
     if (!messages.length) {
-        throw new Error('Responses payload produced no chat messages');
+        throw new ProviderProtocolError('Responses payload produced no chat messages', {
+            code: 'MALFORMED_REQUEST',
+            protocol: 'openai-responses',
+            providerType: 'responses',
+            details: {
+                context: 'buildChatRequestFromResponses',
+                inputLength: Array.isArray(context.input) ? context.input.length : undefined,
+                requestId: context.requestId
+            }
+        });
     }
     // 如果只有 system 消息且无 user/assistant/tool，后续桥接 action 会从 instructions 注入兜底 user 消息
     const result = { model: payload.model, messages };
@@ -190,17 +200,50 @@ function mergeResponsesTools(originalTools, fromChat) {
 export function buildResponsesRequestFromChat(payload, ctx, extras) {
     const chat = unwrapData(payload);
     const out = {};
+    const forceWebSearch = !!ctx &&
+        isObject(ctx.metadata) &&
+        isObject(ctx.metadata.webSearch) &&
+        ctx.metadata.webSearch.force === true;
     // 基本字段
     out.model = chat.model;
     // tools: 反向映射为 ResponsesToolDefinition 形状
-    const responsesToolsFromChat = mapChatToolsToBridge(chat.tools, {
+    const chatTools = Array.isArray(chat.tools) ? chat.tools : [];
+    // 对于 openai-responses upstream，内建 web_search 由官方服务器处理。
+    // Chat 侧注入的 server-side web_search 函数（带 engine/query/recency/count）
+    // 仅用于非 Responses provider 的 server-tool 回环；在这里构造真正的
+    // `/v1/responses` 请求时，需要：
+    //   1) 不再把函数版 web_search 透传上游；
+    //   2) 若检测到 Chat 侧启用了 web_search 且原始请求中没有 builtin web_search，
+    //      则补一个 `{ type: "web_search" }` 内建工具给 OpenAI Responses。
+    const hasServerSideWebSearch = !forceWebSearch && chatTools.some((tool) => {
+        const fn = tool && typeof tool === 'object' ? tool.function : undefined;
+        const name = typeof fn?.name === 'string' ? fn.name.trim().toLowerCase() : '';
+        return name === 'web_search';
+    });
+    const toolsForBridge = hasServerSideWebSearch
+        ? chatTools.filter((tool) => {
+            const fn = tool && typeof tool === 'object' ? tool.function : undefined;
+            const name = typeof fn?.name === 'string' ? fn.name.trim().toLowerCase() : '';
+            return name !== 'web_search';
+        })
+        : chatTools;
+    const responsesToolsFromChat = mapChatToolsToBridge(toolsForBridge, {
         sanitizeName: sanitizeResponsesFunctionName
     });
     // Prefer Chat‑normalized tools, but if the original Responses payload carried
     // non‑function tools (such as builtin `web_search`), merge them back so that
     // upstream `/v1/responses` providers see their original tool definitions.
     const originalTools = Array.isArray(ctx?.toolsRaw) ? ctx.toolsRaw : undefined;
-    const mergedTools = mergeResponsesTools(originalTools, responsesToolsFromChat);
+    let mergedTools = mergeResponsesTools(originalTools, responsesToolsFromChat);
+    if (hasServerSideWebSearch) {
+        const normalizeType = (value) => typeof value === 'string' ? value.trim().toLowerCase() : '';
+        const hasBuiltinWebSearch = (mergedTools && mergedTools.some((tool) => normalizeType(tool.type) === 'web_search')) ||
+            (originalTools && originalTools.some((tool) => normalizeType(tool.type) === 'web_search'));
+        if (!hasBuiltinWebSearch) {
+            const injected = { type: 'web_search' };
+            mergedTools = mergedTools ? [...mergedTools, injected] : [injected];
+        }
+    }
     if (mergedTools?.length) {
         out.tools = mergedTools;
     }
@@ -503,15 +546,76 @@ export function buildResponsesPayloadFromChat(payload, context) {
     if (response.object === 'response' && Array.isArray(response.output)) {
         return response;
     }
-    if (!Array.isArray(response.choices) || !response.choices.length) {
-        throw new Error('Responses bridge expects OpenAI Chat completion payload');
+    const hasChoicesArray = Array.isArray(response.choices);
+    const choicesLength = hasChoicesArray ? response.choices.length : 0;
+    // Graceful fallback for provider payloads that do not contain a valid
+    // ChatCompletion-style choices array (e.g. certain compat error envelopes).
+    if (!hasChoicesArray || choicesLength === 0) {
+        const rawStatus = response.status;
+        const statusCode = typeof rawStatus === 'string' && rawStatus.trim().length
+            ? rawStatus.trim()
+            : typeof rawStatus === 'number'
+                ? String(rawStatus)
+                : undefined;
+        const message = typeof response.msg === 'string' && response.msg.trim().length
+            ? response.msg.trim()
+            : typeof response.message === 'string' && response.message.trim().length
+                ? response.message.trim()
+                : 'Upstream returned non-standard Chat completion payload (missing choices).';
+        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: 'failed',
+            output: []
+        };
+        if (message) {
+            out.output_text = message;
+            out.error = {
+                type: 'provider_error',
+                code: statusCode,
+                message
+            };
+        }
+        if (context) {
+            for (const k of ['metadata', 'parallel_tool_calls', 'tool_choice', 'include']) {
+                if (context[k] !== undefined)
+                    out[k] = context[k];
+            }
+            if (!shouldStripHostManagedFields(context) && context.store !== undefined) {
+                out.store = context.store;
+            }
+        }
+        if (typeof response.request_id === 'string') {
+            out.request_id = response.request_id;
+        }
+        else if (typeof response.id === 'string') {
+            out.request_id = response.id;
+        }
+        else if (typeof context?.requestId === 'string') {
+            out.request_id = context.requestId;
+        }
+        if (out.metadata) {
+            stripInternalToolingMetadata(out.metadata);
+        }
+        return out;
     }
     const canonical = canonicalizeChatResponseTools(response);
     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;
     if (!message) {
-        throw new Error('Responses bridge could not locate assistant message in Chat completion');
+        throw new ProviderProtocolError('Responses bridge could not locate assistant message in Chat completion', {
+            code: 'MALFORMED_RESPONSE',
+            protocol: 'openai-chat',
+            providerType: 'openai',
+            details: {
+                context: 'buildResponsesPayloadFromChat',
+                choicesLength: choices.length,
+                requestId: context?.requestId
+            }
+        });
     }
     if (message) {
         try {