@jsonstudio/llms 0.6.3275 → 0.6.3379

package/dist/conversion/hub/response/response-runtime.js

@@ -223,8 +223,7 @@ export function buildOpenAIChatFromAnthropicMessage(payload, options) {
     };
     const includeToolCallIds = options?.includeToolCallIds === true;
     const canonicalToolCalls = toolCalls.map((tc) => ({
-        id: tc.id,
-        ...(includeToolCallIds ? { call_id: tc.id, tool_call_id: tc.id } : {}),
+        ...(includeToolCallIds ? { id: tc.id, call_id: tc.id, tool_call_id: tc.id } : {}),
         type: 'function',
         function: { name: tc.name, arguments: tc.args }
     }));
@@ -246,6 +245,14 @@ export function buildOpenAIChatFromAnthropicMessage(payload, options) {
                 if (!("tool_call_id" in inferred))
                     inferred.tool_call_id = inferredId;
             }
+            else if (!includeToolCallIds) {
+                if ("id" in inferred)
+                    delete inferred.id;
+                if ("call_id" in inferred)
+                    delete inferred.call_id;
+                if ("tool_call_id" in inferred)
+                    delete inferred.tool_call_id;
+            }
             canonicalToolCalls.push(inferred);
             if (key)
                 seen.add(key);
@@ -259,9 +266,13 @@ export function buildOpenAIChatFromAnthropicMessage(payload, options) {
                     call.call_id = cid;
                 if (!("tool_call_id" in call))
                     call.tool_call_id = cid;
+                if (!("id" in call))
+                    call.id = cid;
             }
         }
         else {
+            if ("id" in call)
+                delete call.id;
             if ("call_id" in call)
                 delete call.call_id;
             if ("tool_call_id" in call)
@@ -443,10 +454,7 @@ function sanitizeAnthropicMessage(message) {
         .filter((block) => block !== null);
     const usage = message.usage;
     if (usage && typeof usage === 'object') {
-        sanitized.usage = {
-            input_tokens: usage.input_tokens ?? 0,
-            output_tokens: usage.output_tokens ?? 0
-        };
+        sanitized.usage = JSON.parse(JSON.stringify(usage));
     }
     return sanitized;
 }

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

@@ -238,12 +238,6 @@ function buildClientToolIndex(toolsRaw) {
     }
     return index;
 }
-const CLIENT_TOOL_NAME_ALIASES = new Map([
-    ['shell_command', 'exec_command'],
-    ['shell', 'exec_command'],
-    ['bash', 'exec_command'],
-    ['terminal', 'exec_command']
-]);
 function resolveClientToolName(toolIndex, rawToolName) {
     const trimmed = rawToolName.trim();
     if (!trimmed.length)
@@ -256,12 +250,18 @@ function resolveClientToolName(toolIndex, rawToolName) {
             return key;
         }
     }
-    const aliased = CLIENT_TOOL_NAME_ALIASES.get(lower);
-    if (!aliased)
+    const hasBash = Array.from(toolIndex.keys()).some((key) => key.toLowerCase() === 'bash');
+    if (hasBash)
         return undefined;
