@jsonstudio/rcc 0.90.814 → 0.90.876

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/operation-table-runner.js

@@ -10,7 +10,10 @@ const INBOUND_BRIDGE_SPECS = {
     'gemini-chat': { protocol: 'gemini-chat', stage: 'request_inbound', messages: 'chat_envelope' }
 };
 const OUTBOUND_BRIDGE_SPECS = {
-    'openai-chat': { protocol: 'openai-chat', stage: 'request_outbound', messages: 'format_payload_messages', includeCapturedToolResults: true },
+    // openai-chat outbound post-map hooks do not write back `state.messages` into payload.
+    // Feeding full payload.messages here only adds O(n) scan cost on large histories.
+    // Keep hooks metadata-only by not passing message arrays.
+    'openai-chat': { protocol: 'openai-chat', stage: 'request_outbound', messages: 'none', includeCapturedToolResults: true },
     // Keep parity: openai-responses outbound actions should not touch normalized messages.
     'openai-responses': { protocol: 'openai-responses', stage: 'request_outbound', messages: 'none', moduleType: 'openai-responses' },
     'anthropic-messages': { protocol: 'anthropic-messages', stage: 'request_outbound', messages: 'none', includeCapturedToolResults: true },
@@ -41,24 +44,82 @@ function buildCapturedToolResults(toolOutputs) {
         name: entry.name
     }));
 }
