@jsonstudio/rcc 0.90.876 → 0.90.1270

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

@@ -5,198 +5,168 @@ const DEFAULT_INPUT_TOKEN_THRESHOLD = 120_000;
 function readBooleanEnv(names, fallback) {
     for (const name of names) {
         const raw = process.env[name];
-        if (raw === undefined) {
+        if (raw === undefined)
             continue;
-        }
         const normalized = String(raw).trim().toLowerCase();
-        if (TRUTHY.has(normalized)) {
+        if (TRUTHY.has(normalized))
             return true;
-        }
-        if (FALSY.has(normalized)) {
+        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) {
+        if (raw === undefined)
             continue;
-        }
         const parsed = Number.parseInt(String(raw).trim(), 10);
-        if (Number.isFinite(parsed) && parsed > 0) {
+        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),
+        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 }
-            : {}),
-    };
+    if (!isHeavyInputFastpathEnabled()) {
+        return false;
+    }
+    if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+        return false;
+    }
+    const record = metadata;
+    const rt = readRuntimeMetadata(record);
+    if (rt?.hubFastpathHeavyInput === true) {
+        return true;
+    }
+    const estimatedInputTokens = typeof record.estimatedInputTokens === "number" && Number.isFinite(record.estimatedInputTokens)
+        ? record.estimatedInputTokens
+        : typeof rt?.hubFastpathEstimatedInputTokens === "number" && Number.isFinite(rt.hubFastpathEstimatedInputTokens)
+            ? Number(rt.hubFastpathEstimatedInputTokens)
+            : undefined;
+    if (estimatedInputTokens === undefined) {
+        return false;
+    }
+    return estimatedInputTokens >= resolveHeavyInputTokenThreshold();
 }
 export function markHeavyInputFastpath(options) {
-    const { metadata, estimatedInputTokens, reason } = options;
-    if (!metadata || typeof metadata !== "object") {
+    if (!options || typeof options !== "object" || Array.isArray(options)) {
         return;
     }
-    const config = getConfig();
-    if (!config.enabled) {
+    const record = options;
+    const metadata = record.metadata && typeof record.metadata === "object" && !Array.isArray(record.metadata)
+        ? record.metadata
+        : undefined;
+    if (!metadata) {
         return;
     }
     const rt = ensureRuntimeMetadata(metadata);
     rt.hubFastpathHeavyInput = true;
+    const reason = typeof record.reason === "string" && record.reason.trim()
+        ? record.reason.trim()
+        : "heavy_input";
     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;
+    const estimatedInputTokens = typeof record.estimatedInputTokens === "number" && Number.isFinite(record.estimatedInputTokens)
+        ? Math.max(0, Math.floor(record.estimatedInputTokens))
+        : typeof metadata.estimatedInputTokens === "number" && Number.isFinite(metadata.estimatedInputTokens)
+            ? Math.max(0, Math.floor(Number(metadata.estimatedInputTokens)))
+            : undefined;
+    if (estimatedInputTokens !== undefined) {
+        metadata.estimatedInputTokens = estimatedInputTokens;
+        rt.hubFastpathEstimatedInputTokens = estimatedInputTokens;
     }
 }
 export function buildCapturedChatRequestInput(args) {
-    const { workingRequest, normalizedMetadata } = args;
-    const fastpath = shouldUseHeavyInputFastpath(normalizedMetadata);
-    if (fastpath.hit) {
+    const directRequest = args && typeof args === "object" && !Array.isArray(args)
+        ? args
+        : undefined;
+    if (!directRequest) {
+        return {};
+    }
+    const record = directRequest;
+    const workingRequest = record.workingRequest && typeof record.workingRequest === "object" && !Array.isArray(record.workingRequest)
+        ? record.workingRequest
+        : (record.messages || record.input ? record : undefined);
+    const normalizedMetadata = record.normalizedMetadata &&
+        typeof record.normalizedMetadata === "object" &&
+        !Array.isArray(record.normalizedMetadata)
+        ? record.normalizedMetadata
+        : undefined;
+    if (normalizedMetadata && shouldUseHeavyInputFastpath(normalizedMetadata)) {
         markHeavyInputFastpath({
             metadata: normalizedMetadata,
-            estimatedInputTokens: fastpath.estimatedInputTokens,
-            reason: "metadata_threshold",
+            estimatedInputTokens: normalizedMetadata.estimatedInputTokens,
+            reason: "captured_snapshot"
         });
     }
-    // Hard rule: captured request must preserve full semantic payload.
+    const model = (typeof workingRequest?.model === "string" && String(workingRequest.model).trim()) ||
+        (typeof normalizedMetadata?.model === "string" && normalizedMetadata.model.trim()) ||
+        null;
+    const messages = Array.isArray(workingRequest?.messages) ? workingRequest?.messages : [];
+    const hasInput = Boolean(workingRequest && Object.prototype.hasOwnProperty.call(workingRequest, "input"));
+    const input = hasInput ? workingRequest?.input : undefined;
+    const tools = Array.isArray(workingRequest?.tools) ? workingRequest?.tools : null;
+    const parameters = workingRequest?.parameters && typeof workingRequest.parameters === "object" && !Array.isArray(workingRequest.parameters)
+        ? workingRequest.parameters
+        : null;
     return {
-        model: workingRequest.model,
-        messages: workingRequest.messages,
-        tools: workingRequest.tools,
-        parameters: workingRequest.parameters,
+        model,
+        messages,
+        ...(hasInput ? { input } : {}),
+        tools,
+        parameters,
     };
 }
-function estimateContentChars(content, cap) {
-    if (cap <= 0 || content === undefined || content === null) {
+export function roughEstimateInputTokensFromRequest(request) {
+    if (!request || typeof request !== "object" || Array.isArray(request)) {
         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;
+    const requestRecord = request;
+    const estimateTextTokens = (value) => {
+        if (typeof value === "string") {
+            return Math.ceil(value.length / 4);
+        }
+        if (Array.isArray(value)) {
+            return value.reduce((sum, item) => sum + estimateTextTokens(item), 0);
+        }
+        if (value && typeof value === "object") {
+            const record = value;
             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);
+                return Math.ceil(record.text.length / 4);
             }
-            else if (typeof record.output_text === "string") {
-                used += Math.min(record.output_text.length, cap - used);
+            if (typeof record.content === "string") {
+                return Math.ceil(record.content.length / 4);
             }
-            else {
-                used += Math.min(64, cap - used);
+            let total = 0;
+            for (const nested of Object.values(record)) {
+                total += estimateTextTokens(nested);
             }
+            return total;
         }
-        return used;
+        return 0;
+    };
+    let total = 0;
+    if (Array.isArray(requestRecord.messages)) {
+        total += estimateTextTokens(requestRecord.messages);
     }
-    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 (Object.prototype.hasOwnProperty.call(requestRecord, "input")) {
+        total += estimateTextTokens(requestRecord.input);
+    }
+    if (Object.prototype.hasOwnProperty.call(requestRecord, "instructions")) {
+        total += estimateTextTokens(requestRecord.instructions);
     }
-    if (Array.isArray(request.tools)) {
-        chars += request.tools.length * 256;
+    if (total <= 0) {
+        total += estimateTextTokens(requestRecord);
     }
-    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));
+    return Math.max(0, Math.floor(total));
 }
 export function resolveHeavyInputTokenThreshold() {
     return getConfig().inputTokenThreshold;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/hub-pipeline-max-tokens-policy.js

@@ -1,3 +1,38 @@
+const QWEN_HARD_MAX_OUTPUT_TOKENS = 65_536;
+function normalizeToken(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim().toLowerCase();
+    return trimmed || undefined;
+}
+function isQwenTarget(value) {
+    if (!value) {
+        return false;
+    }
+    return (value === "qwen" ||
+        value.startsWith("qwen.") ||
+        value.includes(".qwen.") ||
+        value.includes("qwen/"));
+}
+function resolveHardMaxTokens(target, routerEngine) {
+    const registry = routerEngine.providerRegistry;
+    const profile = target.providerKey
+        ? registry?.get?.(target.providerKey)
+        : undefined;
+    const identities = [
+        normalizeToken(target.providerType),
+        normalizeToken(target.providerKey),
+        normalizeToken(target.modelId),
+        normalizeToken(profile?.providerType),
+        normalizeToken(profile?.providerKey),
+        normalizeToken(profile?.modelId),
+    ];
+    if (identities.some((value) => isQwenTarget(value))) {
+        return QWEN_HARD_MAX_OUTPUT_TOKENS;
+    }
+    return undefined;
+}
 export function applyMaxTokensPolicyForRequest(request, target, routerEngine) {
     if (!target) {
         return;
@@ -26,7 +61,11 @@ export function applyMaxTokensPolicyForRequest(request, target, routerEngine) {
             configuredDefault = candidate;
         }
     }
-    const desired = requested && requested > 0 ? requested : configuredDefault;
+    const hardCap = resolveHardMaxTokens(target, routerEngine);
+    const desiredBase = requested && requested > 0 ? requested : configuredDefault;
+    const desired = desiredBase && desiredBase > 0 && hardCap && hardCap > 0
+        ? Math.min(desiredBase, hardCap)
+        : desiredBase;
     if (desired && desired > 0) {
         params.max_tokens = desired;
         if (params.max_output_tokens !== undefined) {

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

@@ -17,7 +17,6 @@ export declare function executeRouteAndBuildOutbound<TContext = Record<string, u
     nodeResults: HubPipelineNodeResult[];
     inboundRecorder?: StageRecorder;
     activeProcessMode: "chat" | "passthrough";
-    responsesResume?: Record<string, unknown>;
     serverToolRequired: boolean;
     hasImageAttachment: boolean;
     passthroughAudit?: Record<string, unknown>;

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

@@ -8,8 +8,17 @@ 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";
+function isCapturedChatRequestShapeValid(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    const hasMessages = Array.isArray(record.messages);
+    const hasInput = Object.prototype.hasOwnProperty.call(record, "input") && record.input !== undefined;
+    return hasMessages || hasInput;
+}
 export async function executeRouteAndBuildOutbound(args) {
-    const { normalized, hooks, routerEngine, config, nodeResults, inboundRecorder, activeProcessMode, responsesResume, serverToolRequired, hasImageAttachment, passthroughAudit, rawRequest, contextSnapshot, semanticMapper, effectivePolicy, shadowCompareBaselineMode, routeSelectTiming, } = args;
+    const { normalized, hooks, routerEngine, config, nodeResults, inboundRecorder, activeProcessMode, serverToolRequired, hasImageAttachment, passthroughAudit, rawRequest, contextSnapshot, semanticMapper, effectivePolicy, shadowCompareBaselineMode, routeSelectTiming, } = args;
     let { workingRequest } = args;
     const sessionIdentifiers = extractSessionIdentifiersFromMetadata(normalized.metadata);
     // 将从 metadata / clientHeaders 中解析出的会话标识同步回 normalized.metadata，
@@ -41,7 +50,7 @@ export async function executeRouteAndBuildOutbound(args) {
         providerProtocol: normalized.providerProtocol,
         routeHint: normalized.routeHint,
         stage: normalized.stage,
-        responsesResume,
+        requestSemantics: workingRequest.semantics,
         includeEstimatedInputTokens: true,
         serverToolRequired: serverToolRequired === true,
         sessionId: sessionIdentifiers.sessionId,
@@ -156,6 +165,14 @@ export async function executeRouteAndBuildOutbound(args) {
         workingRequest,
         normalizedMetadata: normalized.metadata,
     }));
+    if (!isCapturedChatRequestShapeValid(capturedChatRequest)) {
+        throw Object.assign(new Error("[HubPipeline] capturedChatRequest must be chat-like (messages or input) for response-side servertool."), {
+            code: "ERR_CAPTURED_CHAT_REQUEST_INVALID",
+            requestId: normalized.id,
+            processMode: activeProcessMode,
+            entryEndpoint: normalized.entryEndpoint,
+        });
+    }
     const metadata = buildHubPipelineResultMetadataWithNative({
         normalized: {
             metadata: normalized.metadata,

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

@@ -100,8 +100,6 @@ export declare function __unsafeBuildAdapterContextForTest(normalized: Normalize
 export declare class HubPipeline {
     private readonly routerEngine;
     private config;
-    private unsubscribeProviderErrors?;
-    private unsubscribeProviderSuccess?;
     constructor(config: HubPipelineConfig);
     updateRuntimeDeps(deps: {
         healthStore?: HubPipelineConfig["healthStore"] | null;

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

@@ -1,6 +1,5 @@
 import { VirtualRouterEngine } from "../../../router/virtual-router/engine.js";
-import { providerErrorCenter } from "../../../router/virtual-router/error-center.js";
-import { providerSuccessCenter } from "../../../router/virtual-router/success-center.js";
+import { setVirtualRouterPolicyRuntimeRouterHooks } from "../../../router/virtual-router/provider-runtime-ingress.js";
 import { setHubPolicyRuntimePolicy, } from "../policy/policy-engine.js";
 import { clearHubStageTiming, } from "./hub-stage-timing.js";
 import { REQUEST_STAGE_HOOKS, } from "./hub-pipeline-stage-hooks.js";
@@ -8,6 +7,26 @@ import { executeRequestStagePipeline } from "./hub-pipeline-execute-request-stag
 import { executeChatProcessEntryPipeline } from "./hub-pipeline-execute-chat-process-entry.js";
 import { buildAdapterContextFromNormalized } from "./hub-pipeline-adapter-context.js";
 import { normalizeHubPipelineRequest } from "./hub-pipeline-normalize-request.js";
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.stack || `${error.name}: ${error.message}`;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function logHubPipelineNonBlockingError(stage, error, details) {
+    try {
+        const suffix = details && Object.keys(details).length > 0 ? ` details=${JSON.stringify(details)}` : '';
+        console.warn(`[hub-pipeline] ${stage} failed (non-blocking): ${formatUnknownError(error)}${suffix}`);
+    }
+    catch {
+        void 0;
+    }
+}
 // Test-only seam: keep clock/session scope regression script independent from class internals.
 export function __unsafeBuildAdapterContextForTest(normalized, target) {
     return buildAdapterContextFromNormalized(normalized, target);
@@ -15,8 +34,6 @@ export function __unsafeBuildAdapterContextForTest(normalized, target) {
 export class HubPipeline {
     routerEngine;
     config;
-    unsubscribeProviderErrors;
-    unsubscribeProviderSuccess;
     constructor(config) {
         this.config = config;
         this.routerEngine = new VirtualRouterEngine({
@@ -27,30 +44,27 @@ export class HubPipeline {
         this.routerEngine.initialize(config.virtualRouter);
         setHubPolicyRuntimePolicy(config.policy);
         try {
-            this.unsubscribeProviderErrors = providerErrorCenter.subscribe((event) => {
-                try {
-                    this.routerEngine.handleProviderError(event);
-                }
-                catch {
-                    // ignore subscriber errors
+            setVirtualRouterPolicyRuntimeRouterHooks(this, {
+                handleProviderError: (event) => {
+                    try {
+                        this.routerEngine.handleProviderError(event);
+                    }
+                    catch (subscriberError) {
+                        logHubPipelineNonBlockingError('provider-runtime-ingress.handleProviderError', subscriberError);
+                    }
+                },
+                handleProviderSuccess: (event) => {
+                    try {
+                        this.routerEngine.handleProviderSuccess(event);
+                    }
+                    catch (subscriberError) {
+                        logHubPipelineNonBlockingError('provider-runtime-ingress.handleProviderSuccess', subscriberError);
+                    }
                 }
             });
         }
-        catch {
-            this.unsubscribeProviderErrors = undefined;
-        }
-        try {
-            this.unsubscribeProviderSuccess = providerSuccessCenter.subscribe((event) => {
-                try {
-                    this.routerEngine.handleProviderSuccess(event);
-                }
-                catch {
-                    // ignore subscriber errors
-                }
-            });
-        }
-        catch {
-            this.unsubscribeProviderSuccess = undefined;
+        catch (hookError) {
+            logHubPipelineNonBlockingError('provider-runtime-ingress.register', hookError);
         }
     }
     updateRuntimeDeps(deps) {
@@ -74,8 +88,8 @@ export class HubPipeline {
                 quotaView: this.config.quotaView ?? null,
             });
         }
-        catch {
-            // best-effort: runtime deps updates must never break routing
+        catch (updateDepsError) {
+            logHubPipelineNonBlockingError('updateRuntimeDeps.routerEngine.updateDeps', updateDepsError);
         }
     }
     updateVirtualRouterConfig(nextConfig) {
@@ -86,23 +100,11 @@ export class HubPipeline {
         this.routerEngine.initialize(nextConfig);
     }
     dispose() {
-        if (this.unsubscribeProviderErrors) {
-            try {
-                this.unsubscribeProviderErrors();
-            }
-            catch {
-                // ignore dispose failures
-            }
-            this.unsubscribeProviderErrors = undefined;
+        try {
+            setVirtualRouterPolicyRuntimeRouterHooks(this, undefined);
         }
-        if (this.unsubscribeProviderSuccess) {
-            try {
-                this.unsubscribeProviderSuccess();
-            }
-            catch {
-                // ignore dispose failures
-            }
-            this.unsubscribeProviderSuccess = undefined;
+        catch (disposeError) {
+            logHubPipelineNonBlockingError('dispose.provider-runtime-ingress.unregister', disposeError);
         }
     }
     async execute(request) {

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/route-aware-responses-continuation.d.ts

@@ -0,0 +1,10 @@
+import type { ProcessedRequest, StandardizedRequest } from '../types/standardized.js';
+import type { JsonObject } from '../types/json.js';
+export declare function resolveRouteAwareResponsesContinuation(args: {
+    request: StandardizedRequest | ProcessedRequest;
+    rawRequest: JsonObject;
+    normalizedMetadata?: Record<string, unknown>;
+    requestId: string;
+    entryProtocol: string;
+    outboundProtocol: string;
+}): StandardizedRequest | ProcessedRequest;