@jsonstudio/llms 0.4.6 → 0.6.2

package/dist/conversion/shared/chat-envelope-validator.js

@@ -0,0 +1,128 @@
+import { isJsonObject } from '../hub/types/json.js';
+const ALLOWED_ROLES = new Set(['system', 'user', 'assistant', 'tool']);
+const RESERVED_EXACT_KEYS = new Set(['stages', 'stageExpectations']);
+const RESERVED_PREFIXES = ['__rcc_'];
+export function validateChatEnvelope(chat, options) {
+    if (!chat || typeof chat !== 'object') {
+        throw buildError('chatEnvelope_missing', 'Chat envelope must be an object', options);
+    }
+    assertNoReservedKeys(chat, 'chatEnvelope', options);
+    if (!Array.isArray(chat.messages) || chat.messages.length === 0) {
+        throw buildError('messages_missing', 'Chat envelope must include at least one message', options);
+    }
+    chat.messages.forEach((message, index) => {
+        if (!message || typeof message !== 'object') {
+            throw buildError('message_shape', `messages[${index}] must be an object`, options);
+        }
+        assertNoReservedKeys(message, `messages[${index}]`, options);
+        if (typeof message.role !== 'string' || !ALLOWED_ROLES.has(message.role)) {
+            throw buildError('message_role', `messages[${index}].role must be one of ${Array.from(ALLOWED_ROLES).join(', ')}`, options);
+        }
+        validateToolCalls(message, index, options);
+    });
+    if (!isJsonObject(chat.parameters) || typeof chat.parameters.model !== 'string' || !chat.parameters.model.trim()) {
+        throw buildError('parameters_model', 'Chat envelope parameters.model must be a string', options);
+    }
+    assertNoReservedKeys(chat.parameters, 'parameters', options);
+    validateTools(chat.tools, options);
+    validateToolOutputs(chat.toolOutputs, options);
+    validateMetadata(chat.metadata, options);
+}
+function validateToolCalls(message, messageIndex, options) {
+    if (!Array.isArray(message.tool_calls)) {
+        return;
+    }
+    message.tool_calls.forEach((entry, callIndex) => {
+        if (!entry || typeof entry !== 'object') {
+            throw buildError('tool_call_shape', `messages[${messageIndex}].tool_calls[${callIndex}] must be an object`, options);
+        }
+        if (entry.type !== 'function') {
+            throw buildError('tool_call_type', `messages[${messageIndex}].tool_calls[${callIndex}].type must equal "function"`, options);
+        }
+        const fnNode = entry.function;
+        if (!fnNode || typeof fnNode !== 'object') {
+            throw buildError('tool_call_function', `messages[${messageIndex}].tool_calls[${callIndex}].function must be an object`, options);
+        }
+        const fnRecord = fnNode;
+        if (typeof fnRecord.name !== 'string' || !fnRecord.name.trim()) {
+            throw buildError('tool_call_name', `messages[${messageIndex}].tool_calls[${callIndex}].function.name must be a string`, options);
+        }
+        if (typeof fnRecord.arguments !== 'string') {
+            throw buildError('tool_call_arguments', `messages[${messageIndex}].tool_calls[${callIndex}].function.arguments must be a JSON string`, options);
+        }
+    });
+}
+function validateTools(tools, options) {
+    if (tools === undefined) {
+        return;
+    }
+    if (!Array.isArray(tools)) {
+        throw buildError('tools_shape', 'Chat envelope tools must be an array when provided', options);
+    }
+    tools.forEach((tool, index) => {
+        if (!tool || typeof tool !== 'object') {
+            throw buildError('tools_shape', `tools[${index}] must be an object`, options);
+        }
+        if (tool.type !== 'function') {
+            throw buildError('tools_type', `tools[${index}].type must equal "function"`, options);
+        }
+        const fnNode = tool.function;
+        if (!fnNode || typeof fnNode !== 'object' || typeof fnNode.name !== 'string' || !fnNode.name.trim()) {
+            throw buildError('tools_function', `tools[${index}].function.name must be a string`, options);
+        }
+    });
+}
+function validateToolOutputs(outputs, options) {
+    if (outputs === undefined) {
+        return;
+    }
+    if (!Array.isArray(outputs)) {
+        throw buildError('tool_outputs_shape', 'toolOutputs must be an array when provided', options);
+    }
+    outputs.forEach((entry, index) => {
+        if (!entry || typeof entry !== 'object') {
+            throw buildError('tool_outputs_shape', `toolOutputs[${index}] must be an object`, options);
+        }
+        if (typeof entry.tool_call_id !== 'string' || !entry.tool_call_id.trim()) {
+            throw buildError('tool_outputs_id', `toolOutputs[${index}].tool_call_id must be a string`, options);
+        }
+        if (typeof entry.content !== 'string') {
+            throw buildError('tool_outputs_content', `toolOutputs[${index}].content must be a string`, options);
+        }
+    });
+}
+function validateMetadata(metadata, options) {
+    if (!isJsonObject(metadata)) {
+        throw buildError('metadata_shape', 'Chat envelope metadata must be an object', options);
+    }
+    assertNoReservedKeys(metadata, 'metadata', options);
+    if (!isJsonObject(metadata.context)) {
+        throw buildError('metadata_context', 'metadata.context must be an object', options);
+    }
+    if (metadata.extraFields !== undefined) {
+        if (!isJsonObject(metadata.extraFields)) {
+            throw buildError('metadata_extra_fields', 'metadata.extraFields must be an object when provided', options);
+        }
+        assertNoReservedKeys(metadata.extraFields, 'metadata.extraFields', options, true);
+    }
+    if (metadata.providerMetadata !== undefined && !isJsonObject(metadata.providerMetadata)) {
+        throw buildError('metadata_provider', 'metadata.providerMetadata must be an object when provided', options);
+    }
+}
+function assertNoReservedKeys(target, path, options, allowStageKeys = false) {
+    if (!target || typeof target !== 'object') {
+        return;
+    }
+    for (const key of Object.keys(target)) {
+        if (!allowStageKeys && RESERVED_EXACT_KEYS.has(key)) {
+            throw buildError('reserved_key', `${path} contains reserved field "${key}"`, options);
+        }
+        if (RESERVED_PREFIXES.some((prefix) => key.startsWith(prefix))) {
+            throw buildError('reserved_key', `${path} contains reserved field "${key}"`, options);
+        }
+    }
+}
+function buildError(code, detail, options) {
+    const source = options.source ? ` source=${options.source}` : '';
+    return new Error(`ChatEnvelopeValidationError(${options.stage}/${options.direction})[${code}] ${detail}${source}`);
+}

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

