@jsonstudio/llms 0.6.1892 → 0.6.2172

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

@@ -1,18 +1,18 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import { ensureBridgeInstructions } from '../shared/bridge-instructions.js';
 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 { createToolCallIdTransformer, enforceToolCallIdStyle, resolveToolCallIdStyle, sanitizeResponsesFunctionName } from '../shared/responses-tool-utils.js';
 import { mapBridgeToolsToChat, mapChatToolsToBridge } from '../shared/tool-mapping.js';
 import { ProviderProtocolError } from '../shared/errors.js';
 import { readRuntimeMetadata } from '../shared/runtime-metadata.js';
 import { clampResponsesInputItemId } from '../shared/bridge-id-utils.js';
+import { isImagePath } from '../shared/media.js';
 // --- Utilities (ported strictly) ---
-import { canonicalizeChatResponseTools } from '../shared/tool-canonicalizer.js';
-import { normalizeMessageReasoningTools } from '../shared/reasoning-tool-normalizer.js';
 import { createBridgeActionState, runBridgeActionPipeline } from '../shared/bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from '../shared/bridge-policies.js';
-import { buildResponsesOutputFromChat } from '../shared/responses-output-builder.js';
-import { consumeResponsesPayloadSnapshot, consumeResponsesPassthrough } from '../shared/responses-reasoning-registry.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -45,7 +45,192 @@ function filterBridgeInputForUpstream(input, options) {
 }
 // normalizeTools unified in ../shared/args-mapping.ts
 // --- Structured self-repair helpers for tool failures (Responses path) ---
