@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/conversion/shared/chat-envelope-validator.d.ts

@@ -0,0 +1,8 @@
+import type { ChatEnvelope } from '../hub/types/chat-envelope.js';
+export type ChatValidationStage = 'req_inbound' | 'req_outbound' | 'resp_inbound' | 'resp_outbound';
+export interface ChatEnvelopeValidationOptions {
+    stage: ChatValidationStage;
+    direction: 'request' | 'response';
+    source?: string;
+}
+export declare function validateChatEnvelope(chat: ChatEnvelope, options: ChatEnvelopeValidationOptions): void;

package/vendor/llmswitch-core/dist/conversion/shared/chat-envelope-validator.js

@@ -0,0 +1,4 @@
+import { validateChatEnvelopeWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
+export function validateChatEnvelope(chat, options) {
+    validateChatEnvelopeWithNative(chat, options);
+}

package/vendor/llmswitch-core/dist/conversion/shared/chat-output-normalizer.d.ts

@@ -0,0 +1,4 @@
+export declare function normalizeChatMessageContent(content: unknown): {
+    contentText?: string;
+    reasoningText?: string;
+};

package/vendor/llmswitch-core/dist/conversion/shared/chat-output-normalizer.js

@@ -0,0 +1,10 @@
+import { normalizeChatMessageContentWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+function assertChatOutputNormalizerNativeAvailable() {
+    if (typeof normalizeChatMessageContentWithNative !== 'function') {
+        throw new Error('[chat-output-normalizer] native bindings unavailable');
+    }
+}
+export function normalizeChatMessageContent(content) {
+    assertChatOutputNormalizerNativeAvailable();
+    return normalizeChatMessageContentWithNative(content);
+}

package/vendor/llmswitch-core/dist/conversion/shared/chat-request-filters.d.ts

@@ -0,0 +1,8 @@
+import type { ConversionContext, ConversionProfile } from '../types.js';
+/**
+ * Native-primary Chat request filters.
+ *
+ * Historical TS FilterEngine implementation archived at:
+ * - src/conversion/shared/archive/chat-request-filters.ts
+ */
+export declare function runStandardChatRequestFilters(chatRequest: any, profile: ConversionProfile, context: ConversionContext): Promise<any>;

package/vendor/llmswitch-core/dist/conversion/shared/chat-request-filters.js

@@ -0,0 +1,63 @@
+import { normalizeChatRequest } from './openai-message-normalize.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.
+ *
+ * Historical TS FilterEngine implementation archived at:
+ * - src/conversion/shared/archive/chat-request-filters.ts
+ */
+export async function runStandardChatRequestFilters(chatRequest, profile, context) {
+    const existingMetadata = context.metadata ?? {};
+    if (!context.metadata) {
+        context.metadata = existingMetadata;
+    }
+    const inboundStreamFromContext = typeof existingMetadata.inboundStream === 'boolean' ? existingMetadata.inboundStream : undefined;
+    const inboundStreamDetected = chatRequest && typeof chatRequest === 'object' && chatRequest.stream === true ? true : undefined;
+    const normalizedInboundStream = inboundStreamFromContext ?? inboundStreamDetected;
+    if (typeof normalizedInboundStream === 'boolean') {
+        existingMetadata.inboundStream = normalizedInboundStream;
+    }
+    const requestId = context.requestId ?? `req_${Date.now()}`;
+    const endpoint = context.entryEndpoint || context.endpoint || '/v1/chat/completions';
+    const snapshot = createSnapshotWriter({
+        requestId,
+        endpoint,
+        folderHint: 'openai-chat'
+    });
+    const snapshotStage = (stage, payload) => {
+        if (!snapshot)
+            return;
+        snapshot(stage, payload);
+    };
+    snapshotStage('req_process_filters_input', chatRequest);
+    const incomingProtocol = (profile.incomingProtocol || '').toLowerCase();
+    const entryEndpointLower = endpoint.toLowerCase();
+    const originalToolCount = chatRequest && typeof chatRequest === 'object' && Array.isArray(chatRequest.tools)
+        ? chatRequest.tools.length
+        : 0;
+    const isAnthropicProfile = incomingProtocol === 'anthropic-messages' ||
+        entryEndpointLower.includes('/v1/messages');
+    const skipAutoToolInjection = isAnthropicProfile && originalToolCount === 0;
+    const nativeGovernedPayload = buildGovernedFilterPayloadWithNativeFallback(chatRequest);
+    if (skipAutoToolInjection && nativeGovernedPayload && typeof nativeGovernedPayload === 'object') {
+        if (!Array.isArray(nativeGovernedPayload.tools)) {
+            nativeGovernedPayload.tools = [];
+        }
+        nativeGovernedPayload.__rcc_disable_mcp_tools = true;
+    }
+    snapshotStage('req_process_filters_native_payload', nativeGovernedPayload);
+    let normalized = normalizeChatRequest(nativeGovernedPayload);
+    snapshotStage('req_process_filters_normalized', normalized);
+    if (skipAutoToolInjection && normalized && typeof normalized === 'object') {
+        if (!Array.isArray(normalized.tools)) {
+            normalized.tools = [];
+        }
+        normalized.__rcc_disable_mcp_tools = true;
+    }
+    const preserveStreamField = profile.incomingProtocol === 'openai-chat' && profile.outgoingProtocol === 'openai-chat';
+    const pruned = pruneChatRequestPayloadWithNative(normalized, preserveStreamField);
+    snapshotStage('req_process_filters_output', pruned);
+    return pruned;
+}

package/vendor/llmswitch-core/dist/conversion/shared/gemini-tool-utils.d.ts

@@ -0,0 +1,7 @@
+import type { BridgeToolDefinition } from '../types/bridge-message-types.js';
+import type { MissingField } from '../hub/types/chat-envelope.js';
+import type { JsonValue, JsonObject } from '../hub/types/json.js';
+export declare function prepareGeminiToolsForBridge(rawTools: JsonValue | undefined, missing?: MissingField[]): BridgeToolDefinition[] | undefined;
+export declare function buildGeminiToolsFromBridge(defs: BridgeToolDefinition[] | undefined, options?: {
+    mode?: 'antigravity' | 'default';
+}): JsonObject[] | undefined;

package/vendor/llmswitch-core/dist/conversion/shared/gemini-tool-utils.js

@@ -0,0 +1,20 @@
+import { buildGeminiToolsFromBridgeWithNative, prepareGeminiToolsForBridgeWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function prepareGeminiToolsForBridge(rawTools, missing) {
+    if (!rawTools) {
+        return undefined;
+    }
+    const result = prepareGeminiToolsForBridgeWithNative(rawTools, Array.isArray(missing) ? missing : []);
+    if (Array.isArray(missing)) {
+        missing.splice(0, missing.length, ...result.missing);
+    }
+    const defs = result.defs;
+    return defs && defs.length ? defs : undefined;
+}
+export function buildGeminiToolsFromBridge(defs, options) {
+    if (!defs || !defs.length) {
+        return undefined;
+    }
+    const mode = options?.mode === 'antigravity' ? 'antigravity' : 'default';
+    const out = buildGeminiToolsFromBridgeWithNative(defs, mode);
+    return out && out.length ? out : undefined;
+}

package/vendor/llmswitch-core/dist/conversion/shared/openai-finalizer.d.ts

@@ -0,0 +1,8 @@
+export type ChatReasoningMode = 'keep' | 'drop' | 'append_to_content';
+export interface FinalizeOptions {
+    requestId?: string;
+    endpoint?: string;
+    stream?: boolean;
+    reasoningMode?: ChatReasoningMode;
+}
+export declare function finalizeOpenAIChatResponse(chatLike: unknown, opts?: FinalizeOptions): Promise<unknown>;

package/vendor/llmswitch-core/dist/conversion/shared/openai-finalizer.js

@@ -0,0 +1,22 @@
+// OpenAI Chat finalizer: enforce canonical shapes without the legacy hook system.
+// - Ensures tool_calls use stringified JSON arguments and sets finish_reason='tool_calls' when applicable
+// - Normalizes potential tool messages (role:'tool') content to strict strings (JSON-stringify for objects)
+import { finalizeRespProcessChatResponseWithNative } from '../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
+function asObject(v) {
+    return v && typeof v === 'object' && !Array.isArray(v) ? v : null;
+}
+// Canonicalization handled by native finalizeChatResponseJson.
+export async function finalizeOpenAIChatResponse(chatLike, opts) {
+    const obj = asObject(chatLike);
+    if (!obj)
+        return chatLike;
+    const finalized = await finalizeRespProcessChatResponseWithNative({
+        payload: obj,
+        stream: opts?.stream === true,
+        reasoningMode: opts?.reasoningMode,
+        endpoint: opts?.endpoint,
+        requestId: opts?.requestId
+    });
+    return finalized;
+}
+// All canonicalization + reasoning policy handled by native finalizeChatResponseJson.

package/vendor/llmswitch-core/dist/conversion/shared/openai-message-normalize.d.ts

@@ -0,0 +1 @@
+export declare function normalizeChatRequest(request: any): any;

package/vendor/llmswitch-core/dist/conversion/shared/openai-message-normalize.js

@@ -0,0 +1,151 @@
+import { injectMcpToolsForChat } from '../mcp-injection.js';
+import { normalizeOpenaiChatMessagesWithNative, normalizeOpenaiMessageWithNative, normalizeOpenaiToolCallWithNative, normalizeOpenaiToolWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { enforceChatBudgetWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+// Message normalization utilities for OpenAI chat payloads (renamed to avoid confusion
+// with the deprecated "openai-normalizer" module entry). This file contains the
+// previously-implemented logic from openai-normalize.ts.
+// Legacy tooling stage removed for Chat; tool canonicalization lives in codecs
+export function normalizeChatRequest(request) {
+    if (!request || typeof request !== 'object')
+        return request;
+    let normalized = { ...request };
+    if (Array.isArray(normalized.messages)) {
+        normalized.messages = normalized.messages.map((msg) => normalizeMessage(msg));
+    }
+    if (Array.isArray(normalized.tools)) {
+        normalized.tools = normalized.tools.map((tool) => normalizeTool(tool));
+    }
+    // Assistant text limit handling has been moved into native budget enforcement.
+    // MCP 注入（两步法）统一走共享实现，避免路径分叉
+    const disableMcpTools = Boolean(normalized.__rcc_disable_mcp_tools);
+    if (!disableMcpTools) {
+        try {
+            const enableMcp = String(process?.env?.ROUTECODEX_MCP_ENABLE ?? '1') !== '0';
+            if (enableMcp) {
+                const known = new Set();
+                const fromEnv = String(process?.env?.RCC_MCP_SERVERS || '').trim();
+                if (fromEnv) {
+                    for (const s of fromEnv.split(',').map((x) => x.trim()).filter(Boolean))
+                        known.add(s);
+                }
+                const addServer = (v) => {
+                    if (typeof v === 'string') {
+                        const s = v.trim();
+                        if (s)
+                            known.add(s);
+                    }
+                };
+                const extractFromOutput = (output) => {
+                    try {
+                        if (Array.isArray(output)) {
+                            for (const item of output) {
+                                if (typeof item === 'string')
+                                    addServer(item);
+                                else if (item && typeof item === 'object' && !Array.isArray(item))
+                                    addServer(item.server);
+                            }
+                            return;
+                        }
+                        if (!output || typeof output !== 'object' || Array.isArray(output))
+                            return;
+                        const o = output;
+                        if (Array.isArray(o.servers))
+                            for (const s of o.servers)
+                                addServer(s);
+                        if (Array.isArray(o.resources))
+                            for (const r of o.resources)
+                                addServer(r?.server ?? r?.source?.server);
+                        if (Array.isArray(o.resourceTemplates))
+                            for (const t of o.resourceTemplates)
+                                addServer(t?.server ?? t?.source?.server);
+                    }
+                    catch {
+                        // best-effort
+                    }
+                };
+                // IMPORTANT: do NOT treat assistant tool_calls as authoritative for MCP server labels
+                // (the model may guess "shell"/"exec_command"/etc). Only trust tool results.
+                try {
+                    const msgs = Array.isArray(normalized.messages) ? normalized.messages : [];
+                    for (const m of msgs) {
+                        if (!m || typeof m !== 'object')
+                            continue;
+                        if (String(m.role || '').toLowerCase() !== 'tool')
+                            continue;
+                        const content = m.content;
+                        if (typeof content !== 'string' || content.trim().length === 0)
+                            continue;
+                        try {
+                            const parsed = JSON.parse(content);
+                            if (parsed && typeof parsed === 'object' && parsed.version === 'rcc.tool.v1' && parsed.tool?.name) {
+                                const toolName = String(parsed.tool.name).toLowerCase();
+                                if (toolName === 'list_mcp_resources') {
+                                    extractFromOutput(parsed.result?.output);
+                                }
+                            }
+                            else {
+                                extractFromOutput(parsed?.output ?? parsed);
+                            }
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                }
+                catch { /* ignore */ }
+                const discovered = Array.from(known);
+                const currentTools = Array.isArray(normalized.tools) ? normalized.tools : [];
+                normalized.tools = injectMcpToolsForChat(currentTools, discovered);
+            }
+        }
+        catch { /* ignore MCP injection */ }
+    }
+    // 工具消息文本化 + 最后一轮 call 结果一致化 + 空 assistant 回合清理（native）
+    try {
+        const msgs = Array.isArray(normalized.messages) ? normalized.messages : [];
+        if (msgs.length) {
+            normalized.messages = normalizeOpenaiChatMessagesWithNative(msgs);
+        }
+    }
+    catch { /* ignore message normalization */ }
+    // 注意：不合并/删除多条 system（与 统一标准，避免高风险修改）。
+    // 基于“载荷预算”（配置驱动）进行裁剪，统一走 native。
+    try {
+        const msgs = Array.isArray(normalized.messages) ? normalized.messages : [];
+        if (msgs.length) {
+            const modelId = String(normalized?.model || '').trim();
+            const budget = resolveBudgetForModelSync(modelId);
+            const allowed = Math.max(32 * 1024, Math.floor(budget.allowedBytes));
+            const sysLimit = (() => {
+                const raw = process?.env?.RCC_SYSTEM_TEXT_LIMIT;
+                const n = Number(raw);
+                return Number.isFinite(n) && n >= 0 ? n : 8192;
+            })();
+            normalized = enforceChatBudgetWithNative(normalized, allowed, sysLimit);
+        }
+    }
+    catch { /* ignore budget enforcement */ }
+    // Do not invoke legacy tooling stage here; codecs perform canonicalization
+    return normalized;
+}
+function normalizeChatResponse(res) {
+    // Deprecated: pass-through. Tool canonicalization and reasoning handling are done in codecs/compat layers.
+    return res;
+    if (false) {
+        // legacy kept for reference
+    }
+}
+function normalizeMessage(message) {
+    const disableShellCoerce = String(process?.env?.RCC_DISABLE_SHELL_COERCE ?? process?.env?.ROUTECODEX_DISABLE_SHELL_COERCE ?? '').toLowerCase();
+    const isDisabled = disableShellCoerce === '1' || disableShellCoerce === 'true';
+    return normalizeOpenaiMessageWithNative(message, isDisabled);
+}
+function normalizeTool(tool) {
+    return normalizeOpenaiToolWithNative(tool);
+}
+function normalizeToolCall(tc) {
+    const disableShellCoerce = String(process?.env?.RCC_DISABLE_SHELL_COERCE ?? process?.env?.ROUTECODEX_DISABLE_SHELL_COERCE ?? '').toLowerCase();
+    const isDisabled = disableShellCoerce === '1' || disableShellCoerce === 'true';
+    return normalizeOpenaiToolCallWithNative(tc, isDisabled);
+}
+import { resolveBudgetForModelSync } from '../payload-budget.js';

package/vendor/llmswitch-core/dist/conversion/shared/output-content-normalizer.d.ts

@@ -0,0 +1,12 @@
+type UnknownRecord = Record<string, unknown>;
+export interface OutputContentExtractionResult {
+    textParts: string[];
+    reasoningParts: string[];
+}
+export declare function extractOutputSegments(source: UnknownRecord | undefined, itemsKey?: string): OutputContentExtractionResult;
+export declare function normalizeContentPart(part: unknown, reasoningCollector: string[]): UnknownRecord | null;
+export declare function normalizeMessageContentParts(parts: unknown, reasoningCollector?: string[]): {
+    normalizedParts: UnknownRecord[];
+    reasoningChunks: string[];
+};
+export {};

package/vendor/llmswitch-core/dist/conversion/shared/output-content-normalizer.js

@@ -0,0 +1,26 @@
+import { extractOutputSegmentsWithNative, normalizeContentPartWithNative, normalizeMessageContentPartsWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+function assertOutputContentNormalizerNativeAvailable() {
+    if (typeof extractOutputSegmentsWithNative !== 'function' ||
+        typeof normalizeContentPartWithNative !== 'function' ||
+        typeof normalizeMessageContentPartsWithNative !== 'function') {
+        throw new Error('[output-content-normalizer] native bindings unavailable');
+    }
+}
+export function extractOutputSegments(source, itemsKey = 'output') {
+    assertOutputContentNormalizerNativeAvailable();
+    return extractOutputSegmentsWithNative(source, itemsKey);
+}
+export function normalizeContentPart(part, reasoningCollector) {
+    assertOutputContentNormalizerNativeAvailable();
+    const normalized = normalizeContentPartWithNative(part, reasoningCollector);
+    reasoningCollector.splice(0, reasoningCollector.length, ...normalized.reasoningCollector);
+    return normalized.normalized;
+}
+export function normalizeMessageContentParts(parts, reasoningCollector) {
+    assertOutputContentNormalizerNativeAvailable();
+    const normalized = normalizeMessageContentPartsWithNative(parts, reasoningCollector ?? []);
+    if (reasoningCollector) {
+        reasoningCollector.splice(0, reasoningCollector.length, ...normalized.reasoningChunks);
+    }
+    return normalized;
+}

package/vendor/llmswitch-core/dist/conversion/shared/reasoning-mapping.d.ts

@@ -0,0 +1,5 @@
+export interface ReasoningItem {
+    type: 'reasoning';
+    content: string;
+}
+export declare function mapReasoningContentToResponsesOutput(reasoningContent: any): ReasoningItem[];

package/vendor/llmswitch-core/dist/conversion/shared/reasoning-mapping.js

@@ -0,0 +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/vendor/llmswitch-core/dist/conversion/shared/reasoning-normalizer.d.ts

@@ -0,0 +1,25 @@
+import type { JsonObject, JsonValue } from '../hub/types/json.js';
+export declare const RESPONSES_INSTRUCTIONS_REASONING_FIELD = "__rcc_reasoning_instructions";
+interface ResponsesReasoningNormalizeOptions {
+    includeInput?: boolean;
+    includeOutput?: boolean;
+    includeRequiredAction?: boolean;
+    includeInstructions?: boolean;
+}
+export declare function valueMayContainReasoningMarkup(value: unknown): boolean;
+export declare function normalizeReasoningInChatPayload(payload: {
+    messages?: JsonValue[];
+    choices?: JsonValue[];
+} | null | undefined): void;
+export declare function normalizeReasoningInResponsesPayload(payload: {
+    output?: JsonValue[];
+    id?: string;
+    input?: JsonValue[];
+    instructions?: unknown;
+    required_action?: JsonObject;
+} | 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 declare function stripReasoningTransportNoise(text: string): string;
+export {};

package/vendor/llmswitch-core/dist/conversion/shared/reasoning-normalizer.js

@@ -0,0 +1,114 @@
+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'
+];
+const REASONING_TRANSPORT_NOISE_LINE_RE = /^\[(?:Time\/Date)\]:.*$/gim;
+const REASONING_WRAPPER_OPEN_RE = /^\s*\[(?:思考|thinking)\]\s*/i;
+const REASONING_WRAPPER_CLOSE_RE = /\s*\[\/(?:思考|thinking)\]\s*$/i;
+function stringHasReasoningMarker(value) {
+    const lower = value.toLowerCase();
+    return REASONING_TEXT_MARKERS.some((marker) => lower.includes(marker));
+}
+export 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' ||
+        typeof normalizeReasoningInGeminiPayloadWithNative !== 'function' ||
+        typeof normalizeReasoningInAnthropicPayloadWithNative !== 'function' ||
+        typeof normalizeReasoningInOpenAIPayloadWithNative !== 'function') {
+        throw new Error('[reasoning-normalizer] native bindings unavailable');
+    }
+}
+export function normalizeReasoningInChatPayload(payload) {
+    assertReasoningNormalizerNativeAvailable();
+    if (!payload)
+        return;
+    const shouldNormalize = valueMayContainReasoningMarkup(payload.messages) ||
+        valueMayContainReasoningMarkup(payload.choices);
+    if (!shouldNormalize) {
+        return;
+    }
+    const normalized = normalizeReasoningInChatPayloadWithNative(payload);
+    if (normalized && typeof normalized === 'object') {
+        Object.assign(payload, normalized);
+    }
+}
+export function normalizeReasoningInResponsesPayload(payload, options = { includeOutput: true }) {
+    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);
+    }
+}
+export function normalizeReasoningInGeminiPayload(payload) {
+    assertReasoningNormalizerNativeAvailable();
+    if (!payload)
+        return;
+    const normalized = normalizeReasoningInGeminiPayloadWithNative(payload);
+    if (normalized && typeof normalized === 'object') {
+        Object.assign(payload, normalized);
+    }
+}
+export function normalizeReasoningInAnthropicPayload(payload) {
+    assertReasoningNormalizerNativeAvailable();
+    if (!payload)
+        return;
+    const normalized = normalizeReasoningInAnthropicPayloadWithNative(payload);
+    if (normalized && typeof normalized === 'object') {
+        Object.assign(payload, normalized);
+    }
+}
+export function normalizeReasoningInOpenAIPayload(payload) {
+    assertReasoningNormalizerNativeAvailable();
+    if (!payload)
+        return;
+    const normalized = normalizeReasoningInOpenAIPayloadWithNative(payload);
+    if (normalized && typeof normalized === 'object') {
+        Object.assign(payload, normalized);
+    }
+}
+export function stripReasoningTransportNoise(text) {
+    return String(text ?? '')
+        .replace(REASONING_TRANSPORT_NOISE_LINE_RE, '')
+        .replace(REASONING_WRAPPER_OPEN_RE, '')
+        .replace(REASONING_WRAPPER_CLOSE_RE, '')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}

package/vendor/llmswitch-core/dist/conversion/shared/reasoning-tool-normalizer.d.ts

@@ -0,0 +1,12 @@
+type UnknownRecord = Record<string, unknown>;
+export interface ReasoningNormalizationResult {
+    toolCallsAdded: number;
+    cleanedReasoning?: string;
+}
+export declare function normalizeMessageReasoningTools(message: UnknownRecord | null | undefined, options?: {
+    idPrefix?: string;
+}): ReasoningNormalizationResult;
+export declare function normalizeChatResponseReasoningTools(response: UnknownRecord | null | undefined, options?: {
+    idPrefixBase?: string;
+}): void;
+export {};

package/vendor/llmswitch-core/dist/conversion/shared/reasoning-tool-normalizer.js

@@ -0,0 +1,22 @@
+import { normalizeChatResponseReasoningToolsWithNative, normalizeMessageReasoningToolsWithNative } from '../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
+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) {
+    assertReasoningToolNormalizerNativeAvailable();
+    const normalized = normalizeMessageReasoningToolsWithNative(message, typeof options?.idPrefix === 'string' ? options.idPrefix : undefined);
+    return {
+        toolCallsAdded: normalized.toolCallsAdded,
+        ...(typeof normalized.cleanedReasoning === 'string'
+            ? { cleanedReasoning: normalized.cleanedReasoning }
+            : {})
+    };
+}
+export function normalizeChatResponseReasoningTools(response, options) {
+    assertReasoningToolNormalizerNativeAvailable();
+    normalizeChatResponseReasoningToolsWithNative(response, typeof options?.idPrefixBase === 'string' ? options.idPrefixBase : undefined);
+}

package/vendor/llmswitch-core/dist/conversion/shared/reasoning-tool-parser.d.ts

@@ -0,0 +1,10 @@
+type ToolCallRecord = Record<string, unknown>;
+interface ExtractionOptions {
+    idPrefix?: string;
+}
+interface ExtractionResult {
+    cleanedText: string;
+    toolCalls: ToolCallRecord[];
+}
+export declare function extractToolCallsFromReasoningText(text: string, options?: ExtractionOptions): ExtractionResult;
+export {};

package/vendor/llmswitch-core/dist/conversion/shared/reasoning-tool-parser.js

@@ -0,0 +1,11 @@
+import { extractToolCallsFromReasoningTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+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';
+    return extractToolCallsFromReasoningTextWithNative(String(text ?? ''), idPrefix);
+}

package/vendor/llmswitch-core/dist/conversion/shared/reasoning-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function extractReasoningSegments(source: string, reasoningCollector?: string[]): string;
+export declare function sanitizeReasoningTaggedText(value: string): string;

package/vendor/llmswitch-core/dist/conversion/shared/reasoning-utils.js

@@ -0,0 +1,19 @@
+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');
+    }
+}
+export function extractReasoningSegments(source, reasoningCollector) {
+    assertReasoningUtilsNativeAvailable();
+    const output = extractReasoningSegmentsWithNative(source ?? '');
+    if (reasoningCollector) {
+        reasoningCollector.push(...output.segments);
+    }
+    return output.text;
+}
+export function sanitizeReasoningTaggedText(value) {
+    assertReasoningUtilsNativeAvailable();
+    return sanitizeReasoningTaggedTextWithNative(value);
+}

package/vendor/llmswitch-core/dist/conversion/shared/responses-conversation-store.d.ts

@@ -0,0 +1,35 @@
+type AnyRecord = Record<string, unknown>;
+interface CaptureContextArgs {
+    requestId?: string;
+    payload: AnyRecord;
+    context: AnyRecord;
+}
+interface RecordResponseArgs {
+    requestId?: string;
+    response: AnyRecord;
+}
+interface ResumeOptions {
+    requestId?: string;
+}
+interface ResumeResult {
+    payload: AnyRecord;
+    meta: AnyRecord;
+}
+declare class ResponsesConversationStore {
+    private requestMap;
+    private responseIndex;
+    rebindRequestId(oldId: string | undefined, newId: string | undefined): void;
+    captureRequestContext(args: CaptureContextArgs): void;
+    recordResponse(args: RecordResponseArgs): void;
+    resumeConversation(responseId: string, submitPayload: AnyRecord, options?: ResumeOptions): ResumeResult;
+    clearRequest(requestId?: string): void;
+    private cleanupEntry;
+    private prune;
+}
+declare const store: ResponsesConversationStore;
+export declare function captureResponsesRequestContext(args: CaptureContextArgs): void;
+export declare function recordResponsesResponse(args: RecordResponseArgs): void;
+export declare function resumeResponsesConversation(responseId: string, submitPayload: AnyRecord, options?: ResumeOptions): ResumeResult;
+export declare function clearResponsesConversationByRequestId(requestId?: string): void;
+export declare function rebindResponsesConversationRequestId(oldId?: string, newId?: string): void;
+export { store as responsesConversationStore };