@jsonstudio/rcc 0.90.814 → 0.90.876

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?;

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

@@ -1,5 +1,255 @@
 import { createSnapshotWriter } from '../snapshot-utils.js';
 import { normalizeSnapshotStagePayloadWithNative } from '../../router/virtual-router/engine-selection/native-snapshot-hooks.js';
+const SNAPSHOT_STRING_PREVIEW_CHARS = 240;
+const SNAPSHOT_ARRAY_PREVIEW_ITEMS = 2;
+const FORMAT_PARSE_STAGE_NAMES = new Set([
+    'req_inbound_stage1_format_parse',
+    'chat_process.req.stage1.format_parse'
+]);
+const TOOL_GOVERNANCE_STAGE_NAMES = new Set([
+    'req_process_stage1_tool_governance',
+    'chat_process.req.stage4.tool_governance'
+]);
+function clipSnapshotString(value) {
+    const text = String(value ?? '');
+    return text.length > SNAPSHOT_STRING_PREVIEW_CHARS
+        ? `${text.slice(0, SNAPSHOT_STRING_PREVIEW_CHARS)}…`
+        : text;
+}
+function summarizeScalar(value) {
+    if (typeof value === 'string') {
+        return clipSnapshotString(value);
+    }
+    if (value === null ||
+        value === undefined ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    return undefined;
+}
+function summarizeValuePreview(value, depth = 0) {
+    const scalar = summarizeScalar(value);
+    if (scalar !== undefined || value === null) {
+        return scalar;
+    }
+    if (Array.isArray(value)) {
+        if (depth >= 2) {
+            return { type: 'array', count: value.length };
+        }
+        const first = value.slice(0, SNAPSHOT_ARRAY_PREVIEW_ITEMS).map((entry) => summarizeValuePreview(entry, depth + 1));
+        const last = value.slice(-SNAPSHOT_ARRAY_PREVIEW_ITEMS).map((entry) => summarizeValuePreview(entry, depth + 1));
+        return {
+            type: 'array',
+            count: value.length,
+            first,
+            last
+        };
+    }
+    if (!value || typeof value !== 'object') {
+        return String(value);
+    }
+    const record = value;
+    const keys = Object.keys(record);
+    const preferredKeys = ['role', 'type', 'name', 'id', 'call_id', 'content', 'text', 'input', 'output', 'status'];
+    const preview = {};
+    for (const key of preferredKeys) {
+        if (key in record) {
+            preview[key] = summarizeValuePreview(record[key], depth + 1);
+        }
+    }
+    if (!Object.keys(preview).length) {
+        for (const key of keys.slice(0, 6)) {
+            preview[key] = summarizeValuePreview(record[key], depth + 1);
+        }
+    }
+    return {
+        type: 'object',
+        keys,
+        preview
+    };
+}
+function summarizeCollection(value) {
+    if (!Array.isArray(value)) {
+        return summarizeValuePreview(value);
+    }
+    return {
+        count: value.length,
+        preview: summarizeValuePreview(value)
+    };
+}
+function summarizeTools(value) {
+    if (!Array.isArray(value)) {
+        return summarizeValuePreview(value);
+    }
+    return {
+        count: value.length,
+        names: value
+            .map((tool) => {
+            if (!tool || typeof tool !== 'object') {
+                return null;
+            }
+            const node = tool;
+            if (typeof node.name === 'string' && node.name.trim()) {
+                return node.name.trim();
+            }
+            const fn = node.function;
+            if (fn && typeof fn === 'object' && typeof fn.name === 'string') {
+                return String(fn.name).trim();
+            }
+            return typeof node.type === 'string' ? node.type : null;
+        })
+            .filter((name) => Boolean(name))
+            .slice(0, 32)
+    };
+}
+function summarizeMetadata(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return summarizeValuePreview(value);
+    }
+    const metadata = value;
+    const summary = {};
+    for (const key of [
+        'requestId',
+        'clientRequestId',
+        'providerProtocol',
+        'endpoint',
+        'entryEndpoint',
+        'originalEndpoint',
+        'processMode',
+        'sessionId',
+        'conversationId',
+        'workdir',
+        'cwd',
+        'processedAt',
+        'stage',
+        'stream'
+    ]) {
+        if (key in metadata) {
+            summary[key] = summarizeValuePreview(metadata[key]);
+        }
+    }
+    if ('clientHeaders' in metadata) {
+        const headers = metadata.clientHeaders;
+        if (headers && typeof headers === 'object' && !Array.isArray(headers)) {
+            summary.clientHeaders = { keys: Object.keys(headers).sort() };
+        }
+        else {
+            summary.clientHeaders = summarizeValuePreview(headers);
+        }
+    }
+    if ('capturedContext' in metadata) {
+        summary.capturedContext = summarizeValuePreview(metadata.capturedContext);
+    }
+    if ('__rt' in metadata) {
+        summary.__rt = summarizeValuePreview(metadata.__rt);
+    }
+    if ('__raw_request_body' in metadata) {
+        const raw = metadata.__raw_request_body;
+        summary.__raw_request_body = {
+            omitted: true,
+            preview: summarizeValuePreview(raw, 1)
+        };
+    }
+    return summary;
+}
+function summarizeSemantics(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return summarizeValuePreview(value);
+    }
+    const semantics = value;
+    const summary = {};
+    if ('tools' in semantics) {
+        const tools = semantics.tools;
+        const toolsRecord = tools && typeof tools === 'object' && !Array.isArray(tools) ? tools : null;
+        summary.tools = toolsRecord
+            ? {
+                keys: Object.keys(toolsRecord).sort(),
+                toolNameAliasMap: summarizeValuePreview(toolsRecord.toolNameAliasMap, 1),
+                clientToolsRaw: summarizeTools(toolsRecord.clientToolsRaw)
+            }
+            : summarizeValuePreview(tools);
+    }
+    const responses = semantics.responses;
+    const responsesRecord = responses && typeof responses === 'object' && !Array.isArray(responses)
+        ? responses
+        : null;
+    if (responsesRecord) {
+        const context = responsesRecord.context;
+        const contextRecord = context && typeof context === 'object' && !Array.isArray(context)
+            ? context
+            : null;
+        summary.responses = contextRecord
+            ? {
+                context: {
+                    requestId: summarizeValuePreview(contextRecord.requestId),
+                    isChatPayload: summarizeValuePreview(contextRecord.isChatPayload),
+                    isResponsesPayload: summarizeValuePreview(contextRecord.isResponsesPayload),
+                    systemInstruction: summarizeValuePreview(contextRecord.systemInstruction),
+                    parameters: summarizeValuePreview(contextRecord.parameters, 1),
+                    input: summarizeCollection(contextRecord.input),
+                    __captured_tool_results: summarizeCollection(contextRecord.__captured_tool_results),
+                    toolsRaw: summarizeTools(contextRecord.toolsRaw),
+                    toolsNormalized: summarizeTools(contextRecord.toolsNormalized)
+                }
+            }
+            : summarizeValuePreview(responsesRecord);
+    }
+    return summary;
+}
+function buildFormatParseSnapshotSummary(payload) {
+    const envelope = payload.payload && typeof payload.payload === 'object' && !Array.isArray(payload.payload)
+        ? payload.payload
+        : null;
+    return {
+        __snapshot_summary: true,
+        stage: 'format_parse',
+        format: summarizeValuePreview(payload.format),
+        metadata: summarizeValuePreview(payload.metadata, 1),
+        payload: envelope
+            ? {
+                model: summarizeValuePreview(envelope.model),
+                include: summarizeValuePreview(envelope.include, 1),
+                stream: summarizeValuePreview(envelope.stream),
+                tool_choice: summarizeValuePreview(envelope.tool_choice),
+                max_output_tokens: summarizeValuePreview(envelope.max_output_tokens),
+                max_tokens: summarizeValuePreview(envelope.max_tokens),
+                input: summarizeCollection(envelope.input),
+                messages: summarizeCollection(envelope.messages),
+                tools: summarizeTools(envelope.tools)
+            }
+            : summarizeValuePreview(payload.payload, 1)
+    };
+}
+function buildToolGovernanceSnapshotSummary(payload) {
+    return {
+        __snapshot_summary: true,
+        stage: 'tool_governance',
+        model: summarizeValuePreview(payload.model),
+        stream: summarizeValuePreview(payload.stream),
+        tool_choice: summarizeValuePreview(payload.tool_choice),
+        parameters: summarizeValuePreview(payload.parameters, 1),
+        processed: summarizeValuePreview(payload.processed, 1),
+        processingMetadata: summarizeValuePreview(payload.processingMetadata, 1),
+        messages: summarizeCollection(payload.messages),
+        tools: summarizeTools(payload.tools),
+        metadata: summarizeMetadata(payload.metadata),
+        semantics: summarizeSemantics(payload.semantics)
+    };
+}
+export function trimSnapshotHotpathPayloadForNative(stage, payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return payload;
+    }
+    const record = payload;
+    if (FORMAT_PARSE_STAGE_NAMES.has(stage)) {
+        return buildFormatParseSnapshotSummary(record);
+    }
+    if (TOOL_GOVERNANCE_STAGE_NAMES.has(stage)) {
+        return buildToolGovernanceSnapshotSummary(record);
+    }
+    return payload;
+}
 export class SnapshotStageRecorder {
     options;
     writer;
@@ -21,7 +271,8 @@ export class SnapshotStageRecorder {
         if (!this.writer) {
             return;
         }
-        const normalized = normalizeSnapshotStagePayloadWithNative(stage, payload);
+        const trimmed = trimSnapshotHotpathPayloadForNative(stage, payload);
+        const normalized = normalizeSnapshotStagePayloadWithNative(stage, trimmed);
         if (!normalized) {
             return;
         }

package/node_modules/@jsonstudio/llms/dist/conversion/responses/responses-openai-bridge/utils.js

@@ -102,8 +102,10 @@ export function sanitizeCapturedResponsesInput(input) {
             if (!sanitizedName) {
                 continue;
             }
-            const next = jsonClone(entry);
-            next.name = sanitizedName;
+            const rawName = typeof entry.name === 'string' ? String(entry.name) : '';
+            const next = rawName === sanitizedName
+                ? entry
+                : { ...entry, name: sanitizedName };
             const callId = typeof next.call_id === 'string' ? String(next.call_id).trim() : '';
             if (callId) {
                 acceptedCallIds.add(callId);
@@ -117,7 +119,7 @@ export function sanitizeCapturedResponsesInput(input) {
                 continue;
             }
         }
-        out.push(jsonClone(entry));
+        out.push(entry);
     }
     return out;
 }

package/node_modules/@jsonstudio/llms/dist/conversion/responses/responses-openai-bridge.js

@@ -43,6 +43,43 @@ function filterRedundantResponsesReasoningAction(actions) {
         return name !== 'reasoning.extract';
     });
 }
