@jsonstudio/llms 0.6.3541 → 0.6.3685

package/dist/conversion/hub/process/chat-process-media.js

@@ -10,6 +10,42 @@ export function stripHistoricalImageAttachments(messages) {
     }
     return stripped.messages;
 }
+const INLINE_MEDIA_DATA_RE = /data:(image|video)\/[a-z0-9.+-]+;base64,[a-z0-9+/=\s]+/i;
+function isVisualToolMessage(message) {
+    if (!message || typeof message !== 'object') {
+        return false;
+    }
+    if (message.role !== 'tool') {
+        return false;
+    }
+    const name = typeof message.name === 'string' ? message.name.trim().toLowerCase() : '';
+    if (name === 'view_image') {
+        return true;
+    }
+    const content = typeof message.content === 'string' ? message.content : '';
+    return INLINE_MEDIA_DATA_RE.test(content);
+}
+export function stripHistoricalVisualToolOutputs(messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return messages;
+    }
+    let changed = false;
+    const next = messages.map((message) => {
+        if (!isVisualToolMessage(message)) {
+            return message;
+        }
+        const content = typeof message.content === 'string' ? message.content : '';
+        if (!INLINE_MEDIA_DATA_RE.test(content)) {
+            return message;
+        }
+        changed = true;
+        return {
+            ...message,
+            content: '[Image omitted]'
+        };
+    });
+    return changed ? next : messages;
+}
 export function containsImageAttachment(messages) {
     if (!Array.isArray(messages) || !messages.length) {
         return false;

package/dist/conversion/hub/process/chat-process-session-usage.d.ts

@@ -0,0 +1,25 @@
+import type { ProcessedRequest, StandardizedRequest } from '../types/standardized.js';
+type SessionScopeMetadata = {
+    sessionId?: string;
+    conversationId?: string;
+};
+type ChatProcessSessionRequestSnapshot = Pick<StandardizedRequest | ProcessedRequest, 'messages' | 'tools' | 'parameters'>;
+export interface ChatProcessSessionInputEstimateResult {
+    tokens?: number;
+    scope?: string;
+    mode: 'session_reuse' | 'session_delta' | 'unavailable';
+    reason?: 'missing_scope' | 'missing_state' | 'missing_previous_usage' | 'tools_signature_changed' | 'parameters_signature_changed' | 'message_count_regressed' | 'boundary_mismatch';
+    previousMessageCount?: number;
+    appendedMessageCount?: number;
+    hasPreviousTokens?: boolean;
+    hasPreviousMessageCount?: boolean;
+    hasToolsSignature?: boolean;
+    hasParametersSignature?: boolean;
+    previousParametersSignatureDigest?: string;
+    currentParametersSignatureDigest?: string;
+}
+export declare function estimateChatProcessSessionInputTokens(metadata: SessionScopeMetadata, request: StandardizedRequest | ProcessedRequest): number | undefined;
+export declare function estimateChatProcessSessionInputTokensDetailed(metadata: SessionScopeMetadata, request: StandardizedRequest | ProcessedRequest): ChatProcessSessionInputEstimateResult;
+export declare function saveChatProcessSessionInputEstimate(metadata: SessionScopeMetadata, request: StandardizedRequest | ProcessedRequest, estimatedInputTokens: number): void;
+export declare function saveChatProcessSessionActualUsage(metadata: SessionScopeMetadata, usageRaw: unknown, requestSnapshot?: ChatProcessSessionRequestSnapshot): void;
+export {};

package/dist/conversion/hub/process/chat-process-session-usage.js

@@ -0,0 +1,246 @@
+import { loadRoutingInstructionStateSync, saveRoutingInstructionStateSync } from '../../../router/virtual-router/sticky-session-store.js';
+import { countRequestTokens } from '../../../router/virtual-router/token-counter.js';
+function buildEmptyRoutingInstructionState() {
+    return {
+        forcedTarget: undefined,
+        stickyTarget: undefined,
+        preferTarget: undefined,
+        allowedProviders: new Set(),
+        disabledProviders: new Set(),
+        disabledKeys: new Map(),
+        disabledModels: new Map(),
+        stopMessageSource: undefined,
+        stopMessageText: undefined,
+        stopMessageMaxRepeats: undefined,
+        stopMessageUsed: undefined,
+        stopMessageUpdatedAt: undefined,
+        stopMessageLastUsedAt: undefined,
+        stopMessageStageMode: undefined,
+        stopMessageAiMode: undefined,
+        stopMessageAiSeedPrompt: undefined,
+        stopMessageAiHistory: undefined,
+        preCommandSource: undefined,
+        preCommandScriptPath: undefined,
+        preCommandUpdatedAt: undefined,
+        chatProcessInputTokens: undefined,
+        chatProcessMessageCount: undefined,
+        chatProcessToolsSignature: undefined,
+        chatProcessParametersSignature: undefined,
+        chatProcessBoundarySignature: undefined,
+        chatProcessUpdatedAt: undefined
+    };
+}
+function readScope(metadata) {
+    const sessionId = typeof metadata.sessionId === 'string' ? metadata.sessionId.trim() : '';
+    if (sessionId) {
+        return `session:${sessionId}`;
+    }
+    const conversationId = typeof metadata.conversationId === 'string' ? metadata.conversationId.trim() : '';
+    if (conversationId) {
+        return `conversation:${conversationId}`;
+    }
+    return undefined;
+}
+function stableSignature(value) {
+    try {
+        return JSON.stringify(value ?? null) || 'null';
+    }
+    catch {
+        return 'unserializable';
+    }
+}
+function messageBoundarySignature(message) {
+    if (!message) {
+        return undefined;
+    }
+    return stableSignature({
+        role: message.role,
+        content: message.content ?? null,
+        tool_calls: Array.isArray(message.tool_calls) ? message.tool_calls : [],
+        tool_call_id: message.tool_call_id ?? null,
+        name: message.name ?? null
+    });
+}
+function coercePositiveInteger(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0
+        ? Math.max(1, Math.round(value))
+        : undefined;
+}
+function digestSignature(value) {
+    if (!value) {
+        return undefined;
+    }
+    let hash = 2166136261;
+    for (let i = 0; i < value.length; i += 1) {
+        hash ^= value.charCodeAt(i);
+        hash = Math.imul(hash, 16777619);
+    }
+    return `${value.length}:${(hash >>> 0).toString(16)}`;
+}
+function hasReusableSessionUsageShape(state) {
+    if (!state) {
+        return false;
+    }
+    const previousTokens = coercePositiveInteger(state.chatProcessInputTokens);
+    const previousMessageCount = typeof state.chatProcessMessageCount === 'number' &&
+        Number.isFinite(state.chatProcessMessageCount) &&
+        state.chatProcessMessageCount >= 0;
+    const toolsSignature = typeof state.chatProcessToolsSignature === 'string' && state.chatProcessToolsSignature.trim().length > 0;
+    const parametersSignature = typeof state.chatProcessParametersSignature === 'string' &&
+        state.chatProcessParametersSignature.trim().length > 0;
+    return previousTokens !== undefined && previousMessageCount && toolsSignature && parametersSignature;
+}
+function applyRequestSnapshotToState(state, request) {
+    if (!request || typeof request !== 'object') {
+        return false;
+    }
+    const messages = Array.isArray(request.messages) ? request.messages : null;
+    if (!messages) {
+        return false;
+    }
+    state.chatProcessMessageCount = messages.length;
+    state.chatProcessToolsSignature = stableSignature(request.tools ?? null);
+    state.chatProcessParametersSignature = stableSignature(request.parameters ?? null);
+    state.chatProcessBoundarySignature = messageBoundarySignature(messages[messages.length - 1]);
+    return true;
+}
+export function estimateChatProcessSessionInputTokens(metadata, request) {
+    return estimateChatProcessSessionInputTokensDetailed(metadata, request).tokens;
+}
+export function estimateChatProcessSessionInputTokensDetailed(metadata, request) {
+    const scope = readScope(metadata);
+    if (!scope) {
+        return {
+            scope,
+            mode: 'unavailable',
+            reason: 'missing_scope'
+        };
+    }
+    const state = loadRoutingInstructionStateSync(scope);
+    if (!state) {
+        return {
+            scope,
+            mode: 'unavailable',
+            reason: 'missing_state'
+        };
+    }
+    const previousTokens = coercePositiveInteger(state.chatProcessInputTokens);
+    const previousMessageCount = typeof state.chatProcessMessageCount === 'number' &&
+        Number.isFinite(state.chatProcessMessageCount) &&
+        state.chatProcessMessageCount >= 0
+        ? Math.max(0, Math.floor(state.chatProcessMessageCount))
+        : undefined;
+    if (previousTokens === undefined || previousMessageCount === undefined) {
+        return {
+            scope,
+            mode: 'unavailable',
+            reason: 'missing_previous_usage',
+            hasPreviousTokens: previousTokens !== undefined,
+            hasPreviousMessageCount: previousMessageCount !== undefined,
+            hasToolsSignature: Boolean(state.chatProcessToolsSignature),
+            hasParametersSignature: Boolean(state.chatProcessParametersSignature)
+        };
+    }
+    const currentToolsSignature = stableSignature(request.tools ?? null);
+    const currentParametersSignature = stableSignature(request.parameters ?? null);
+    if (state.chatProcessToolsSignature !== currentToolsSignature) {
+        return {
+            scope,
+            mode: 'unavailable',
+            reason: 'tools_signature_changed',
+            previousMessageCount,
+            hasPreviousTokens: true,
+            hasPreviousMessageCount: true
+        };
+    }
+    if (state.chatProcessParametersSignature !== currentParametersSignature) {
+        return {
+            scope,
+            mode: 'unavailable',
+            reason: 'parameters_signature_changed',
+            previousMessageCount,
+            hasPreviousTokens: true,
+            hasPreviousMessageCount: true,
+            previousParametersSignatureDigest: digestSignature(state.chatProcessParametersSignature),
+            currentParametersSignatureDigest: digestSignature(currentParametersSignature)
+        };
+    }
+    const messages = Array.isArray(request.messages) ? request.messages : [];
+    if (previousMessageCount > messages.length) {
+        return {
+            scope,
+            mode: 'unavailable',
+            reason: 'message_count_regressed',
+            previousMessageCount
+        };
+    }
+    if (previousMessageCount > 0) {
+        const boundary = messageBoundarySignature(messages[previousMessageCount - 1]);
+        if ((state.chatProcessBoundarySignature || undefined) !== boundary) {
+            return {
+                scope,
+                mode: 'unavailable',
+                reason: 'boundary_mismatch',
+                previousMessageCount
+            };
+        }
+    }
+    const appendedMessages = messages.slice(previousMessageCount);
+    if (appendedMessages.length === 0) {
+        return {
+            tokens: previousTokens,
+            scope,
+            mode: 'session_reuse',
+            previousMessageCount,
+            appendedMessageCount: 0
+        };
+    }
+    const delta = countRequestTokens({
+        model: request.model,
+        messages: appendedMessages,
+        tools: undefined,
+        parameters: {},
+        metadata: request.metadata ?? { originalEndpoint: '' }
+    });
+    return {
+        tokens: previousTokens + delta,
+        scope,
+        mode: 'session_delta',
+        previousMessageCount,
+        appendedMessageCount: appendedMessages.length
+    };
+}
+export function saveChatProcessSessionInputEstimate(metadata, request, estimatedInputTokens) {
+    const scope = readScope(metadata);
+    const normalized = coercePositiveInteger(estimatedInputTokens);
+    if (!scope || normalized === undefined) {
+        return;
+    }
+    const state = loadRoutingInstructionStateSync(scope) ?? buildEmptyRoutingInstructionState();
+    const messages = Array.isArray(request.messages) ? request.messages : [];
+    state.chatProcessInputTokens = normalized;
+    state.chatProcessMessageCount = messages.length;
+    state.chatProcessToolsSignature = stableSignature(request.tools ?? null);
+    state.chatProcessParametersSignature = stableSignature(request.parameters ?? null);
+    state.chatProcessBoundarySignature = messageBoundarySignature(messages[messages.length - 1]);
+    state.chatProcessUpdatedAt = Date.now();
+    saveRoutingInstructionStateSync(scope, state);
+}
+export function saveChatProcessSessionActualUsage(metadata, usageRaw, requestSnapshot) {
+    const scope = readScope(metadata);
+    if (!scope || !usageRaw || typeof usageRaw !== 'object' || Array.isArray(usageRaw)) {
+        return;
+    }
+    const usage = usageRaw;
+    const actualInputTokens = coercePositiveInteger(usage.prompt_tokens ?? usage.input_tokens ?? usage.total_input_tokens);
+    if (actualInputTokens === undefined) {
+        return;
+    }
+    const state = loadRoutingInstructionStateSync(scope) ?? buildEmptyRoutingInstructionState();
+    if (!hasReusableSessionUsageShape(state) && !applyRequestSnapshotToState(state, requestSnapshot)) {
+        return;
+    }
+    state.chatProcessInputTokens = actualInputTokens;
+    state.chatProcessUpdatedAt = Date.now();
+    saveRoutingInstructionStateSync(scope, state);
+}

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

@@ -15,6 +15,7 @@ import { runRespProcessStage3ServerToolOrchestration } from '../pipeline/stages/
 import { runRespOutboundStage1ClientRemap } from '../pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js';
 import { runRespOutboundStage2SseStream } from '../pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.js';
 import { recordResponsesResponse } from '../../shared/responses-conversation-store.js';
+import { saveChatProcessSessionActualUsage } from '../process/chat-process-session-usage.js';
 import { ProviderProtocolError } from '../../provider-protocol-error.js';
 import { readRuntimeMetadata } from '../../runtime-metadata.js';
 import { commitClockReservation, resolveClockConfig } from '../../../servertool/clock/task-store.js';
@@ -397,6 +398,18 @@ export async function convertProviderResponse(options) {
     });
     applyModelOverride(clientPayload, displayModel);
     stripInternalPolicyDebugFields(clientPayload);
+    try {
+        const usage = clientPayload && typeof clientPayload === 'object' && !Array.isArray(clientPayload)
+            ? clientPayload.usage
+            : undefined;
+        saveChatProcessSessionActualUsage({
+            sessionId: typeof options.context.sessionId === 'string' ? options.context.sessionId : undefined,
+            conversationId: typeof options.context.conversationId === 'string' ? options.context.conversationId : undefined
+        }, usage, isJsonRecord(options.context.capturedChatRequest) ? options.context.capturedChatRequest : undefined);
+    }
+    catch {
+        // best-effort: usage backfill must not break response conversion
+    }
     if (clientProtocol === 'openai-responses') {
         try {
             recordResponsesResponse({

package/dist/conversion/hub/types/chat-envelope.d.ts

@@ -53,6 +53,7 @@ export interface AdapterContext {
     originalModelId?: string;
     clientModelId?: string;
     toolCallIdStyle?: 'fc' | 'preserve';
+    applyPatchToolMode?: 'schema' | 'freeform';
     responsesResume?: JsonObject;
     [key: string]: JsonValue;
 }

package/dist/conversion/pipeline/codecs/v2/openai-openai-pipeline.js

@@ -142,10 +142,6 @@ export class OpenAIOpenAIPipelineCodec {
         if (!Array.isArray(openaiPayload.tools) && Array.isArray(inboundPayload.tools)) {
             openaiPayload.tools = inboundPayload.tools;
         }
-        if (openaiPayload.tool_choice === undefined &&
-            inboundPayload.tool_choice !== undefined) {
-            openaiPayload.tool_choice = inboundPayload.tool_choice;
-        }
         const filterContext = {
             ...context,
             requestId,

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

@@ -55,10 +55,6 @@ function collectRetentionContext(context) {
     const stripHostManagedFields = shouldStripHostManagedFields(context);
     return {
         metadata: context?.metadata,
-        parallelToolCalls: context?.parallel_tool_calls,
-        toolChoice: context?.tool_choice,
-        include: context?.include,
-        store: context?.store,
         stripHostManagedFields
     };
 }
@@ -103,10 +99,6 @@ export function buildResponsesPayloadFromChat(payload, context) {
             requestId: context?.requestId,
             toolsRaw: Array.isArray(context?.toolsRaw) ? context?.toolsRaw : [],
             metadata: retentionContext.metadata,
-            parallelToolCalls: retentionContext.parallelToolCalls,
-            toolChoice: retentionContext.toolChoice,
-            include: retentionContext.include,
-            store: retentionContext.store,
             stripHostManagedFields: retentionContext.stripHostManagedFields,
             sourceForRetention: sourceForRetention
         });
@@ -176,10 +168,6 @@ export function buildResponsesPayloadFromChat(payload, context) {
         requestId: context?.requestId,
         toolsRaw: Array.isArray(context?.toolsRaw) ? context?.toolsRaw : [],
         metadata: retentionContext.metadata,
-        parallelToolCalls: retentionContext.parallelToolCalls,
-        toolChoice: retentionContext.toolChoice,
-        include: retentionContext.include,
-        store: retentionContext.store,
         stripHostManagedFields: retentionContext.stripHostManagedFields,
         sourceForRetention: sourceForRetention
     });

package/dist/conversion/responses/responses-openai-bridge/types.d.ts

@@ -1,6 +1,6 @@
 import type { BridgeInputItem, BridgeToolDefinition } from '../../types/bridge-message-types.js';
 import type { ChatToolDefinition } from '../../hub/types/chat-envelope.js';
-import type { JsonObject, JsonValue } from '../../hub/types/json.js';
+import type { JsonObject } from '../../hub/types/json.js';
 import type { ToolCallIdStyle } from '../../shared/responses-tool-utils.js';
 export type Unknown = Record<string, unknown>;
 export interface ResponsesRequestContext extends Unknown {
@@ -8,15 +8,7 @@ export interface ResponsesRequestContext extends Unknown {
     targetProtocol?: string;
     originalSystemMessages?: string[];
     input?: BridgeInputItem[];
-    include?: unknown;
-    store?: unknown;
-    serviceTier?: unknown;
-    truncation?: unknown;
-    toolChoice?: unknown;
-    parallelToolCalls?: boolean;
     metadata?: JsonObject;
-    responseFormat?: JsonValue;
-    stream?: boolean;
     isChatPayload?: boolean;
     isResponsesPayload?: boolean;
     historyMessages?: Array<{

package/dist/conversion/responses/responses-openai-bridge.d.ts

@@ -10,6 +10,7 @@ export declare function buildChatRequestFromResponses(payload: Record<string, un
 export declare function buildResponsesRequestFromChat(payload: Record<string, unknown>, ctx?: ResponsesRequestContext, extras?: {
     bridgeHistory?: BridgeInputBuildResult;
     systemInstruction?: string;
+    routeToolCallIdStyle?: 'fc' | 'preserve';
 }): BuildResponsesRequestResult;
 export { buildResponsesPayloadFromChat, extractRequestIdFromResponse } from './responses-openai-bridge/response-payload.js';
 export { buildChatResponseFromResponses } from '../shared/responses-response-utils.js';

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

@@ -4,6 +4,7 @@ import { convertBridgeInputToChatMessages } from '../bridge-message-utils.js';
 import { createToolCallIdTransformer, enforceToolCallIdStyle, sanitizeResponsesFunctionName } from '../shared/responses-tool-utils.js';
 import { mapChatToolsToBridge } from '../shared/tool-mapping.js';
 import { ProviderProtocolError } from '../provider-protocol-error.js';
+import { isJsonObject, jsonClone } from '../hub/types/json.js';
 import { captureReqInboundResponsesContextSnapshotWithNative, mapReqInboundBridgeToolsToChatWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 import { appendLocalImageBlockOnLatestUserInputWithNative, buildBridgeHistoryWithNative, filterBridgeInputForUpstreamWithNative, normalizeBridgeHistorySeedWithNative, prepareResponsesRequestEnvelopeWithNative, resolveResponsesRequestBridgeDecisionsWithNative, resolveResponsesBridgeToolsWithNative, runBridgeActionPipelineWithNative } from '../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
 // --- Utilities (ported strictly) ---
@@ -50,7 +51,7 @@ export function captureResponsesContext(payload, dto) {
     const captured = captureReqInboundResponsesContextSnapshotWithNative({
         rawRequest: requestForCapture,
         requestId: dto?.route?.requestId,
-        toolCallIdStyle: payload?.toolCallIdStyle ?? payload?.metadata?.toolCallIdStyle
+        toolCallIdStyle: payload?.toolCallIdStyle
     });
     const instructionReasoning = payload?.__rcc_reasoning_instructions;
     if (instructionReasoning !== undefined && instructionReasoning !== null) {
@@ -68,6 +69,12 @@ export function captureResponsesContext(payload, dto) {
     if (!captured.systemInstruction && typeof payload.instructions === 'string' && payload.instructions.trim().length) {
         captured.systemInstruction = payload.instructions;
     }
+    if (captured.metadata && isJsonObject(captured.metadata)) {
+        const cloned = jsonClone(captured.metadata);
+        delete cloned.toolCallIdStyle;
+        delete cloned.extraFields;
+        captured.metadata = cloned;
+    }
     return captured;
 }
 export function buildChatRequestFromResponses(payload, context) {
@@ -165,9 +172,6 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     const chat = unwrapData(payload);
     const out = {};
     const envelopeMetadata = ctx?.metadata && typeof ctx.metadata === 'object' ? ctx.metadata : undefined;
-    const requestMetadata = chat && typeof chat === 'object' && chat.metadata && typeof chat.metadata === 'object'
-        ? chat.metadata
-        : undefined;
     // 基本字段
     out.model = chat.model;
     let messages = Array.isArray(chat.messages) ? chat.messages : [];
@@ -197,7 +201,7 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     const metadataExtraFields = extractMetadataExtraFields(envelopeMetadata);
     const bridgeDecisions = resolveResponsesRequestBridgeDecisionsWithNative({
         context: ctx && typeof ctx === 'object' ? ctx : undefined,
-        requestMetadata,
+        routeToolCallIdStyle: extras?.routeToolCallIdStyle,
         envelopeMetadata,
         bridgeMetadata,
         extraBridgeHistory: extras?.bridgeHistory
@@ -270,29 +274,27 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
         metadataSystemInstruction: envelopeMetadata?.systemInstruction,
         combinedSystemInstruction,
         reasoningInstructionSegments: ctx?.__rcc_reasoning_instructions_segments,
-        contextParameters: ctx?.parameters,
+        contextParameters: undefined,
         chatParameters: chat.parameters,
-        metadataParameters: metadataExtraFields?.parameters,
-        contextStream: ctx?.stream,
-        metadataStream: metadataExtraFields?.stream,
+        metadataParameters: stripToolControlFieldsFromParameterObject(metadataExtraFields?.parameters),
+        contextStream: undefined,
+        metadataStream: undefined,
         chatStream: streamFromChat,
         chatParametersStream: streamFromParameters,
-        contextInclude: ctx?.include,
-        metadataInclude: metadataExtraFields?.include,
-        contextStore: ctx?.store,
-        metadataStore: metadataExtraFields?.store,
+        contextInclude: undefined,
+        metadataInclude: undefined,
+        contextStore: undefined,
+        metadataStore: undefined,
         stripHostFields,
-        contextToolChoice: ctx?.toolChoice,
-        metadataToolChoice: metadataExtraFields?.tool_choice,
-        contextParallelToolCalls: ctx?.parallelToolCalls,
-        metadataParallelToolCalls: metadataExtraFields?.parallel_tool_calls,
-        contextResponseFormat: ctx?.responseFormat,
-        metadataResponseFormat: metadataExtraFields?.response_format,
-        contextServiceTier: ctx?.serviceTier,
-        metadataServiceTier: metadataExtraFields?.service_tier,
-        contextTruncation: ctx?.truncation,
-        metadataTruncation: metadataExtraFields?.truncation,
-        contextMetadata: ctx?.metadata,
+        contextToolChoice: undefined,
+        contextParallelToolCalls: undefined,
+        contextResponseFormat: undefined,
+        metadataResponseFormat: undefined,
+        contextServiceTier: undefined,
+        metadataServiceTier: undefined,
+        contextTruncation: undefined,
+        metadataTruncation: undefined,
+        contextMetadata: stripToolControlFieldsFromContextMetadata(ctx?.metadata),
         metadataMetadata: metadataExtraFields?.metadata
     });
     Object.assign(out, preparedEnvelope.request);
@@ -326,6 +328,31 @@ function extractMetadataExtraFields(metadata) {
     }
     return undefined;
 }
+function stripToolControlFieldsFromContextMetadata(metadata) {
+    if (!metadata) {
+        return undefined;
+    }
+    const cloned = jsonClone(metadata);
+    const extras = cloned.extraFields;
+    if (!extras || !isPlainObject(extras)) {
+        return cloned;
+    }
+    delete extras.tool_choice;
+    delete extras.parallel_tool_calls;
+    if (Object.keys(extras).length === 0) {
+        delete cloned.extraFields;
+    }
+    return cloned;
+}
+function stripToolControlFieldsFromParameterObject(value) {
+    if (!value) {
+        return undefined;
+    }
+    const cloned = jsonClone(value);
+    delete cloned.tool_choice;
+    delete cloned.parallel_tool_calls;
+    return Object.keys(cloned).length ? cloned : undefined;
+}
 function isPlainObject(value) {
     return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }

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

@@ -16,6 +16,9 @@ function safeJson(v) {
         return '{}';
     }
 }
+function pickBoolean(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
 function stripOpenAIChatToolAliasFields(messages) {
     // No-op: preserve tool_call_id/call_id for downstream consumers and regression parity.
     void messages;
@@ -202,7 +205,8 @@ const ANTHROPIC_TOP_LEVEL_FIELDS = new Set([
     'metadata',
     'stream',
     'tool_choice',
-    'thinking'
+    'thinking',
+    'disable_parallel_tool_use'
 ]);
 const ANTHROPIC_STABLE_TOOL_SCHEMA_NAMES = new Set([
     'exec_command',
@@ -526,6 +530,10 @@ export function buildOpenAIChatFromAnthropic(payload, options) {
     }
     if ('tool_choice' in body)
         request.tool_choice = body.tool_choice;
+    const disableParallelToolUse = pickBoolean(body.disable_parallel_tool_use ?? body.disableParallelToolUse);
+    if (disableParallelToolUse !== undefined) {
+        request.parallel_tool_calls = !disableParallelToolUse;
+    }
     const normalizedTools = mapAnthropicToolsToChat(body.tools);
     if (normalizedTools !== undefined) {
         request.tools = normalizedTools;
@@ -1077,6 +1085,11 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
     if (normalizedToolChoice !== undefined) {
         out.tool_choice = normalizedToolChoice;
     }
+    const parallelToolCalls = pickBoolean(requestBody.parallel_tool_calls
+        ?? requestBody.parallelToolCalls);
+    if (parallelToolCalls !== undefined) {
+        out.disable_parallel_tool_use = !parallelToolCalls;
+    }
     if (requestBody.thinking !== undefined) {
         try {
             out.thinking = JSON.parse(JSON.stringify(requestBody.thinking));

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

@@ -1,5 +1,63 @@
 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 textMayContainReasoningMarkup(text) {
+    if (!text || (text.indexOf('<') === -1 && text.indexOf('`') === -1)) {
+        return false;
+    }
+    const lower = text.toLowerCase();
+    return (lower.includes('<think') ||
+        lower.includes('<reflection') ||
+        lower.includes('</think>') ||
+        lower.includes('</reflection>') ||
+        lower.includes('```think') ||
+        lower.includes('```reflection') ||
+        lower.includes('``` think') ||
+        lower.includes('``` reflection'));
+}
+function valueMayContainReasoningMarkup(value) {
+    if (typeof value === 'string') {
+        return textMayContainReasoningMarkup(value);
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            if (valueMayContainReasoningMarkup(entry)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    for (const entry of Object.values(value)) {
+        if (valueMayContainReasoningMarkup(entry)) {
+            return true;
+        }
+    }
+    return false;
+}
+function responsesPayloadMayNeedReasoningNormalization(payload, options) {
+    if (!payload || typeof payload !== 'object') {
+        return false;
+    }
+    const includeOutput = options.includeOutput ?? true;
+    const includeInput = options.includeInput ?? false;
+    const includeRequiredAction = options.includeRequiredAction ?? false;
+    const includeInstructions = options.includeInstructions ?? false;
+    if (includeOutput && valueMayContainReasoningMarkup(payload.output)) {
+        return true;
+    }
+    if (includeInput && valueMayContainReasoningMarkup(payload.input)) {
+        return true;
+    }
+    if (includeInstructions && valueMayContainReasoningMarkup(payload.instructions)) {
+        return true;
+    }
+    if (includeRequiredAction && valueMayContainReasoningMarkup(payload.required_action)) {
+        return true;
+    }
+    return false;
+}
 function assertReasoningNormalizerNativeAvailable() {
     if (typeof normalizeReasoningInChatPayloadWithNative !== 'function' ||
         typeof normalizeReasoningInResponsesPayloadWithNative !== 'function' ||
@@ -22,6 +80,9 @@ export function normalizeReasoningInResponsesPayload(payload, options = { includ
     assertReasoningNormalizerNativeAvailable();
     if (!payload)
         return;
+    if (!responsesPayloadMayNeedReasoningNormalization(payload, options)) {
+        return;
+    }
     const normalized = normalizeReasoningInResponsesPayloadWithNative(payload, options);
     if (normalized && typeof normalized === 'object') {
         Object.assign(payload, normalized);