@jsonstudio/llms 0.6.3409 → 0.6.3539

package/dist/conversion/pipeline/codecs/v2/responses-openai-pipeline.js

@@ -1,11 +1,10 @@
-import { ProtocolConversionPipeline } from '../../index.js';
-import { chatEnvelopeToStandardized } from '../../../hub/standardized-bridge.js';
-import { ResponsesFormatAdapter } from '../../../hub/format-adapters/responses-format-adapter.js';
-import { ResponsesSemanticMapper } from '../../../hub/semantic-mappers/responses-mapper.js';
-import { captureResponsesContext, buildChatRequestFromResponses, buildResponsesPayloadFromChat } from '../../../responses/responses-openai-bridge.js';
-import { buildAdapterContextFromPipeline } from '../../hooks/adapter-context.js';
 import { runStandardChatRequestFilters } from '../../../index.js';
+import { buildChatRequestFromResponses, buildResponsesPayloadFromChat, captureResponsesContext } from '../../../responses/responses-openai-bridge.js';
+import { ConversionMetaBag } from '../../meta/meta-bag.js';
 import { canonicalizeOpenAIChatResponse, convertStandardizedToOpenAIChat as convertCanonicalToOpenAIChat, OPENAI_PROTOCOL } from './shared/openai-chat-helpers.js';
