@jsonstudio/rcc 0.90.814 → 0.90.872

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

package/node_modules/@jsonstudio/llms/dist/conversion/hub/response/provider-response.js

@@ -14,7 +14,7 @@ import { runRespProcessStage3ServerToolOrchestration } from '../pipeline/stages/
 import { runRespOutboundStage1ClientRemap } from '../pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js';
 import { runRespOutboundStage2SseStream } from '../pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.js';
 import { applyResponseBlacklistWithNative } from '../../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
-import { measureHubStage } from '../pipeline/hub-stage-timing.js';
+import { measureHubStage, peekHubStageTopSummary } from '../pipeline/hub-stage-timing.js';
 import { recordResponsesResponse } from '../../shared/responses-conversation-store.js';
 import { saveChatProcessSessionActualUsage } from '../process/chat-process-session-usage.js';
 import { coerceClientPayloadToCanonicalChatCompletionOrThrow, maybeCommitClockReservationFromContext, resolveProviderResponseContextSignals } from './provider-response-helpers.js';
@@ -47,6 +47,94 @@ const INTERNAL_POLICY_DEBUG_BLACKLIST_PATHS = [
     '__responses_passthrough',
     'anthropicToolNameMap'
 ];
+function normalizeHubStageTopEntries(raw) {
+    if (!Array.isArray(raw) || raw.length === 0) {
+        return [];
+    }
+    return raw
+        .map((entry) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            return null;
+        }
+        const record = entry;
+        const stage = typeof record.stage === 'string' ? record.stage.trim() : '';
+        const totalMs = typeof record.totalMs === 'number' && Number.isFinite(record.totalMs)
+            ? Math.max(0, Math.round(record.totalMs))
+            : undefined;
+        if (!stage || totalMs === undefined) {
+            return null;
+        }
+        const count = typeof record.count === 'number' && Number.isFinite(record.count)
+            ? Math.max(0, Math.floor(record.count))
+            : undefined;
+        const avgMs = typeof record.avgMs === 'number' && Number.isFinite(record.avgMs)
+            ? Math.max(0, Math.round(record.avgMs))
+            : undefined;
+        const maxMs = typeof record.maxMs === 'number' && Number.isFinite(record.maxMs)
+            ? Math.max(0, Math.round(record.maxMs))
+            : undefined;
+        return {
+            stage,
+            totalMs,
+            ...(count !== undefined ? { count } : {}),
+            ...(avgMs !== undefined ? { avgMs } : {}),
+            ...(maxMs !== undefined ? { maxMs } : {})
+        };
+    })
+        .filter((entry) => Boolean(entry));
+}
+function mergeHubStageTopEntries(baseEntries, appendEntries) {
+    if (baseEntries.length === 0) {
+        return appendEntries;
+    }
+    if (appendEntries.length === 0) {
+        return baseEntries;
+    }
+    const merged = new Map();
+    const apply = (entry) => {
+        const existing = merged.get(entry.stage);
+        if (!existing) {
+            merged.set(entry.stage, { ...entry });
+            return;
+        }
+        const totalMs = Math.max(0, Math.round((existing.totalMs ?? 0) + (entry.totalMs ?? 0)));
+        const count = Math.max(0, Math.round((existing.count ?? 0) + (entry.count ?? 0)));
+        const maxMs = Math.max(existing.maxMs ?? 0, entry.maxMs ?? 0, entry.totalMs ?? 0);
+        merged.set(entry.stage, {
+            stage: entry.stage,
+            totalMs,
+            ...(count > 0 ? { count } : {}),
+            ...(count > 0 ? { avgMs: Math.max(0, Math.round(totalMs / count)) } : {}),
+            ...(maxMs > 0 ? { maxMs } : {})
+        });
+    };
+    for (const item of baseEntries) {
+        apply(item);
+    }
+    for (const item of appendEntries) {
+        apply(item);
+    }
+    return Array.from(merged.values()).sort((a, b) => b.totalMs - a.totalMs);
+}
+function attachHubStageTopToContext(context, requestId) {
+    if (!requestId || requestId === 'unknown') {
+        return;
+    }
+    const latest = normalizeHubStageTopEntries(peekHubStageTopSummary(requestId, { topN: 12, minMs: 1 }));
+    if (latest.length === 0) {
+        return;
+    }
+    const contextRecord = context;
+    const rt = contextRecord.__rt && typeof contextRecord.__rt === 'object' && !Array.isArray(contextRecord.__rt)
+        ? contextRecord.__rt
+        : {};
+    const existing = normalizeHubStageTopEntries(rt.hubStageTop);
+    const merged = mergeHubStageTopEntries(existing, latest);
+    contextRecord.__rt = {
+        ...rt,
+        hubStageTop: merged
+    };
+}
 export async function convertProviderResponse(options) {
     const requestId = options.context.requestId || 'unknown';
     const contextSignals = resolveProviderResponseContextSignals(options.context, options.entryEndpoint);
@@ -265,6 +353,7 @@ export async function convertProviderResponse(options) {
             hasBody: Boolean(value.body)
         })
     });
+    attachHubStageTopToContext(options.context, requestId);
     // Commit scheduled-task delivery only after a successful client payload/stream is prepared.
     await maybeCommitClockReservationFromContext(options.context);
     try {

package/node_modules/@jsonstudio/llms/dist/conversion/hub/snapshot-recorder.d.ts

@@ -4,6 +4,7 @@ export interface SnapshotStageRecorderOptions {
     context: AdapterContext;
     endpoint: string;
 }
+export declare function trimSnapshotHotpathPayloadForNative(stage: string, payload: unknown): unknown;
 export declare class SnapshotStageRecorder implements StageRecorder {
     private readonly options;
     private readonly writer?;