@@ -1,6 +1,7 @@
-import { FilterEngine, RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter, RequestStreamingToNonStreamingFilter } from '../../filters/index.js';
+import { FilterEngine, RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter } from '../../filters/index.js';
 import { normalizeChatRequest } from '../index.js';
 import { loadFieldMapConfig } from '../../filters/utils/fieldmap-loader.js';
+import { createSnapshotWriter } from './snapshot-utils.js';
 /**
  * 统一的 Chat 请求侧过滤链路。
  *
@@ -9,6 +10,16 @@ import { loadFieldMapConfig } from '../../filters/utils/fieldmap-loader.js';
  *   都在这里走同一套工具治理与参数标准化逻辑。
  */
 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;
+    const normalizedInboundStream = inboundStreamFromContext ?? inboundStreamDetected ?? undefined;
+    if (typeof normalizedInboundStream === 'boolean') {
+        existingMetadata.inboundStream = normalizedInboundStream;
+    }
     const requestId = context.requestId ?? `req_${Date.now()}`;
     const modelId = (chatRequest && typeof chatRequest === 'object' && typeof chatRequest.model === 'string')
         ? String(chatRequest.model)
@@ -16,6 +27,17 @@ export async function runStandardChatRequestFilters(chatRequest, profile, contex
     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 reqCtxBase = {
         requestId,
         model: modelId,
@@ -24,18 +46,26 @@ export async function runStandardChatRequestFilters(chatRequest, profile, contex
         debug: { emit: () => { } }
     };
     const engine = new FilterEngine();
+    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;
     // Request-side initial filters（与 openai-openai-codec 保持一致）
-    try {
-        const { RequestToolListFilter } = await import('../../filters/index.js');
-        engine.registerFilter(new RequestToolListFilter());
-    }
-    catch {
-        // 可选过滤器，失败时保持向后兼容
+    if (!skipAutoToolInjection) {
+        try {
+            const { RequestToolListFilter } = await import('../../filters/index.js');
+            engine.registerFilter(new RequestToolListFilter());
+        }
+        catch {
+            // 可选过滤器，失败时保持向后兼容
+        }
     }
     engine.registerFilter(new RequestToolCallsStringifyFilter());
     engine.registerFilter(new RequestToolChoicePolicyFilter());
-    // 统一将 Provider 请求转为非流式 Chat；流式语义由上层 SSE 合成处理
-    engine.registerFilter(new RequestStreamingToNonStreamingFilter());
     // FieldMap：保持与 Chat 入口一致，使用 openai-openai.fieldmap.json
     try {
         const cfg = await loadFieldMapConfig('openai-openai.fieldmap.json');
@@ -56,42 +86,93 @@ export async function runStandardChatRequestFilters(chatRequest, profile, contex
         // best-effort：缺少 fieldmap 时保持原样
     }
     let staged = await engine.run('request_pre', chatRequest, reqCtxBase);
+    snapshotStage('req_process_filters_request_pre', staged);
     staged = await engine.run('request_map', staged, reqCtxBase);
+    snapshotStage('req_process_filters_request_map', staged);
     staged = await engine.run('request_post', staged, reqCtxBase);
+    snapshotStage('req_process_filters_request_post', staged);
+    if (skipAutoToolInjection && staged && typeof staged === 'object') {
+        if (!Array.isArray(staged.tools)) {
+            staged.tools = [];
+        }
+        staged.__rcc_disable_mcp_tools = true;
+    }
     // 归一化 Chat 请求后再做最终工具治理
     let normalized = normalizeChatRequest(staged);
+    snapshotStage('req_process_filters_normalized', normalized);
     try {
         const { RequestOpenAIToolsNormalizeFilter, ToolPostConstraintsFilter } = await import('../../filters/index.js');
         engine.registerFilter(new RequestOpenAIToolsNormalizeFilter());
         // 工具治理后的最后约束层：默认配置为空，由宿主/配置系统按 profile/provider/modelId 决定是否启用具体规则。
         engine.registerFilter(new ToolPostConstraintsFilter('request_finalize'));
         normalized = await engine.run('request_finalize', normalized, reqCtxBase);
+        snapshotStage('req_process_filters_request_finalize', normalized);
     }
     catch {
         // 可选工具归一过滤器，失败时保持已归一化结果
     }
-    return ensureToolParameterDefaults(normalized);
+    const preserveStreamField = profile.incomingProtocol === 'openai-chat' && profile.outgoingProtocol === 'openai-chat';
+    const pruned = pruneChatRequestPayload(normalized, { preserveStreamField });
+    snapshotStage('req_process_filters_output', pruned);
+    return pruned;
 }
-function ensureToolParameterDefaults(chatRequest) {
+function pruneChatRequestPayload(chatRequest, options) {
     if (!chatRequest || typeof chatRequest !== 'object')
         return chatRequest;
-    const next = { ...chatRequest };
-    if (!Array.isArray(next.tools))
-        return next;
-    next.tools = next.tools.map((tool) => {
-        if (!tool || typeof tool !== 'object')
-            return tool;
-        if (tool.type !== 'function')
-            return tool;
-        const fn = tool.function && typeof tool.function === 'object' ? { ...tool.function } : tool.function;
-        if (fn && typeof fn === 'object' && fn.parameters && typeof fn.parameters === 'object') {
-            const params = { ...fn.parameters };
-            if (!Object.prototype.hasOwnProperty.call(params, 'additionalProperties')) {
-                params.additionalProperties = true;
-            }
-            fn.parameters = params;
+    const stripped = { ...chatRequest };
+    stripSentinelKeys(stripped);
+    if ('originalStream' in stripped) {
+        delete stripped.originalStream;
+    }
+    if ('_originalStreamOptions' in stripped) {
+        delete stripped._originalStreamOptions;
+    }
+    if ('metadata' in stripped) {
+        delete stripped.metadata;
+    }
+    if (!options?.preserveStreamField && 'stream' in stripped && stripped.stream !== true) {
+        delete stripped.stream;
+    }
+    if (Array.isArray(stripped.messages)) {
+        stripped.messages = stripped.messages.map((message) => sanitizeMessageEntry(message));
+    }
+    return stripped;
+}
+function sanitizeMessageEntry(message) {
+    if (!message || typeof message !== 'object')
+        return message;
+    const clone = { ...message };
+    if (Array.isArray(clone.tool_calls) && clone.tool_calls.length) {
+        clone.tool_calls = clone.tool_calls.map((call) => sanitizeToolCallEntry(call));
+    }
+    if (clone.role === 'tool') {
+        if (typeof clone.tool_call_id !== 'string' && typeof clone.call_id === 'string') {
+            clone.tool_call_id = clone.call_id;
+        }
+        if ('id' in clone) {
+            delete clone.id;
+        }
+    }
+    if ('call_id' in clone) {
+        delete clone.call_id;
+    }
+    return clone;
+}
+function sanitizeToolCallEntry(call) {
+    if (!call || typeof call !== 'object')
+        return call;
+    const clone = { ...call };
+    delete clone.call_id;
+    delete clone.tool_call_id;
+    if (clone.function && typeof clone.function === 'object') {
+        clone.function = { ...clone.function };
+    }
+    return clone;
+}
+function stripSentinelKeys(record) {
+    Object.keys(record).forEach((key) => {
+        if (key.startsWith('__rcc_')) {
+            delete record[key];
         }
-        return { ...tool, function: fn };
     });
-    return next;
 }

package/dist/conversion/shared/mcp-injection.js

@@ -1,10 +1,15 @@
 // Shared MCP tool exposure logic (two-step), aligned with claude-code-router
-const obj = (props, req) => ({
-    type: 'object',
-    properties: props,
-    required: req,
-    additionalProperties: false,
-});
+const obj = (props, req = []) => {
+    const schema = {
+        type: 'object',
+        properties: props,
+        additionalProperties: false
+    };
+    if (Array.isArray(req) && req.length > 0) {
+        schema.required = req;
+    }
+    return schema;
+};
 function uniq(arr) { return Array.from(new Set(arr)); }
 export function injectMcpToolsForChat(tools, discoveredServers) {
     const out = [];
@@ -23,7 +28,7 @@ export function injectMcpToolsForChat(tools, discoveredServers) {
             continue;
         }
         if (lower === 'list_mcp_resources') {
-            ensure('list_mcp_resources', { type: 'function', function: { name: 'list_mcp_resources', description: t.function?.description || 'List resources from a given MCP server.', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }, []) } });
+            ensure('list_mcp_resources', { type: 'function', function: { name: 'list_mcp_resources', description: t.function?.description || 'List resources from a given MCP server (arguments.server = server label).', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }) } });
             continue;
         }
         if (lower === 'read_mcp_resource' || lower === 'list_mcp_resource_templates') {
@@ -43,7 +48,7 @@ export function injectMcpToolsForChat(tools, discoveredServers) {
     }
     // Ensure list exists when user did not provide it
     if (!keep.has('list_mcp_resources')) {
-        out.push({ type: 'function', function: { name: 'list_mcp_resources', description: 'List resources from a given MCP server (arguments.server = server label).', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }, []) } });
+        out.push({ type: 'function', function: { name: 'list_mcp_resources', description: 'List resources from a given MCP server (arguments.server = server label).', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }) } });
     }
     return out;
 }
