@jsonstudio/llms 0.6.3551 → 0.6.3686

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

@@ -1,18 +1,108 @@
-import { analyzeChatProcessMedia, stripChatProcessHistoricalImages } from '../../../router/virtual-router/engine-selection/native-router-hotpath.js';
+import { analyzeChatProcessMedia, stripChatProcessHistoricalImages, } from "../../../router/virtual-router/engine-selection/native-router-hotpath.js";
 export function stripHistoricalImageAttachments(messages) {
     if (!Array.isArray(messages) || !messages.length) {
         return messages;
     }
-    const placeholderText = '[Image omitted]';
+    const placeholderText = "[Image omitted]";
     const stripped = stripChatProcessHistoricalImages(messages, placeholderText);
     if (stripped.changed !== true || !Array.isArray(stripped.messages)) {
         return 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;
     }
     return analyzeChatProcessMedia(messages).containsCurrentTurnImage === true;
 }
+export function repairIncompleteToolCalls(messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return messages;
+    }
+    const toolCallIdsWithResponse = new Set();
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg?.role === "tool" && typeof msg.tool_call_id === "string") {
+            toolCallIdsWithResponse.add(msg.tool_call_id);
+        }
+    }
+    const result = [];
+    let changed = false;
+    for (const msg of messages) {
+        if (msg?.role === "assistant" && Array.isArray(msg.tool_calls)) {
+            const completeToolCalls = [];
+            const missingToolCallIds = [];
+            for (const tc of msg.tool_calls) {
+                const tcId = typeof tc?.id === "string" ? tc.id : "";
+                if (tcId && toolCallIdsWithResponse.has(tcId)) {
+                    completeToolCalls.push(tc);
+                }
+                else if (tcId) {
+                    missingToolCallIds.push(tcId);
+                }
+            }
+            if (missingToolCallIds.length > 0) {
+                changed = true;
+                const repaired = {
+                    ...msg,
+                    tool_calls: completeToolCalls.length > 0 ? completeToolCalls : undefined,
+                };
+                if (!repaired.tool_calls) {
+                    delete repaired.tool_calls;
+                }
+                result.push(repaired);
+                for (const missingId of missingToolCallIds) {
+                    result.push({
+                        role: "tool",
+                        tool_call_id: missingId,
+                        content: '{"status":"tool_call_repaired_orphaned_tool_call"}',
+                    });
+                }
+            }
+            else {
+                result.push(msg);
+            }
+        }
+        else {
+            result.push(msg);
+        }
+    }
+    return changed ? result : messages;
+}

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

@@ -0,0 +1,7 @@
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { ProcessedRequest, StandardizedRequest } from '../types/standardized.js';
+export declare function estimateSessionBoundTokens(request: StandardizedRequest | ProcessedRequest, metadata: Record<string, unknown> | undefined): number | undefined;
+export declare function saveChatProcessSessionActualUsage(options: {
+    context: AdapterContext;
+    usage: Record<string, unknown> | undefined;
+}): void;

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

