@jsonstudio/llms 0.6.3275 → 0.6.3405

package/dist/conversion/shared/reasoning-normalizer.js

@@ -1,409 +1,56 @@
-import { normalizeChatMessageContent } from './chat-output-normalizer.js';
-import { extractReasoningSegments } from './reasoning-utils.js';
-import { expandResponsesMessageItem } from '../../sse/shared/responses-output-normalizer.js';
-import { sanitizeReasoningTaggedTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { normalizeReasoningInAnthropicPayloadWithNative, normalizeReasoningInChatPayloadWithNative, normalizeReasoningInGeminiPayloadWithNative, normalizeReasoningInOpenAIPayloadWithNative, normalizeReasoningInResponsesPayloadWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export const RESPONSES_INSTRUCTIONS_REASONING_FIELD = '__rcc_reasoning_instructions';
-function isRecord(value) {
-    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
-}
-export function normalizeReasoningInChatPayload(payload) {
-    if (!payload) {
-        return;
-    }
-    if (Array.isArray(payload.messages)) {
-        payload.messages = payload.messages.map(entry => normalizeChatMessageEntry(entry));
-    }
-    if (Array.isArray(payload.choices)) {
-        payload.choices.forEach(choice => {
-            normalizeChatChoice(choice);
-        });
+function assertReasoningNormalizerNativeAvailable() {
+    if (typeof normalizeReasoningInChatPayloadWithNative !== 'function' ||
+        typeof normalizeReasoningInResponsesPayloadWithNative !== 'function' ||
+        typeof normalizeReasoningInGeminiPayloadWithNative !== 'function' ||
+        typeof normalizeReasoningInAnthropicPayloadWithNative !== 'function' ||
+        typeof normalizeReasoningInOpenAIPayloadWithNative !== 'function') {
+        throw new Error('[reasoning-normalizer] native bindings unavailable');
     }
 }
-function normalizeChatMessageEntry(entry) {
-    if (!entry || typeof entry !== 'object') {
-        return entry;
-    }
-    const msg = entry;
-    applyNormalizedChatContent(msg);
-    return msg;
-}
-function normalizeChatChoice(choice) {
-    if (!choice || typeof choice !== 'object') {
+export function normalizeReasoningInChatPayload(payload) {
+    assertReasoningNormalizerNativeAvailable();
+    if (!payload)
         return;
-    }
-    const record = choice;
-    const containers = [];
-    if (record.message && typeof record.message === 'object') {
-        containers.push(record.message);
-    }
-    if (record.delta && typeof record.delta === 'object') {
-        containers.push(record.delta);
-    }
-    containers.forEach(container => applyNormalizedChatContent(container));
-}
-function applyNormalizedChatContent(container) {
-    const existingReasoning = typeof container.reasoning_content === 'string' && container.reasoning_content.trim().length
-        ? container.reasoning_content.trim()
-        : undefined;
-    const normalized = normalizeChatMessageContent(container.content);
-    const role = typeof container.role === 'string' ? container.role : undefined;
-    if (normalized.contentText !== undefined && normalized.contentText.trim().length) {
-        container.content = normalized.contentText;
-    }
-    else if (typeof container.reasoning_content === 'string' && container.reasoning_content.trim().length) {
-        container.content = container.reasoning_content.trim();
-    }
-    else if (role && role !== 'system' && role !== 'tool') {
-        container.content = '';
-    }
-    if (normalized.reasoningText && normalized.reasoningText.trim().length) {
-        container.reasoning_content = normalized.reasoningText.trim();
-    }
-    else if (existingReasoning) {
-        container.reasoning_content = existingReasoning;
-    }
-    else if ('reasoning_content' in container) {
-        delete container.reasoning_content;
+    const normalized = normalizeReasoningInChatPayloadWithNative(payload);
+    if (normalized && typeof normalized === 'object') {
+        Object.assign(payload, normalized);
     }
 }
 export function normalizeReasoningInResponsesPayload(payload, options = { includeOutput: true }) {
-    if (!payload) {
-        return;
-    }
-    const includeOutput = options.includeOutput !== false;
-    if (includeOutput) {
-        normalizeResponsesOutput(payload);
-    }
-    if (options.includeInput) {
-        normalizeResponsesInput(payload);
-    }
-    if (options.includeInstructions) {
-        normalizeResponsesInstructions(payload);
-    }
-    if (options.includeRequiredAction) {
-        normalizeResponsesRequiredAction(payload);
-    }
-}
-function normalizeResponsesOutput(payload) {
-    if (!Array.isArray(payload.output)) {
-        return;
-    }
-    const normalized = [];
-    payload.output.forEach((entry, index) => {
-        if (isResponsesMessageItem(entry)) {
-            const expanded = expandResponsesMessageItem(entry, {
-                requestId: typeof payload.id === 'string' ? payload.id : 'responses',
-                outputIndex: index
-            });
-            expanded.forEach((item) => {
-                normalized.push(item);
-            });
-        }
-        else {
-            normalized.push(entry);
-        }
-    });
-    payload.output = normalized;
-}
-function isResponsesMessageItem(entry) {
-    if (!isRecord(entry)) {
-        return false;
-    }
-    const type = typeof entry.type === 'string' ? entry.type : undefined;
-    if (type !== 'message') {
-        return false;
-    }
-    if (!Array.isArray(entry.content)) {
-        return false;
-    }
-    const status = typeof entry.status === 'string' ? entry.status : undefined;
-    const role = typeof entry.role === 'string' ? entry.role : undefined;
-    return Boolean(status && role);
-}
-function normalizeResponsesInput(payload) {
-    if (!Array.isArray(payload.input)) {
+    assertReasoningNormalizerNativeAvailable();
+    if (!payload)
         return;
-    }
-    payload.input.forEach((entry) => {
-        if (!isRecord(entry))
-            return;
-        const reasoningSegments = [];
-        if (typeof entry.content === 'string') {
-            const { cleaned, segments } = stripReasoningFromString(entry.content);
-            entry.content = cleaned;
-            reasoningSegments.push(...segments);
-        }
-        else if (Array.isArray(entry.content)) {
-            entry.content = entry.content.map((block) => normalizeResponsesContentBlock(block, reasoningSegments));
-        }
-        if (isRecord(entry.message)) {
-            normalizeResponsesMessageBlock(entry.message, reasoningSegments);
-        }
-        if (typeof entry.text === 'string') {
-            const { cleaned, segments } = stripReasoningFromString(entry.text);
-            entry.text = cleaned;
-            reasoningSegments.push(...segments);
-        }
-        if (reasoningSegments.length) {
-            entry.reasoning_content = mergeReasoningText(entry.reasoning_content, reasoningSegments);
-        }
-        else if ('reasoning_content' in entry) {
-            delete entry.reasoning_content;
-        }
-    });
-}
-function normalizeResponsesMessageBlock(message, collector) {
-    const localSegments = [];
-    if (Array.isArray(message.content)) {
-        message.content = message.content.map((block) => normalizeResponsesContentBlock(block, localSegments));
-    }
-    else if (typeof message.content === 'string') {
-        const { cleaned, segments } = stripReasoningFromString(message.content);
-        message.content = cleaned;
-        localSegments.push(...segments);
-    }
-    if (typeof message.text === 'string') {
-        const { cleaned, segments } = stripReasoningFromString(message.text);
-        message.text = cleaned;
-        localSegments.push(...segments);
-    }
-    if (localSegments.length) {
-        collector.push(...localSegments);
-        message.reasoning_content = mergeReasoningText(message.reasoning_content, localSegments);
-    }
-    else if ('reasoning_content' in message) {
-        delete message.reasoning_content;
+    const normalized = normalizeReasoningInResponsesPayloadWithNative(payload, options);
+    if (normalized && typeof normalized === 'object') {
+        Object.assign(payload, normalized);
     }
 }
-function normalizeResponsesContentBlock(block, collector) {
-    if (typeof block === 'string') {
-        const { cleaned, segments } = stripReasoningFromString(block);
-        collector.push(...segments);
-        return cleaned;
-    }
-    if (!isRecord(block)) {
-        return block;
-    }
-    const type = typeof block.type === 'string' ? block.type.toLowerCase() : '';
-    if ((type === 'input_text' || type === 'output_text' || type === 'text' || type === 'commentary') && typeof block.text === 'string') {
-        const { cleaned, segments } = stripReasoningFromString(block.text);
-        block.text = cleaned;
-        if (segments.length) {
-            collector.push(...segments);
-            block.reasoning_content = mergeReasoningText(block.reasoning_content, segments);
-        }
-        else if ('reasoning_content' in block) {
-            delete block.reasoning_content;
-        }
-    }
-    if (Array.isArray(block.content)) {
-        block.content = block.content.map((nested) => normalizeResponsesContentBlock(nested, collector));
-    }
-    else if (typeof block.content === 'string') {
-        const { cleaned, segments } = stripReasoningFromString(block.content);
-        block.content = cleaned;
-        if (segments.length) {
-            collector.push(...segments);
-            block.reasoning_content = mergeReasoningText(block.reasoning_content, segments);
-        }
-        else if ('reasoning_content' in block) {
-            delete block.reasoning_content;
-        }
-    }
-    return block;
-}
-function normalizeResponsesInstructions(payload) {
-    if (typeof payload.instructions !== 'string') {
-        if (RESPONSES_INSTRUCTIONS_REASONING_FIELD in payload) {
-            delete payload[RESPONSES_INSTRUCTIONS_REASONING_FIELD];
-        }
-        return;
-    }
-    const { cleaned, segments } = stripReasoningFromString(payload.instructions);
-    payload.instructions = cleaned;
-    if (segments.length) {
-        payload[RESPONSES_INSTRUCTIONS_REASONING_FIELD] = segments.join('\n');
-    }
-    else if (RESPONSES_INSTRUCTIONS_REASONING_FIELD in payload) {
-        delete payload[RESPONSES_INSTRUCTIONS_REASONING_FIELD];
-    }
-}
-function normalizeResponsesRequiredAction(payload) {
-    if (!isRecord(payload.required_action)) {
-        return;
-    }
-    const submit = payload.required_action.submit_tool_outputs;
-    if (!submit || typeof submit !== 'object') {
-        return;
-    }
-    const toolCalls = Array.isArray(submit.tool_calls)
-        ? submit.tool_calls
-        : [];
-    toolCalls.forEach((call) => {
-        if (!isRecord(call))
-            return;
-        if (typeof call.instructions === 'string') {
-            const { cleaned, segments } = stripReasoningFromString(call.instructions);
-            call.instructions = cleaned;
-            if (segments.length) {
-                call.reasoning_content = mergeReasoningText(call.reasoning_content, segments);
-            }
-            else if ('reasoning_content' in call) {
-                delete call.reasoning_content;
-            }
-        }
-    });
-}
-function stripReasoningFromString(value) {
-    if (typeof value !== 'string') {
-        return { cleaned: typeof value === 'string' ? value : '', segments: [] };
-    }
-    const segments = [];
-    const cleaned = extractReasoningSegments(value, segments);
-    const cleanedNative = sanitizeReasoningTaggedTextWithNative(value);
-    const stableCleaned = typeof cleanedNative === 'string' ? cleanedNative : cleaned;
-    return { cleaned: stableCleaned, segments };
-}
-function mergeReasoningText(existing, segments) {
-    const combined = [];
-    if (typeof existing === 'string' && existing.trim().length) {
-        combined.push(existing.trim());
-    }
-    for (const segment of segments) {
-        if (typeof segment === 'string' && segment.trim().length) {
-            combined.push(segment.trim());
-        }
-    }
-    return combined.join('\n');
-}
 export function normalizeReasoningInGeminiPayload(payload) {
-    if (!payload) {
+    assertReasoningNormalizerNativeAvailable();
+    if (!payload)
         return;
+    const normalized = normalizeReasoningInGeminiPayloadWithNative(payload);
+    if (normalized && typeof normalized === 'object') {
+        Object.assign(payload, normalized);
     }
-    const contents = Array.isArray(payload.contents) ? payload.contents : [];
-    contents.forEach((content) => {
-        if (!isRecord(content))
-            return;
-        const parts = Array.isArray(content.parts) ? content.parts : [];
-        parts.forEach((part) => {
-            if (!isRecord(part) || typeof part.text !== 'string') {
-                return;
-            }
-            const reasoningSegments = [];
-            const cleaned = extractReasoningSegments(part.text, reasoningSegments);
-            part.text = cleaned;
-            if (reasoningSegments.length) {
-                part.reasoning = reasoningSegments.join('\n');
-            }
-            else if ('reasoning' in part) {
-                delete part.reasoning;
-            }
-        });
-    });
 }
 export function normalizeReasoningInAnthropicPayload(payload) {
-    if (!payload) {
+    assertReasoningNormalizerNativeAvailable();
+    if (!payload)
         return;
-    }
-    const responseContent = Array.isArray(payload.content) ? payload.content : undefined;
-    if (responseContent) {
-        const responseReasoning = [];
-        responseContent.forEach((block) => normalizeAnthropicBlock(block, responseReasoning));
-        if (responseReasoning.length) {
-            payload.reasoning_content = mergeReasoningText(payload.reasoning_content, responseReasoning);
-        }
-        else if ('reasoning_content' in payload) {
-            delete payload.reasoning_content;
-        }
-    }
-    const messages = Array.isArray(payload.messages) ? payload.messages : [];
-    messages.forEach((message) => {
-        if (!isRecord(message))
-            return;
-        normalizeAnthropicMessage(message);
-    });
-    const systemField = payload.system;
-    if (typeof systemField === 'string') {
-        const { cleaned } = stripReasoningFromString(systemField);
-        payload.system = cleaned;
-    }
-    else if (Array.isArray(systemField)) {
-        systemField.forEach((entry) => normalizeAnthropicBlock(entry, []));
-    }
-    else if (isRecord(systemField) && Array.isArray(systemField.content)) {
-        const sysBlocks = systemField.content;
-        systemField.content = sysBlocks.map((block) => {
-            normalizeAnthropicBlock(block, []);
-            return block;
-        });
-    }
-}
-function normalizeAnthropicMessage(message) {
-    const reasoningSegments = [];
-    if (Array.isArray(message.content)) {
-        message.content.forEach((block) => normalizeAnthropicBlock(block, reasoningSegments));
-    }
-    else if (typeof message.content === 'string') {
-        const { cleaned, segments } = stripReasoningFromString(message.content);
-        message.content = cleaned;
-        reasoningSegments.push(...segments);
-    }
-    if (reasoningSegments.length) {
-        message.reasoning_content = mergeReasoningText(message.reasoning_content, reasoningSegments);
-    }
-    else if ('reasoning_content' in message) {
-        delete message.reasoning_content;
+    const normalized = normalizeReasoningInAnthropicPayloadWithNative(payload);
+    if (normalized && typeof normalized === 'object') {
+        Object.assign(payload, normalized);
     }
 }
-function normalizeAnthropicBlock(block, collector) {
-    if (typeof block === 'string') {
-        const { cleaned, segments } = stripReasoningFromString(block);
-        collector.push(...segments);
+export function normalizeReasoningInOpenAIPayload(payload) {
+    assertReasoningNormalizerNativeAvailable();
+    if (!payload)
         return;
+    const normalized = normalizeReasoningInOpenAIPayloadWithNative(payload);
+    if (normalized && typeof normalized === 'object') {
+        Object.assign(payload, normalized);
     }
-    if (!isRecord(block)) {
-        return;
-    }
-    const type = typeof block.type === 'string' ? block.type.toLowerCase() : '';
-    if (type === 'text' && typeof block.text === 'string') {
-        const { cleaned, segments } = stripReasoningFromString(block.text);
-        block.text = cleaned;
-        collector.push(...segments);
-        return;
-    }
-    if (type === 'thinking' || type === 'reasoning') {
-        const flattened = flattenAnthropicText(block);
-        if (flattened.trim().length) {
-            collector.push(flattened.trim());
-        }
-        return;
-    }
-    if (Array.isArray(block.content)) {
-        block.content.forEach((nested) => normalizeAnthropicBlock(nested, collector));
-    }
-    else if (typeof block.content === 'string') {
-        const { cleaned, segments } = stripReasoningFromString(block.content);
-        block.content = cleaned;
-        collector.push(...segments);
-    }
-}
-function flattenAnthropicText(source) {
-    if (typeof source === 'string') {
-        return source;
-    }
-    if (Array.isArray(source)) {
-        return source.map((entry) => flattenAnthropicText(entry)).filter(Boolean).join('');
-    }
-    if (isRecord(source)) {
-        if (typeof source.text === 'string') {
-            return source.text;
-        }
-        if (typeof source.content === 'string') {
-            return source.content;
-        }
-        if (Array.isArray(source.content)) {
-            return source.content.map((entry) => flattenAnthropicText(entry)).filter(Boolean).join('');
-        }
-    }
-    return '';
 }

package/dist/conversion/shared/reasoning-tool-normalizer.js

@@ -1,18 +1,14 @@
 import { normalizeChatResponseReasoningToolsWithNative, normalizeMessageReasoningToolsWithNative } from '../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
-function overwriteRecordInPlace(target, source) {
-    for (const key of Object.keys(target)) {
-        delete target[key];
-    }
-    for (const [key, value] of Object.entries(source)) {
-        target[key] = value;
+const MODULE_NAME = 'reasoning-tool-normalizer';
+function assertReasoningToolNormalizerNativeAvailable() {
+    if (typeof normalizeMessageReasoningToolsWithNative !== 'function' ||
+        typeof normalizeChatResponseReasoningToolsWithNative !== 'function') {
+        throw new Error(`[${MODULE_NAME}] native bindings unavailable`);
     }
 }
 export function normalizeMessageReasoningTools(message, options) {
-    if (!message || typeof message !== 'object') {
-        return { toolCallsAdded: 0 };
-    }
+    assertReasoningToolNormalizerNativeAvailable();
     const normalized = normalizeMessageReasoningToolsWithNative(message, typeof options?.idPrefix === 'string' ? options.idPrefix : undefined);
-    overwriteRecordInPlace(message, normalized.message);
     return {
         toolCallsAdded: normalized.toolCallsAdded,
         ...(typeof normalized.cleanedReasoning === 'string'
@@ -21,9 +17,6 @@ export function normalizeMessageReasoningTools(message, options) {
     };
 }
 export function normalizeChatResponseReasoningTools(response, options) {
-    if (!response || typeof response !== 'object') {
-        return;
-    }
-    const normalized = normalizeChatResponseReasoningToolsWithNative(response, typeof options?.idPrefixBase === 'string' ? options.idPrefixBase : undefined);
-    overwriteRecordInPlace(response, normalized);
+    assertReasoningToolNormalizerNativeAvailable();
+    normalizeChatResponseReasoningToolsWithNative(response, typeof options?.idPrefixBase === 'string' ? options.idPrefixBase : undefined);
 }

package/dist/conversion/shared/reasoning-tool-parser.js

@@ -1,12 +1,11 @@
 import { extractToolCallsFromReasoningTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
-export function extractToolCallsFromReasoningText(text, options) {
-    if (typeof text !== 'string' || !text.trim()) {
-        return { cleanedText: typeof text === 'string' ? text : '', toolCalls: [] };
+function assertReasoningToolParserNativeAvailable() {
+    if (typeof extractToolCallsFromReasoningTextWithNative !== 'function') {
+        throw new Error('[reasoning-tool-parser] native bindings unavailable');
     }
+}
+export function extractToolCallsFromReasoningText(text, options) {
+    assertReasoningToolParserNativeAvailable();
     const idPrefix = options?.idPrefix ?? 'reasoning';
-    const output = extractToolCallsFromReasoningTextWithNative(text, idPrefix);
-    return {
-        cleanedText: output.cleanedText,
-        toolCalls: output.toolCalls
-    };
+    return extractToolCallsFromReasoningTextWithNative(String(text ?? ''), idPrefix);
 }

package/dist/conversion/shared/reasoning-utils.js

@@ -1,41 +1,19 @@
-import { sanitizeReasoningTaggedTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
-export function extractReasoningSegments(source, reasoningCollector) {
-    let working = source ?? '';
-    const hasExplicitOpen = /<think>/i.test(source) ||
-        /<reflection>/i.test(source) ||
-        /```\s*(?:think|reflection)/i.test(source);
-    const hasExplicitClose = /<\/think>/i.test(source) ||
-        /<\/reflection>/i.test(source);
-    const push = (value) => {
-        const trimmed = (value ?? '').trim();
-        if (trimmed && reasoningCollector) {
-            reasoningCollector.push(trimmed);
-        }
-    };
-    const patterns = [
-        /<think>([\s\S]*?)<\/think>/gi,
-        /<reflection>([\s\S]*?)<\/reflection>/gi,
-        /```\s*(?:think|reflection)[\s\S]*?```/gi
-    ];
-    for (const pattern of patterns) {
-        working = working.replace(pattern, (_match, inner) => {
-            push(inner);
-            return '';
-        });
+import { extractReasoningSegmentsWithNative, sanitizeReasoningTaggedTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+function assertReasoningUtilsNativeAvailable() {
+    if (typeof extractReasoningSegmentsWithNative !== 'function' ||
+        typeof sanitizeReasoningTaggedTextWithNative !== 'function') {
+        throw new Error('[reasoning-utils] native bindings unavailable');
     }
-    working = working
-        .replace(/<\/?think>/gi, '')
-        .replace(/<\/?reflection>/gi, '');
-    working = working.replace(/\n{3,}/g, '\n\n');
-    if (reasoningCollector && !hasExplicitOpen && hasExplicitClose) {
-        const trimmed = working.trim();
-        if (trimmed.length) {
-            reasoningCollector.push(trimmed);
-        }
-        return '';
+}
+export function extractReasoningSegments(source, reasoningCollector) {
+    assertReasoningUtilsNativeAvailable();
+    const output = extractReasoningSegmentsWithNative(source ?? '');
+    if (reasoningCollector) {
+        reasoningCollector.push(...output.segments);
     }
-    return working.trim();
+    return output.text;
 }
 export function sanitizeReasoningTaggedText(value) {
+    assertReasoningUtilsNativeAvailable();
     return sanitizeReasoningTaggedTextWithNative(value);
 }

package/dist/conversion/shared/responses-response-utils.js

@@ -2,7 +2,7 @@ import { extractOutputSegments } from './output-content-normalizer.js';
 import { createBridgeActionState, runBridgeActionPipeline } from '../bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from '../bridge-policies.js';
 import { registerResponsesPayloadSnapshot, registerResponsesPassthrough } from './responses-reasoning-registry.js';
-import { normalizeFunctionCallIdWithNative, sanitizeReasoningTaggedTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { collectToolCallsFromResponsesWithNative, normalizeFunctionCallIdWithNative, resolveFinishReasonWithNative, sanitizeReasoningTaggedTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 import { sanitizeResponsesFunctionNameWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
 function selectCallId(entry) {
     const candidates = [
@@ -53,55 +53,10 @@ function normalizeToolCall(entry, fallbackPrefix) {
     };
 }
 export function collectToolCallsFromResponses(response) {
-    const collected = [];
-    const seenIds = new Set();
-    const pushCall = (call, source) => {
-        if (!call)
-            return;
-        const key = typeof call.id === 'string' ? call.id : `${source}_${collected.length}`;
-        if (key && seenIds.has(key))
-            return;
-        if (key)
-            seenIds.add(key);
-        collected.push(call);
-    };
-    const required = response?.required_action?.submit_tool_outputs?.tool_calls;
-    if (Array.isArray(required)) {
-        for (const call of required) {
-            pushCall(normalizeToolCall(call, 'req_call'), 'req_call');
-        }
-    }
-    const outputItems = Array.isArray(response.output) ? response.output : [];
-    for (const item of outputItems) {
-        if (!item || typeof item !== 'object')
-            continue;
-        const type = typeof item.type === 'string' ? String(item.type).toLowerCase() : '';
-        if (type !== 'function_call')
-            continue;
-        pushCall(normalizeToolCall(item, 'output_call'), 'output_call');
-    }
-    return collected;
+    return collectToolCallsFromResponsesWithNative(response);
 }
 export function resolveFinishReason(response, toolCalls) {
-    const meta = response.metadata && typeof response.metadata === 'object'
-        ? response.metadata
-        : undefined;
-    if (meta && typeof meta.finish_reason === 'string') {
-        return meta.finish_reason;
-    }
-    if (toolCalls.length > 0) {
-        return 'tool_calls';
-    }
-    const status = typeof response.status === 'string' ? response.status.toLowerCase() : '';
-    if (status === 'requires_action')
-        return 'tool_calls';
-    if (status === 'in_progress' || status === 'streaming')
-        return 'length';
-    if (status === 'cancelled')
-        return 'cancelled';
-    if (status === 'failed')
-        return 'error';
-    return 'stop';
+    return resolveFinishReasonWithNative(response, toolCalls);
 }
 function unwrapResponsesResponse(payload) {
     if (!payload || typeof payload !== 'object')

package/dist/conversion/shared/responses-tool-utils.d.ts

@@ -6,9 +6,9 @@ export interface CallIdTransformer {
     normalizeOutputId(callId: string, raw: unknown): string;
 }
 export declare function createToolCallIdTransformer(style: ToolCallIdStyle): CallIdTransformer | null;
-export declare function enforceToolCallIdStyle(input: BridgeInputItem[], transformer: CallIdTransformer): void;
 export declare function normalizeResponsesToolCallIds(payload: Record<string, unknown> | null | undefined): void;
 export declare function resolveToolCallIdStyle(metadata: Record<string, unknown> | undefined): ToolCallIdStyle;
 export declare function stripInternalToolingMetadata(metadata: unknown): void;
 export declare function sanitizeResponsesFunctionName(rawName: unknown): string | undefined;
+export declare function enforceToolCallIdStyle(input: BridgeInputItem[], transformer: CallIdTransformer): void;
 export {};