@jsonstudio/llms 0.6.1164 → 0.6.1354

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage1_format_parse/index.js

@@ -1,6 +1,6 @@
 import { recordStage } from '../../../stages/utils.js';
 export async function runReqInboundStage1FormatParse(options) {
     const envelope = (await options.formatAdapter.parseRequest(options.rawRequest, options.adapterContext));
-    recordStage(options.stageRecorder, 'req_inbound_stage1_format_parse', envelope);
+    recordStage(options.stageRecorder, 'chat_process.req.stage1.format_parse', envelope);
     return envelope;
 }

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage2_semantic_map/index.d.ts

@@ -7,6 +7,13 @@ export interface ReqInboundStage2SemanticMapOptions {
     adapterContext: AdapterContext;
     formatEnvelope: FormatEnvelope<JsonObject>;
     semanticMapper: Pick<SemanticMapper, 'toChat'>;
+    /**
+     * Mappable cross-protocol semantics (e.g. /v1/responses submit resume) must be
+     * lifted into chat semantics before entering chat_process.
+     *
+     * This must never be stored in metadata/AdapterContext.
+     */
+    responsesResume?: JsonObject;
     stageRecorder?: StageRecorder;
 }
 export interface ReqInboundStage2SemanticMapResult {

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage2_semantic_map/index.js

@@ -2,6 +2,7 @@ import { chatEnvelopeToStandardized } from '../../../../standardized-bridge.js';
 import { validateChatEnvelope } from '../../../../../shared/chat-envelope-validator.js';
 import { applyHubOperationTableInbound } from '../../../../operation-table/operation-table-runner.js';
 import { recordStage } from '../../../stages/utils.js';
+import { isJsonObject, jsonClone } from '../../../../types/json.js';
 export async function runReqInboundStage2SemanticMap(options) {
     const chatEnvelope = await options.semanticMapper.toChat(options.formatEnvelope, options.adapterContext);
     applyHubOperationTableInbound({
@@ -9,11 +10,74 @@ export async function runReqInboundStage2SemanticMap(options) {
         chatEnvelope,
         adapterContext: options.adapterContext
     });
+    // Semantic Gate (request): before entering chat_process, lift any mappable protocol semantics
+    // into ChatEnvelope.semantics. Do not persist these in metadata.
+    try {
+        if (!chatEnvelope.semantics || typeof chatEnvelope.semantics !== 'object') {
+            chatEnvelope.semantics = {};
+        }
+        const semantics = chatEnvelope.semantics;
+        if (!semantics.tools || !isJsonObject(semantics.tools)) {
+            semantics.tools = {};
+        }
+        const toolsNode = semantics.tools;
+        const rawTools = Array.isArray(options.formatEnvelope.payload?.tools)
+            ? (options.formatEnvelope.payload.tools ?? [])
+            : [];
+        if (rawTools.length && toolsNode.clientToolsRaw === undefined) {
+            toolsNode.clientToolsRaw = jsonClone(rawTools);
+        }
+        if (options.responsesResume && isJsonObject(options.responsesResume)) {
+            if (!semantics.responses || !isJsonObject(semantics.responses)) {
+                semantics.responses = {};
+            }
+            const responsesNode = semantics.responses;
+            if (responsesNode.resume === undefined) {
+                responsesNode.resume = jsonClone(options.responsesResume);
+            }
+            // If this is a Responses submit/resume hop, tool outputs may exist only in resume metadata.
+            // Lift them into canonical chat.toolOutputs so chat_process sees a single unified surface.
+            const hasDirectToolOutputs = Array.isArray(chatEnvelope.toolOutputs) && chatEnvelope.toolOutputs.length > 0;
+            if (!hasDirectToolOutputs) {
+                const detailed = Array.isArray(options.responsesResume.toolOutputsDetailed)
+                    ? options.responsesResume.toolOutputsDetailed
+                    : undefined;
+                if (detailed && detailed.length) {
+                    const mapped = detailed
+                        .map((entry, index) => {
+                        if (!entry || typeof entry !== 'object')
+                            return undefined;
+                        const callId = typeof entry.callId === 'string' && String(entry.callId).trim().length
+                            ? String(entry.callId).trim()
+                            : typeof entry.originalId === 'string' && String(entry.originalId).trim().length
+                                ? String(entry.originalId).trim()
+                                : `resume_tool_${index + 1}`;
+                        const outputText = typeof entry.outputText === 'string'
+                            ? entry.outputText
+                            : (() => { try {
+                                return JSON.stringify(entry.outputText ?? '');
+                            }
+                            catch {
+                                return String(entry.outputText ?? '');
+                            } })();
+                        return { tool_call_id: callId, content: outputText };
+                    })
+                        .filter(Boolean);
+                    if (mapped.length) {
+                        chatEnvelope.toolOutputs = mapped;
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // fail-fast is enforced at chat_process entry; this gate is best-effort
+    }
     validateChatEnvelope(chatEnvelope, {
         stage: 'req_inbound',
         direction: 'request'
     });
-    recordStage(options.stageRecorder, 'req_inbound_stage2_semantic_map', chatEnvelope);
+    recordStage(options.stageRecorder, 'chat_process.req.stage2.semantic_map', chatEnvelope);
     const standardizedRequest = chatEnvelopeToStandardized(chatEnvelope, {
         adapterContext: options.adapterContext,
         endpoint: options.adapterContext.entryEndpoint,

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/index.js

@@ -1,26 +1,7 @@
 import { captureResponsesContext, buildChatRequestFromResponses } from '../../../../../responses/responses-openai-bridge.js';
+import { captureResponsesRequestContext } from '../../../../../shared/responses-conversation-store.js';
 import { recordStage } from '../../../stages/utils.js';
 export async function runReqInboundStage3ContextCapture(options) {
-    // 对由 server-side 工具触发的二跳/内部跳转请求（例如 stopMessage followup），
-    // 跳过工具输出扫描与 apply_patch 诊断日志，避免在内部流中重复放大客户端已收到的
-    // 工具错误信息。此类请求的工具治理在 chat-process 阶段完成，这里仅保留最小快照。
-    try {
-        const ctx = options.adapterContext;
-        const followupFlag = ctx?.serverToolFollowup;
-        const isFollowup = followupFlag === true ||
-            (typeof followupFlag === 'string' && followupFlag.trim().toLowerCase() === 'true');
-        if (isFollowup) {
-            const snapshot = {
-                providerProtocol: options.adapterContext.providerProtocol ?? 'unknown',
-                tool_outputs: []
-            };
-            recordStage(options.stageRecorder, 'req_inbound_stage3_context_capture', snapshot);
-            return snapshot;
-        }
-    }
-    catch {
-        // best-effort: 若检测 serverToolFollowup 失败，则继续走通用路径
-    }
     let context;
     if (options.captureContext) {
         try {
@@ -37,7 +18,7 @@ export async function runReqInboundStage3ContextCapture(options) {
     const snapshot = context
         ? augmentContextSnapshot(context, fallbackSnapshot)
         : fallbackSnapshot;
-    recordStage(options.stageRecorder, 'req_inbound_stage3_context_capture', snapshot);
+    recordStage(options.stageRecorder, 'chat_process.req.stage3.context_capture', snapshot);
     return context ?? snapshot;
 }
 export function runChatContextCapture(options) {
@@ -73,6 +54,28 @@ export function captureResponsesContextSnapshot(options) {
     catch {
         // best-effort context capture
     }
+    // OpenAI Responses tool loop: store the request context keyed by requestId so that
+    // `/v1/responses/:id/submit_tool_outputs` can resume the conversation later.
+    //
+    // This must be done on the hub pipeline inbound path (not in host/provider), because:
+    // - the tool loop is a client-protocol behavior (/v1/responses), independent of providerProtocol;
+    // - providers must remain transport-only;
+    // - the host may later enhance requestId with providerKey/model for logging, which is handled via rebind.
+    try {
+        const requestId = typeof options.adapterContext.requestId === 'string' && options.adapterContext.requestId.trim().length
+            ? options.adapterContext.requestId
+            : undefined;
+        if (requestId) {
+            captureResponsesRequestContext({
+                requestId,
+                payload: options.rawRequest,
+                context: context
+            });
+        }
+    }
+    catch {
+        // best-effort: capture failures must not block the request path
+    }
     return context;
 }
 function captureChatContextSnapshot(options) {
@@ -306,7 +309,7 @@ function buildApplyPatchDiagnostics(output) {
         return '\n\n[RouteCodex precheck] apply_patch 参数解析失败：缺少字段 "input"。当前 RouteCodex 期望 { input, patch } 形态，并且两个字段都应包含完整统一 diff 文本。';
     }
     if (output.includes('invalid type: map, expected a string')) {
-        return '\n\n[RouteCodex precheck] apply_patch 参数类型错误：检测到 JSON 对象（map），但客户端期望字符串。请先对参数做 JSON.stringify 再写入 arguments，或直接提供 { patch: \"<统一 diff>\" } 形式。';
+        return '\n\n[RouteCodex precheck] apply_patch 参数类型错误：检测到 JSON 对象（map），但客户端期望字符串。请先对参数做 JSON.stringify 再写入 arguments，或直接提供 { patch: "<统一 diff>" } 形式。';
     }
     return undefined;
 }

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/index.js

@@ -28,7 +28,7 @@ export async function runReqOutboundStage1SemanticMap(options) {
         formatEnvelope,
         adapterContext: options.adapterContext
     });
-    recordStage(options.stageRecorder, 'req_outbound_stage1_semantic_map', chatEnvelope);
+    recordStage(options.stageRecorder, 'chat_process.req.stage6.outbound.semantic_map', chatEnvelope);
     return { chatEnvelope, formatEnvelope };
 }
 function attachToolOutputsFromContext(chatEnvelope, snapshot) {

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage2_format_build/index.d.ts

@@ -5,7 +5,7 @@ import type { FormatAdapter, StageRecorder } from '../../../../format-adapters/i
 export interface ReqOutboundStage2FormatBuildOptions {
     formatEnvelope: FormatEnvelope<JsonObject>;
     adapterContext: AdapterContext;
-    formatAdapter: Pick<FormatAdapter, 'buildResponse'>;
+    formatAdapter: Pick<FormatAdapter, 'buildRequest'>;
     stageRecorder?: StageRecorder;
 }
 export declare function runReqOutboundStage2FormatBuild(options: ReqOutboundStage2FormatBuildOptions): Promise<JsonObject>;

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage2_format_build/index.js

@@ -1,9 +1,9 @@
 import { recordStage } from '../../../stages/utils.js';
 const PRIVATE_FIELD_PREFIX = '__rcc_';
 export async function runReqOutboundStage2FormatBuild(options) {
-    const payload = (await options.formatAdapter.buildResponse(options.formatEnvelope, options.adapterContext));
+    const payload = (await options.formatAdapter.buildRequest(options.formatEnvelope, options.adapterContext));
     stripPrivateFields(payload);
-    recordStage(options.stageRecorder, 'req_outbound_stage2_format_build', payload);
+    recordStage(options.stageRecorder, 'chat_process.req.stage7.outbound.format_build', payload);
     return payload;
 }
 function stripPrivateFields(value) {

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage3_compat/index.js

@@ -6,7 +6,7 @@ function pickCompatProfile(adapterContext) {
 export async function runReqOutboundStage3Compat(options) {
     const profile = pickCompatProfile(options.adapterContext);
     const result = applyRequestCompat(profile, options.payload, { adapterContext: options.adapterContext });
-    options.stageRecorder?.record('req_outbound_stage3_compat', {
+    options.stageRecorder?.record('chat_process.req.stage8.outbound.compat', {
         applied: Boolean(result.appliedProfile),
         profile: result.appliedProfile || profile || 'passthrough'
     });
@@ -15,7 +15,7 @@ export async function runReqOutboundStage3Compat(options) {
 export function runRespInboundStageCompatResponse(options) {
     const profile = pickCompatProfile(options.adapterContext);
     const result = applyResponseCompat(profile, options.payload, { adapterContext: options.adapterContext });
-    options.stageRecorder?.record('resp_inbound_stage_compat', {
+    options.stageRecorder?.record('chat_process.resp.stage3.compat', {
         applied: Boolean(result.appliedProfile),
         profile: result.appliedProfile || profile || 'passthrough'
     });

package/dist/conversion/hub/pipeline/stages/req_process/req_process_stage1_tool_governance/index.js

@@ -10,7 +10,7 @@ export async function runReqProcessStage1ToolGovernance(options) {
         requestId: options.requestId
     });
     if (result.processedRequest) {
-        recordStage(options.stageRecorder, 'req_process_stage1_tool_governance', result.processedRequest);
+        recordStage(options.stageRecorder, 'chat_process.req.stage4.tool_governance', result.processedRequest);
         // Best-effort: capture apply_patch execution failures reported by tool role messages.
         // This is for errorsamples collection only and must not affect runtime behavior.
         captureApplyPatchExecutionFailuresFromProcessedRequest(result.processedRequest);

package/dist/conversion/hub/pipeline/stages/req_process/req_process_stage2_route_select/index.js

@@ -5,7 +5,7 @@ export function runReqProcessStage2RouteSelect(options) {
     const result = options.routerEngine.route(options.request, options.metadataInput);
     applyTargetMetadata(options.normalizedMetadata, result.target, result.decision.routeName, previousModel);
     applyTargetToSubject(options.request, result.target, previousModel);
-    recordStage(options.stageRecorder, 'req_process_stage2_route_select', {
+    recordStage(options.stageRecorder, 'chat_process.req.stage5.route_select', {
         target: result.target,
         decision: result.decision,
         diagnostics: result.diagnostics

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage1_sse_decode/index.js

@@ -43,43 +43,43 @@ export async function runRespInboundStage1SseDecode(options) {
     // 某些 mock-provider / 捕获样本在 SSE 连接被异常终止时会携带 error 标记，
     // 即使仍保留 __sse_responses 流，也应视为上游异常并终止。
     if (wrapperError) {
-        recordStage(options.stageRecorder, 'resp_inbound_stage1_sse_decode', {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage1.sse_decode', {
             streamDetected: Boolean(stream),
             decoded: false,
             protocol: options.providerProtocol,
             reason: 'sse_wrapper_error',
             error: wrapperError
         });
-        throw new ProviderProtocolError(`[resp_inbound_stage1_sse_decode] Upstream SSE terminated: ${wrapperError}`, {
+        throw new ProviderProtocolError(`[chat_process.resp.stage1.sse_decode] Upstream SSE terminated: ${wrapperError}`, {
             code: 'SSE_DECODE_ERROR',
             protocol: options.providerProtocol,
             providerType: resolveProviderType(options.providerProtocol),
             details: {
-                phase: 'resp_inbound_stage1_sse_decode',
+                phase: 'chat_process.resp.stage1.sse_decode',
                 requestId: options.adapterContext.requestId,
                 message: wrapperError
             }
         });
     }
     if (!stream) {
-        recordStage(options.stageRecorder, 'resp_inbound_stage1_sse_decode', {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage1.sse_decode', {
             streamDetected: false
         });
         return { payload: options.payload, decodedFromSse: false };
     }
     if (!supportsSseProtocol(options.providerProtocol)) {
-        recordStage(options.stageRecorder, 'resp_inbound_stage1_sse_decode', {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage1.sse_decode', {
             streamDetected: true,
             decoded: false,
             reason: 'protocol_unsupported',
             protocol: options.providerProtocol
         });
-        throw new ProviderProtocolError(`[resp_inbound_stage1_sse_decode] Protocol ${options.providerProtocol} does not support SSE decoding`, {
+        throw new ProviderProtocolError(`[chat_process.resp.stage1.sse_decode] Protocol ${options.providerProtocol} does not support SSE decoding`, {
             code: 'SSE_DECODE_ERROR',
             protocol: options.providerProtocol,
             providerType: resolveProviderType(options.providerProtocol),
             details: {
-                phase: 'resp_inbound_stage1_sse_decode',
+                phase: 'chat_process.resp.stage1.sse_decode',
                 reason: 'protocol_unsupported'
             }
         });
@@ -90,7 +90,7 @@ export async function runRespInboundStage1SseDecode(options) {
             requestId: options.adapterContext.requestId,
             model: options.adapterContext.modelId
         }));
-        recordStage(options.stageRecorder, 'resp_inbound_stage1_sse_decode', {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage1.sse_decode', {
             streamDetected: true,
             decoded: true,
             protocol: options.providerProtocol
@@ -99,18 +99,18 @@ export async function runRespInboundStage1SseDecode(options) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        recordStage(options.stageRecorder, 'resp_inbound_stage1_sse_decode', {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage1.sse_decode', {
             streamDetected: true,
             decoded: false,
             protocol: options.providerProtocol,
             error: message
         });
-        throw new ProviderProtocolError(`[resp_inbound_stage1_sse_decode] Failed to decode SSE payload for protocol ${options.providerProtocol}: ${message}`, {
+        throw new ProviderProtocolError(`[chat_process.resp.stage1.sse_decode] Failed to decode SSE payload for protocol ${options.providerProtocol}: ${message}`, {
             code: 'SSE_DECODE_ERROR',
             protocol: options.providerProtocol,
             providerType: resolveProviderType(options.providerProtocol),
             details: {
-                phase: 'resp_inbound_stage1_sse_decode',
+                phase: 'chat_process.resp.stage1.sse_decode',
                 requestId: options.adapterContext.requestId,
                 message
             }

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage2_format_parse/index.js

@@ -1,6 +1,6 @@
 import { recordStage } from '../../../stages/utils.js';
 export async function runRespInboundStage2FormatParse(options) {
     const envelope = (await options.formatAdapter.parseResponse(options.payload, options.adapterContext));
-    recordStage(options.stageRecorder, 'resp_inbound_stage2_format_parse', envelope);
+    recordStage(options.stageRecorder, 'chat_process.resp.stage2.format_parse', envelope);
     return envelope;
 }

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage3_semantic_map/index.d.ts

@@ -7,6 +7,7 @@ export interface RespInboundStage3SemanticMapOptions {
     adapterContext: AdapterContext;
     formatEnvelope: FormatEnvelope<JsonObject>;
     mapper: ResponseMapper;
+    requestSemantics?: JsonObject;
     stageRecorder?: StageRecorder;
 }
 export declare function runRespInboundStage3SemanticMap(options: RespInboundStage3SemanticMapOptions): Promise<ChatCompletionLike>;

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage3_semantic_map/index.js

@@ -1,6 +1,8 @@
 import { recordStage } from '../../../stages/utils.js';
 export async function runRespInboundStage3SemanticMap(options) {
-    const chatResponse = await options.mapper.toChatCompletion(options.formatEnvelope, options.adapterContext);
-    recordStage(options.stageRecorder, 'resp_inbound_stage3_semantic_map', chatResponse);
+    const chatResponse = await options.mapper.toChatCompletion(options.formatEnvelope, options.adapterContext, {
+        requestSemantics: options.requestSemantics
+    });
+    recordStage(options.stageRecorder, 'chat_process.resp.stage4.semantic_map_to_chat', chatResponse);
     return chatResponse;
 }

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.d.ts

@@ -7,6 +7,7 @@ export interface RespOutboundStage1ClientRemapOptions {
     clientProtocol: ClientProtocol;
     requestId: string;
     adapterContext?: AdapterContext;
+    requestSemantics?: JsonObject;
     stageRecorder?: StageRecorder;
 }
 export declare function runRespOutboundStage1ClientRemap(options: RespOutboundStage1ClientRemapOptions): JsonObject;

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js

@@ -8,24 +8,28 @@ export function runRespOutboundStage1ClientRemap(options) {
     }
     else if (options.clientProtocol === 'anthropic-messages') {
         clientPayload = buildAnthropicResponseFromChat(options.payload, {
-            aliasMap: resolveAliasMapFromContext(options.adapterContext)
+            aliasMap: resolveAliasMapFromSemantics(options.requestSemantics)
         });
     }
     else {
-        const toolsRaw = resolveClientToolsRawFromContext(options.adapterContext);
+        const toolsRaw = resolveClientToolsRawFromSemantics(options.requestSemantics);
         clientPayload = buildResponsesPayloadFromChat(options.payload, {
             requestId: options.requestId,
             ...(toolsRaw ? { toolsRaw } : {})
         });
     }
-    recordStage(options.stageRecorder, 'resp_outbound_stage1_client_remap', clientPayload);
+    recordStage(options.stageRecorder, 'chat_process.resp.stage9.client_remap', clientPayload);
     return clientPayload;
 }
-function resolveAliasMapFromContext(adapterContext) {
-    if (!adapterContext) {
+function resolveAliasMapFromSemantics(semantics) {
+    if (!semantics || typeof semantics !== 'object' || Array.isArray(semantics)) {
         return undefined;
     }
-    const candidate = adapterContext.anthropicToolNameMap;
+    const toolsNode = semantics.tools;
+    if (!toolsNode || typeof toolsNode !== 'object' || Array.isArray(toolsNode)) {
+        return undefined;
+    }
+    const candidate = toolsNode.toolNameAliasMap;
     if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
         return undefined;
     }
@@ -43,11 +47,15 @@ function resolveAliasMapFromContext(adapterContext) {
     }
     return Object.keys(map).length ? map : undefined;
 }
-function resolveClientToolsRawFromContext(adapterContext) {
-    if (!adapterContext) {
+function resolveClientToolsRawFromSemantics(semantics) {
+    if (!semantics || typeof semantics !== 'object' || Array.isArray(semantics)) {
+        return undefined;
+    }
+    const toolsNode = semantics.tools;
+    if (!toolsNode || typeof toolsNode !== 'object' || Array.isArray(toolsNode)) {
         return undefined;
     }
-    const candidate = adapterContext.clientToolsRaw;
+    const candidate = toolsNode.clientToolsRaw;
     if (!candidate || !Array.isArray(candidate)) {
         return undefined;
     }

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.js

@@ -2,7 +2,7 @@ import { defaultSseCodecRegistry } from '../../../../../../sse/index.js';
 import { recordStage } from '../../../stages/utils.js';
 export async function runRespOutboundStage2SseStream(options) {
     if (!options.wantsStream) {
-        recordStage(options.stageRecorder, 'resp_outbound_stage2_sse_stream', {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage10.sse_stream', {
             passthrough: false,
             protocol: options.clientProtocol,
             payload: options.clientPayload
@@ -13,7 +13,7 @@ export async function runRespOutboundStage2SseStream(options) {
     const stream = await codec.convertJsonToSse(options.clientPayload, {
         requestId: options.requestId
     });
-    recordStage(options.stageRecorder, 'resp_outbound_stage2_sse_stream', {
+    recordStage(options.stageRecorder, 'chat_process.resp.stage10.sse_stream', {
         passthrough: false,
         protocol: options.clientProtocol,
         payload: options.clientPayload

package/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage1_tool_governance/index.js

@@ -1,17 +1,55 @@
 import { runChatResponseToolFilters } from '../../../../../shared/tool-filter-pipeline.js';
 import { normalizeApplyPatchToolCallsOnResponse } from '../../../../../shared/tool-governor.js';
+import { buildChatResponseFromResponses } from '../../../../../shared/responses-response-utils.js';
 import { ToolGovernanceEngine } from '../../../../tool-governance/index.js';
 import { recordStage } from '../../../stages/utils.js';
 const toolGovernanceEngine = new ToolGovernanceEngine();
+function isCanonicalChatCompletion(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return false;
+    }
+    const obj = payload;
+    const choices = Array.isArray(obj.choices) ? obj.choices : [];
+    if (!choices.length)
+        return false;
+    const first = choices[0] && typeof choices[0] === 'object' && !Array.isArray(choices[0]) ? choices[0] : null;
+    if (!first)
+        return false;
+    const msg = first.message;
+    return Boolean(msg && typeof msg === 'object' && !Array.isArray(msg));
+}
+function coerceToCanonicalChatCompletion(payload) {
+    if (isCanonicalChatCompletion(payload)) {
+        return payload;
+    }
+    // ServerTool followups may re-enter via the client protocol shape (e.g. OpenAI Responses object:'response').
+    // Response tool governance requires an OpenAI-chat-like surface (choices[].message) so text tool harvesting
+    // and tool governance remain a single fixed path.
+    try {
+        const coerced = buildChatResponseFromResponses(payload);
+        if (isCanonicalChatCompletion(coerced)) {
+            return coerced;
+        }
+    }
+    catch {
+        // best-effort: keep original payload when bridge fails
+    }
+    return payload;
+}
 export async function runRespProcessStage1ToolGovernance(options) {
-    const filtered = await runChatResponseToolFilters(options.payload, {
+    const canonicalInput = coerceToCanonicalChatCompletion(options.payload);
+    recordStage(options.stageRecorder, 'chat_process.resp.stage6.canonicalize_chat_completion', {
+        converted: canonicalInput !== options.payload,
+        canonicalPayload: canonicalInput
+    });
+    const filtered = await runChatResponseToolFilters(canonicalInput, {
         entryEndpoint: options.entryEndpoint,
         requestId: options.requestId,
         profile: 'openai-chat'
     });
     const patched = normalizeApplyPatchToolCallsOnResponse(filtered);
     const { payload: governed, summary } = toolGovernanceEngine.governResponse(patched, options.clientProtocol);
-    recordStage(options.stageRecorder, 'resp_process_stage1_tool_governance', {
+    recordStage(options.stageRecorder, 'chat_process.resp.stage7.tool_governance', {
         summary,
         applied: summary?.applied,
         filteredPayload: patched,

package/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage2_finalize/index.js

@@ -11,7 +11,7 @@ export async function runRespProcessStage2Finalize(options) {
     const processedRequest = buildProcessedRequestFromChatResponse(finalized, {
         stream: options.wantsStream
     });
-    recordStage(options.stageRecorder, 'resp_process_stage2_finalize', {
+    recordStage(options.stageRecorder, 'chat_process.resp.stage8.finalize', {
         model: finalized.model,
         stream: options.wantsStream
     });

package/dist/conversion/hub/pipeline/target-utils.js

@@ -1,3 +1,4 @@
+import { ensureRuntimeMetadata } from '../../shared/runtime-metadata.js';
 export function applyTargetMetadata(metadata, target, routeName, originalModel) {
     if (!metadata || typeof metadata !== 'object') {
         return;
@@ -9,11 +10,14 @@ export function applyTargetMetadata(metadata, target, routeName, originalModel)
     metadata.providerType = target.providerType;
     metadata.modelId = target.modelId;
     metadata.processMode = target.processMode || 'chat';
-    if (target.forceWebSearch === true) {
-        metadata.forceWebSearch = true;
-    }
-    if (target.forceVision === true) {
-        metadata.forceVision = true;
+    if (target.forceWebSearch === true || target.forceVision === true) {
+        const rt = ensureRuntimeMetadata(metadata);
+        if (target.forceWebSearch === true) {
+            rt.forceWebSearch = true;
+        }
+        if (target.forceVision === true) {
+            rt.forceVision = true;
+        }
     }
     if (target.responsesConfig?.toolCallIdStyle) {
         metadata.toolCallIdStyle = target.responsesConfig.toolCallIdStyle;