@@ -0,0 +1,147 @@
+import { loadRoutingInstructionStateSync, saveRoutingInstructionStateSync } from '../../../router/virtual-router/sticky-session-store.js';
+import { countRequestTokens } from '../../../router/virtual-router/token-counter.js';
+function createEmptyRoutingInstructionState() {
+    return {
+        allowedProviders: new Set(),
+        disabledProviders: new Set(),
+        disabledKeys: new Map(),
+        disabledModels: new Map()
+    };
+}
+function resolveSessionUsageScope(record) {
+    const sessionId = typeof record?.sessionId === 'string' ? record.sessionId.trim() : '';
+    if (sessionId) {
+        return `session:${sessionId}`;
+    }
+    const conversationId = typeof record?.conversationId === 'string' ? record.conversationId.trim() : '';
+    if (conversationId) {
+        return `conversation:${conversationId}`;
+    }
+    return undefined;
+}
+function loadState(scope) {
+    try {
+        return loadRoutingInstructionStateSync(scope);
+    }
+    catch {
+        return null;
+    }
+}
+function readRoundedToken(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return undefined;
+    }
+    const rounded = Math.round(value);
+    return rounded > 0 ? rounded : undefined;
+}
+function buildSnapshot(scope, state) {
+    if (!state) {
+        return null;
+    }
+    const totalTokens = readRoundedToken(state.chatProcessLastTotalTokens);
+    const inputTokens = readRoundedToken(state.chatProcessLastInputTokens);
+    const messageCount = readRoundedToken(state.chatProcessLastMessageCount);
+    const updatedAtMs = readRoundedToken(state.chatProcessLastUpdatedAt);
+    if (totalTokens === undefined && inputTokens === undefined) {
+        return null;
+    }
+    return {
+        scope,
+        ...(totalTokens !== undefined ? { totalTokens } : {}),
+        ...(inputTokens !== undefined ? { inputTokens } : {}),
+        ...(messageCount !== undefined ? { messageCount } : {}),
+        ...(updatedAtMs !== undefined ? { updatedAtMs } : {})
+    };
+}
+function normalizeUsage(usage) {
+    if (!usage || typeof usage !== 'object') {
+        return null;
+    }
+    const inputTokens = readRoundedToken(usage.input_tokens ??
+        usage.prompt_tokens ??
+        usage.inputTokens ??
+        usage.promptTokens ??
+        usage.request_tokens ??
+        usage.requestTokens);
+    const outputTokens = readRoundedToken(usage.output_tokens ??
+        usage.completion_tokens ??
+        usage.outputTokens ??
+        usage.completionTokens ??
+        usage.response_tokens ??
+        usage.responseTokens);
+    const totalTokens = readRoundedToken(usage.total_tokens ??
+        usage.totalTokens ??
+        ((inputTokens ?? 0) + (outputTokens ?? 0) > 0
+            ? (inputTokens ?? 0) + (outputTokens ?? 0)
+            : undefined));
+    if (totalTokens === undefined && inputTokens === undefined) {
+        return null;
+    }
+    return {
+        ...(inputTokens !== undefined ? { inputTokens } : {}),
+        ...(outputTokens !== undefined ? { outputTokens } : {}),
+        ...(totalTokens !== undefined ? { totalTokens } : {})
+    };
+}
+function estimateDeltaTokens(request, previousMessageCount) {
+    const messages = Array.isArray(request.messages) ? request.messages : [];
+    if (previousMessageCount < 0 || previousMessageCount > messages.length) {
+        return undefined;
+    }
+    const appendedMessages = messages.slice(previousMessageCount);
+    if (appendedMessages.length === 0) {
+        return 0;
+    }
+    return countRequestTokens({
+        model: request.model,
+        messages: appendedMessages,
+        parameters: {},
+        metadata: { originalEndpoint: request.metadata?.originalEndpoint ?? '/v1/chat/completions' }
+    });
+}
+export function estimateSessionBoundTokens(request, metadata) {
+    const scope = resolveSessionUsageScope(metadata);
+    if (!scope) {
+        return undefined;
+    }
+    const snapshot = buildSnapshot(scope, loadState(scope));
+    if (!snapshot) {
+        return undefined;
+    }
+    const previousTotal = snapshot.totalTokens ?? snapshot.inputTokens;
+    const previousMessageCount = snapshot.messageCount;
+    if (previousTotal === undefined || previousMessageCount === undefined) {
+        return undefined;
+    }
+    const deltaTokens = estimateDeltaTokens(request, previousMessageCount);
+    if (deltaTokens === undefined) {
+        return undefined;
+    }
+    return Math.max(1, Math.round(previousTotal + deltaTokens));
+}
+export function saveChatProcessSessionActualUsage(options) {
+    const scope = resolveSessionUsageScope(options.context);
+    if (!scope) {
+        return;
+    }
+    const normalizedUsage = normalizeUsage(options.usage);
+    if (!normalizedUsage) {
+        return;
+    }
+    const capturedChatRequest = options.context.capturedChatRequest;
+    const messageCount = Array.isArray(capturedChatRequest?.messages)
+        ? (capturedChatRequest.messages ?? []).length
+        : undefined;
+    const state = loadState(scope) ?? createEmptyRoutingInstructionState();
+    if (normalizedUsage.totalTokens !== undefined) {
+        state.chatProcessLastTotalTokens = normalizedUsage.totalTokens;
+    }
+    if (normalizedUsage.inputTokens !== undefined) {
+        state.chatProcessLastInputTokens = normalizedUsage.inputTokens;
+    }
+    if (typeof messageCount === 'number' && Number.isFinite(messageCount)) {
+        state.chatProcessLastMessageCount = Math.max(0, Math.round(messageCount));
+    }
+    state.chatProcessLastUpdatedAt = Date.now();
+    saveRoutingInstructionStateSync(scope, state);
+}

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

