@jsonstudio/rcc 0.90.814 → 0.90.876

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/hub-stage-timing.d.ts

@@ -1,5 +1,16 @@
 export declare function isHubStageTimingDetailEnabled(): boolean;
 export declare function clearHubStageTiming(requestId: string | undefined | null): void;
+export type HubStageTopSummaryEntry = {
+    stage: string;
+    totalMs: number;
+    count: number;
+    avgMs: number;
+    maxMs: number;
+};
+export declare function peekHubStageTopSummary(requestId: string | undefined | null, options?: {
+    topN?: number;
+    minMs?: number;
+}): HubStageTopSummaryEntry[];
 export declare function logHubStageTiming(requestId: string, stage: string, phase: 'start' | 'completed' | 'error', details?: Record<string, unknown>): void;
 export declare function measureHubStage<T>(requestId: string, stage: string, fn: () => Promise<T> | T, options?: {
     startDetails?: Record<string, unknown>;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/hub-stage-timing.js

@@ -1,9 +1,13 @@
 const truthy = new Set(['1', 'true', 'yes', 'on']);
 const falsy = new Set(['0', 'false', 'no', 'off']);
+// Native alignment note: timing integrates with *WithNative stage orchestration flow.
 const REQUEST_TIMELINES = new Map();
 const REQUEST_TIMELINE_TTL_MS = 30 * 60 * 1000;
 const REQUEST_TIMELINE_MAX = 4096;
 const DEFAULT_HUB_STAGE_LOG_MIN_MS = 50;
+const DEFAULT_HUB_STAGE_TOP_N = 5;
+const DEFAULT_HUB_STAGE_TOP_MIN_MS = 5;
+const REQUEST_STAGE_BREAKDOWNS = new Map();
 function resolveBool(raw, fallback) {
     if (raw === undefined) {
         return fallback;
@@ -62,6 +66,7 @@ function prune(nowMs) {
     for (const [key, timeline] of REQUEST_TIMELINES.entries()) {
         if (nowMs - timeline.lastAtMs >= REQUEST_TIMELINE_TTL_MS) {
             REQUEST_TIMELINES.delete(key);
+            REQUEST_STAGE_BREAKDOWNS.delete(key);
         }
     }
     while (REQUEST_TIMELINES.size > REQUEST_TIMELINE_MAX) {
@@ -70,6 +75,7 @@ function prune(nowMs) {
             break;
         }
         REQUEST_TIMELINES.delete(oldestKey);
+        REQUEST_STAGE_BREAKDOWNS.delete(oldestKey);
     }
 }
 function touchTiming(requestId) {
@@ -125,8 +131,82 @@ export function clearHubStageTiming(requestId) {
         return;
     }
     REQUEST_TIMELINES.delete(requestId);
+    REQUEST_STAGE_BREAKDOWNS.delete(requestId);
+}
+function recordHubStageElapsed(requestId, stage, elapsedMs) {
+    if (!requestId || !stage || !Number.isFinite(elapsedMs) || elapsedMs < 0) {
+        return;
+    }
+    const nowMs = Date.now();
+    prune(nowMs);
+    const byStage = REQUEST_STAGE_BREAKDOWNS.get(requestId) ?? new Map();
+    if (!REQUEST_STAGE_BREAKDOWNS.has(requestId)) {
+        REQUEST_STAGE_BREAKDOWNS.set(requestId, byStage);
+    }
+    const existing = byStage.get(stage);
+    if (!existing) {
+        byStage.set(stage, {
+            totalMs: elapsedMs,
+            count: 1,
+            maxMs: elapsedMs
+        });
+        return;
+    }
+    existing.totalMs += elapsedMs;
+    existing.count += 1;
+    existing.maxMs = Math.max(existing.maxMs, elapsedMs);
+}
+function readIntEnv(name, fallback) {
+    const raw = process.env[name];
+    const parsed = Number.parseInt(String(raw ?? '').trim(), 10);
+    if (Number.isFinite(parsed) && parsed > 0) {
+        return parsed;
+    }
+    return fallback;
+}
+export function peekHubStageTopSummary(requestId, options) {
+    if (!requestId) {
+        return [];
+    }
+    const byStage = REQUEST_STAGE_BREAKDOWNS.get(requestId);
+    if (!byStage || !byStage.size) {
+        return [];
+    }
+    const topN = Math.max(1, options?.topN ?? readIntEnv('ROUTECODEX_HUB_STAGE_TOP_N', DEFAULT_HUB_STAGE_TOP_N));
+    const minMs = Math.max(0, options?.minMs ?? readIntEnv('ROUTECODEX_HUB_STAGE_TOP_MIN_MS', DEFAULT_HUB_STAGE_TOP_MIN_MS));
+    return Array.from(byStage.entries())
+        .map(([stage, stats]) => {
+        const totalMs = Math.max(0, Math.round(stats.totalMs));
+        const count = Math.max(0, Math.floor(stats.count));
+        const maxMs = Math.max(0, Math.round(stats.maxMs));
+        const avgMs = count > 0 ? Math.max(0, Math.round(totalMs / count)) : 0;
+        return {
+            stage,
+            totalMs,
+            count,
+            avgMs,
+            maxMs
+        };
+    })
+        .filter((entry) => entry.totalMs >= minMs)
+        .sort((a, b) => b.totalMs - a.totalMs)
+        .slice(0, topN);
 }
 export function logHubStageTiming(requestId, stage, phase, details) {
+    const stageElapsedMs = phase === 'completed' || phase === 'error'
+        ? (typeof details?.elapsedMs === 'number'
+            ? details.elapsedMs
+            : typeof details?.nativeMs === 'number'
+                ? details.nativeMs
+                : undefined)
+        : undefined;
+    if (requestId &&
+        stage &&
+        typeof stageElapsedMs === 'number' &&
+        Number.isFinite(stageElapsedMs) &&
+        stageElapsedMs >= 0) {
+        recordHubStageElapsed(requestId, stage, stageElapsedMs);
+    }
     if (!isHubStageTimingEnabled() || !requestId || !stage) {
         return;
     }
@@ -200,10 +280,11 @@ export async function measureHubStage(requestId, stage, fn, options) {
         return value;
     }
     catch (error) {
+        const elapsedMs = Math.max(0, Date.now() - startedAt);
         const mapped = options?.mapErrorDetails?.(error);
         const message = error instanceof Error ? error.message : String(error ?? 'unknown');
         logHubStageTiming(requestId, stage, 'error', mapped ?? {
-            elapsedMs: Math.max(0, Date.now() - startedAt),
+            elapsedMs,
             message
         });
         throw error;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage2_semantic_map/index.js

@@ -1,4 +1,4 @@
-import { isJsonObject, jsonClone, } from "../../../../types/json.js";
+import { isJsonObject, } from "../../../../types/json.js";
 import { applyHubOperationTableInbound } from "../../../../operation-table/operation-table-runner.js";
 import { recordStage } from "../../../stages/utils.js";
 import { liftReqInboundSemantics } from "./semantic-lift.js";
@@ -7,6 +7,28 @@ import { chatEnvelopeToStandardizedWithNative } from "../../../../../../router/v
 import { normalizeReqInboundShellLikeToolCallsWithNative } from "../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics-tools.js";
 import { fixApplyPatchToolCallsWithNative } from "../../../../../../router/virtual-router/engine-selection/native-compat-action-semantics.js";
 import { isHubStageTimingDetailEnabled, logHubStageTiming, } from "../../../hub-stage-timing.js";
+function buildSlimResponsesContextForSemantics(context) {
+    if (!context || typeof context !== "object" || Array.isArray(context)) {
+        return undefined;
+    }
+    // Keep semantic essentials only; avoid carrying full `input` history through
+    // chat_process and req_process stages (it can be huge and is not required for
+    // non-responses outbound paths).
+    //
+    // IMPORTANT:
+    // Do not spread-clone first and then delete heavy keys. For large /v1/responses
+    // payloads that would deep-copy gigantic arrays/strings into a temporary object.
+    // Build a filtered object directly to keep this step O(selected fields).
+    const src = context;
+    const out = {};
+    for (const [key, value] of Object.entries(src)) {
+        if (key === "input" || key === "__captured_tool_results") {
+            continue;
+        }
+        out[key] = value;
+    }
+    return out;
+}
 export async function runReqInboundStage2SemanticMap(options) {
     const requestId = options.adapterContext.requestId || "unknown";
     const forceDetailLog = isHubStageTimingDetailEnabled();
@@ -25,8 +47,12 @@ export async function runReqInboundStage2SemanticMap(options) {
         const contextNode = responsesNode && isJsonObject(responsesNode.context)
             ? responsesNode.context
             : undefined;
-        return contextNode ? jsonClone(contextNode) : undefined;
+        // Perf: keep reference instead of deep clone to avoid multi-pass cloning on
+        // heavy /v1/responses histories.
+        return contextNode;
     })();
+    const semanticsResponsesContext = buildSlimResponsesContextForSemantics(preservedResponsesContext) ??
+        preservedResponsesContext;
     logHubStageTiming(requestId, "req_inbound.stage2_operation_table_inbound", "start");
     const operationTableStart = Date.now();
     applyHubOperationTableInbound({
@@ -52,11 +78,11 @@ export async function runReqInboundStage2SemanticMap(options) {
         elapsedMs: Date.now() - semanticLiftStart,
         forceLog: forceDetailLog,
     });
-    if (preservedResponsesContext) {
+    if (semanticsResponsesContext) {
         const currentSemantics = chatEnvelope.semantics;
         if (!currentSemantics || typeof currentSemantics !== "object") {
             chatEnvelope.semantics = {
-                responses: { context: jsonClone(preservedResponsesContext) },
+                responses: { context: semanticsResponsesContext },
             };
         }
         else {
@@ -69,19 +95,24 @@ export async function runReqInboundStage2SemanticMap(options) {
                     ...semantics,
                     responses: {
                         ...responsesNode,
-                        context: jsonClone(preservedResponsesContext),
+                        context: semanticsResponsesContext,
                     },
                 };
             }
         }
     }
-    normalizeReqInboundShellLikeToolCallsWithNative(chatEnvelope);
-    const fixedApplyPatch = fixApplyPatchToolCallsWithNative({
-        messages: (Array.isArray(chatEnvelope.messages)
-            ? chatEnvelope.messages
-            : []),
-    });
-    chatEnvelope.messages = fixedApplyPatch.messages;
+    // openai-responses path already ran request_inbound bridge policy in
+    // buildChatRequestFromResponses (including call-id/apply-patch compat actions).
+    // Skip duplicate message-wide normalization passes here to reduce heavy-input cost.
+    if (options.formatEnvelope.protocol !== "openai-responses") {
+        normalizeReqInboundShellLikeToolCallsWithNative(chatEnvelope);
+        const fixedApplyPatch = fixApplyPatchToolCallsWithNative({
+            messages: (Array.isArray(chatEnvelope.messages)
+                ? chatEnvelope.messages
+                : []),
+        });
+        chatEnvelope.messages = fixedApplyPatch.messages;
+    }
     logHubStageTiming(requestId, "req_inbound.stage2_validate_chat_envelope", "start");
     const validateStart = Date.now();
     validateChatEnvelopeWithNative(chatEnvelope, {
@@ -107,7 +138,7 @@ export async function runReqInboundStage2SemanticMap(options) {
         const envelopeSemantics = chatEnvelope.semantics;
         const existing = standardizedRequest.semantics;
         if (!existing || typeof existing !== "object") {
-            standardizedRequest.semantics = jsonClone(envelopeSemantics);
+            standardizedRequest.semantics = envelopeSemantics;
         }
         else {
             const existingObj = existing;
@@ -118,11 +149,13 @@ export async function runReqInboundStage2SemanticMap(options) {
                 ? envelopeResponses.context
                 : undefined;
             if (envelopeContext) {
+                const slimContext = buildSlimResponsesContextForSemantics(envelopeContext) ??
+                    envelopeContext;
                 const nextResponses = {
                     ...(isJsonObject(existingObj.responses)
                         ? existingObj.responses
                         : {}),
-                    context: jsonClone(envelopeContext),
+                    context: slimContext,
                 };
                 standardizedRequest.semantics = {
                     ...existingObj,

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/index.js

@@ -19,6 +19,49 @@ export async function runReqOutboundStage1SemanticMap(options) {
         request: options.request,
         adapterContext: options.adapterContext
     });
+    // Perf: when outbound target is not /v1/responses, the large responses.context
+    // semantic snapshot is not needed for provider request mapping and can cause
+    // expensive deep traversals in downstream native mappers/policy actions.
+    if (providerProtocol !== 'openai-responses') {
+        const semantics = chatEnvelope.semantics;
+        const responsesNode = semantics && typeof semantics.responses === 'object' && semantics.responses !== null && !Array.isArray(semantics.responses)
+            ? semantics.responses
+            : undefined;
+        if (responsesNode && Object.prototype.hasOwnProperty.call(responsesNode, 'context')) {
+            const { context: _unusedContext, ...restResponses } = responsesNode;
+            if (Object.keys(restResponses).length > 0) {
+                chatEnvelope.semantics = {
+                    ...(semantics ?? {}),
+                    responses: restResponses
+                };
+            }
+            else if (semantics && Object.keys(semantics).length > 0) {
+                const { responses: _unusedResponses, ...restSemantics } = semantics;
+                chatEnvelope.semantics =
+                    Object.keys(restSemantics).length > 0
+                        ? restSemantics
+                        : undefined;
+            }
+        }
+    }
+    if (providerProtocol === 'openai-responses'
+        && options.contextSnapshot
+        && typeof options.contextSnapshot === 'object'
+        && !Array.isArray(options.contextSnapshot)) {
+        const semantics = chatEnvelope.semantics && typeof chatEnvelope.semantics === 'object' && !Array.isArray(chatEnvelope.semantics)
+            ? chatEnvelope.semantics
+            : {};
+        const responsesNode = semantics.responses && typeof semantics.responses === 'object' && !Array.isArray(semantics.responses)
+            ? semantics.responses
+            : {};
+        chatEnvelope.semantics = {
+            ...semantics,
+            responses: {
+                ...responsesNode,
+                context: options.contextSnapshot
+            }
+        };
+    }
     logHubStageTiming(requestId, 'req_outbound.stage1_native_to_chat_envelope', 'completed', {
         elapsedMs: Date.now() - toChatStart,
         forceLog: forceDetailLog

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/client-remap-protocol-switch.js

@@ -9,8 +9,60 @@ function asRecord(value) {
         ? value
         : undefined;
 }
-function extractClientToolNameMap(clientToolsRaw) {
-    const map = new Map();
+function stripFunctionNamespace(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return '';
+    }
+    const lowered = trimmed.toLowerCase();
+    if (lowered.startsWith('functions.')) {
+        return trimmed.slice('functions.'.length).trim();
+    }
+    if (lowered.startsWith('function.')) {
+        return trimmed.slice('function.'.length).trim();
+    }
+    return trimmed;
+}
+function toCanonicalToolName(raw) {
+    const stripped = stripFunctionNamespace(raw).toLowerCase().trim();
+    if (!stripped) {
+        return '';
+    }
+    return stripped
+        .replace(/[\s_-]+/g, '.')
+        .replace(/\.{2,}/g, '.')
+        .replace(/^\.+|\.+$/g, '');
+}
+function toCompactToolName(raw) {
+    const canonical = toCanonicalToolName(raw);
+    if (!canonical) {
+        return '';
+    }
+    return canonical.replace(/[._-]/g, '');
+}
+function resolveToolFamily(raw) {
+    const canonicalLower = toCanonicalToolName(raw);
+    if (!canonicalLower) {
+        return '';
+    }
+    const shellCandidate = canonicalLower.replace(/\./g, '_');
+    if (isShellToolName(canonicalLower) || isShellToolName(shellCandidate) || canonicalLower === 'terminal') {
+        return 'shell_like';
+    }
+    if (canonicalLower === 'apply.patch' || canonicalLower === 'apply_patch') {
+        return 'apply_patch';
+    }
+    if (canonicalLower === 'write.stdin' || canonicalLower === 'write_stdin') {
+        return 'write_stdin';
+    }
+    return canonicalLower;
+}
+function extractClientToolIndex(clientToolsRaw) {
+    const byExactLower = new Map();
+    const byStrippedLower = new Map();
+    const byCanonicalLower = new Map();
+    const byCompactLower = new Map();
+    const byFamily = new Map();
     for (const tool of clientToolsRaw ?? []) {
         const functionBag = asRecord(tool.function);
         const rawName = (typeof functionBag?.name === 'string' ? functionBag.name : undefined)
@@ -19,15 +71,70 @@ function extractClientToolNameMap(clientToolsRaw) {
         if (!normalizedName) {
             continue;
         }
-        map.set(normalizedName.toLowerCase(), tool);
+        const entry = {
+            declaredName: normalizedName,
+            tool
+        };
+        const exactLower = normalizedName.toLowerCase();
+        const strippedLower = stripFunctionNamespace(normalizedName).toLowerCase();
+        const canonicalLower = toCanonicalToolName(normalizedName);
+        const compactLower = toCompactToolName(normalizedName);
+        const family = resolveToolFamily(normalizedName);
+        if (!byExactLower.has(exactLower)) {
+            byExactLower.set(exactLower, entry);
+        }
+        if (strippedLower && !byStrippedLower.has(strippedLower)) {
+            byStrippedLower.set(strippedLower, entry);
+        }
+        if (canonicalLower && !byCanonicalLower.has(canonicalLower)) {
+            byCanonicalLower.set(canonicalLower, entry);
+        }
+        if (compactLower && !byCompactLower.has(compactLower)) {
+            byCompactLower.set(compactLower, entry);
+        }
+        if (family && !byFamily.has(family)) {
+            byFamily.set(family, entry);
+        }
+    }
+    return { byExactLower, byStrippedLower, byCanonicalLower, byCompactLower, byFamily };
+}
+function resolveClientToolFromIndex(index, rawName) {
+    const trimmed = rawName.trim();
+    if (!trimmed) {
+        return undefined;
     }
-    return map;
+    const exactLower = trimmed.toLowerCase();
+    const strippedLower = stripFunctionNamespace(trimmed).toLowerCase();
+    const canonicalLower = toCanonicalToolName(trimmed);
+    const compactLower = toCompactToolName(trimmed);
+    const family = resolveToolFamily(trimmed);
+    return (index.byExactLower.get(exactLower)
+        ?? index.byExactLower.get(strippedLower)
+        ?? index.byStrippedLower.get(strippedLower)
+        ?? (canonicalLower ? index.byCanonicalLower.get(canonicalLower) : undefined)
+        ?? (canonicalLower ? index.byStrippedLower.get(canonicalLower) : undefined)
+        ?? (compactLower ? index.byCompactLower.get(compactLower) : undefined)
+        ?? (family ? index.byFamily.get(family) : undefined));
 }
 function remapChatToolCallsToClientNames(payload, clientToolsRaw) {
-    const toolMap = extractClientToolNameMap(clientToolsRaw);
-    if (!toolMap.size) {
-        return;
+    const toolIndex = extractClientToolIndex(clientToolsRaw);
+    if (!toolIndex.byExactLower.size) {
+        return [];
     }
+    const unknownNames = [];
+    const seenUnknown = new Set();
+    const pushUnknown = (name) => {
+        const key = name.trim();
+        if (!key || seenUnknown.has(key)) {
+            return;
+        }
+        seenUnknown.add(key);
+        unknownNames.push(key);
+    };
+    const readSchema = (entry) => {
+        const functionBag = asRecord(entry?.tool.function);
+        return functionBag?.parameters;
+    };
     const choices = Array.isArray(payload.choices)
         ? payload.choices
         : [];
@@ -40,20 +147,13 @@ function remapChatToolCallsToClientNames(payload, clientToolsRaw) {
             if (!currentName) {
                 continue;
             }
-            const normalizedCurrentName = currentName.toLowerCase();
-            const matchedTool = toolMap.get(normalizedCurrentName)
-                ?? (isShellToolName(normalizedCurrentName)
-                    ? Array.from(toolMap.entries()).find(([toolName]) => isShellToolName(toolName))?.[1]
-                    : undefined);
+            const matchedTool = resolveClientToolFromIndex(toolIndex, currentName);
             if (!matchedTool) {
+                pushUnknown(currentName);
                 continue;
             }
-            const matchedFunction = asRecord(matchedTool.function);
-            const clientName = (typeof matchedFunction?.name === 'string' ? matchedFunction.name : undefined)
-                ?? (typeof matchedTool.name === 'string' ? matchedTool.name : undefined)
-                ?? currentName;
-            functionBag.name = clientName;
-            const schema = matchedFunction?.parameters;
+            functionBag.name = matchedTool.declaredName;
+            const schema = readSchema(matchedTool);
             const rawArgs = functionBag?.arguments;
             let parsedArgs = rawArgs;
             if (typeof rawArgs === 'string') {
@@ -75,13 +175,115 @@ function remapChatToolCallsToClientNames(payload, clientToolsRaw) {
             }
         }
     }
+    return unknownNames;
+}
+function remapResponsesToolCallsToClientNames(payload, clientToolsRaw) {
+    const toolIndex = extractClientToolIndex(clientToolsRaw);
+    if (!toolIndex.byExactLower.size) {
+        return [];
+    }
+    const unknownNames = [];
+    const seenUnknown = new Set();
+    const pushUnknown = (name) => {
+        const key = name.trim();
+        if (!key || seenUnknown.has(key)) {
+            return;
+        }
+        seenUnknown.add(key);
+        unknownNames.push(key);
+    };
+    const requiredActionCalls = Array.isArray(payload?.required_action?.submit_tool_outputs?.tool_calls)
+        ? payload.required_action.submit_tool_outputs.tool_calls
+        : [];
+    for (const call of requiredActionCalls) {
+        const callBag = asRecord(call);
+        if (!callBag) {
+            continue;
+        }
+        const rawName = typeof callBag.name === 'string' ? callBag.name.trim() : '';
+        if (!rawName) {
+            continue;
+        }
+        const matched = resolveClientToolFromIndex(toolIndex, rawName);
+        if (!matched) {
+            pushUnknown(rawName);
+            continue;
+        }
+        callBag.name = matched.declaredName;
+    }
+    const outputItems = Array.isArray(payload?.output) ? payload.output : [];
+    for (const item of outputItems) {
+        const itemBag = asRecord(item);
+        if (!itemBag) {
+            continue;
+        }
+        const type = typeof itemBag.type === 'string' ? itemBag.type.trim().toLowerCase() : '';
+        if (type !== 'function_call') {
+            continue;
+        }
+        const rawName = typeof itemBag.name === 'string' ? itemBag.name.trim() : '';
+        if (!rawName) {
+            continue;
+        }
+        const matched = resolveClientToolFromIndex(toolIndex, rawName);
+        if (!matched) {
+            pushUnknown(rawName);
+            continue;
+        }
+        itemBag.name = matched.declaredName;
+    }
+    return unknownNames;
+}
+function assertNoUnknownToolNames(args) {
+    const uniqueUnknown = Array.from(new Set(args.unknownNames.map((name) => name.trim()).filter(Boolean)));
+    if (!uniqueUnknown.length) {
+        return;
+    }
+    const declaredNames = (args.clientToolsRaw ?? [])
+        .map((tool) => {
+        const fn = asRecord(tool.function);
+        const fnName = typeof fn?.name === 'string' ? fn.name.trim() : '';
+        if (fnName) {
+            return fnName;
+        }
+        const topName = typeof tool.name === 'string' ? tool.name.trim() : '';
+        return topName || '';
+    })
+        .filter(Boolean);
+    const declaredPreview = declaredNames.slice(0, 20).join(', ');
+    const error = new Error(`[client-remap] tool name mismatch after remap: unknown=[${uniqueUnknown.join(', ')}]` +
+        ` protocol=${args.clientProtocol} requestId=${args.requestId}` +
+        (declaredPreview ? ` declared=[${declaredPreview}]` : ' declared=[none]'));
+    error.code = 'CLIENT_TOOL_NAME_MISMATCH';
+    error.statusCode = 502;
+    error.retryable = true;
+    error.details = {
+        unknownToolNames: uniqueUnknown,
+        declaredToolNames: declaredNames,
+        protocol: args.clientProtocol,
+        requestId: args.requestId
+    };
+    throw error;
+}
+function enforceClientToolNameContract(options, payload, toolsRaw) {
+    const hasClientTools = Array.isArray(toolsRaw) && toolsRaw.length > 0;
+    if (!hasClientTools) {
+        return;
+    }
+    const unknownFromChat = remapChatToolCallsToClientNames(payload, toolsRaw);
+    const unknownFromResponses = remapResponsesToolCallsToClientNames(payload, toolsRaw);
+    assertNoUnknownToolNames({
+        requestId: options.requestId,
+        clientProtocol: options.clientProtocol,
+        unknownNames: [...unknownFromChat, ...unknownFromResponses],
+        clientToolsRaw: toolsRaw
+    });
 }
 export function buildClientPayloadForProtocol(options) {
     let clientPayload;
     const toolsRaw = resolveClientToolsRawFromSemantics(options.requestSemantics);
     if (options.clientProtocol === 'openai-chat') {
         clientPayload = options.payload;
-        remapChatToolCallsToClientNames(clientPayload, toolsRaw);
     }
     else if (options.clientProtocol === 'anthropic-messages') {
         clientPayload = buildAnthropicResponseFromChat(options.payload, {
@@ -99,5 +301,6 @@ export function buildClientPayloadForProtocol(options) {
     if (options.clientProtocol === 'openai-responses') {
         normalizeResponsesToolCallIds(clientPayload);
     }
+    enforceClientToolNameContract(options, clientPayload, toolsRaw);
     return clientPayload;
 }

package/node_modules/@jsonstudio/llms/dist/conversion/hub/policy/policy-engine.js

@@ -212,7 +212,7 @@ export function recordHubPolicyObservation(options) {
         return;
     }
     const compatibilityProfile = typeof options.compatibilityProfile === 'string' ? options.compatibilityProfile.trim().toLowerCase() : '';
-    if (compatibilityProfile === 'chat:deepseek-web') {
+    if (compatibilityProfile === 'chat:deepseek-web' || compatibilityProfile === 'chat:qwenchat-web') {
         return;
     }
     if (!shouldSample(effectivePolicy?.sampleRate)) {
@@ -247,7 +247,7 @@ export function applyHubProviderOutboundPolicy(options) {
     }
     const normalizedProviderProtocol = normalizeHubProviderProtocol(options.providerProtocol);
     const compatibilityProfile = typeof options.compatibilityProfile === 'string' ? options.compatibilityProfile.trim().toLowerCase() : '';
-    if (compatibilityProfile === 'chat:deepseek-web') {
+    if (compatibilityProfile === 'chat:deepseek-web' || compatibilityProfile === 'chat:qwenchat-web') {
         return options.payload;
     }
     const result = applyProviderOutboundPolicy(normalizedProviderProtocol, options.payload);

package/node_modules/@jsonstudio/llms/dist/conversion/hub/process/chat-process-pending-tool-sync.js

@@ -3,19 +3,34 @@ import { analyzePendingToolSync } from '../../../router/virtual-router/engine-se
 function readString(value) {
     return typeof value === 'string' ? value : undefined;
 }
-function resolveSessionIdForPending(metadata, request) {
-    const candidate = readString(metadata.sessionId) ?? readString(request.metadata?.sessionId);
-    return candidate && candidate.trim() ? candidate.trim() : null;
+function resolvePendingSessionCandidates(metadata, request) {
+    const candidates = [
+        readString(metadata.sessionId),
+        readString(request.metadata?.sessionId),
+        readString(metadata.conversationId),
+        readString(request.metadata?.conversationId)
+    ]
+        .filter((value) => typeof value === 'string' && value.trim().length > 0)
+        .map((value) => value.trim());
+    return Array.from(new Set(candidates));
 }
 export async function maybeInjectPendingServerToolResultsAfterClientTools(request, metadata, deps = {}) {
     const loadFn = deps.loadPendingServerToolInjectionFn ?? loadPendingServerToolInjection;
     const clearFn = deps.clearPendingServerToolInjectionFn ?? clearPendingServerToolInjection;
     const analyzeFn = deps.analyzePendingToolSyncFn ?? analyzePendingToolSync;
-    const sessionId = resolveSessionIdForPending(metadata, request);
-    if (!sessionId) {
+    const sessionCandidates = resolvePendingSessionCandidates(metadata, request);
+    if (!sessionCandidates.length) {
         return request;
     }
-    const pending = await loadFn(sessionId);
+    let loadedSessionId = null;
+    let pending = null;
+    for (const sessionId of sessionCandidates) {
+        pending = await loadFn(sessionId);
+        if (pending) {
+            loadedSessionId = sessionId;
+            break;
+        }
+    }
     if (!pending) {
         return request;
     }
@@ -43,7 +58,9 @@ export async function maybeInjectPendingServerToolResultsAfterClientTools(reques
     const nextMessages = messages.slice();
     nextMessages.splice(analysis.insertAt + 1, 0, ...inject);
     try {
-        await clearFn(sessionId);
+        if (loadedSessionId) {
+            await clearFn(loadedSessionId);
+        }
     }
     catch {
         // best-effort