@@ -51,6 +56,7 @@ export function injectMcpToolsForResponses(tools, discoveredServers) {
     const out = [];
     const keep = new Set();
     const listServers = { type: 'string' };
+    const templateServer = discoveredServers && discoveredServers.length ? { type: 'string', enum: uniq(discoveredServers) } : { type: 'string' };
     const ensure = (name, def) => { if (!keep.has(name)) {
         out.push(def);
         keep.add(name);
@@ -64,26 +70,41 @@ export function injectMcpToolsForResponses(tools, discoveredServers) {
             continue;
         }
         if (lower === 'list_mcp_resources') {
-            ensure('list_mcp_resources', { type: 'function', function: { name: 'list_mcp_resources', description: t.function?.description || 'List resources from a given MCP server.', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }, []) } });
+            ensure('list_mcp_resources', { type: 'function', function: { name: 'list_mcp_resources', description: t.function?.description || 'List resources from a given MCP server (arguments.server = server label).', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }) } });
             continue;
         }
-        if (lower === 'read_mcp_resource' || lower === 'list_mcp_resource_templates') {
-            if (discoveredServers.length > 0) {
-                const srv = { type: 'string', enum: uniq(discoveredServers) };
-                if (lower === 'read_mcp_resource') {
-                    ensure('read_mcp_resource', { type: 'function', function: { name: 'read_mcp_resource', description: t.function?.description || 'Read a resource via MCP server.', parameters: obj({ server: srv, uri: { type: 'string' } }, ['server', 'uri']) } });
-                }
-                else {
-                    ensure('list_mcp_resource_templates', { type: 'function', function: { name: 'list_mcp_resource_templates', description: 'List resource templates via MCP server.', parameters: obj({ server: srv }, ['server']) } });
+        if (lower === 'list_mcp_resource_templates') {
+            ensure('list_mcp_resource_templates', {
+                type: 'function',
+                function: {
+                    name: 'list_mcp_resource_templates',
+                    description: t.function?.description || 'List resource templates from MCP servers.',
+                    parameters: obj({ server: templateServer, cursor: { type: 'string' } })
                 }
-                continue;
-            }
+            });
+            continue;
+        }
+        if (lower === 'read_mcp_resource' && discoveredServers.length > 0) {
+            const srv = { type: 'string', enum: uniq(discoveredServers) };
+            ensure('read_mcp_resource', { type: 'function', function: { name: 'read_mcp_resource', description: t.function?.description || 'Read a resource via MCP server.', parameters: obj({ server: srv, uri: { type: 'string' } }, ['server', 'uri']) } });
+            continue;
         }
         out.push(t);
         keep.add(lower);
     }
     if (!keep.has('list_mcp_resources')) {
-        out.push({ type: 'function', function: { name: 'list_mcp_resources', description: 'List resources from a given MCP server (arguments.server = server label).', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }, []) } });
+        out.push({ type: 'function', function: { name: 'list_mcp_resources', description: 'List resources from a given MCP server (arguments.server = server label).', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }) } });
+        keep.add('list_mcp_resources');
+    }
+    if (!keep.has('list_mcp_resource_templates')) {
+        out.push({
+            type: 'function',
+            function: {
+                name: 'list_mcp_resource_templates',
+                description: 'List resource templates from MCP servers.',
+                parameters: obj({ server: templateServer, cursor: { type: 'string' } })
+            }
+        });
     }
     return out;
 }

