@jsonstudio/rcc 0.85.9 → 0.89.3

package/node_modules/@jsonstudio/llms/dist/conversion/shared/bridge-actions.js

@@ -0,0 +1,881 @@
+import { normalizeMessageReasoningTools } from './reasoning-tool-normalizer.js';
+import { extractReasoningSegments } from './reasoning-utils.js';
+import { extractOutputSegments } from './output-content-normalizer.js';
+import { normalizeChatMessageContent } from './chat-output-normalizer.js';
+import { convertMessagesToBridgeInput } from './bridge-message-utils.js';
+const registry = new Map();
+export function registerBridgeAction(name, action) {
+    registry.set(name, action);
+}
+export function createBridgeActionState(seed) {
+    const state = {
+        messages: Array.isArray(seed?.messages) ? seed.messages : []
+    };
+    if (seed?.requiredAction)
+        state.requiredAction = seed.requiredAction;
+    if (seed?.capturedToolResults)
+        state.capturedToolResults = seed.capturedToolResults;
+    if (seed?.rawRequest)
+        state.rawRequest = seed.rawRequest;
+    if (seed?.rawResponse)
+        state.rawResponse = seed.rawResponse;
+    if (seed?.metadata)
+        state.metadata = seed.metadata;
+    return state;
+}
+export function runBridgeActionPipeline(options) {
+    const { stage, actions, protocol, moduleType, requestId, state } = options;
+    if (!actions?.length)
+        return;
+    for (const descriptor of actions) {
+        if (!descriptor || typeof descriptor !== 'object')
+            continue;
+        const action = registry.get(descriptor.name);
+        if (!action)
+            continue;
+        try {
+            action({
+                stage,
+                protocol,
+                moduleType,
+                requestId,
+                descriptor,
+                state
+            });
+        }
+        catch {
+            // Ignore action failures to preserve core flow; telemetry hooks can be added later.
+        }
+    }
+}
+function ensureMessagesArray(state) {
+    if (!Array.isArray(state.messages)) {
+        state.messages = [];
+    }
+    return state.messages;
+}
+function flattenContentToString(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const parts = value
+            .map((entry) => flattenContentToString(entry))
+            .filter((entry) => typeof entry === 'string' && entry.length > 0);
+        if (parts.length) {
+            return parts.join('\n');
+        }
+        return '';
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        if (typeof record.text === 'string') {
+            return record.text;
+        }
+        if (typeof record.content === 'string') {
+            return record.content;
+        }
+        if (Array.isArray(record.content)) {
+            return flattenContentToString(record.content);
+        }
+    }
+    return undefined;
+}
+function ensureMetadataRecord(state) {
+    if (!state.metadata || typeof state.metadata !== 'object') {
+        state.metadata = {};
+    }
+    return state.metadata;
+}
+const injectSystemInstructionAction = (ctx) => {
+    if (ctx.stage !== 'request_inbound')
+        return;
+    const raw = ctx.state.rawRequest;
+    if (!raw || typeof raw !== 'object')
+        return;
+    const field = typeof ctx.descriptor.options?.field === 'string' ? ctx.descriptor.options.field : 'instructions';
+    const reasoningField = typeof ctx.descriptor.options?.reasoningField === 'string' ? ctx.descriptor.options.reasoningField : undefined;
+    const instructions = readInstructionValue(raw, field);
+    if (!instructions)
+        return;
+    const reasoningSegments = readInstructionReasoning(raw, reasoningField);
+    const message = buildInstructionMessage('system', instructions, reasoningSegments);
+    if (!message)
+        return;
+    const messages = ensureMessagesArray(ctx.state);
+    messages.unshift(message);
+};
+function readInstructionValue(source, field) {
+    if (!source || typeof source !== 'object')
+        return undefined;
+    const raw = source[field];
+    if (typeof raw !== 'string')
+        return undefined;
+    const trimmed = raw.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function readInstructionReasoning(source, field) {
+    if (!field || !source || typeof source !== 'object')
+        return [];
+    const raw = source[field];
+    if (!raw)
+        return [];
+    if (typeof raw === 'string') {
+        const trimmed = raw.trim();
+        return trimmed.length ? [trimmed] : [];
+    }
+    if (Array.isArray(raw)) {
+        return raw
+            .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))
+            .filter((entry) => entry.length > 0);
+    }
+    return [];
+}
+function buildInstructionMessage(role, text, reasoningSegments) {
+    const normalized = normalizeChatMessageContent(text);
+    const content = typeof normalized.contentText === 'string' ? normalized.contentText : '';
+    const merged = [];
+    if (typeof normalized.reasoningText === 'string' && normalized.reasoningText.trim().length) {
+        merged.push(normalized.reasoningText.trim());
+    }
+    for (const segment of reasoningSegments) {
+        if (typeof segment === 'string' && segment.trim().length) {
+            merged.push(segment.trim());
+        }
+    }
+    if (!content.trim().length && !merged.length) {
+        return null;
+    }
+    const message = { role, content };
+    if (merged.length) {
+        message.reasoning_content = merged.join('\n');
+    }
+    return message;
+}
+function mapToolResults(state) {
+    const toolResults = new Map();
+    const append = (id, output, name) => {
+        if (typeof id !== 'string' || !id.trim()) {
+            return;
+        }
+        let text = '';
+        if (typeof output === 'string') {
+            text = output;
+        }
+        else if (output != null) {
+            try {
+                text = JSON.stringify(output);
+            }
+            catch {
+                text = String(output);
+            }
+        }
+        const trimmed = text.trim();
+        toolResults.set(id, trimmed);
+        if (typeof name === 'string' && name.trim().length) {
+            toolResults.set(`${id}::name`, name.trim());
+        }
+    };
+    const captured = state.capturedToolResults;
+    if (Array.isArray(captured)) {
+        for (const entry of captured) {
+            append(entry?.tool_call_id ?? entry?.call_id, entry?.output, entry?.name);
+        }
+    }
+    return toolResults;
+}
+function findFirstNonToolIndex(messages, startIndex) {
+    let index = startIndex;
+    while (index < messages.length) {
+        const msg = messages[index];
+        if (!msg || typeof msg !== 'object') {
+            break;
+        }
+        const role = String(msg.role || '').toLowerCase();
+        if (role !== 'tool') {
+            break;
+        }
+        index++;
+    }
+    return index;
+}
+function extractToolCallIdentifier(message) {
+    const id = message.tool_call_id ||
+        message.call_id ||
+        message.tool_use_id ||
+        message.id;
+    return typeof id === 'string' && id.trim().length ? id.trim() : undefined;
+}
+function findToolResponseIndex(messages, startIndex, endIndex, callId) {
+    const limit = Math.min(endIndex, messages.length);
+    for (let i = startIndex; i < limit; i++) {
+        const msg = messages[i];
+        if (!msg || typeof msg !== 'object') {
+            continue;
+        }
+        const role = String(msg.role || '').toLowerCase();
+        if (role !== 'tool') {
+            break;
+        }
+        const id = extractToolCallIdentifier(msg);
+        if (id === callId) {
+            return i;
+        }
+    }
+    return -1;
+}
+function extractToolResponse(messages, startIndex, callId) {
+    for (let i = startIndex; i < messages.length; i++) {
+        const msg = messages[i];
+        if (!msg || typeof msg !== 'object') {
+            continue;
+        }
+        const role = String(msg.role || '').toLowerCase();
+        if (role !== 'tool') {
+            continue;
+        }
+        const id = extractToolCallIdentifier(msg);
+        if (id === callId) {
+            const [removed] = messages.splice(i, 1);
+            return removed;
+        }
+    }
+    return undefined;
+}
+function buildToolPlaceholder(callId, call, toolResults) {
+    const content = toolResults.get(callId) ?? '';
+    const inferredName = toolResults.get(`${callId}::name`) ||
+        normalizeToolName(call.name) ||
+        normalizeToolName(call?.function?.name);
+    const toolMessage = {
+        role: 'tool',
+        tool_call_id: callId,
+        content
+    };
+    if (inferredName) {
+        toolMessage.name = inferredName;
+    }
+    return toolMessage;
+}
+function normalizeToolName(value) {
+    if (typeof value === 'string' && value.trim().length) {
+        return value.trim();
+    }
+    return undefined;
+}
+const ensureToolResponsePlaceholders = (ctx) => {
+    const messages = ensureMessagesArray(ctx.state);
+    if (!messages.length)
+        return;
+    const toolResults = mapToolResults(ctx.state);
+    let index = 0;
+    while (index < messages.length) {
+        const message = messages[index];
+        if (!message || typeof message !== 'object') {
+            index++;
+            continue;
+        }
+        const role = String(message.role || '').toLowerCase();
+        if (role !== 'assistant') {
+            index++;
+            continue;
+        }
+        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : undefined;
+        if (!toolCalls?.length) {
+            index++;
+            continue;
+        }
+        let insertionIndex = index + 1;
+        for (const call of toolCalls) {
+            if (!call || typeof call !== 'object')
+                continue;
+            const callId = call.id ||
+                call.call_id ||
+                call.tool_call_id;
+            if (typeof callId !== 'string' || !callId.trim())
+                continue;
+            const normalizedId = callId.trim();
+            const windowEnd = findFirstNonToolIndex(messages, insertionIndex);
+            const existingIndex = findToolResponseIndex(messages, insertionIndex, windowEnd, normalizedId);
+            if (existingIndex >= 0) {
+                insertionIndex = existingIndex + 1;
+                continue;
+            }
+            const relocated = extractToolResponse(messages, windowEnd, normalizedId);
+            if (relocated) {
+                messages.splice(insertionIndex, 0, relocated);
+                insertionIndex++;
+                continue;
+            }
+            const placeholder = buildToolPlaceholder(normalizedId, call, toolResults);
+            messages.splice(insertionIndex, 0, placeholder);
+            insertionIndex++;
+        }
+        index = Math.max(index + 1, insertionIndex);
+    }
+};
+function assignReasoning(message, parts) {
+    const trimmed = parts.map((item) => item.trim()).filter(Boolean);
+    if (!trimmed.length)
+        return;
+    const existing = typeof message.reasoning_content === 'string' && message.reasoning_content.trim().length
+        ? [message.reasoning_content.trim()]
+        : [];
+    const merged = [...existing, ...trimmed].filter(Boolean);
+    if (merged.length) {
+        message.reasoning_content = merged.join('\n').trim();
+    }
+}
+function processTextValue(value, collector, dropFromContent) {
+    try {
+        const sanitized = extractReasoningSegments(value, collector);
+        return dropFromContent ? sanitized : value;
+    }
+    catch {
+        return value;
+    }
+}
+function stripReasoningFromValue(value, collector, dropFromContent) {
+    if (typeof value === 'string') {
+        return processTextValue(value, collector, dropFromContent);
+    }
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            value[i] = stripReasoningFromValue(value[i], collector, dropFromContent);
+        }
+        return value;
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        if (typeof record.text === 'string') {
+            record.text = processTextValue(record.text, collector, dropFromContent);
+        }
+        if (typeof record.content === 'string') {
+            record.content = processTextValue(record.content, collector, dropFromContent);
+        }
+        else if (Array.isArray(record.content)) {
+            record.content = record.content.map((part) => stripReasoningFromValue(part, collector, dropFromContent));
+        }
+        return value;
+    }
+    return value;
+}
+const extractReasoningAction = (ctx) => {
+    const messages = ensureMessagesArray(ctx.state);
+    if (!messages.length)
+        return;
+    const dropFromContent = ctx.descriptor.options?.dropFromContent !== false;
+    const idPrefixBase = typeof ctx.descriptor.options?.idPrefix === 'string' && ctx.descriptor.options.idPrefix.trim().length
+        ? ctx.descriptor.options.idPrefix.trim()
+        : `${ctx.protocol ?? 'bridge'}_${ctx.stage}`;
+    for (let i = 0; i < messages.length; i++) {
+        const message = messages[i];
+        if (!message || typeof message !== 'object')
+            continue;
+        const reasoningParts = [];
+        if (typeof message.content === 'string') {
+            message.content = processTextValue(message.content, reasoningParts, dropFromContent);
+        }
+        else if (Array.isArray(message.content)) {
+            message.content = message.content.map((part) => stripReasoningFromValue(part, reasoningParts, dropFromContent));
+        }
+        assignReasoning(message, reasoningParts);
+        try {
+            normalizeMessageReasoningTools(message, {
+                idPrefix: `${idPrefixBase}_${i + 1}`
+            });
+        }
+        catch {
+            // best-effort normalization; ignore failures
+        }
+    }
+};
+registerBridgeAction('messages.inject-system-instruction', injectSystemInstructionAction);
+registerBridgeAction('reasoning.extract', extractReasoningAction);
+registerBridgeAction('tools.ensure-response-placeholders', ensureToolResponsePlaceholders);
+const ensureSystemInstructionAction = (ctx) => {
+    const messages = ensureMessagesArray(ctx.state);
+    if (!messages.length) {
+        return;
+    }
+    if (ctx.stage === 'request_outbound') {
+        const originals = [];
+        for (const message of messages) {
+            if (!message || typeof message !== 'object')
+                continue;
+            const role = String(message.role || '').toLowerCase();
+            if (role !== 'system')
+                continue;
+            const text = flattenContentToString(message.content);
+            if (typeof text === 'string' && text.trim().length) {
+                originals.push(text.trim());
+            }
+        }
+        if (!originals.length) {
+            return;
+        }
+        const metadata = ensureMetadataRecord(ctx.state);
+        metadata.systemInstruction = originals.join('\n\n');
+        metadata.originalSystemMessages = originals.slice();
+        return;
+    }
+    if (ctx.stage === 'request_inbound') {
+        const metadata = ctx.state.metadata;
+        const systemInstruction = typeof metadata?.systemInstruction === 'string' && metadata.systemInstruction.trim().length
+            ? metadata.systemInstruction.trim()
+            : undefined;
+        if (!systemInstruction) {
+            return;
+        }
+        const hasSystem = messages.some((message) => {
+            if (!message || typeof message !== 'object')
+                return false;
+            return String(message.role || '').toLowerCase() === 'system';
+        });
+        if (hasSystem) {
+            return;
+        }
+        messages.unshift({
+            role: 'system',
+            content: systemInstruction
+        });
+    }
+};
+const normalizeHistoryAction = (ctx) => {
+    if (ctx.stage !== 'request_outbound') {
+        return;
+    }
+    const messages = ensureMessagesArray(ctx.state);
+    if (!messages.length) {
+        return;
+    }
+    const toolsNode = ctx.state.rawRequest &&
+        typeof ctx.state.rawRequest === 'object' &&
+        Array.isArray(ctx.state.rawRequest.tools)
+        ? ctx.state.rawRequest.tools
+        : undefined;
+    try {
+        const result = convertMessagesToBridgeInput({
+            messages,
+            tools: toolsNode
+        });
+        const metadata = ensureMetadataRecord(ctx.state);
+        metadata.bridgeHistory = result;
+    }
+    catch {
+        // normalization best-effort
+    }
+};
+const ensureOutputFieldsAction = (ctx) => {
+    if (ctx.stage !== 'request_outbound') {
+        return;
+    }
+    const messages = ensureMessagesArray(ctx.state);
+    if (!messages.length) {
+        return;
+    }
+    const fallback = typeof ctx.descriptor.options?.toolFallback === 'string' && ctx.descriptor.options.toolFallback.trim().length
+        ? ctx.descriptor.options.toolFallback.trim()
+        : 'Tool call completed (no output).';
+    for (const message of messages) {
+        if (!message || typeof message !== 'object') {
+            continue;
+        }
+        const role = String(message.role || '').toLowerCase();
+        if (role === 'tool') {
+            let text = flattenContentToString(message.content);
+            if (text === undefined) {
+                text = fallback;
+            }
+            message.content = text;
+            continue;
+        }
+        if (role === 'assistant') {
+            const toolCalls = Array.isArray(message.tool_calls)
+                ? message.tool_calls
+                : undefined;
+            const hasToolCalls = Boolean(toolCalls && toolCalls.length);
+            const text = flattenContentToString(message.content);
+            const hasText = typeof text === 'string' && text.trim().length > 0;
+            if (text !== undefined && typeof message.content !== 'string') {
+                message.content = text;
+                continue;
+            }
+            if (hasText) {
+                continue;
+            }
+            const reasoningText = typeof message.reasoning_content === 'string' && message.reasoning_content.trim().length
+                ? message.reasoning_content.trim()
+                : undefined;
+            if (reasoningText) {
+                message.content = reasoningText;
+                continue;
+            }
+            if (hasToolCalls) {
+                // Assistant-only tool call is valid; leave content empty to avoid fabricated summaries.
+                continue;
+            }
+            const assistantFallback = typeof ctx.descriptor.options?.assistantFallback === 'string' && ctx.descriptor.options.assistantFallback.trim().length
+                ? ctx.descriptor.options.assistantFallback.trim()
+                : 'Assistant response unavailable.';
+            message.content = assistantFallback;
+        }
+    }
+};
+const ensureToolPlaceholdersAction = (ctx) => {
+    ensureToolResponsePlaceholders(ctx);
+};
+const captureToolResultsAction = (ctx) => {
+    const source = ctx.stage.startsWith('request') ? ctx.state.rawRequest :
+        ctx.stage.startsWith('response') ? ctx.state.rawResponse :
+            undefined;
+    if ((!Array.isArray(ctx.state.capturedToolResults) || ctx.state.capturedToolResults.length === 0) &&
+        source &&
+        typeof source === 'object' &&
+        Array.isArray(source.tool_outputs)) {
+        ctx.state.capturedToolResults = source.tool_outputs.map((entry) => ({
+            tool_call_id: typeof entry?.tool_call_id === 'string' ? entry.tool_call_id : undefined,
+            call_id: typeof entry?.call_id === 'string' ? entry.call_id : undefined,
+            output: entry?.output,
+            name: typeof entry?.name === 'string' ? entry.name : undefined
+        }));
+    }
+    if (ctx.stage === 'request_outbound' &&
+        Array.isArray(ctx.state.capturedToolResults) &&
+        ctx.state.capturedToolResults.length) {
+        const metadata = ensureMetadataRecord(ctx.state);
+        metadata.capturedToolResults = ctx.state.capturedToolResults.map((entry) => ({ ...entry }));
+    }
+};
+const attachReasoningOutputAction = (ctx) => {
+    responsesOutputReasoningAction(ctx);
+};
+registerBridgeAction('messages.ensure-system-instruction', ensureSystemInstructionAction);
+registerBridgeAction('messages.normalize-history', normalizeHistoryAction);
+registerBridgeAction('messages.ensure-output-fields', ensureOutputFieldsAction);
+registerBridgeAction('tools.ensure-placeholders', ensureToolPlaceholdersAction);
+registerBridgeAction('tools.capture-results', captureToolResultsAction);
+registerBridgeAction('reasoning.attach-output', attachReasoningOutputAction);
+function deriveToolIdPrefix(ctx) {
+    if (typeof ctx.descriptor.options?.idPrefix === 'string' && ctx.descriptor.options.idPrefix.trim().length) {
+        return ctx.descriptor.options.idPrefix.trim();
+    }
+    if (typeof ctx.requestId === 'string' && ctx.requestId.trim().length) {
+        const safe = ctx.requestId.trim().replace(/[^A-Za-z0-9]/g, '');
+        if (safe.length) {
+            return `${safe.slice(-24)}_tool`;
+        }
+    }
+    const base = ctx.protocol || 'bridge';
+    return `${base}_tool`;
+}
+const normalizeToolIdentifiersAction = (ctx) => {
+    const messages = ensureMessagesArray(ctx.state);
+    const idPrefix = deriveToolIdPrefix(ctx);
+    let counter = 0;
+    const aliasMap = new Map();
+    const knownIds = new Set();
+    const pendingQueue = [];
+    const registerAlias = (raw, normalized) => {
+        if (typeof raw === 'string' && raw.trim().length) {
+            aliasMap.set(raw.trim(), normalized);
+        }
+        aliasMap.set(normalized, normalized);
+    };
+    const consumePending = (id) => {
+        const index = pendingQueue.indexOf(id);
+        if (index >= 0) {
+            pendingQueue.splice(index, 1);
+        }
+    };
+    const nextId = () => {
+        counter += 1;
+        return `${idPrefix}_${counter}`;
+    };
+    const normalizeIdValue = (raw, consumeQueue) => {
+        if (typeof raw === 'string' && raw.trim().length) {
+            const existing = raw.trim();
+            if (aliasMap.has(existing)) {
+                const normalized = aliasMap.get(existing);
+                knownIds.add(normalized);
+                return normalized;
+            }
+            if (consumeQueue && pendingQueue.length) {
+                const queued = pendingQueue.shift();
+                knownIds.add(queued);
+                aliasMap.set(existing, queued);
+                aliasMap.set(queued, queued);
+                return queued;
+            }
+            knownIds.add(existing);
+            aliasMap.set(existing, existing);
+            return existing;
+        }
+        if (consumeQueue && pendingQueue.length) {
+            const queued = pendingQueue.shift();
+            knownIds.add(queued);
+            aliasMap.set(queued, queued);
+            return queued;
+        }
+        const generated = nextId();
+        knownIds.add(generated);
+        aliasMap.set(generated, generated);
+        return generated;
+    };
+    const normalizeToolCall = (call, consumeQueue) => {
+        if (!call || typeof call !== 'object') {
+            return undefined;
+        }
+        const normalized = normalizeIdValue(call.id || call.tool_call_id || call.call_id, consumeQueue);
+        registerAlias(call.id, normalized);
+        registerAlias(call.tool_call_id, normalized);
+        registerAlias(call.call_id, normalized);
+        call.id = normalized;
+        call.tool_call_id = normalized;
+        call.call_id = normalized;
+        return normalized;
+    };
+    const normalizeToolOutputs = (outputs) => {
+        if (!Array.isArray(outputs)) {
+            return;
+        }
+        outputs.forEach((entry) => {
+            if (!entry || typeof entry !== 'object') {
+                return;
+            }
+            const normalized = normalizeIdValue(entry.tool_call_id || entry.call_id || entry.id, true);
+            registerAlias(entry.tool_call_id, normalized);
+            registerAlias(entry.call_id, normalized);
+            consumePending(normalized);
+            entry.tool_call_id = normalized;
+            entry.call_id = normalized;
+        });
+    };
+    for (const message of messages) {
+        if (!message || typeof message !== 'object')
+            continue;
+        const role = String(message.role || '').toLowerCase();
+        if (role === 'assistant') {
+            const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : undefined;
+            if (!toolCalls?.length)
+                continue;
+            for (const call of toolCalls) {
+                const normalized = normalizeToolCall(call, false);
+                if (normalized) {
+                    pendingQueue.push(normalized);
+                }
+            }
+        }
+        else if (role === 'tool') {
+            const normalized = normalizeIdValue(message.tool_call_id || message.call_id || message.id, true);
+            registerAlias(message.tool_call_id, normalized);
+            registerAlias(message.call_id, normalized);
+            consumePending(normalized);
+            message.tool_call_id = normalized;
+            message.call_id = normalized;
+            if (!message.id) {
+                message.id = normalized;
+            }
+        }
+    }
+    if (ctx.state.rawRequest && typeof ctx.state.rawRequest === 'object') {
+        normalizeToolOutputs(ctx.state.rawRequest.tool_outputs);
+        const required = ctx.state.rawRequest.required_action;
+        if (required && typeof required === 'object') {
+            const submit = required.submit_tool_outputs;
+            if (submit && typeof submit === 'object' && Array.isArray(submit.tool_calls)) {
+                const submitCalls = submit.tool_calls;
+                submitCalls.forEach((call) => normalizeToolCall(call, false));
+            }
+        }
+    }
+    if (ctx.state.capturedToolResults && Array.isArray(ctx.state.capturedToolResults)) {
+        ctx.state.capturedToolResults.forEach((entry) => {
+            const normalized = normalizeIdValue(entry?.tool_call_id ?? entry?.call_id, true);
+            registerAlias(entry?.tool_call_id, normalized);
+            registerAlias(entry?.call_id, normalized);
+            consumePending(normalized);
+            entry.tool_call_id = normalized;
+            entry.call_id = normalized;
+        });
+    }
+};
+registerBridgeAction('tools.normalize-call-ids', normalizeToolIdentifiersAction);
+const responsesOutputReasoningAction = (ctx) => {
+    if (ctx.stage !== 'response_inbound')
+        return;
+    const raw = ctx.state.rawResponse;
+    if (!raw || typeof raw !== 'object')
+        return;
+    const { textParts, reasoningParts } = extractOutputSegments(raw);
+    if (!textParts.length && !reasoningParts.length)
+        return;
+    const messages = ensureMessagesArray(ctx.state);
+    if (!messages.length) {
+        messages.push({
+            role: 'assistant',
+            content: textParts.join('\n')
+        });
+    }
+    const target = messages.find((message) => {
+        if (!message || typeof message !== 'object')
+            return false;
+        const role = String(message.role || '').toLowerCase();
+        return role === 'assistant';
+    }) ?? messages[0];
+    if (!target || typeof target !== 'object')
+        return;
+    if (textParts.length) {
+        const combinedText = textParts.join('\n');
+        const existing = target.content;
+        if (typeof existing !== 'string' || !existing.trim().length) {
+            target.content = combinedText;
+        }
+    }
+    if (reasoningParts.length) {
+        assignReasoning(target, reasoningParts);
+    }
+    try {
+        normalizeMessageReasoningTools(target, {
+            idPrefix: `${ctx.protocol ?? 'responses'}_${ctx.stage}_output`
+        });
+    }
+    catch {
+        // best-effort normalization
+    }
+};
+registerBridgeAction('responses.output-reasoning', responsesOutputReasoningAction);
+function collectExtraFieldsMap(source, allowed) {
+    const extras = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (allowed && allowed.has(key))
+            continue;
+        extras[key] = value;
+    }
+    if (Object.keys(extras).length === 0) {
+        return undefined;
+    }
+    return extras;
+}
+const metadataExtraFieldsAction = (ctx) => {
+    const allowedKeysRaw = ctx.descriptor.options?.allowedKeys;
+    const allowed = Array.isArray(allowedKeysRaw)
+        ? new Set(allowedKeysRaw
+            .map((key) => (typeof key === 'string' ? key : undefined))
+            .filter((key) => !!key))
+        : undefined;
+    const target = ctx.stage.startsWith('request') ? ctx.state.rawRequest : ctx.state.rawResponse;
+    if (!target || typeof target !== 'object')
+        return;
+    if (ctx.stage.endsWith('inbound')) {
+        const extras = collectExtraFieldsMap(target, allowed);
+        if (!extras)
+            return;
+        const metadata = ensureMetadataRecord(ctx.state);
+        const existing = metadata.extraFields && typeof metadata.extraFields === 'object'
+            ? metadata.extraFields
+            : undefined;
+        metadata.extraFields = existing ? { ...existing, ...extras } : extras;
+        return;
+    }
+    const metadata = ctx.state.metadata;
+    if (!metadata || typeof metadata !== 'object')
+        return;
+    const extras = metadata.extraFields;
+    if (!extras || typeof extras !== 'object')
+        return;
+    const source = extras;
+    for (const [key, value] of Object.entries(source)) {
+        if (target[key] === undefined) {
+            target[key] = value;
+        }
+    }
+};
+const metadataProviderFieldAction = (ctx) => {
+    const field = typeof ctx.descriptor.options?.field === 'string' ? ctx.descriptor.options.field : 'metadata';
+    const targetKey = typeof ctx.descriptor.options?.target === 'string' ? ctx.descriptor.options.target : 'providerMetadata';
+    const payload = ctx.stage.startsWith('request') ? ctx.state.rawRequest :
+        ctx.stage.startsWith('response') ? ctx.state.rawResponse :
+            undefined;
+    if (!payload || typeof payload !== 'object')
+        return;
+    if (ctx.stage.endsWith('inbound')) {
+        const value = payload[field];
+        if (!value || typeof value !== 'object')
+            return;
+        const metadata = ensureMetadataRecord(ctx.state);
+        metadata[targetKey] = value;
+        return;
+    }
+    const metadata = ctx.state.metadata;
+    if (!metadata || typeof metadata !== 'object')
+        return;
+    const provider = metadata[targetKey];
+    if (!provider || typeof provider !== 'object')
+        return;
+    if (payload[field] === undefined) {
+        payload[field] = provider;
+    }
+};
+const metadataProviderSentinelAction = (ctx) => {
+    const sentinel = typeof ctx.descriptor.options?.sentinel === 'string'
+        ? ctx.descriptor.options.sentinel
+        : undefined;
+    if (!sentinel)
+        return;
+    const targetKey = typeof ctx.descriptor.options?.target === 'string'
+        ? ctx.descriptor.options.target
+        : 'providerMetadata';
+    const payload = ctx.stage.startsWith('request') ? ctx.state.rawRequest :
+        ctx.stage.startsWith('response') ? ctx.state.rawResponse :
+            undefined;
+    if (!payload || typeof payload !== 'object')
+        return;
+    if (ctx.stage.endsWith('inbound')) {
+        const rawValue = payload[sentinel];
+        if (rawValue === undefined)
+            return;
+        let provider;
+        if (typeof rawValue === 'string') {
+            try {
+                const parsed = JSON.parse(rawValue);
+                if (parsed && typeof parsed === 'object')
+                    provider = parsed;
+            }
+            catch {
+                provider = undefined;
+            }
+        }
+        else if (rawValue && typeof rawValue === 'object') {
+            provider = rawValue;
+        }
+        delete payload[sentinel];
+        if (!provider)
+            return;
+        const metadata = ensureMetadataRecord(ctx.state);
+        metadata[targetKey] = provider;
+        return;
+    }
+    if (ctx.stage === 'request_outbound') {
+        delete payload[sentinel];
+        return;
+    }
+    const metadata = ctx.state.metadata;
+    if (!metadata || typeof metadata !== 'object') {
+        delete payload[sentinel];
+        return;
+    }
+    const provider = metadata[targetKey];
+    if (!provider || typeof provider !== 'object') {
+        delete payload[sentinel];
+        return;
+    }
+    try {
+        payload[sentinel] = JSON.stringify(provider);
+    }
+    catch {
+        payload[sentinel] = provider;
+    }
+};
+registerBridgeAction('metadata.provider-field', metadataProviderFieldAction);
+registerBridgeAction('metadata.provider-sentinel', metadataProviderSentinelAction);