@@ -19,6 +19,7 @@ import { ProviderProtocolError } from '../../provider-protocol-error.js';
 import { readRuntimeMetadata } from '../../runtime-metadata.js';
 import { commitClockReservation, resolveClockConfig } from '../../../servertool/clock/task-store.js';
 import { detectProviderResponseShapeWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';
+import { saveChatProcessSessionActualUsage } from '../process/chat-process-session-usage.js';
 const PROVIDER_RESPONSE_REGISTRY = {
     'openai-chat': {
         createFormatAdapter: () => new ChatFormatAdapter(),
@@ -451,6 +452,18 @@ export async function convertProviderResponse(options) {
     });
     // Commit scheduled-task delivery only after a successful client payload/stream is prepared.
     await maybeCommitClockReservationFromContext(options.context);
+    try {
+        const usage = clientPayload && typeof clientPayload === 'object' && !Array.isArray(clientPayload)
+            ? clientPayload.usage
+            : undefined;
+        saveChatProcessSessionActualUsage({
+            context: options.context,
+            usage
+        });
+    }
+    catch {
+        // best-effort: usage persistence must not break response delivery
+    }
     if (outbound.stream) {
         const usage = clientPayload && typeof clientPayload === 'object' && !Array.isArray(clientPayload)
             ? clientPayload.usage

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.js

@@ -4,10 +4,12 @@ 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) ---
 import { resolveBridgePolicy, resolvePolicyActions } from '../bridge-policies.js';
+import { logHubStageTiming } from '../hub/pipeline/hub-stage-timing.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -37,18 +39,22 @@ function runNativeResponsesBridgePipeline(input) {
             : undefined
     };
 }