package/dist/conversion/shared/openai-finalizer.d.ts

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

package/dist/conversion/shared/openai-finalizer.js

@@ -100,5 +100,78 @@ export async function finalizeOpenAIChatResponse(chatLike, opts) {
         }
     }
     catch { /* ignore normalization errors */ }
+    applyChatReasoningPolicy(obj, opts?.reasoningMode);
     return obj;
 }
+function applyChatReasoningPolicy(target, mode) {
+    if (!mode || mode === 'keep') {
+        return;
+    }
+    const containers = [];
+    if (Array.isArray(target.messages)) {
+        target.messages.forEach(entry => {
+            if (entry && typeof entry === 'object') {
+                containers.push(entry);
+            }
+        });
+    }
+    if (Array.isArray(target.choices)) {
+        target.choices.forEach(choice => {
+            if (!choice || typeof choice !== 'object') {
+                return;
+            }
+            const record = choice;
+            if (record.message && typeof record.message === 'object') {
+                containers.push(record.message);
+            }
+            if (record.delta && typeof record.delta === 'object') {
+                containers.push(record.delta);
+            }
+        });
+    }
+    containers.forEach(container => normalizeReasoningField(container, mode));
+}
+function normalizeReasoningField(container, mode) {
+    const bag = container;
+    const rawValue = typeof bag.reasoning_content === 'string' ? bag.reasoning_content : '';
+    const trimmed = rawValue.trim();
+    if (!trimmed && Object.prototype.hasOwnProperty.call(bag, 'reasoning_content')) {
+        delete bag.reasoning_content;
+        return;
+    }
+    if (!trimmed) {
+        return;
+    }
+    if (mode === 'drop') {
+        delete bag.reasoning_content;
+        return;
+    }
+    if (mode === 'append_to_content') {
+        appendReasoningToContent(bag, trimmed);
+        delete bag.reasoning_content;
+    }
+}
+function appendReasoningToContent(container, reasoning) {
+    const separator = reasoning.startsWith('\n') ? '' : '\n';
+    if (typeof container.content === 'string') {
+        const base = container.content.trim().length ? container.content : '';
+        container.content = base ? `${base}${separator}${reasoning}` : reasoning;
+        return;
+    }
+    if (Array.isArray(container.content)) {
+        const list = container.content;
+        list.push({ type: 'text', text: reasoning });
+        return;
+    }
+    if (container.content && typeof container.content === 'object') {
+        try {
+            const serialized = JSON.stringify(container.content);
+            container.content = serialized ? `${serialized}${separator}${reasoning}` : reasoning;
+        }
+        catch {
+            container.content = reasoning;
+        }
+        return;
+    }
+    container.content = reasoning;
+}