+function hasToolSignalsInMessages(messages) {
+    for (const message of messages) {
+        if (!message || typeof message !== 'object') {
+            continue;
+        }
+        const role = typeof message.role === 'string' ? message.role.trim().toLowerCase() : '';
+        if (role === 'tool') {
+            return true;
+        }
+        if (typeof message.tool_call_id === 'string' && message.tool_call_id.trim().length) {
+            return true;
+        }
+        const toolCalls = message.tool_calls;
+        if (Array.isArray(toolCalls) && toolCalls.length > 0) {
+            return true;
+        }
+    }
+    return false;
+}
+function filterResponsesInboundActionsByPayloadHints(actions, messages) {
+    if (!actions?.length) {
+        return actions;
+    }
+    const hasToolSignals = hasToolSignalsInMessages(messages);
+    if (hasToolSignals) {
+        return actions;
+    }
+    const toolOnlyActions = new Set([
+        'tools.normalize-call-ids',
+        'compat.fix-apply-patch',
+        'tools.ensure-placeholders'
+    ]);
+    return actions.filter((action) => {
+        const name = typeof action?.name === 'string' ? action.name.trim().toLowerCase() : '';
+        return !toolOnlyActions.has(name);
+    });
+}
 export function captureResponsesContext(payload, dto) {
     const preservedInput = Array.isArray(payload.input)
         ? payload.input
@@ -71,9 +108,12 @@ export function captureResponsesContext(payload, dto) {
         captured.systemInstruction = payload.instructions;
     }
     if (captured.metadata && isJsonObject(captured.metadata)) {
-        const cloned = jsonClone(captured.metadata);
-        delete cloned.extraFields;
-        captured.metadata = cloned;
+        const rawMetadata = captured.metadata;
+        if (Object.prototype.hasOwnProperty.call(rawMetadata, 'extraFields')) {
+            const cloned = jsonClone(rawMetadata);
+            delete cloned.extraFields;
+            captured.metadata = cloned;
+        }
     }
     return captured;
 }