+function filterRedundantResponsesReasoningAction(actions) {
+    return actions?.filter((action) => {
+        const name = typeof action?.name === 'string' ? action.name.trim().toLowerCase() : '';
+        return name !== 'reasoning.extract';
+    });
+}
 // normalizeTools unified in ../args-mapping.ts
 // NOTE: 自修复提示已移除（统一标准：不做模糊兜底）。
 // --- Public bridge functions ---
 export function captureResponsesContext(payload, dto) {
-    const preservedInput = cloneBridgeEntries(payload.input);
+    const preservedInput = Array.isArray(payload.input)
+        ? payload.input
+        : undefined;
     ensureBridgeInstructions(payload);
-    const requestForCapture = {
-        ...payload,
-        ...(preservedInput ? { input: preservedInput } : {})
-    };
     const captured = captureReqInboundResponsesContextSnapshotWithNative({
-        rawRequest: requestForCapture,
+        rawRequest: payload,
         requestId: dto?.route?.requestId,
         toolCallIdStyle: payload?.toolCallIdStyle ?? payload?.metadata?.toolCallIdStyle
     });
@@ -68,26 +74,42 @@ 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.extraFields;
+        captured.metadata = cloned;
+    }
     return captured;
 }
 export function buildChatRequestFromResponses(payload, context) {
+    const requestId = typeof context.requestId === 'string' && context.requestId.trim().length
+        ? context.requestId
+        : 'unknown';
     // V3: 对 Responses 路径仅做“形状转换”，不做参数解析/修复。
     // 将顶层 { type,name,description,parameters,strict } 归一为 OpenAI Chat tools 形状：
     // { type:'function', function:{ name,description,parameters,strict? } }
     const toolsNormalized = Array.isArray(context.toolsNormalized) && context.toolsNormalized.length
-        ? cloneBridgeEntries(context.toolsNormalized)
+        ? context.toolsNormalized
         : mapReqInboundBridgeToolsToChatWithNative(payload.tools);
     // 不在 Responses 路径进行 MCP 工具注入；统一由 Chat 后半段治理注入
+    logHubStageTiming(requestId, 'req_inbound.responses.convert_input_to_messages', 'start');
+    const convertStart = Date.now();
     let messages = convertBridgeInputToChatMessages({
         input: context.input,
         tools: toolsNormalized,
         normalizeFunctionName: 'responses',
         toolResultFallbackText: 'Command succeeded (no output).'
     });
+    logHubStageTiming(requestId, 'req_inbound.responses.convert_input_to_messages', 'completed', {
+        elapsedMs: Date.now() - convertStart,
+        forceLog: true
+    });
     try {
         const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-responses', moduleType: 'openai-responses' });
-        const policyActions = resolvePolicyActions(bridgePolicy, 'request_inbound');
+        const policyActions = filterRedundantResponsesReasoningAction(resolvePolicyActions(bridgePolicy, 'request_inbound'));
         if (policyActions?.length) {
+            logHubStageTiming(requestId, 'req_inbound.responses.inbound_policy', 'start');
+            const policyStart = Date.now();
             const actionState = runNativeResponsesBridgePipeline({
                 stage: 'request_inbound',
                 actions: policyActions,
@@ -99,6 +121,10 @@ export function buildChatRequestFromResponses(payload, context) {
                 rawRequest: payload
             });
             messages = actionState.messages;
+            logHubStageTiming(requestId, 'req_inbound.responses.inbound_policy', 'completed', {
+                elapsedMs: Date.now() - policyStart,
+                forceLog: true
+            });
         }
     }
     catch {
@@ -174,7 +200,7 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     let bridgeMetadata;
     try {
         const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-responses', moduleType: 'openai-responses' });
-        const policyActions = resolvePolicyActions(bridgePolicy, 'request_outbound');
+        const policyActions = filterRedundantResponsesReasoningAction(resolvePolicyActions(bridgePolicy, 'request_outbound'));
         if (policyActions?.length) {
             const actionState = runNativeResponsesBridgePipeline({
                 stage: 'request_outbound',
@@ -270,29 +296,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);
@@ -300,22 +324,6 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     ensureBridgeInstructions(out);
     return { request: out, originalSystemMessages };
 }
-function cloneBridgeEntries(entries) {
-    if (!Array.isArray(entries)) {
-        return undefined;
-    }
-    return entries.map((entry) => {
-        if (!entry || typeof entry !== 'object') {
-            return entry;
-        }
-        try {
-            return JSON.parse(JSON.stringify(entry));
-        }
-        catch {
-            return entry;
-        }
-    });
-}
 function extractMetadataExtraFields(metadata) {
     if (!metadata) {
         return undefined;
@@ -326,6 +334,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/reasoning-normalizer.js

@@ -1,5 +1,40 @@
 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';
+const REASONING_TEXT_MARKERS = [
+    '<think',
+    '</think',
+    '<reflection',
+    '</reflection',
+    '```think',
+    '```reflection'
+];
+function stringHasReasoningMarker(value) {
+    const lower = value.toLowerCase();
+    return REASONING_TEXT_MARKERS.some((marker) => lower.includes(marker));
+}
+function valueMayContainReasoningMarkup(value) {
+    if (typeof value === 'string') {
+        return stringHasReasoningMarker(value);
+    }
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            if (valueMayContainReasoningMarkup(entry)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    const record = value;
+    for (const entry of Object.values(record)) {
+        if (valueMayContainReasoningMarkup(entry)) {
+            return true;
+        }
+    }
+    return false;
+}
 function assertReasoningNormalizerNativeAvailable() {
     if (typeof normalizeReasoningInChatPayloadWithNative !== 'function' ||
         typeof normalizeReasoningInResponsesPayloadWithNative !== 'function' ||
@@ -22,6 +57,13 @@ export function normalizeReasoningInResponsesPayload(payload, options = { includ
     assertReasoningNormalizerNativeAvailable();
     if (!payload)
         return;
+    const shouldNormalize = (options.includeInput === true && valueMayContainReasoningMarkup(payload.input)) ||
+        (options.includeOutput === true && valueMayContainReasoningMarkup(payload.output)) ||
+        (options.includeInstructions === true && valueMayContainReasoningMarkup(payload.instructions)) ||
+        (options.includeRequiredAction === true && valueMayContainReasoningMarkup(payload.required_action));
+    if (!shouldNormalize) {
+        return;
+    }
     const normalized = normalizeReasoningInResponsesPayloadWithNative(payload, options);
     if (normalized && typeof normalized === 'object') {
         Object.assign(payload, normalized);

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

@@ -94,9 +94,8 @@ export function enforceToolCallIdStyle(input, transformer) {
         if (type === 'function_call_output' || type === 'tool_result' || type === 'tool_message') {
             const normalizedCallId = transformer.normalizeCallId(entry.call_id ?? entry.tool_call_id ?? entry.id);
             entry.call_id = normalizedCallId;
-            if (entry.tool_call_id !== undefined) {
-                delete entry.tool_call_id;
-            }
+            // Keep tool_call_id for providers that expect it (e.g., Qwen)
+            entry.tool_call_id = normalizedCallId;
             entry.id = transformer.normalizeOutputId(normalizedCallId, entry.id);
         }
     }

package/dist/router/virtual-router/bootstrap/profile-builder.js

@@ -22,6 +22,7 @@ export function buildProviderProfiles(targetKeys, runtimeEntries) {
             providerType: runtime.providerType,
             endpoint: runtime.endpoint,
             auth: { ...runtime.auth },
+            ...(runtime.enabled !== undefined ? { enabled: runtime.enabled } : {}),
             outboundProfile: runtime.outboundProfile,
             compatibilityProfile: runtime.compatibilityProfile,
             runtimeKey,

package/dist/router/virtual-router/bootstrap/provider-normalization.d.ts

@@ -12,6 +12,7 @@ export interface NormalizedProvider {
     providerType: string;
     endpoint: string;
     headers?: Record<string, string>;
+    enabled?: boolean;
     outboundProfile: string;
     compatibilityProfile: string;
     processMode: 'chat' | 'passthrough';

package/dist/router/virtual-router/bootstrap/provider-normalization.js

@@ -11,6 +11,11 @@ import { normalizeModelStreaming, normalizeModelContextTokens, normalizeModelOut
  */
 export function normalizeProvider(providerId, raw) {
     const provider = asRecord(raw);
+    const enabled = typeof provider.enabled === 'boolean'
+        ? provider.enabled
+        : typeof provider.enabled === 'string'
+            ? provider.enabled.trim().toLowerCase() !== 'false'
+            : undefined;
     const providerType = detectProviderType(provider);
     const endpoint = typeof provider.endpoint === 'string' && provider.endpoint.trim()
         ? provider.endpoint.trim()
@@ -46,6 +51,7 @@ export function normalizeProvider(providerId, raw) {
         providerType,
         endpoint,
         headers,
+        ...(enabled !== undefined ? { enabled } : {}),
         outboundProfile: mapOutboundProfile(providerType),
         compatibilityProfile,
         processMode,