-function applyBridgePolicy(spec, options) {
-    const bridgePolicy = resolveBridgePolicy({ protocol: spec.protocol, moduleType: spec.moduleType ?? spec.protocol });
-    const actions = resolvePolicyActions(bridgePolicy, spec.stage);
+function hasToolSignalsInMessages(messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return false;
+    }
+    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 > 0) {
+            return true;
+        }
+        const toolCalls = message.tool_calls;
+        if (Array.isArray(toolCalls) && toolCalls.length > 0) {
+            return true;
+        }
+    }
+    return false;
+}
+function filterToolOnlyActionsWhenNoToolSignals(stage, actions, messages) {
     if (!actions?.length) {
-        return;
+        return actions;
     }
-    const metadata = options.chatEnvelope.metadata;
+    if (stage !== 'request_outbound' && stage !== 'request_inbound') {
+        return actions;
+    }
+    if (hasToolSignalsInMessages(messages)) {
+        return actions;
+    }
+    const toolOnlyActions = new Set([
+        'tools.capture-results',
+        '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);
+    });
+}
+function applyBridgePolicy(spec, options) {
+    const bridgePolicy = resolveBridgePolicy({ protocol: spec.protocol, moduleType: spec.moduleType ?? spec.protocol });
+    const resolvedActions = resolvePolicyActions(bridgePolicy, spec.stage);
     const messages = spec.messages === 'chat_envelope'
         ? options.chatEnvelope.messages
         : spec.messages === 'format_payload_messages'
             ? extractPayloadMessages(options.payload)
             : undefined;
+    const actions = filterToolOnlyActionsWhenNoToolSignals(spec.stage, resolvedActions, messages);
+    if (!actions?.length) {
+        return;
+    }
+    const metadata = options.chatEnvelope.metadata;
+    const rawRequestForActionState = (() => {
+        if (spec.messages !== 'format_payload_messages') {
+            return options.payload;
+        }
+        if (!messages || !Array.isArray(messages) || messages.length === 0) {
+            return options.payload;
+        }
+        // Performance stop-bleed: avoid duplicating a very large messages[] payload in both
+        // `state.messages` and `state.rawRequest.messages`. Bridge actions still receive the
+        // canonical messages via `state.messages`.
+        const compact = { ...options.payload };
+        delete compact.messages;
+        return compact;
+    })();
     const capturedToolResults = spec.includeCapturedToolResults
         ? buildCapturedToolResults(options.chatEnvelope.toolOutputs)
         : undefined;
     const actionState = createBridgeActionState({
         ...(messages ? { messages } : {}),
-        rawRequest: options.payload,
+        rawRequest: rawRequestForActionState,
         metadata,
         ...(capturedToolResults ? { capturedToolResults } : {})
     });

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/anthropic-mapper-from-chat.js

@@ -1,10 +1,88 @@
 import { isJsonObject, jsonClone } from '../../types/json.js';
 import { buildAnthropicRequestFromOpenAIChat } from '../../../codecs/anthropic-openai-codec.js';
+import { buildAnthropicFromOpenAIChatWithNative } from '../../../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
 import { encodeMetadataPassthrough } from '../../../metadata-passthrough.js';
+import { isHubStageTimingDetailEnabled, logHubStageTiming } from '../../pipeline/hub-stage-timing.js';
 import { applyEffortBudget, buildAnthropicThinkingFromConfig, mergeAnthropicOutputConfig, mergeAnthropicThinkingConfig, normalizeAnthropicThinkingConfigFromUnknown, resolveConfiguredAnthropicThinkingBudgets, resolveConfiguredAnthropicThinkingConfig } from './anthropic-thinking-config.js';
 import { appendDroppedFieldAudit, appendLossyFieldAudit, hasExplicitEmptyToolsSemantics, isResponsesOrigin, } from './anthropic-semantics-audit.js';
 import { ANTHROPIC_TOP_LEVEL_FIELDS, PASSTHROUGH_METADATA_PREFIX, PASSTHROUGH_PARAMETERS, RESPONSES_DROPPED_PARAMETER_KEYS, sanitizeAnthropicPayload, } from './anthropic-mapper-config.js';
+const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
+const FALSY = new Set(['0', 'false', 'no', 'off']);
+const DEFAULT_HEAVY_INPUT_THRESHOLD = 120_000;
+function readBooleanEnv(names, fallback) {
+    for (const name of names) {
+        const raw = process.env[name];
+        if (raw === undefined) {
+            continue;
+        }
+        const normalized = String(raw).trim().toLowerCase();
+        if (TRUTHY.has(normalized)) {
+            return true;
+        }
+        if (FALSY.has(normalized)) {
+            return false;
+        }
+    }
+    return fallback;
+}
+function readPositiveIntEnv(names, fallback) {
+    for (const name of names) {
+        const raw = process.env[name];
+        if (raw === undefined) {
+            continue;
+        }
+        const parsed = Number.parseInt(String(raw).trim(), 10);
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return parsed;
+        }
+    }
+    return fallback;
+}
+function shouldUseNativeBuild(ctx) {
+    const enabled = readBooleanEnv([
+        'ROUTECODEX_HUB_FASTPATH_ANTHROPIC_NATIVE_BUILD',
+        'RCC_HUB_FASTPATH_ANTHROPIC_NATIVE_BUILD',
+        // backward-compatible manual knob
+        'ROUTECODEX_HUB_ANTHROPIC_NATIVE_BUILD',
+        'RCC_HUB_ANTHROPIC_NATIVE_BUILD',
+    ], false);
+    if (!enabled) {
+        return false;
+    }
+    const threshold = readPositiveIntEnv([
+        'ROUTECODEX_HUB_FASTPATH_INPUT_TOKEN_THRESHOLD',
+        'RCC_HUB_FASTPATH_INPUT_TOKEN_THRESHOLD',
+    ], DEFAULT_HEAVY_INPUT_THRESHOLD);
+    const rt = ctx.__rt;
+    if (rt &&
+        typeof rt === 'object' &&
+        rt.hubFastpathHeavyInput === true) {
+        return true;
+    }
+    const estimatedInputTokens = ctx.estimatedInputTokens;
+    return (typeof estimatedInputTokens === 'number' &&
+        Number.isFinite(estimatedInputTokens) &&
+        estimatedInputTokens >= threshold);
+}
+function hasAnthropicSystemSemantic(chat) {
+    try {
+        const sysNode = chat.semantics && typeof chat.semantics === 'object'
+            ? chat.semantics.system
+            : undefined;
+        if (!sysNode || typeof sysNode !== 'object' || Array.isArray(sysNode)) {
+            return false;
+        }
+        return Object.prototype.hasOwnProperty.call(sysNode, 'blocks');
+    }
+    catch {
+        return false;
+    }
+}
 export function buildAnthropicFormatEnvelopeFromChat(chat, ctx) {
+    const requestId = typeof ctx.requestId === 'string' && ctx.requestId.trim().length
+        ? ctx.requestId
+        : 'unknown';
+    const forceDetailLog = isHubStageTimingDetailEnabled();
     const model = chat.parameters?.model;
     if (typeof model !== 'string' || !model.trim()) {
         throw new Error('ChatEnvelope.parameters.model is required for anthropic-messages outbound conversion');
@@ -114,15 +192,72 @@ export function buildAnthropicFormatEnvelopeFromChat(chat, ctx) {
     catch {
         // ignore
     }
-    const payloadSource = buildAnthropicRequestFromOpenAIChat(baseRequest);
-    const payload = sanitizeAnthropicPayload(JSON.parse(JSON.stringify(payloadSource)));
+    const useNativeBuild = shouldUseNativeBuild(ctx);
+    let payloadSource;
+    if (useNativeBuild) {
+        logHubStageTiming(requestId, 'req_outbound.anthropic.build_request_native', 'start');
+        const nativeBuildStartedAt = Date.now();
+        try {
+            payloadSource = buildAnthropicFromOpenAIChatWithNative(baseRequest, {
+                requestId: typeof ctx.requestId === 'string' && ctx.requestId.trim().length
+                    ? ctx.requestId
+                    : undefined,
+                entryEndpoint: typeof ctx.entryEndpoint === 'string' && ctx.entryEndpoint.trim().length
+                    ? ctx.entryEndpoint
+                    : undefined,
+            });
+            if (hasAnthropicSystemSemantic(chat) &&
+                !Object.prototype.hasOwnProperty.call(payloadSource, 'system')) {
+                throw new Error('native_missing_system_semantic_replay');
+            }
+            logHubStageTiming(requestId, 'req_outbound.anthropic.build_request_native', 'completed', {
+                elapsedMs: Date.now() - nativeBuildStartedAt,
+                forceLog: forceDetailLog,
+            });
+        }
+        catch {
+            logHubStageTiming(requestId, 'req_outbound.anthropic.build_request_native', 'completed', {
+                elapsedMs: Date.now() - nativeBuildStartedAt,
+                forceLog: true,
+                fallbackToJs: true,
+            });
+            logHubStageTiming(requestId, 'req_outbound.anthropic.build_request_js_fallback', 'start');
+            const jsFallbackStartedAt = Date.now();
+            payloadSource = buildAnthropicRequestFromOpenAIChat(baseRequest, {
+                requestId,
+            });
+            logHubStageTiming(requestId, 'req_outbound.anthropic.build_request_js_fallback', 'completed', {
+                elapsedMs: Date.now() - jsFallbackStartedAt,
+                forceLog: forceDetailLog,
+            });
+        }
+    }
+    else {
+        logHubStageTiming(requestId, 'req_outbound.anthropic.build_request_js', 'start');
+        const jsBuildStartedAt = Date.now();
+        payloadSource = buildAnthropicRequestFromOpenAIChat(baseRequest, {
+            requestId,
+        });
+        logHubStageTiming(requestId, 'req_outbound.anthropic.build_request_js', 'completed', {
+            elapsedMs: Date.now() - jsBuildStartedAt,
+            forceLog: forceDetailLog,
+        });
+    }
+    logHubStageTiming(requestId, 'req_outbound.anthropic.payload_sanitize', 'start');
+    const sanitizeStartedAt = Date.now();
+    const payload = sanitizeAnthropicPayload({
+        ...payloadSource,
+    });
     if (baseRequest.thinking !== undefined) {
         payload.thinking = jsonClone(baseRequest.thinking);
     }
     if (baseRequest.output_config !== undefined) {
         payload.output_config = jsonClone(baseRequest.output_config);
     }
-    sanitizeAnthropicPayload(payload);
+    logHubStageTiming(requestId, 'req_outbound.anthropic.payload_sanitize', 'completed', {
+        elapsedMs: Date.now() - sanitizeStartedAt,
+        forceLog: forceDetailLog,
+    });
     return {
         protocol: 'anthropic-messages',
         direction: 'response',

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/hub-pipeline-chat-process-request-utils.js

@@ -3,6 +3,7 @@ import { buildPassthroughAuditWithNative, readResponsesResumeFromRequestSemantic
 import { readRuntimeMetadata } from "../../runtime-metadata.js";
 import { computeRequestTokens } from "../../../router/virtual-router/token-estimator.js";
 import { estimateSessionBoundTokens } from "../process/chat-process-session-usage.js";
+import { isHeavyInputFastpathEnabled, markHeavyInputFastpath, resolveHeavyInputTokenThreshold, roughEstimateInputTokensFromRequest, } from "./hub-pipeline-heavy-input-fastpath.js";
 export function sanitizeStandardizedRequestMessages(standardizedRequest) {
     return {
         ...standardizedRequest,
@@ -37,12 +38,35 @@ export function resolveActiveProcessModeAndAudit(args) {
 export function estimateInputTokensForWorkingRequest(args) {
     const { workingRequest, normalizedMetadata } = args;
     try {
+        const fastpathEnabled = isHeavyInputFastpathEnabled();
+        const threshold = resolveHeavyInputTokenThreshold();
+        if (fastpathEnabled && threshold > 0) {
+            const roughEstimate = roughEstimateInputTokensFromRequest(workingRequest);
+            if (roughEstimate >= threshold) {
+                if (normalizedMetadata && typeof normalizedMetadata === "object") {
+                    normalizedMetadata.estimatedInputTokens = roughEstimate;
+                    markHeavyInputFastpath({
+                        metadata: normalizedMetadata,
+                        estimatedInputTokens: roughEstimate,
+                        reason: "rough_estimate",
+                    });
+                }
+                return;
+            }
+        }
         const estimatedTokens = estimateSessionBoundTokens(workingRequest, normalizedMetadata) ?? computeRequestTokens(workingRequest, "");
         if (typeof estimatedTokens === "number" &&
             Number.isFinite(estimatedTokens) &&
             estimatedTokens > 0) {
             if (normalizedMetadata && typeof normalizedMetadata === "object") {
                 normalizedMetadata.estimatedInputTokens = estimatedTokens;
+                if (fastpathEnabled && estimatedTokens >= threshold) {
+                    markHeavyInputFastpath({
+                        metadata: normalizedMetadata,
+                        estimatedInputTokens: estimatedTokens,
+                        reason: "full_estimate",
+                    });
+                }
             }
         }
     }

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/hub-pipeline-execute-chat-process-entry.js

@@ -1,4 +1,5 @@
 import { shouldRecordSnapshots } from "../../snapshot-utils.js";
+import { ensureRuntimeMetadata } from "../../runtime-metadata.js";
 import { REQUEST_STAGE_HOOKS } from "./hub-pipeline-stage-hooks.js";
 import { buildReqInboundSkippedNodeWithNative, coerceStandardizedRequestFromPayloadWithNative, findMappableSemanticsKeysWithNative, liftResponsesResumeIntoSemanticsWithNative, prepareRuntimeMetadataForServertoolsWithNative, syncResponsesContextFromCanonicalMessagesWithNative, } from "../../../router/virtual-router/engine-selection/native-hub-pipeline-orchestration-semantics.js";
 import { runReqProcessStage1ToolGovernance } from "./stages/req_process/req_process_stage1_tool_governance/index.js";
@@ -7,6 +8,7 @@ import { deriveWorkingRequestFlags, estimateInputTokensForWorkingRequest, propag
 import { annotatePassthroughAuditSkipped, appendPassthroughGovernanceSkippedNode, appendToolGovernanceNodeResult, propagateClockReservationToMetadata, } from "./hub-pipeline-chat-process-governance-utils.js";
 import { createSnapshotRecorder } from "../snapshot-recorder.js";
 import { executeRouteAndBuildOutbound } from "./hub-pipeline-route-and-outbound.js";
+import { peekHubStageTopSummary } from "./hub-stage-timing.js";
 export async function executeChatProcessEntryPipeline(args) {
     const { normalized, routerEngine, config } = args;
     const hooks = REQUEST_STAGE_HOOKS[normalized.providerProtocol];
@@ -119,7 +121,6 @@ export async function executeChatProcessEntryPipeline(args) {
         normalizedMetadata: normalized.metadata ??
             (normalized.metadata = {}),
     });
-    const normalizedMeta = normalized.metadata;
     // responsesResume is a client-protocol semantic (/v1/responses tool loop) and must live in chat.semantics.
     // Do not read it from metadata once entering chat_process.
     const { responsesResume, hasImageAttachment, serverToolRequired } = deriveWorkingRequestFlags(workingRequest);
@@ -145,6 +146,11 @@ export async function executeChatProcessEntryPipeline(args) {
             enabled: false,
         },
     });
+    const hubStageTop = peekHubStageTopSummary(normalized.id);
+    if (hubStageTop.length) {
+        const rt = ensureRuntimeMetadata(outbound.metadata);
+        rt.hubStageTop = hubStageTop;
+    }
     return {
         requestId: normalized.id,
         providerPayload: outbound.providerPayload,

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

@@ -1,5 +1,7 @@
 import { executeRequestStageInbound, } from "./hub-pipeline-execute-request-stage-inbound.js";
 import { executeRouteAndBuildOutbound, } from "./hub-pipeline-route-and-outbound.js";
+import { ensureRuntimeMetadata } from "../../runtime-metadata.js";
+import { peekHubStageTopSummary } from "./hub-stage-timing.js";
 export async function executeRequestStagePipeline(args) {
     const { normalized, hooks, routerEngine, config } = args;
     const inbound = await executeRequestStageInbound({
@@ -30,6 +32,11 @@ export async function executeRequestStagePipeline(args) {
             requestId: normalized.id,
         },
     });
+    const hubStageTop = peekHubStageTopSummary(normalized.id);
+    if (hubStageTop.length) {
+        const rt = ensureRuntimeMetadata(outbound.metadata);
+        rt.hubStageTop = hubStageTop;
+    }
     return {
         requestId: normalized.id,
         providerPayload: outbound.providerPayload,

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/hub-pipeline-heavy-input-fastpath.d.ts

@@ -0,0 +1,24 @@
+import type { ProcessedRequest, StandardizedRequest } from "../types/standardized.js";
+export declare function isHeavyInputFastpathEnabled(): boolean;
+export declare function shouldUseHeavyInputFastpath(metadata?: Record<string, unknown>): {
+    enabled: boolean;
+    hit: boolean;
+    threshold: number;
+    estimatedInputTokens?: number;
+};
+export declare function markHeavyInputFastpath(options: {
+    metadata?: Record<string, unknown>;
+    estimatedInputTokens?: number;
+    reason: "rough_estimate" | "full_estimate" | "metadata_threshold";
+}): void;
+export declare function buildCapturedChatRequestInput(args: {
+    workingRequest: StandardizedRequest | ProcessedRequest;
+    normalizedMetadata?: Record<string, unknown>;
+}): {
+    model?: unknown;
+    messages?: unknown;
+    tools?: unknown;
+    parameters?: unknown;
+};
+export declare function roughEstimateInputTokensFromRequest(request: StandardizedRequest | ProcessedRequest): number;
+export declare function resolveHeavyInputTokenThreshold(): number;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/hub-pipeline-heavy-input-fastpath.js

@@ -0,0 +1,203 @@
+import { ensureRuntimeMetadata, readRuntimeMetadata } from "../../runtime-metadata.js";
+const TRUTHY = new Set(["1", "true", "yes", "on"]);
+const FALSY = new Set(["0", "false", "no", "off"]);
+const DEFAULT_INPUT_TOKEN_THRESHOLD = 120_000;
+function readBooleanEnv(names, fallback) {
+    for (const name of names) {
+        const raw = process.env[name];
+        if (raw === undefined) {
+            continue;
+        }
+        const normalized = String(raw).trim().toLowerCase();
+        if (TRUTHY.has(normalized)) {
+            return true;
+        }
+        if (FALSY.has(normalized)) {
+            return false;
+        }
+    }
+    return fallback;
+}
+function readPositiveIntEnv(names, fallback) {
+    for (const name of names) {
+        const raw = process.env[name];
+        if (raw === undefined) {
+            continue;
+        }
+        const parsed = Number.parseInt(String(raw).trim(), 10);
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return parsed;
+        }
+    }
+    return fallback;
+}
+function getConfig() {
+    return {
+        enabled: readBooleanEnv([
+            "ROUTECODEX_HUB_FASTPATH_HEAVY_INPUT",
+            "RCC_HUB_FASTPATH_HEAVY_INPUT",
+        ], true),
+        inputTokenThreshold: readPositiveIntEnv([
+            "ROUTECODEX_HUB_FASTPATH_INPUT_TOKEN_THRESHOLD",
+            "RCC_HUB_FASTPATH_INPUT_TOKEN_THRESHOLD",
+        ], DEFAULT_INPUT_TOKEN_THRESHOLD),
+    };
+}
+export function isHeavyInputFastpathEnabled() {
+    return getConfig().enabled;
+}
+function readEstimatedInputTokens(metadata) {
+    if (!metadata || typeof metadata !== "object") {
+        return undefined;
+    }
+    const candidate = typeof metadata.estimatedInputTokens === "number" &&
+        Number.isFinite(metadata.estimatedInputTokens)
+        ? Math.max(0, Math.floor(metadata.estimatedInputTokens))
+        : undefined;
+    if (candidate && candidate > 0) {
+        return candidate;
+    }
+    const rt = readRuntimeMetadata(metadata);
+    const rtCandidate = typeof rt
+        ?.hubFastpathEstimatedInputTokens === "number" &&
+        Number.isFinite(rt.hubFastpathEstimatedInputTokens)
+        ? Math.max(0, Math.floor(rt.hubFastpathEstimatedInputTokens))
+        : undefined;
+    return rtCandidate && rtCandidate > 0 ? rtCandidate : undefined;
+}
+export function shouldUseHeavyInputFastpath(metadata) {
+    const config = getConfig();
+    const estimatedInputTokens = readEstimatedInputTokens(metadata);
+    const rt = metadata ? readRuntimeMetadata(metadata) : undefined;
+    const runtimeForced = rt &&
+        typeof rt.hubFastpathHeavyInput ===
+            "boolean" &&
+        rt.hubFastpathHeavyInput === true;
+    const hit = config.enabled &&
+        (runtimeForced ||
+            (typeof estimatedInputTokens === "number" &&
+                estimatedInputTokens >= config.inputTokenThreshold));
+    return {
+        enabled: config.enabled,
+        hit,
+        threshold: config.inputTokenThreshold,
+        ...(typeof estimatedInputTokens === "number"
+            ? { estimatedInputTokens }
+            : {}),
+    };
+}
+export function markHeavyInputFastpath(options) {
+    const { metadata, estimatedInputTokens, reason } = options;
+    if (!metadata || typeof metadata !== "object") {
+        return;
+    }
+    const config = getConfig();
+    if (!config.enabled) {
+        return;
+    }
+    const rt = ensureRuntimeMetadata(metadata);
+    rt.hubFastpathHeavyInput = true;
+    rt.hubFastpathReason = reason;
+    rt.hubFastpathInputTokenThreshold =
+        config.inputTokenThreshold;
+    if (typeof estimatedInputTokens === "number" &&
+        Number.isFinite(estimatedInputTokens) &&
+        estimatedInputTokens > 0) {
+        const rounded = Math.max(1, Math.floor(estimatedInputTokens));
+        metadata.estimatedInputTokens = rounded;
+        rt.hubFastpathEstimatedInputTokens = rounded;
+    }
+}
+export function buildCapturedChatRequestInput(args) {
+    const { workingRequest, normalizedMetadata } = args;
+    const fastpath = shouldUseHeavyInputFastpath(normalizedMetadata);
+    if (fastpath.hit) {
+        markHeavyInputFastpath({
+            metadata: normalizedMetadata,
+            estimatedInputTokens: fastpath.estimatedInputTokens,
+            reason: "metadata_threshold",
+        });
+    }
+    // Hard rule: captured request must preserve full semantic payload.
+    return {
+        model: workingRequest.model,
+        messages: workingRequest.messages,
+        tools: workingRequest.tools,
+        parameters: workingRequest.parameters,
+    };
+}
+function estimateContentChars(content, cap) {
+    if (cap <= 0 || content === undefined || content === null) {
+        return 0;
+    }
+    if (typeof content === "string") {
+        return Math.min(content.length, cap);
+    }
+    if (Array.isArray(content)) {
+        let used = 0;
+        for (const part of content) {
+            if (used >= cap) {
+                break;
+            }
+            if (typeof part === "string") {
+                used += Math.min(part.length, cap - used);
+                continue;
+            }
+            if (!part || typeof part !== "object") {
+                continue;
+            }
+            const record = part;
+            if (typeof record.text === "string") {
+                used += Math.min(record.text.length, cap - used);
+            }
+            else if (typeof record.input_text === "string") {
+                used += Math.min(record.input_text.length, cap - used);
+            }
+            else if (typeof record.output_text === "string") {
+                used += Math.min(record.output_text.length, cap - used);
+            }
+            else {
+                used += Math.min(64, cap - used);
+            }
+        }
+        return used;
+    }
+    return Math.min(64, cap);
+}
+export function roughEstimateInputTokensFromRequest(request) {
+    const config = getConfig();
+    let chars = 0;
+    const charCap = Math.max(config.inputTokenThreshold * 8, 16_384);
+    const messages = Array.isArray(request.messages) ? request.messages : [];
+    for (const message of messages) {
+        if (chars >= charCap) {
+            break;
+        }
+        if (!message || typeof message !== "object") {
+            chars += 16;
+            continue;
+        }
+        const record = message;
+        if (typeof record.role === "string") {
+            chars += Math.min(record.role.length, charCap - chars);
+        }
+        if (typeof record.name === "string") {
+            chars += Math.min(record.name.length, Math.max(0, charCap - chars));
+        }
+        if (typeof record.tool_call_id === "string") {
+            chars += Math.min(record.tool_call_id.length, Math.max(0, charCap - chars));
+        }
+        chars += estimateContentChars(record.content, Math.max(0, charCap - chars));
+        if (Array.isArray(record.tool_calls)) {
+            chars += Math.min(record.tool_calls.length * 128, Math.max(0, charCap - chars));
+        }
+    }
+    if (Array.isArray(request.tools)) {
+        chars += request.tools.length * 256;
+    }
+    const estimated = Math.max(Math.ceil(chars / 3.5), messages.length * 8 + (Array.isArray(request.tools) ? request.tools.length * 32 : 0));
+    return Math.max(1, Math.floor(estimated));
+}
+export function resolveHeavyInputTokenThreshold() {
+    return getConfig().inputTokenThreshold;
+}

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/hub-pipeline-route-and-outbound.js

@@ -1,4 +1,3 @@
-import { jsonClone } from "../types/json.js";
 import { runReqProcessStage2RouteSelect } from "./stages/req_process/req_process_stage2_route_select/index.js";
 import { buildAdapterContextFromNormalized } from "./hub-pipeline-adapter-context.js";
 import { extractSessionIdentifiersFromMetadata } from "./session-identifiers.js";
@@ -8,6 +7,7 @@ import { logHubStageTiming } from "./hub-stage-timing.js";
 import { shouldRecordSnapshots } from "../../snapshot-utils.js";
 import { createSnapshotRecorder } from "../snapshot-recorder.js";
 import { applyOutboundStreamPreferenceWithNative, applyHasImageAttachmentFlagWithNative, buildCapturedChatRequestSnapshotWithNative, buildHubPipelineResultMetadataWithNative, buildReqOutboundNodeResultWithNative, buildRouterMetadataInputWithNative, resolveOutboundStreamIntentWithNative, syncSessionIdentifiersToMetadataWithNative, } from "../../../router/virtual-router/engine-selection/native-hub-pipeline-orchestration-semantics.js";
+import { buildCapturedChatRequestInput } from "./hub-pipeline-heavy-input-fastpath.js";
 export async function executeRouteAndBuildOutbound(args) {
     const { normalized, hooks, routerEngine, config, nodeResults, inboundRecorder, activeProcessMode, responsesResume, serverToolRequired, hasImageAttachment, passthroughAudit, rawRequest, contextSnapshot, semanticMapper, effectivePolicy, shadowCompareBaselineMode, routeSelectTiming, } = args;
     let { workingRequest } = args;
@@ -16,6 +16,11 @@ export async function executeRouteAndBuildOutbound(args) {
     // 便于后续 AdapterContext（响应侧 servertool）也能访问到相同的 sessionId /
     // conversationId，用于 sticky-session 相关逻辑（例如 stopMessage）。
     const normalizedMetadata = normalized.metadata;
+    const routeRuntimeDirectives = normalizedMetadata &&
+        typeof normalizedMetadata.__rt === "object" &&
+        !Array.isArray(normalizedMetadata.__rt)
+        ? normalizedMetadata.__rt
+        : undefined;
     if (normalizedMetadata && typeof normalizedMetadata === "object") {
         const next = syncSessionIdentifiersToMetadataWithNative({
             metadata: normalizedMetadata,
@@ -43,6 +48,11 @@ export async function executeRouteAndBuildOutbound(args) {
         conversationId: sessionIdentifiers.conversationId,
         metadata: normalizedMetadata,
     });
+    if (routeRuntimeDirectives) {
+        metadataInput.__rt = {
+            ...routeRuntimeDirectives,
+        };
+    }
     if (routeSelectTiming?.enabled) {
         logHubStageTiming(routeSelectTiming.requestId ?? normalized.id, "req_process.stage2_route_select", "start");
     }
@@ -60,7 +70,8 @@ export async function executeRouteAndBuildOutbound(args) {
     try {
         const logger = (normalized.metadata &&
             normalized.metadata.logger);
-        if (logger &&
+        if (routeRuntimeDirectives?.disableVirtualRouterHitLog !== true &&
+            logger &&
             typeof logger.logVirtualRouterHit === "function" &&
             routing.decision?.routeName &&
             routing.target?.providerKey) {
@@ -141,16 +152,10 @@ export async function executeRouteAndBuildOutbound(args) {
     // 注意：这里不再根据 processMode(passthrough/chat) 做分支判断——即使某些
     // route 将 processMode 标记为 passthrough，我们仍然需要保留一次规范化后的
     // Chat 请求快照，供 stopMessage 等被动触发型 servertool 在响应阶段使用。
-    const capturedChatRequest = buildCapturedChatRequestSnapshotWithNative({
-        model: workingRequest.model,
-        messages: jsonClone(workingRequest.messages),
-        tools: workingRequest.tools
-            ? jsonClone(workingRequest.tools)
-            : workingRequest.tools,
-        parameters: workingRequest.parameters
-            ? jsonClone(workingRequest.parameters)
-            : workingRequest.parameters,
-    });
+    const capturedChatRequest = buildCapturedChatRequestSnapshotWithNative(buildCapturedChatRequestInput({
+        workingRequest,
+        normalizedMetadata: normalized.metadata,
+    }));
     const metadata = buildHubPipelineResultMetadataWithNative({
         normalized: {
             metadata: normalized.metadata,