@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/conversion/shared/bridge-actions.js

@@ -1,881 +0,0 @@
-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);