-// use shared isImagePath
+const IMAGE_MIME_BY_EXT = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.bmp': 'image/bmp',
+    '.svg': 'image/svg+xml',
+    '.tif': 'image/tiff',
+    '.tiff': 'image/tiff',
+    '.ico': 'image/x-icon',
+    '.heic': 'image/heic',
+    '.jxl': 'image/jxl'
+};
+function decodeEscapedPathLikeText(input) {
+    if (!input || input.indexOf('\\') < 0) {
+        return input;
+    }
+    return input
+        .replace(/\\\//g, '/')
+        .replace(/\\u([0-9a-fA-F]{4})/g, (_m, hex) => {
+        const codepoint = Number.parseInt(hex, 16);
+        return Number.isFinite(codepoint) ? String.fromCharCode(codepoint) : '';
+    })
+        .replace(/\\x([0-9a-fA-F]{2})/g, (_m, hex) => {
+        const codepoint = Number.parseInt(hex, 16);
+        return Number.isFinite(codepoint) ? String.fromCharCode(codepoint) : '';
+    })
+        .replace(/\\\\/g, '\\');
+}
+function normalizeLocalImagePath(candidate) {
+    if (!candidate || typeof candidate !== 'string')
+        return null;
+    let value = decodeEscapedPathLikeText(candidate.trim());
+    if (!value)
+        return null;
+    if (/^https?:\/\//i.test(value))
+        return null;
+    if (value.toLowerCase().startsWith('file://')) {
+        try {
+            const parsed = new URL(value);
+            value = decodeURIComponent(parsed.pathname || '');
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!value)
+        return null;
+    if (value.startsWith('~')) {
+        value = path.join(os.homedir(), value.slice(1));
+    }
+    const isAbsolutePath = path.isAbsolute(value);
+    const normalized = isAbsolutePath ? path.normalize(value) : path.resolve(process.cwd(), value);
+    return isImagePath(normalized) ? normalized : null;
+}
+function collectLocalImagePathCandidates(text) {
+    if (typeof text !== 'string' || !text.trim())
+        return [];
+    const candidates = new Set();
+    const variants = [text, decodeEscapedPathLikeText(text)].filter(Boolean);
+    const quotedPathRegex = /(["'`])((?:\\.|(?!\1).)+)\1/g;
+    const barePathRegex = /(?:^|[\s(])((?:~|\/|\.\.?\/)[^\s"'`<>]+?\.(?:png|jpg|jpeg|gif|webp|bmp|svg|tiff?|ico|heic|jxl))(?=$|[\s),.;!?])/gi;
+    for (const variant of variants) {
+        let quotedMatch;
+        quotedPathRegex.lastIndex = 0;
+        while ((quotedMatch = quotedPathRegex.exec(variant)) !== null) {
+            const normalized = normalizeLocalImagePath(quotedMatch[2] || '');
+            if (normalized)
+                candidates.add(normalized);
+        }
+        let bareMatch;
+        barePathRegex.lastIndex = 0;
+        while ((bareMatch = barePathRegex.exec(variant)) !== null) {
+            const normalized = normalizeLocalImagePath(bareMatch[1] || '');
+            if (normalized)
+                candidates.add(normalized);
+        }
+    }
+    return Array.from(candidates);
+}
+function detectImageMime(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return IMAGE_MIME_BY_EXT[ext] || 'application/octet-stream';
+}
+function encodeLocalImageAsDataUrl(filePath) {
+    const imageBuffer = fs.readFileSync(filePath);
+    const mimeType = detectImageMime(filePath);
+    return `data:${mimeType};base64,${imageBuffer.toString('base64')}`;
+}
+function messageHasImageContent(content) {
+    if (!Array.isArray(content))
+        return false;
+    return content.some((part) => {
+        if (!part || typeof part !== 'object')
+            return false;
+        const type = String(part.type || '').toLowerCase();
+        if (type !== 'image_url' && type !== 'input_image' && type !== 'image')
+            return false;
+        const imageUrl = part.image_url;
+        return typeof imageUrl === 'string' || Boolean(imageUrl && typeof imageUrl === 'object' && typeof imageUrl.url === 'string');
+    });
+}
+function appendLocalImageBlockOnLatestUserInput(messages, context) {
+    if (!Array.isArray(messages) || !messages.length)
+        return;
+    let latestUserIndex = -1;
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        const role = String(messages[idx]?.role || '').toLowerCase();
+        if (role === 'user') {
+            latestUserIndex = idx;
+            break;
+        }
+    }
+    if (latestUserIndex < 0)
+        return;
+    const latestUserMessage = messages[latestUserIndex];
+    const originalContent = latestUserMessage.content;
+    if (messageHasImageContent(originalContent))
+        return;
+    const textCandidates = [];
+    if (typeof originalContent === 'string' && originalContent.trim().length) {
+        textCandidates.push(originalContent);
+    }
+    else if (Array.isArray(originalContent)) {
+        for (const part of originalContent) {
+            if (!part || typeof part !== 'object')
+                continue;
+            const type = String(part.type || '').toLowerCase();
+            if ((type === 'text' || type === 'input_text' || type === 'output_text' || type === 'commentary') &&
+                typeof part.text === 'string' &&
+                part.text.trim().length) {
+                textCandidates.push(part.text);
+            }
+        }
+    }
+    if (!textCandidates.length)
+        return;
+    const imagePaths = new Set();
+    for (const text of textCandidates) {
+        for (const candidate of collectLocalImagePathCandidates(text)) {
+            imagePaths.add(candidate);
+        }
+    }
+    if (!imagePaths.size)
+        return;
+    const normalizedContent = [];
+    if (typeof originalContent === 'string') {
+        normalizedContent.push({ type: 'text', text: originalContent });
+    }
+    else if (Array.isArray(originalContent)) {
+        for (const part of originalContent) {
+            if (part && typeof part === 'object') {
+                normalizedContent.push({ ...part });
+            }
+            else if (typeof part === 'string') {
+                normalizedContent.push({ type: 'text', text: part });
+            }
+        }
+    }
+    const unreadableImageNotices = [];
+    for (const imagePath of imagePaths) {
+        let dataUrl = '';
+        try {
+            dataUrl = encodeLocalImageAsDataUrl(imagePath);
+        }
+        catch (error) {
+            const reason = error instanceof Error
+                ? `${error.code ?? 'READ_FAILED'}: ${error.message}`
+                : String(error ?? 'READ_FAILED');
+            unreadableImageNotices.push(`[local_image_unreadable] 文件不可读，已跳过该图片路径: ${imagePath} (${reason})`);
+            continue;
+        }
+        normalizedContent.push({ type: 'image_url', image_url: { url: dataUrl } });
+    }
+    if (unreadableImageNotices.length) {
+        normalizedContent.push({
+            type: 'text',
+            text: unreadableImageNotices.join('\n')
+        });
+    }
+    if (!messageHasImageContent(normalizedContent) && !unreadableImageNotices.length) {
+        return;
+    }
+    latestUserMessage.content = normalizedContent;
+}
 // NOTE: 自修复提示已移除（统一标准：不做模糊兜底）。
 // --- Public bridge functions ---
 export function captureResponsesContext(payload, dto) {
@@ -149,6 +334,7 @@ export function buildChatRequestFromResponses(payload, context) {
             messages = [...preservedSystems, ...nonSystemMessages];
         }
     }
+    appendLocalImageBlockOnLatestUserInput(messages, context);
     // 不在 Responses 路径做工具治理；统一在 Chat 后半段处理
     // No system tips for MCP on OpenAI Responses path (avoid leaking tool names)
     if (!messages.length) {
@@ -625,496 +811,6 @@ function extractMetadataExtraFields(metadata) {
 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;
-        }
-        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;
-}
-export function buildResponsesPayloadFromChat(payload, context) {
-    if (!payload || typeof payload !== 'object')
-        return payload;
-    const response = unwrapData(payload);
-    if (!response || typeof response !== 'object')
-        return payload;
-    if (response.object === 'response' && Array.isArray(response.output)) {
-        return response;
-    }
-    const snapshotLookupKey = resolveSnapshotLookupKey(response, 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);
-    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;
-        }
-        const mergedFallback = sourceForRetention && typeof sourceForRetention === 'object'
-            ? mergeResponseTopLevelFields({
-                base: out,
-                source: sourceForRetention,
-                sourceWinsKeys: ['metadata', 'temperature', 'top_p', 'prompt_cache_key', 'reasoning']
-            })
-            : out;
-        if (mergedFallback.metadata) {
-            stripInternalToolingMetadata(mergedFallback.metadata);
-        }
-        return mergedFallback;
-    }
-    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 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 {
-            const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-responses', moduleType: 'openai-responses' });
-            const policyActions = resolvePolicyActions(bridgePolicy, 'response_outbound');
-            if (policyActions?.length) {
-                const actionState = createBridgeActionState({ messages: [message] });
-                runBridgeActionPipeline({
-                    stage: 'response_outbound',
-                    actions: policyActions,
-                    protocol: bridgePolicy?.protocol ?? 'openai-responses',
-                    moduleType: bridgePolicy?.moduleType ?? 'openai-responses',
-                    requestId: context?.requestId,
-                    state: actionState
-                });
-            }
-        }
-        catch (error) {
-            const message = error instanceof Error
-                ? error.message
-                : typeof error === 'string'
-                    ? error
-                    : 'unknown_error';
-            try {
-                // eslint-disable-next-line no-console
-                console.error(`\x1b[31m[responses-bridge][response_outbound] bridge action pipeline failed requestId=${context?.requestId ?? 'unknown'} error=${message}\x1b[0m`);
-            }
-            catch {
-                // ignore logging failures
-            }
-            // Do not fail-close here: preserve protocol-correct payload shape and let the client
-            // handle any downstream validation errors. The bridge policy pipeline is best-effort.
-        }
-    }
-    if (message) {
-        try {
-            normalizeMessageReasoningTools(message, {
-                idPrefix: `responses_reasoning_${context?.requestId ?? 'canonical'}`
-            });
-        }
-        catch {
-            // best-effort reasoning normalization
-        }
-    }
-    const outputBuild = buildResponsesOutputFromChat({
-        response: response,
-        message,
-        requestId: context?.requestId,
-        sanitizeFunctionName: sanitizeResponsesFunctionName
-    });
-    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
-    };
-    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;
-    // Normalize tool_call arguments for client-declared tool formats (e.g. format:"freeform").
-    // If we cannot repair/match the declared schema/format, we fall back to returning the
-    // original tool-call arguments and let the client surface the error.
-    normalizeResponsesToolCallArgumentsForClient(out, context);
-    // Do not inject captured tool results here; keep Chat back-half behavior standard.
-    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 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;
-}
-function normalizeResponsesToolCallArgumentsForClient(responsesPayload, context) {
-    const toolsRaw = Array.isArray(context?.toolsRaw) ? context?.toolsRaw : [];
-    if (!toolsRaw.length) {
-        return;
-    }
-    const toolIndex = buildClientToolIndex(toolsRaw);
-    if (!toolIndex.size) {
-        return;
-    }
-    const normalizeCallArgs = (toolName, argsRaw) => {
-        const spec = toolIndex.get(toolName);
-        if (!spec)
-            return argsRaw;
-        // format:"freeform" means client expects raw text (not JSON) in the arguments field.
-        if (typeof spec.format === 'string' && spec.format.trim().toLowerCase() === 'freeform') {
-            const rawText = extractFreeformTextFromArgs(argsRaw);
-            if (rawText && rawText.trim().length) {
-                return rawText;
-            }
-            return argsRaw;
-        }
-        // Schema-aware key alignment for common server-side tools.
-        // If we cannot repair, keep original args and let the client surface the error.
-        const params = spec.parameters;
-        if (!params)
-            return argsRaw;
-        const schema = extractJsonSchemaLike(params);
-        if (!schema)
-            return argsRaw;
-        const parsed = tryParseJson(argsRaw);
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return argsRaw;
-        }
-        const record = parsed;
-        const repaired = repairToolArgsBySchemaKeys(toolName, record, schema);
-        if (!repaired) {
-            return argsRaw;
-        }
-        try {
-            return JSON.stringify(repaired);
-        }
-        catch {
-            return argsRaw;
-        }
-    };
-    // 1) output[] function_call items
-    const output = Array.isArray(responsesPayload.output) ? responsesPayload.output : [];
-    for (const item of output) {
-        if (!item || typeof item !== 'object')
-            continue;
-        const type = typeof item.type === 'string' ? String(item.type).trim().toLowerCase() : '';
-        if (type !== 'function_call')
-            continue;
-        const name = typeof item.name === 'string' ? String(item.name).trim() : '';
-        if (!name)
-            continue;
-        if (!toolIndex.has(name))
-            continue;
-        item.arguments = normalizeCallArgs(name, item.arguments);
-    }
-    // 2) required_action.submit_tool_outputs.tool_calls[] tool calls
-    const toolCalls = responsesPayload?.required_action?.submit_tool_outputs?.tool_calls;
-    const calls = Array.isArray(toolCalls) ? toolCalls : [];
-    for (const call of calls) {
-        if (!call || typeof call !== 'object')
-            continue;
-        const fn = call.function && typeof call.function === 'object' && !Array.isArray(call.function) ? call.function : null;
-        const name = typeof fn?.name === 'string' ? String(fn.name).trim() : '';
-        if (!name)
-            continue;
-        if (!toolIndex.has(name))
-            continue;
-        fn.arguments = normalizeCallArgs(name, fn.arguments);
-    }
-}
-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 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 unwrapData(value) {
     let current = value;
     const seen = new Set();
@@ -1146,13 +842,6 @@ function shouldStripHostManagedFields(context) {
     const result = evaluateResponsesHostPolicy(context, typeof context?.targetProtocol === 'string' ? context?.targetProtocol : undefined);
     return result.shouldStripHostManagedFields;
 }
-export function extractRequestIdFromResponse(response) {
-    if (response && typeof response === 'object' && 'metadata' in response && response.metadata && typeof response.metadata === 'object') {
-        const meta = response.metadata;
-        if (typeof meta.requestId === 'string')
-            return meta.requestId;
-    }
-    return undefined;
-}
+export { buildResponsesPayloadFromChat, extractRequestIdFromResponse } from './responses-openai-bridge/response-payload.js';
 export { buildChatResponseFromResponses } from '../shared/responses-response-utils.js';
 // (imports moved to top)