-    for (const key of toolIndex.keys()) {
-        if (key.toLowerCase() === aliased) {
-            return key;
+    if (!['shell_command', 'exec_command', 'shell', 'terminal', 'bash'].includes(lower)) {
+        return undefined;
+    }
+    const preferred = ['shell_command', 'exec_command', 'shell', 'terminal'];
+    for (const candidate of preferred) {
+        for (const key of toolIndex.keys()) {
+            if (key.toLowerCase() === candidate) {
+                return key;
+            }
         }
     }
     return undefined;

package/dist/conversion/shared/anthropic-message-utils.js

@@ -186,12 +186,7 @@ function requireSystemText(block, context) {
     }
     return text;
 }
-const ANTHROPIC_TOOL_NAME_ALIASES = new Map([
-    ['bash', 'shell_command'],
-    ['shell', 'shell_command'],
-    ['terminal', 'shell_command'],
-    ['exec_command', 'shell_command']
-]);
+const ANTHROPIC_TOOL_NAME_ALIASES = new Map();
 const CANONICAL_TO_ANTHROPIC_TOOL_NAMES = new Map([['shell_command', 'Bash']]);
 const ANTHROPIC_TOP_LEVEL_FIELDS = new Set([
     'model',
@@ -1398,12 +1393,7 @@ export function buildAnthropicToolAliasMap(rawTools) {
             continue;
         }
         aliasMap.set(canonicalKey, rawName);
-        // Anthropic shell-like tools (e.g. Bash) and exec_command are treated as one family.
-        // Keep an explicit exec_command key so reverse mapping can preserve
-        // canonical exec_command when upstream already uses that name.
-        if (canonicalKey === 'shell_command' && !aliasMap.has('exec_command')) {
-            aliasMap.set('exec_command', rawName);
-        }
+        const lowered = canonicalKey.toLowerCase();
         const lowerKey = canonicalKey.toLowerCase();
         if (lowerKey !== canonicalKey && !aliasMap.has(lowerKey)) {
             aliasMap.set(lowerKey, rawName);

package/dist/conversion/shared/chat-request-filters.js

@@ -1,6 +1,7 @@
 import { normalizeChatRequest } from '../index.js';
 import { createSnapshotWriter } from '../snapshot-utils.js';
 import { buildGovernedFilterPayloadWithNativeFallback } from '../../router/virtual-router/engine-selection/native-chat-request-filter-semantics.js';
+import { pruneChatRequestPayloadWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 /**
  * Native-primary Chat request filters.
  *
@@ -56,67 +57,7 @@ export async function runStandardChatRequestFilters(chatRequest, profile, contex
         normalized.__rcc_disable_mcp_tools = true;
     }
     const preserveStreamField = profile.incomingProtocol === 'openai-chat' && profile.outgoingProtocol === 'openai-chat';
-    const pruned = pruneChatRequestPayload(normalized, { preserveStreamField });
+    const pruned = pruneChatRequestPayloadWithNative(normalized, preserveStreamField);
     snapshotStage('req_process_filters_output', pruned);
     return pruned;
 }
-function pruneChatRequestPayload(chatRequest, options) {
-    if (!chatRequest || typeof chatRequest !== 'object')
-        return chatRequest;
-    const stripped = { ...chatRequest };
-    stripSentinelKeys(stripped);
-    if ('originalStream' in stripped) {
-        delete stripped.originalStream;
-    }
-    if ('_originalStreamOptions' in stripped) {
-        delete stripped._originalStreamOptions;
-    }
-    if ('metadata' in stripped) {
-        delete stripped.metadata;
-    }
-    if (!options?.preserveStreamField && 'stream' in stripped && stripped.stream !== true) {
-        delete stripped.stream;
-    }
-    if (Array.isArray(stripped.messages)) {
-        stripped.messages = stripped.messages.map((message) => sanitizeMessageEntry(message));
-    }
-    return stripped;
-}
-function sanitizeMessageEntry(message) {
-    if (!message || typeof message !== 'object')
-        return message;
-    const clone = { ...message };
-    if (Array.isArray(clone.tool_calls) && clone.tool_calls.length) {
-        clone.tool_calls = clone.tool_calls.map((call) => sanitizeToolCallEntry(call));
-    }
-    if (clone.role === 'tool') {
-        if (typeof clone.tool_call_id !== 'string' && typeof clone.call_id === 'string') {
-            clone.tool_call_id = clone.call_id;
-        }
-        if ('id' in clone) {
-            delete clone.id;
-        }
-    }
-    if ('call_id' in clone) {
-        delete clone.call_id;
-    }
-    return clone;
-}
-function sanitizeToolCallEntry(call) {
-    if (!call || typeof call !== 'object')
-        return call;
-    const clone = { ...call };
-    delete clone.call_id;
-    delete clone.tool_call_id;
-    if (clone.function && typeof clone.function === 'object') {
-        clone.function = { ...clone.function };
-    }
-    return clone;
-}
-function stripSentinelKeys(record) {
-    Object.keys(record).forEach((key) => {
-        if (key.startsWith('__rcc_')) {
-            delete record[key];
-        }
-    });
-}

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

@@ -1,4 +1,7 @@
 import { mapReasoningContentToResponsesOutputWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export function mapReasoningContentToResponsesOutput(reasoningContent) {
+    if (typeof mapReasoningContentToResponsesOutputWithNative !== 'function') {
+        throw new Error('[reasoning-mapping] native bindings unavailable');
+    }
     return mapReasoningContentToResponsesOutputWithNative(reasoningContent);
 }

package/dist/conversion/shared/reasoning-normalizer.d.ts

@@ -19,4 +19,5 @@ export declare function normalizeReasoningInResponsesPayload(payload: {
 } | null | undefined, options?: ResponsesReasoningNormalizeOptions): void;
 export declare function normalizeReasoningInGeminiPayload(payload: JsonObject | null | undefined): void;
 export declare function normalizeReasoningInAnthropicPayload(payload: JsonObject | null | undefined): void;
+export declare function normalizeReasoningInOpenAIPayload(payload: JsonObject | null | undefined): void;
 export {};

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 '';
 }