+import { buildAdapterContextFromPipeline } from '../../hooks/adapter-context.js';
+import { chatEnvelopeToStandardizedWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+import { standardizedToChatEnvelopeWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
 const DEFAULT_RESPONSES_ENDPOINT = '/v1/responses';
 const RESPONSES_PROTOCOL = 'openai-responses';
 function assertJsonObject(value, stage) {
@@ -117,49 +116,6 @@ function captureToolResults(payload) {
     }
     return results;
 }
-function createResponsesHooks() {
-    const formatAdapter = new ResponsesFormatAdapter();
-    const semanticMapper = new ResponsesSemanticMapper();
-    return {
-        id: 'responses-openai-v2',
-        protocol: RESPONSES_PROTOCOL,
-        inbound: {
-            parse: async ({ wire, context, meta }) => {
-                const adapterContext = buildAdapterContextFromPipeline(context, {
-                    defaultEntryEndpoint: DEFAULT_RESPONSES_ENDPOINT,
-                    overrideProtocol: RESPONSES_PROTOCOL
-                });
-                const formatEnvelope = await formatAdapter.parseRequest(wire, adapterContext);
-                const chatEnvelope = await semanticMapper.toChat(formatEnvelope, adapterContext);
-                const canonical = chatEnvelopeToStandardized(chatEnvelope, {
-                    adapterContext,
-                    endpoint: adapterContext.entryEndpoint,
-                    requestId: adapterContext.requestId
-                });
-                // Capture Responses-specific context for outbound mapping parity
-                const responsesContext = captureResponsesContext(wire, { route: { requestId: adapterContext.requestId } });
-                const built = buildChatRequestFromResponses(wire, responsesContext);
-                if (built.toolsNormalized) {
-                    responsesContext.toolsNormalized = built.toolsNormalized;
-                }
-                const captured = captureToolResults(wire);
-                if (captured.length) {
-                    responsesContext.__captured_tool_results = captured;
-                }
-                meta.set('responsesContext', cloneResponsesContext(responsesContext));
-                return { canonical };
-            }
-        },
-        outbound: {
-            serialize: async ({ canonical, meta }) => {
-                const stored = meta.consume('responsesContext');
-                const responsesContext = restoreResponsesContext(stored);
-                const payload = buildResponsesPayloadFromChat(canonical, responsesContext);
-                return { payload: assertJsonObject(payload, 'responses_outbound_serialize') };
-            }
-        }
-    };
-}
 function buildPipelineContext(profile, context) {
     return {
         requestId: context.requestId,
@@ -173,12 +129,8 @@ function buildPipelineContext(profile, context) {
 }
 export class ResponsesOpenAIPipelineCodec {
     id = 'responses-openai-v2';
-    pipeline;
     requestMetaStore = new Map();
     initialized = false;
-    constructor() {
-        this.pipeline = new ProtocolConversionPipeline(createResponsesHooks());
-    }
     async initialize() {
         this.initialized = true;
     }
@@ -195,13 +147,44 @@ export class ResponsesOpenAIPipelineCodec {
         const inboundContext = buildPipelineContext(profile, context);
         const requestId = context.requestId ?? inboundContext.requestId ?? `req_${Date.now()}`;
         inboundContext.requestId = requestId;
-        const inboundOptions = {
-            payload: assertJsonObject(payload, 'responses_inbound_request'),
-            context: inboundContext
-        };
-        const inbound = await this.pipeline.convertInbound(inboundOptions);
-        this.stashMeta(requestId, inbound.meta);
-        const openaiPayload = await convertCanonicalToOpenAIChat(inbound.canonical, inbound.context);
+        const wire = assertJsonObject(payload, 'responses_inbound_request');
+        const responsesContext = captureResponsesContext(wire, { route: { requestId } });
+        const built = buildChatRequestFromResponses(wire, responsesContext);
+        if (built.toolsNormalized) {
+            responsesContext.toolsNormalized = built.toolsNormalized;
+        }
+        const captured = captureToolResults(wire);
+        if (captured.length) {
+            responsesContext.__captured_tool_results = captured;
+        }
+        const adapterContext = buildAdapterContextFromPipeline(inboundContext, {
+            defaultEntryEndpoint: DEFAULT_RESPONSES_ENDPOINT,
+            overrideProtocol: RESPONSES_PROTOCOL
+        });
+        const chatEnvelope = standardizedToChatEnvelopeWithNative({
+            request: {
+                model: built.request.model,
+                messages: built.request.messages,
+                tools: built.request.tools ?? [],
+                parameters: {
+                    ...(typeof built.request.model === 'string'
+                        ? { model: built.request.model }
+                        : {})
+                },
+                metadata: {}
+            },
+            adapterContext: adapterContext
+        });
+        const canonical = chatEnvelopeToStandardizedWithNative({
+            chatEnvelope: chatEnvelope,
+            adapterContext: adapterContext,
+            endpoint: adapterContext.entryEndpoint ?? DEFAULT_RESPONSES_ENDPOINT,
+            requestId
+        });
+        const meta = new ConversionMetaBag();
+        meta.set('responsesContext', cloneResponsesContext(responsesContext));
+        this.stashMeta(requestId, meta);
+        const openaiPayload = await convertCanonicalToOpenAIChat(canonical, inboundContext);
         const filterContext = {
             ...context,
             requestId,
@@ -221,13 +204,9 @@ export class ResponsesOpenAIPipelineCodec {
         if (storedMeta) {
             this.requestMetaStore.delete(requestId);
         }
+        const stored = storedMeta?.responsesContext;
+        const responsesContext = restoreResponsesContext(stored);
         const sanitized = await canonicalizeOpenAIChatResponse(assertJsonObject(payload, 'responses_openai_response'), context);
-        const outboundOptions = {
-            canonical: sanitized,
-            context: pipelineContext,
-            meta: storedMeta
-        };
-        const outbound = await this.pipeline.convertOutbound(outboundOptions);
-        return outbound.payload;
+        return assertJsonObject(buildResponsesPayloadFromChat(sanitized, responsesContext), 'responses_outbound_serialize');
     }
 }

package/dist/conversion/pipeline/codecs/v2/shared/openai-chat-helpers.js

@@ -1,13 +1,9 @@
-import { standardizedToChatEnvelope } from '../../../../hub/standardized-bridge.js';
 import { buildAdapterContextFromPipeline } from '../../../hooks/adapter-context.js';
-import { ChatFormatAdapter } from '../../../../hub/format-adapters/chat-format-adapter.js';
-import { ChatSemanticMapper } from '../../../../hub/semantic-mappers/chat-mapper.js';
-import { FilterEngine, ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter } from '../../../../../filters/index.js';
-import { normalizeChatResponseReasoningTools } from '../../../../shared/reasoning-tool-normalizer.js';
+import { standardizedToChatEnvelopeWithNative } from '../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
+import { mapOpenaiChatFromChatWithNative } from '../../../../../router/virtual-router/engine-selection/native-hub-pipeline-semantic-mappers.js';
+import { runOpenAIResponseCodecWithNative } from '../../../../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
 export const DEFAULT_OPENAI_ENDPOINT = '/v1/chat/completions';
 export const OPENAI_PROTOCOL = 'openai-chat';
-const sharedChatFormatAdapter = new ChatFormatAdapter();
-const sharedChatSemanticMapper = new ChatSemanticMapper();
 function ensureJsonObject(value, stage) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         throw new Error(`OpenAI chat helper requires JSON object payload at ${stage}`);
@@ -19,41 +15,20 @@ export async function convertStandardizedToOpenAIChat(standardized, context, opt
         defaultEntryEndpoint: options?.defaultEndpoint ?? DEFAULT_OPENAI_ENDPOINT,
         overrideProtocol: OPENAI_PROTOCOL
     });
-    const chatEnvelope = standardizedToChatEnvelope(standardized, { adapterContext });
-    const formatEnvelope = await sharedChatSemanticMapper.fromChat(chatEnvelope, adapterContext);
-    const payload = await sharedChatFormatAdapter.buildRequest(formatEnvelope, adapterContext);
-    return ensureJsonObject(payload, 'openai_request_build');
+    const chatEnvelope = standardizedToChatEnvelopeWithNative({
+        request: standardized,
+        adapterContext: adapterContext
+    });
+    const formatEnvelope = mapOpenaiChatFromChatWithNative(chatEnvelope, adapterContext);
+    return ensureJsonObject(formatEnvelope.payload, 'openai_request_build');
 }
 export async function canonicalizeOpenAIChatResponse(payload, context, options) {
-    const dto = {
-        data: payload,
-        metadata: {
-            requestId: context.requestId ?? `req_${Date.now()}`,
-            pipelineId: context.metadata?.pipelineId ?? 'conversion-router',
-            processingTime: 0,
-            stages: []
-        }
-    };
-    const filterContext = {
-        requestId: dto.metadata.requestId,
-        model: typeof payload.model === 'string' ? payload.model : undefined,
+    return ensureJsonObject(runOpenAIResponseCodecWithNative(payload, {
+        requestId: context.requestId ?? `req_${Date.now()}`,
         endpoint: context.entryEndpoint ?? context.endpoint ?? options?.defaultEndpoint ?? DEFAULT_OPENAI_ENDPOINT,
+        stream: context.stream === true,
+        reasoningMode: context.metadata?.reasoningMode,
         profile: options?.profile ?? OPENAI_PROTOCOL,
-        debug: { emit: () => { } }
-    };
-    const engine = new FilterEngine();
-    engine.registerFilter(new ResponseToolTextCanonicalizeFilter());
-    engine.registerFilter(new ResponseToolArgumentsStringifyFilter());
-    engine.registerFilter(new ResponseFinishInvariantsFilter());
-    const stage1 = await engine.run('response_pre', dto.data, filterContext);
-    const stage2 = await engine.run('response_map', stage1, filterContext);
-    const stage3 = await engine.run('response_post', stage2, filterContext);
-    const normalized = ensureJsonObject(stage3, 'openai_response_filters');
-    try {
-        normalizeChatResponseReasoningTools(normalized, { idPrefixBase: 'reasoning_choice' });
-    }
-    catch {
-        // reasoning normalization best-effort
-    }
-    return normalized;
+        idPrefixBase: 'reasoning_choice'
+    }), 'openai_response_filters');
 }

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

@@ -2,270 +2,11 @@ import { evaluateResponsesHostPolicy } from '../responses-host-policy.js';
 import { normalizeMessageReasoningTools } from '../../shared/reasoning-tool-normalizer.js';
 import { createBridgeActionState, runBridgeActionPipeline } from '../../bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from '../../bridge-policies.js';
-import { buildResponsesOutputFromChat } from '../../shared/responses-output-builder.js';
 import { consumeResponsesPayloadSnapshot, consumeResponsesPassthrough } from '../../shared/responses-reasoning-registry.js';
-import { sanitizeResponsesFunctionName, stripInternalToolingMetadata } from '../../shared/responses-tool-utils.js';
+import { stripInternalToolingMetadata } from '../../shared/responses-tool-utils.js';
 import { ProviderProtocolError } from '../../provider-protocol-error.js';
-import { normalizeResponsesToolCallArgumentsForClientWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+import { buildResponsesPayloadFromChatWithNative, normalizeResponsesToolCallArgumentsForClientWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
 import { normalizeChatResponseReasoningToolsWithNative } from '../../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
-function isPlainObject(value) {
-    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
-}
-function deepCloneRecord(value) {
-    try {
-        const structuredCloneImpl = globalThis.structuredClone;
-        if (typeof structuredCloneImpl === 'function') {
-            return structuredCloneImpl(value);
-        }
-    }
-    catch {
-        // ignore structuredClone failures
-    }
-    try {
-        return JSON.parse(JSON.stringify(value));
-    }
-    catch {
-        return { ...value };
-    }
-}
-function isMissingResponseField(value) {
-    if (value === undefined || value === null) {
-        return true;
-    }
-    if (Array.isArray(value)) {
-        return value.length === 0;
-    }
-    return false;
-}
-function mergeResponseOutputItems(baseOutput, sourceOutput) {
-    if (!Array.isArray(baseOutput) || !Array.isArray(sourceOutput)) {
-        return baseOutput;
-    }
-    const sourceById = new Map();
-    sourceOutput.forEach((entry) => {
-        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
-            return;
-        }
-        const id = typeof entry.id === 'string' ? entry.id.trim() : '';
-        if (!id.length) {
-            return;
-        }
-        sourceById.set(id, entry);
-    });
-    return baseOutput.map((entry, index) => {
-        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
-            return entry;
-        }
-        const baseItem = deepCloneRecord(entry);
-        const baseId = typeof baseItem.id === 'string' ? String(baseItem.id).trim() : '';
-        let sourceItem;
-        if (baseId.length) {
-            sourceItem = sourceById.get(baseId);
-        }
-        if (!sourceItem) {
-            const candidate = sourceOutput[index];
-            if (candidate && typeof candidate === 'object' && !Array.isArray(candidate)) {
-                sourceItem = candidate;
-            }
-        }
-        if (!sourceItem) {
-            return baseItem;
-        }
-        if (isMissingResponseField(baseItem.content) && sourceItem.content !== undefined) {
-            baseItem.content = deepCloneRecord({ value: sourceItem.content }).value;
-        }
-        if (isMissingResponseField(baseItem.summary) && sourceItem.summary !== undefined) {
-            baseItem.summary = deepCloneRecord({ value: sourceItem.summary }).value;
-        }
-        if (isMissingResponseField(baseItem.encrypted_content) && sourceItem.encrypted_content !== undefined) {
-            baseItem.encrypted_content = deepCloneRecord({ value: sourceItem.encrypted_content }).value;
-        }
-        return baseItem;
-    });
-}
-function mergeResponseTopLevelFields(options) {
-    const merged = deepCloneRecord(options.base);
-    const source = options.source;
-    const sourceWins = options.sourceWinsKeys ?? [];
-    for (const key of sourceWins) {
-        if (source[key] !== undefined) {
-            merged[key] = deepCloneRecord({ value: source[key] }).value;
-        }
-    }
-    const passthroughKeys = ['metadata', 'temperature', 'top_p', 'prompt_cache_key', 'reasoning'];
-    for (const key of passthroughKeys) {
-        if (source[key] !== undefined && merged[key] === undefined) {
-            merged[key] = deepCloneRecord({ value: source[key] }).value;
-        }
-    }
-    if (merged.output !== undefined && source.output !== undefined) {
-        merged.output = mergeResponseOutputItems(merged.output, source.output);
-    }
-    return merged;
-}
-function tryParseJson(value) {
-    if (typeof value !== 'string')
-        return null;
-    const trimmed = value.trim();
-    if (!trimmed)
-        return null;
-    if (!(trimmed.startsWith('{') || trimmed.startsWith('[')))
-        return null;
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch {
-        return null;
-    }
-}
-function looksLikeApplyPatchText(value) {
-    const trimmed = value.trim();
-    if (!trimmed)
-        return false;
-    return trimmed.includes('*** Begin Patch') && trimmed.includes('*** End Patch');
-}
-function extractFreeformTextFromArgs(argsRaw) {
-    if (typeof argsRaw === 'string') {
-        const trimmed = argsRaw.trim();
-        if (!trimmed)
-            return null;
-        // If JSON wrapper, extract common fields first.
-        const parsed = tryParseJson(trimmed);
-        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-            const rec = parsed;
-            for (const key of ['instructions', 'patch', 'input', 'text']) {
-                if (typeof rec[key] === 'string' && rec[key].trim().length) {
-                    return String(rec[key]).trim();
-                }
-            }
-        }
-        // If it's already freeform (not a JSON wrapper), keep.
-        if (!trimmed.startsWith('{') && !trimmed.startsWith('[') && looksLikeApplyPatchText(trimmed)) {
-            return trimmed;
-        }
-        // Unknown freeform: return as-is so client can error.
-        return trimmed;
-    }
-    // If arguments is an object (malformed), try to extract patch-like fields.
-    if (argsRaw && typeof argsRaw === 'object' && !Array.isArray(argsRaw)) {
-        const rec = argsRaw;
-        for (const key of ['instructions', 'patch', 'input', 'text']) {
-            if (typeof rec[key] === 'string' && rec[key].trim().length) {
-                return String(rec[key]).trim();
-            }
-        }
-    }
-    return null;
-}
-function extractJsonSchemaLike(parameters) {
-    const required = Array.isArray(parameters.required)
-        ? parameters.required.filter((v) => typeof v === 'string' && v.trim().length > 0).map((v) => v.trim())
-        : [];
-    const props = parameters.properties && typeof parameters.properties === 'object' && !Array.isArray(parameters.properties)
-        ? parameters.properties
-        : {};
-    const properties = Object.keys(props);
-    if (!required.length && !properties.length) {
-        return null;
-    }
-    const additionalProperties = typeof parameters.additionalProperties === 'boolean' ? parameters.additionalProperties : true;
-    return { required, properties, additionalProperties };
-}
-function repairToolArgsBySchemaKeys(toolName, record, schema) {
-    // Apply known alias mappings only if the target keys are present in schema properties.
-    const wants = new Set(schema.properties);
-    const out = { ...record };
-    if (toolName === 'exec_command') {
-        if (wants.has('cmd') && out.command !== undefined && out.cmd === undefined)
-            out.cmd = out.command;
-        if (wants.has('command') && out.cmd !== undefined && out.command === undefined)
-            out.command = out.cmd;
-    }
-    if (toolName === 'write_stdin') {
-        if (wants.has('chars') && out.text !== undefined && out.chars === undefined)
-            out.chars = out.text;
-        if (wants.has('text') && out.chars !== undefined && out.text === undefined)
-            out.text = out.chars;
-    }
-    if (toolName === 'apply_patch') {
-        if (wants.has('instructions') && out.instructions === undefined) {
-            if (typeof out.patch === 'string' && out.patch.trim().length)
-                out.instructions = out.patch;
-            else if (typeof out.input === 'string' && out.input.trim().length)
-                out.instructions = out.input;
-        }
-        if (wants.has('patch') && out.patch === undefined) {
-            if (typeof out.instructions === 'string' && out.instructions.trim().length)
-                out.patch = out.instructions;
-            else if (typeof out.input === 'string' && out.input.trim().length)
-                out.patch = out.input;
-        }
-    }
-    for (const key of schema.required) {
-        if (!Object.prototype.hasOwnProperty.call(out, key)) {
-            return null;
-        }
-    }
-    if (schema.additionalProperties === false && schema.properties.length > 0) {
-        for (const key of Object.keys(out)) {
-            if (!wants.has(key))
-                delete out[key];
-        }
-    }
-    return out;
-}
-function buildClientToolIndex(toolsRaw) {
-    const index = new Map();
-    for (const tool of toolsRaw) {
-        if (!tool || typeof tool !== 'object' || Array.isArray(tool))
-            continue;
-        const t = tool;
-        const fn = t.function && typeof t.function === 'object' && !Array.isArray(t.function) ? t.function : undefined;
-        const nameRaw = (fn && typeof fn.name === 'string' ? fn.name : undefined) ?? (typeof t.name === 'string' ? t.name : undefined);
-        const name = typeof nameRaw === 'string' ? nameRaw.trim() : '';
-        if (!name)
-            continue;
-        const formatRaw = (typeof t.format === 'string' ? t.format : undefined) ??
-            (fn && typeof fn.format === 'string' ? fn.format : undefined);
-        const parametersRaw = (fn && fn.parameters && typeof fn.parameters === 'object' && !Array.isArray(fn.parameters) ? fn.parameters : undefined) ??
-            (t.parameters && typeof t.parameters === 'object' && !Array.isArray(t.parameters) ? t.parameters : undefined) ??
-            undefined;
-        index.set(name, {
-            name,
-            ...(typeof formatRaw === 'string' && formatRaw.trim().length ? { format: formatRaw.trim() } : {}),
-            ...(parametersRaw ? { parameters: parametersRaw } : {})
-        });
-    }
-    return index;
-}
-function resolveClientToolName(toolIndex, rawToolName) {
-    const trimmed = rawToolName.trim();
-    if (!trimmed.length)
-        return undefined;
-    if (toolIndex.has(trimmed))
-        return trimmed;
-    const lower = trimmed.toLowerCase();
-    for (const key of toolIndex.keys()) {
-        if (key.toLowerCase() === lower) {
-            return key;
-        }
-    }
-    const hasBash = Array.from(toolIndex.keys()).some((key) => key.toLowerCase() === 'bash');
-    if (hasBash)
-        return undefined;
-    if (!['shell_command', 'exec_command', 'shell', 'terminal', 'bash'].includes(lower)) {
-        return undefined;
-    }
-    const preferred = ['shell_command', 'exec_command', 'shell', 'terminal'];
-    for (const candidate of preferred) {
-        for (const key of toolIndex.keys()) {
-            if (key.toLowerCase() === candidate) {
-                return key;
-            }
-        }
-    }
-    return undefined;
-}
 function normalizeResponsesToolCallArgumentsForClient(responsesPayload, context) {
     const toolsRaw = Array.isArray(context?.toolsRaw) ? context?.toolsRaw : [];
     if (!toolsRaw.length) {
@@ -310,6 +51,23 @@ function shouldStripHostManagedFields(context) {
     const result = evaluateResponsesHostPolicy(context, typeof context?.targetProtocol === 'string' ? context?.targetProtocol : undefined);
     return result.shouldStripHostManagedFields;
 }
+function collectRetentionContext(context) {
+    const stripHostManagedFields = shouldStripHostManagedFields(context);
+    return {
+        metadata: context?.metadata,
+        parallelToolCalls: context?.parallel_tool_calls,
+        toolChoice: context?.tool_choice,
+        include: context?.include,
+        store: context?.store,
+        stripHostManagedFields
+    };
+}
+function readInlineRetentionPayload(response, key) {
+    const candidate = response[key];
+    return candidate && typeof candidate === 'object' && !Array.isArray(candidate)
+        ? candidate
+        : undefined;
+}
 export function buildResponsesPayloadFromChat(payload, context) {
     if (!payload || typeof payload !== 'object')
         return payload;
@@ -323,7 +81,10 @@ export function buildResponsesPayloadFromChat(payload, context) {
     const snapshotPayload = snapshotLookupKey ? consumeResponsesPayloadSnapshot(snapshotLookupKey) : undefined;
     const passthroughPayload = snapshotLookupKey ? consumeResponsesPassthrough(snapshotLookupKey) : undefined;
     const sourceForRetention = (passthroughPayload && typeof passthroughPayload === 'object' ? passthroughPayload : undefined) ??
-        (snapshotPayload && typeof snapshotPayload === 'object' ? snapshotPayload : undefined);
+        readInlineRetentionPayload(response, '__responses_passthrough') ??
+        (snapshotPayload && typeof snapshotPayload === 'object' ? snapshotPayload : undefined) ??
+        readInlineRetentionPayload(response, '__responses_payload_snapshot');
+    const retentionContext = collectRetentionContext(context);
     const hasChoicesArray = Array.isArray(response.choices);
     const choicesLength = hasChoicesArray ? response.choices.length : 0;
     if (!hasChoicesArray || choicesLength === 0) {
@@ -338,47 +99,17 @@ export function buildResponsesPayloadFromChat(payload, context) {
             : 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;
-        }
-        const mergedFallback = sourceForRetention && typeof sourceForRetention === 'object'
-            ? mergeResponseTopLevelFields({
-                base: out,
-                source: sourceForRetention,
-                sourceWinsKeys: ['metadata', 'temperature', 'top_p', 'prompt_cache_key', 'reasoning']
-            })
-            : out;
+        const mergedFallback = buildResponsesPayloadFromChatWithNative(response, {
+            requestId: context?.requestId,
+            toolsRaw: Array.isArray(context?.toolsRaw) ? context?.toolsRaw : [],
+            metadata: retentionContext.metadata,
+            parallelToolCalls: retentionContext.parallelToolCalls,
+            toolChoice: retentionContext.toolChoice,
+            include: retentionContext.include,
+            store: retentionContext.store,
+            stripHostManagedFields: retentionContext.stripHostManagedFields,
+            sourceForRetention: sourceForRetention
+        });
         if (mergedFallback.metadata) {
             stripInternalToolingMetadata(mergedFallback.metadata);
         }
@@ -441,57 +172,25 @@ export function buildResponsesPayloadFromChat(payload, context) {
             // best-effort reasoning normalization
         }
     }
-    const outputBuild = buildResponsesOutputFromChat({
-        response: response,
-        message,
+    const nativeBuilt = buildResponsesPayloadFromChatWithNative(response, {
         requestId: context?.requestId,
-        sanitizeFunctionName: sanitizeResponsesFunctionName
+        toolsRaw: Array.isArray(context?.toolsRaw) ? context?.toolsRaw : [],
+        metadata: retentionContext.metadata,
+        parallelToolCalls: retentionContext.parallelToolCalls,
+        toolChoice: retentionContext.toolChoice,
+        include: retentionContext.include,
+        store: retentionContext.store,
+        stripHostManagedFields: retentionContext.stripHostManagedFields,
+        sourceForRetention: sourceForRetention
     });
     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: outputBuild.status,
-        output: outputBuild.outputItems
+        ...nativeBuilt
     };
-    if (typeof outputBuild.outputText === 'string') {
-        out.output_text = outputBuild.outputText;
-    }
-    if (outputBuild.usage !== undefined)
-        out.usage = outputBuild.usage;
-    if (outputBuild.requiredAction)
-        out.required_action = outputBuild.requiredAction;
     normalizeResponsesToolCallArgumentsForClient(out, context);
-    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 (out.metadata) {
+        stripInternalToolingMetadata(out.metadata);
     }
-    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;
-    }
-    const merged = sourceForRetention && typeof sourceForRetention === 'object'
-        ? mergeResponseTopLevelFields({
-            base: out,
-            source: sourceForRetention,
-            sourceWinsKeys: ['metadata', 'temperature', 'top_p', 'prompt_cache_key', 'reasoning']
-        })
-        : out;
-    if (merged.metadata) {
-        stripInternalToolingMetadata(merged.metadata);
-    }
-    return merged;
+    return out;
 }
 export function extractRequestIdFromResponse(response) {
     if (response && typeof response === 'object' && 'metadata' in response && response.metadata && typeof response.metadata === 'object') {