@@ -98,7 +138,7 @@ export function buildChatRequestFromResponses(payload, context) {
     });
     try {
         const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-responses', moduleType: 'openai-responses' });
-        const policyActions = filterRedundantResponsesReasoningAction(resolvePolicyActions(bridgePolicy, 'request_inbound'));
+        const policyActions = filterResponsesInboundActionsByPayloadHints(filterRedundantResponsesReasoningAction(resolvePolicyActions(bridgePolicy, 'request_inbound')), messages);
         if (policyActions?.length) {
             logHubStageTiming(requestId, 'req_inbound.responses.inbound_policy', 'start');
             const policyStart = Date.now();

package/node_modules/@jsonstudio/llms/dist/conversion/shared/anthropic-message-utils-openai-request.d.ts

@@ -1,3 +1,5 @@
 type Unknown = Record<string, unknown>;
-export declare function buildAnthropicRequestFromOpenAIChat(chatReq: unknown): Unknown;
+export declare function buildAnthropicRequestFromOpenAIChat(chatReq: unknown, options?: {
+    requestId?: string;
+}): Unknown;
 export {};

package/node_modules/@jsonstudio/llms/dist/conversion/shared/anthropic-message-utils-openai-request.js

@@ -1,8 +1,7 @@
-import { createBridgeActionState, runBridgeActionPipeline } from '../bridge-actions.js';
-import { resolveBridgePolicy, resolvePolicyActions } from '../bridge-policies.js';
 import { mapChatToolsToAnthropicTools } from './anthropic-message-utils-tool-schema.js';
 import { ProviderProtocolError } from '../provider-protocol-error.js';
 import { jsonClone } from '../hub/types/json.js';
+import { logHubStageTiming } from '../hub/pipeline/hub-stage-timing.js';
 import { parseLenientJsonishWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 import { isObject, normalizeShellLikeToolInput, requireSystemText, requireTrimmedString, sanitizeToolUseId } from './anthropic-message-utils-core.js';
 import { normalizeAnthropicToolChoice } from './anthropic-message-utils-openai-response.js';
@@ -22,30 +21,18 @@ const ANTHROPIC_TOP_LEVEL_FIELDS = new Set([
     'tool_choice',
     'thinking'
 ]);
-export function buildAnthropicRequestFromOpenAIChat(chatReq) {
+export function buildAnthropicRequestFromOpenAIChat(chatReq, options) {
     const requestBody = isObject(chatReq) ? chatReq : {};
+    const requestId = typeof options?.requestId === 'string' && options.requestId.trim().length
+        ? options.requestId.trim()
+        : 'unknown';
     const model = String(requestBody?.model || 'unknown');
     const messages = [];
-    try {
-        const bridgePolicy = resolveBridgePolicy({ protocol: 'anthropic-messages' });
-        const actions = resolvePolicyActions(bridgePolicy, 'request_outbound');
-        if (actions?.length && Array.isArray(requestBody.messages)) {
-            const actionState = createBridgeActionState({
-                messages: requestBody.messages,
-                rawRequest: requestBody
-            });
-            runBridgeActionPipeline({
-                stage: 'request_outbound',
-                actions,
-                protocol: bridgePolicy?.protocol ?? 'anthropic-messages',
-                moduleType: bridgePolicy?.moduleType ?? 'anthropic-messages',
-                state: actionState
-            });
-        }
-    }
-    catch {
-        // ignore policy errors
-    }
+    // IMPORTANT:
+    // The request_outbound bridge-policy pipeline was previously executed here, but
+    // its output state was never consumed by this builder. That made the whole pass
+    // pure overhead (large-message O(n) scans/clones) with zero semantic effect.
+    // To preserve payload semantics and stop latency bleed, we skip that no-op pass.
     const collectText = (val) => {
         if (!val)
             return '';
@@ -65,6 +52,8 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
     const mirrorShapes = extractMirrorShapesFromRequest(requestBody);
     let mirrorIndex = 0;
     const knownToolCallIds = new Set();
+    logHubStageTiming(requestId, 'req_outbound.anthropic.pre_scan_tool_calls', 'start');
+    const preScanStart = Date.now();
     for (const m of msgs) {
         if (!m || typeof m !== 'object')
             continue;
@@ -81,6 +70,9 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
             knownToolCallIds.add(id);
         }
     }
+    logHubStageTiming(requestId, 'req_outbound.anthropic.pre_scan_tool_calls', 'completed', {
+        elapsedMs: Date.now() - preScanStart
+    });
     const systemBlocks = [];
     const pushSystemBlock = (text) => {
         const trimmed = text.trim();
@@ -117,6 +109,8 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
     catch {
         // ignore system pre-scan errors
     }
+    logHubStageTiming(requestId, 'req_outbound.anthropic.map_messages', 'start');
+    const mapMessagesStart = Date.now();
     for (const m of msgs) {
         if (!m || typeof m !== 'object')
             continue;
@@ -253,6 +247,9 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
             messages.push({ role, content: contentNode });
         }
     }
+    logHubStageTiming(requestId, 'req_outbound.anthropic.map_messages', 'completed', {
+        elapsedMs: Date.now() - mapMessagesStart
+    });
     const out = { model };
     if (systemBlocks.length) {
         out.system = systemBlocks;