package/dist/conversion/shared/openai-message-normalize.js

@@ -1,3 +1,4 @@
+import { injectMcpToolsForChat } from './mcp-injection.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.
@@ -47,48 +48,48 @@ export function normalizeChatRequest(request) {
     }
     catch { /* ignore limit errors */ }
     // MCP 注入（两步法）统一走共享实现，避免路径分叉
-    try {
-        const enableMcp = String(process?.env?.ROUTECODEX_MCP_ENABLE ?? '1') !== '0';
-        if (enableMcp) {
-            const known = new Set();
-            try {
-                const msgs = Array.isArray(normalized.messages) ? normalized.messages : [];
-                for (const m of msgs) {
-                    if (!m || typeof m !== 'object')
-                        continue;
-                    if (m.role === 'tool' && typeof m.content === 'string') {
-                        try {
-                            const obj = JSON.parse(m.content);
-                            const sv = obj?.arguments?.server;
-                            if (typeof sv === 'string' && sv.trim())
-                                known.add(sv.trim());
-                        }
-                        catch { /* ignore */ }
-                    }
-                    if (m.role === 'assistant' && Array.isArray(m.tool_calls)) {
-                        for (const tc of m.tool_calls) {
+    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();
+                try {
+                    const msgs = Array.isArray(normalized.messages) ? normalized.messages : [];
+                    for (const m of msgs) {
+                        if (!m || typeof m !== 'object')
+                            continue;
+                        if (m.role === 'tool' && typeof m.content === 'string') {
                             try {
-                                const argStr = String(tc?.function?.arguments ?? '');
-                                const parsed = JSON.parse(argStr);
-                                const sv = parsed?.server;
+                                const obj = JSON.parse(m.content);
+                                const sv = obj?.arguments?.server;
                                 if (typeof sv === 'string' && sv.trim())
                                     known.add(sv.trim());
                             }
                             catch { /* ignore */ }
                         }
+                        if (m.role === 'assistant' && Array.isArray(m.tool_calls)) {
+                            for (const tc of m.tool_calls) {
+                                try {
+                                    const argStr = String(tc?.function?.arguments ?? '');
+                                    const parsed = JSON.parse(argStr);
+                                    const sv = parsed?.server;
+                                    if (typeof sv === 'string' && sv.trim())
+                                        known.add(sv.trim());
+                                }
+                                catch { /* ignore */ }
+                            }
+                        }
                     }
                 }
+                catch { /* ignore */ }
+                const discovered = Array.from(known);
+                const currentTools = Array.isArray(normalized.tools) ? normalized.tools : [];
+                normalized.tools = injectMcpToolsForChat(currentTools, discovered);
             }
-            catch { /* ignore */ }
-            const discovered = Array.from(known);
-            // Dynamic import replaced with require-style to keep function non-async
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
-            const inj = require('./mcp-injection.js');
-            const currentTools = Array.isArray(normalized.tools) ? normalized.tools : [];
-            normalized.tools = inj.injectMcpToolsForChat(currentTools, discovered);
         }
+        catch { /* ignore MCP injection */ }
     }
-    catch { /* ignore MCP injection */ }
     // Normalize assistant.tool_calls arguments (stringify only; do NOT reshape)
     try {
         const msgs = Array.isArray(normalized.messages) ? normalized.messages : [];

package/dist/conversion/shared/protocol-state.d.ts

@@ -0,0 +1,4 @@
+import type { ChatEnvelope } from '../hub/types/chat-envelope.js';
+import { type JsonObject } from '../hub/types/json.js';
+export declare function ensureProtocolState(metadata: ChatEnvelope['metadata'], protocol: string): JsonObject;
+export declare function getProtocolState(metadata: ChatEnvelope['metadata'] | undefined, protocol: string): JsonObject | undefined;

package/dist/conversion/shared/protocol-state.js

@@ -0,0 +1,23 @@
+import { isJsonObject } from '../hub/types/json.js';
+const PROTOCOL_STATE_KEY = 'protocolState';
+export function ensureProtocolState(metadata, protocol) {
+    if (!metadata[PROTOCOL_STATE_KEY] || !isJsonObject(metadata[PROTOCOL_STATE_KEY])) {
+        metadata[PROTOCOL_STATE_KEY] = {};
+    }
+    const container = metadata[PROTOCOL_STATE_KEY];
+    if (!isJsonObject(container[protocol])) {
+        container[protocol] = {};
+    }
+    return container[protocol];
+}
+export function getProtocolState(metadata, protocol) {
+    if (!metadata) {
+        return undefined;
+    }
+    const store = metadata[PROTOCOL_STATE_KEY];
+    if (!isJsonObject(store)) {
+        return undefined;
+    }
+    const node = store[protocol];
+    return isJsonObject(node) ? node : undefined;
+}

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

@@ -8,6 +8,7 @@ interface ResponsesReasoningNormalizeOptions {
 }
 export declare function normalizeReasoningInChatPayload(payload: {
     messages?: JsonValue[];
+    choices?: JsonValue[];
 } | null | undefined): void;
 export declare function normalizeReasoningInResponsesPayload(payload: {
     output?: JsonValue[];