@jsonstudio/rcc 0.90.872 → 0.90.1270

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

@@ -1,15 +1,9 @@
 import type { JsonObject, JsonValue } from '../../types/json.js';
 import type { NativeProviderProtocolToken } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
-type ShapeFilterConfig = Record<string, unknown>;
-type ResponseBlacklistConfig = Record<string, unknown>;
-type FieldMapping = Record<string, unknown>;
-type RequestRulesConfig = Record<string, unknown>;
-type AutoThinkingConfig = Record<string, unknown>;
-type ResponseNormalizeConfig = Record<string, unknown>;
-type ResponseValidateConfig = Record<string, unknown>;
-type HarvestToolCallsFromTextConfig = Record<string, unknown>;
-type ToolTextRequestGuidanceConfig = Record<string, unknown>;
-type DeepSeekWebResponseConfig = Record<string, unknown>;
+export interface AnthropicClaudeCodeSystemPromptConfig {
+    systemText?: string;
+    preserveExistingSystemAsUserMessage?: boolean;
+}
 export type CompatDirection = 'request' | 'response';
 export type CompatNativeProtocolToken = NativeProviderProtocolToken;
 export interface CompatProfileConfig {
@@ -25,151 +19,17 @@ export interface CompatStageConfig {
     mappings?: MappingInstruction[];
     filters?: FilterInstruction[];
 }
-export type MappingInstruction = {
-    action: 'remove';
-    path: string;
-} | {
-    action: 'shallow_pick';
-    allowTopLevel: string[];
-} | {
-    action: 'rename';
-    from: string;
-    to: string;
-} | {
-    action: 'set';
-    path: string;
-    value: JsonValue;
-} | {
-    action: 'stringify';
-    path: string;
-    fallback?: JsonValue;
-} | {
-    action: 'set_default';
-    path: string;
-    value?: JsonValue;
-    valueSource?: 'timestamp_seconds' | 'chat_completion_id';
-} | {
-    action: 'normalize_tool_choice';
-    path?: string;
-    objectReplacement?: string;
-} | {
-    action: 'normalize_tool_call_ids';
-} | {
-    action: 'lmstudio_responses_fc_ids';
-} | {
-    action: 'lmstudio_responses_input_stringify';
-} | {
-    action: 'iflow_kimi_history_media_placeholder';
-} | {
-    action: 'iflow_kimi_cli_defaults';
-} | {
-    action: 'iflow_kimi_thinking_reasoning_fill';
-} | {
-    action: 'inject_instruction';
-    sourcePath: string;
-    targetPath?: string;
-    role?: string;
-    contentType?: string;
-    stripHtml?: boolean;
-    maxLengthEnv?: string[];
-} | {
-    action: 'parse_json';
-    path: string;
-    fallback?: JsonValue;
-} | {
-    action: 'convert_responses_output_to_choices';
-} | {
-    action: 'extract_glm_tool_markup';
-} | {
-    action: 'harvest_tool_calls_from_text';
-    config?: HarvestToolCallsFromTextConfig;
-} | {
-    action: 'tool_text_request_guidance';
-    config?: ToolTextRequestGuidanceConfig;
-} | {
-    action: 'strip_orphan_function_calls_tag';
-} | {
-    action: 'dto_unwrap';
-} | {
-    action: 'dto_rewrap';
-} | {
-    action: 'shape_filter';
-    config: ShapeFilterConfig;
-    target?: CompatDirection;
-} | {
-    action: 'field_map';
-    direction?: 'incoming' | 'outgoing';
-    config: FieldMapping[];
-} | {
-    action: 'tool_schema_sanitize';
-    mode?: 'glm_shell';
-} | {
-    action: 'apply_rules';
-    config: RequestRulesConfig;
-} | {
-    action: 'auto_thinking';
-    config: AutoThinkingConfig;
-} | {
-    action: 'snapshot';
-    phase: 'compat-pre' | 'compat-post';
-    channel?: string;
-} | {
-    action: 'resp_blacklist';
-    config: ResponseBlacklistConfig;
-} | {
-    action: 'response_normalize';
-    config?: ResponseNormalizeConfig;
-} | {
-    action: 'response_validate';
-    config?: ResponseValidateConfig;
-} | {
-    action: 'qwen_request_transform';
-} | {
-    action: 'qwen_response_transform';
-} | {
-    action: 'glm_web_search_request';
-} | {
-    action: 'glm_image_content';
-} | {
-    action: 'glm_vision_prompt';
-} | {
-    action: 'gemini_web_search_request';
-} | {
-    action: 'iflow_web_search_request';
-} | {
-    action: 'iflow_tool_text_fallback';
-    models?: string[];
-} | {
-    action: 'iflow_response_body_unwrap';
-} | {
-    action: 'deepseek_web_request';
-} | {
-    action: 'deepseek_web_response';
-    config?: DeepSeekWebResponseConfig;
-} | {
-    action: 'claude_thinking_tool_schema';
-} | {
-    action: 'anthropic_claude_code_system_prompt';
-    config?: AnthropicClaudeCodeSystemPromptConfig;
-};
-export type AnthropicClaudeCodeSystemPromptConfig = {
-    /**
-     * Force the Anthropic `system` prompt to match Claude Code official format.
-     * Defaults to "You are Claude Code, Anthropic's official CLI for Claude."
-     */
-    systemText?: string;
-    /**
-     * When replacing an existing system prompt, optionally move the previous
-     * system text into the beginning of the user message history.
-     */
-    preserveExistingSystemAsUserMessage?: boolean;
-};
-export type FilterInstruction = {
-    action: 'rate_limit_text';
-    needle: string;
-};
+export interface MappingInstruction {
+    action: string;
+    config?: JsonValue;
+    phase?: string;
+    [key: string]: JsonValue | undefined;
+}
+export interface FilterInstruction {
+    action: string;
+    [key: string]: JsonValue | undefined;
+}
 export interface CompatApplicationResult {
     payload: JsonObject;
     appliedProfile?: string;
 }
-export {};

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

@@ -1,5 +1,7 @@
+import type { AdapterContext } from "../types/chat-envelope.js";
 import type { ProcessedRequest, StandardizedRequest } from "../types/standardized.js";
 import type { NormalizedRequest } from "./hub-pipeline.js";
+import { type ReasoningStopMode } from "../../../servertool/handlers/reasoning-stop-state.js";
 export declare function sanitizeStandardizedRequestMessages(standardizedRequest: StandardizedRequest): StandardizedRequest;
 export declare function propagateApplyPatchToolModeToRequestMetadata(normalizedMetadata: Record<string, unknown> | undefined, standardizedRequest: StandardizedRequest): void;
 export declare function resolveActiveProcessModeAndAudit(args: {
@@ -15,7 +17,10 @@ export declare function estimateInputTokensForWorkingRequest(args: {
     normalizedMetadata: Record<string, unknown> | undefined;
 }): void;
 export declare function deriveWorkingRequestFlags(workingRequest: StandardizedRequest | ProcessedRequest): {
-    responsesResume?: Record<string, unknown>;
     hasImageAttachment: boolean;
     serverToolRequired: boolean;
 };
+export declare function prepareReasoningStopRequestTooling(args: {
+    request: StandardizedRequest;
+    adapterContext: AdapterContext;
+}): ReasoningStopMode;

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

@@ -1,9 +1,66 @@
+import { jsonClone } from "../types/json.js";
 import { containsImageAttachment, repairIncompleteToolCalls, stripHistoricalImageAttachments, stripHistoricalVisualToolOutputs, } from "../process/chat-process-media.js";
-import { buildPassthroughAuditWithNative, readResponsesResumeFromRequestSemanticsWithNative, resolveActiveProcessModeWithNative } from "../../../router/virtual-router/engine-selection/native-hub-pipeline-orchestration-semantics.js";
+import { buildPassthroughAuditWithNative, resolveActiveProcessModeWithNative } from "../../../router/virtual-router/engine-selection/native-hub-pipeline-orchestration-semantics.js";
 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";
+import { REASONING_STOP_TOOL_DEF, syncReasoningStopModeFromRequest } from "../../../servertool/handlers/reasoning-stop-state.js";
+function hasReasoningStopTool(tools) {
+    return Boolean(Array.isArray(tools) &&
+        tools.some((tool) => {
+            const name = tool &&
+                typeof tool === 'object' &&
+                tool.function &&
+                typeof tool.function === 'object' &&
+                typeof tool.function.name === 'string'
+                ? tool.function.name.trim().toLowerCase()
+                : '';
+            return name === 'reasoning.stop';
+        }));
+}
+function buildCapturedChatRequestFromStandardized(request) {
+    const out = {
+        model: request.model,
+        messages: jsonClone(request.messages)
+    };
+    if (Array.isArray(request.tools)) {
+        out.tools = jsonClone(request.tools);
+    }
+    if (request.parameters && typeof request.parameters === 'object') {
+        out.parameters = jsonClone(request.parameters);
+    }
+    return out;
+}
+function readSessionLikeToken(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function backfillAdapterContextSessionIdentifiersFromRequest(request, adapterContext) {
+    const adapterRecord = adapterContext;
+    const requestMetadata = request.metadata && typeof request.metadata === "object"
+        ? request.metadata
+        : undefined;
+    if (!requestMetadata) {
+        return;
+    }
+    const sessionId = readSessionLikeToken(adapterRecord.sessionId) ??
+        readSessionLikeToken(requestMetadata.sessionId) ??
+        readSessionLikeToken(requestMetadata.session_id);
+    const conversationId = readSessionLikeToken(adapterRecord.conversationId) ??
+        readSessionLikeToken(requestMetadata.conversationId) ??
+        readSessionLikeToken(requestMetadata.conversation_id);
+    if (sessionId && !readSessionLikeToken(adapterRecord.sessionId)) {
+        adapterRecord.sessionId = sessionId;
+    }
+    if (conversationId &&
+        !readSessionLikeToken(adapterRecord.conversationId)) {
+        adapterRecord.conversationId = conversationId;
+    }
+}
 export function sanitizeStandardizedRequestMessages(standardizedRequest) {
     return {
         ...standardizedRequest,
@@ -75,14 +132,37 @@ export function estimateInputTokensForWorkingRequest(args) {
     }
 }
 export function deriveWorkingRequestFlags(workingRequest) {
-    const responsesResume = readResponsesResumeFromRequestSemanticsWithNative(workingRequest);
     const stdMetadata = workingRequest?.metadata;
     const hasImageAttachment = containsImageAttachment((workingRequest.messages ?? []));
     const serverToolRequired = stdMetadata?.webSearchEnabled === true ||
         stdMetadata?.serverToolRequired === true;
     return {
-        responsesResume,
         hasImageAttachment,
         serverToolRequired,
     };
 }
+export function prepareReasoningStopRequestTooling(args) {
+    backfillAdapterContextSessionIdentifiersFromRequest(args.request, args.adapterContext);
+    const captured = buildCapturedChatRequestFromStandardized(args.request);
+    args.adapterContext.capturedChatRequest = captured;
+    const mode = syncReasoningStopModeFromRequest(args.adapterContext, 'off');
+    const capturedMessages = captured.messages;
+    const strippedMessages = Array.isArray(capturedMessages)
+        ? jsonClone(capturedMessages)
+        : undefined;
+    if (strippedMessages) {
+        args.request.messages = strippedMessages;
+    }
+    if (mode === 'off') {
+        return mode;
+    }
+    if (!hasReasoningStopTool(args.request.tools)) {
+        const nextTools = Array.isArray(args.request.tools) ? [...args.request.tools] : [];
+        nextTools.push(jsonClone(REASONING_STOP_TOOL_DEF));
+        args.request.tools = nextTools;
+    }
+    captured.messages = jsonClone(args.request.messages);
+    captured.tools = jsonClone((args.request.tools ?? []));
+    captured.parameters = jsonClone(args.request.parameters);
+    return mode;
+}

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

@@ -4,7 +4,7 @@ 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";
 import { buildAdapterContextFromNormalized } from "./hub-pipeline-adapter-context.js";
-import { deriveWorkingRequestFlags, estimateInputTokensForWorkingRequest, propagateApplyPatchToolModeToRequestMetadata, resolveActiveProcessModeAndAudit, sanitizeStandardizedRequestMessages, } from "./hub-pipeline-chat-process-request-utils.js";
+import { deriveWorkingRequestFlags, estimateInputTokensForWorkingRequest, prepareReasoningStopRequestTooling, propagateApplyPatchToolModeToRequestMetadata, resolveActiveProcessModeAndAudit, sanitizeStandardizedRequestMessages, } from "./hub-pipeline-chat-process-request-utils.js";
 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";
@@ -68,6 +68,10 @@ export async function executeChatProcessEntryPipeline(args) {
     }
     propagateApplyPatchToolModeToRequestMetadata(metaBase, standardizedRequest);
     const adapterContext = buildAdapterContextFromNormalized(normalized);
+    prepareReasoningStopRequestTooling({
+        request: standardizedRequest,
+        adapterContext,
+    });
     const stageRecorder = (() => {
         if (normalized.externalStageRecorder) {
             return normalized.externalStageRecorder;
@@ -121,9 +125,7 @@ export async function executeChatProcessEntryPipeline(args) {
         normalizedMetadata: normalized.metadata ??
             (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);
+    const { hasImageAttachment, serverToolRequired } = deriveWorkingRequestFlags(workingRequest);
     const outbound = await executeRouteAndBuildOutbound({
         normalized,
         hooks,
@@ -133,7 +135,6 @@ export async function executeChatProcessEntryPipeline(args) {
         nodeResults,
         inboundRecorder: stageRecorder,
         activeProcessMode,
-        responsesResume,
         serverToolRequired,
         hasImageAttachment,
         passthroughAudit,

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/hub-pipeline-execute-request-stage-inbound.d.ts

@@ -21,7 +21,6 @@ export interface RequestStageInboundResult<TContext = Record<string, unknown>> {
     nodeResults: HubPipelineNodeResult[];
     hasImageAttachment: boolean;
     serverToolRequired: boolean;
-    responsesResume?: Record<string, unknown>;
 }
 export declare function executeRequestStageInbound<TContext = Record<string, unknown>>(args: {
     normalized: NormalizedRequest;

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

@@ -2,6 +2,7 @@ import { isJsonObject } from "../types/json.js";
 import { runReqInboundStage1FormatParse } from "./stages/req_inbound/req_inbound_stage1_format_parse/index.js";
 import { runReqInboundStage2SemanticMap } from "./stages/req_inbound/req_inbound_stage2_semantic_map/index.js";
 import { writeCacheEntryForRequest } from "./stages/req_inbound/req_inbound_stage3_context_capture/cache-write.js";
+import { persistResponsesConversationRequestContext } from "./stages/req_inbound/req_inbound_stage3_context_capture/responses-context-snapshot.js";
 import { runReqProcessStage1ToolGovernance } from "./stages/req_process/req_process_stage1_tool_governance/index.js";
 import { isCompactionRequest } from "../../compaction-detect.js";
 import { buildReqInboundNodeResultWithNative, findMappableSemanticsKeysWithNative, prepareRuntimeMetadataForServertoolsWithNative, readResponsesResumeFromMetadataWithNative, resolveApplyPatchToolModeFromEnvWithNative, resolveApplyPatchToolModeFromToolsWithNative, resolveHubClientProtocolWithNative, syncResponsesContextFromCanonicalMessagesWithNative, } from "../../../router/virtual-router/engine-selection/native-hub-pipeline-orchestration-semantics.js";
@@ -113,11 +114,16 @@ export async function executeRequestStageInbound(args) {
     const contextSnapshot = await measureHubStage(normalized.id, "req_inbound.stage3_context_capture", () => {
         if (inboundStage2.responsesContext) {
             // responses 语义上下文已在 stage2 捕获，但请求侧 CACHE.md 仍需写入
-            // 仅做请求写入，不重复 captureContext 逻辑
+            // 仍需补做 conversation-store capture；否则 submit_tool_outputs 无法按 response_id 恢复。
             writeCacheEntryForRequest({
                 rawRequest,
                 adapterContext: inboundAdapterContext,
             });
+            persistResponsesConversationRequestContext({
+                rawRequest,
+                adapterContext: inboundAdapterContext,
+                context: inboundStage2.responsesContext,
+            });
             return inboundStage2.responsesContext;
         }
         return hooks.captureContext({
@@ -184,9 +190,8 @@ export async function executeRequestStageInbound(args) {
         normalizedMetadata: normalized.metadata ??
             (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);
+    // request continuation/state must be consumed from chat.semantics once entering chat_process.
+    const { hasImageAttachment, serverToolRequired } = deriveWorkingRequestFlags(workingRequest);
     return {
         rawRequest,
         semanticMapper,
@@ -202,6 +207,5 @@ export async function executeRequestStageInbound(args) {
         nodeResults,
         hasImageAttachment,
         serverToolRequired,
-        responsesResume,
     };
 }

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

@@ -8,6 +8,119 @@ import { readRuntimeMetadata } from "../../runtime-metadata.js";
 import { applyHubProviderOutboundPolicy, recordHubPolicyObservation, } from "../policy/policy-engine.js";
 import { applyProviderOutboundToolSurface } from "../tool-surface/tool-surface-engine.js";
 import { measureHubStage } from "./hub-stage-timing.js";
+import { resolveRouteAwareResponsesContinuation } from "./route-aware-responses-continuation.js";
+function unwrapRawRequestBody(rawRequest) {
+    const record = rawRequest;
+    const data = record.data && typeof record.data === "object" && !Array.isArray(record.data)
+        ? record.data
+        : undefined;
+    return data ?? record;
+}
+function extractToolNames(tools) {
+    if (!Array.isArray(tools)) {
+        return [];
+    }
+    const names = [];
+    const seen = new Set();
+    for (const tool of tools) {
+        if (!tool || typeof tool !== "object") {
+            continue;
+        }
+        const record = tool;
+        const fn = record.function && typeof record.function === "object" && !Array.isArray(record.function)
+            ? record.function
+            : undefined;
+        const rawName = typeof fn?.name === "string" && fn.name.trim()
+            ? fn.name.trim()
+            : typeof record.name === "string" && record.name.trim()
+                ? record.name.trim()
+                : typeof record.type === "string" && record.type.trim()
+                    ? record.type.trim()
+                    : "";
+        if (!rawName || seen.has(rawName)) {
+            continue;
+        }
+        seen.add(rawName);
+        names.push(rawName);
+    }
+    return names;
+}
+function summarizeMessageToolHistory(messages) {
+    if (!Array.isArray(messages)) {
+        return {
+            messageCount: 0,
+            assistantToolCallTurns: 0,
+            assistantToolCallCount: 0,
+            toolResultTurns: 0,
+            toolResultIds: [],
+        };
+    }
+    let assistantToolCallTurns = 0;
+    let assistantToolCallCount = 0;
+    let toolResultTurns = 0;
+    const toolResultIds = [];
+    for (const message of messages) {
+        if (!message || typeof message !== "object") {
+            continue;
+        }
+        const row = message;
+        const role = typeof row.role === "string" ? row.role.trim().toLowerCase() : "";
+        if (role === "assistant" && Array.isArray(row.tool_calls) && row.tool_calls.length > 0) {
+            assistantToolCallTurns += 1;
+            assistantToolCallCount += row.tool_calls.length;
+        }
+        if (role === "tool") {
+            toolResultTurns += 1;
+            const toolCallId = typeof row.tool_call_id === "string" && row.tool_call_id.trim()
+                ? row.tool_call_id.trim()
+                : typeof row.call_id === "string" && row.call_id.trim()
+                    ? row.call_id.trim()
+                    : "";
+            if (toolCallId && toolResultIds.length < 32) {
+                toolResultIds.push(toolCallId);
+            }
+        }
+    }
+    return {
+        messageCount: messages.length,
+        assistantToolCallTurns,
+        assistantToolCallCount,
+        toolResultTurns,
+        toolResultIds,
+    };
+}
+function recordOutboundToolParity(args) {
+    if (!args.stageRecorder) {
+        return;
+    }
+    const inboundBody = unwrapRawRequestBody(args.rawRequest);
+    const inboundNames = extractToolNames(inboundBody.tools);
+    const outboundNames = extractToolNames(args.providerPayload.tools);
+    const outboundSet = new Set(outboundNames);
+    const inboundSet = new Set(inboundNames);
+    const missingNames = inboundNames.filter((name) => !outboundSet.has(name));
+    const extraNames = outboundNames.filter((name) => !inboundSet.has(name));
+    args.stageRecorder.record("chat_process.req.stage8b.outbound.tool_parity", {
+        requestId: args.requestId,
+        providerProtocol: args.providerProtocol,
+        compatibilityProfile: args.compatibilityProfile ?? null,
+        inboundTools: {
+            count: Array.isArray(inboundBody.tools) ? inboundBody.tools.length : 0,
+            names: inboundNames,
+        },
+        outboundTools: {
+            count: Array.isArray(args.providerPayload.tools)
+                ? args.providerPayload.tools.length
+                : 0,
+            names: outboundNames,
+        },
+        missingNames,
+        extraNames,
+        matched: missingNames.length === 0 && extraNames.length === 0,
+        inboundHistory: summarizeMessageToolHistory(inboundBody.messages),
+        outboundHistory: summarizeMessageToolHistory(args.providerPayload.messages),
+    });
+}
 export async function buildRequestStageProviderPayload(args) {
     const { normalized, hooks, config, workingRequest, rawRequest, contextSnapshot, activeProcessMode, passthroughAudit, outboundProtocol, outboundAdapterContext, outboundStream, outboundRecorder, semanticMapper, effectivePolicy, shadowCompareBaselineMode, } = args;
     let providerPayload;
@@ -45,8 +158,16 @@ export async function buildRequestStageProviderPayload(args) {
     const outboundContextSnapshot = protocolSwitch
         ? undefined
         : contextSnapshot;
-    const outboundStage1 = await measureHubStage(normalized.id, "req_outbound.stage1_semantic_map", () => runReqOutboundStage1SemanticMap({
+    const routeAwareWorkingRequest = resolveRouteAwareResponsesContinuation({
         request: workingRequest,
+        rawRequest,
+        normalizedMetadata: normalized.metadata,
+        requestId: normalized.id,
+        entryProtocol: normalized.providerProtocol,
+        outboundProtocol,
+    });
+    const outboundStage1 = await measureHubStage(normalized.id, "req_outbound.stage1_semantic_map", () => runReqOutboundStage1SemanticMap({
+        request: routeAwareWorkingRequest,
         adapterContext: outboundAdapterContext,
         semanticMapper: outboundSemanticMapper,
         contextSnapshot: outboundContextSnapshot,
@@ -123,6 +244,16 @@ export async function buildRequestStageProviderPayload(args) {
     });
     const rt = readRuntimeMetadata(outboundAdapterContext);
     providerPayload = applyDirectBuiltinWebSearchToolWithNative(providerPayload, outboundProtocol, outboundAdapterContext.routeId, rt);
+    recordOutboundToolParity({
+        rawRequest,
+        providerPayload,
+        providerProtocol: outboundProtocol,
+        compatibilityProfile: typeof outboundAdapterContext.compatibilityProfile === "string"
+            ? outboundAdapterContext.compatibilityProfile
+            : undefined,
+        requestId: normalized.id,
+        stageRecorder: outboundRecorder,
+    });
     recordHubPolicyObservation({
         policy: effectivePolicy,
         providerProtocol: outboundProtocol,

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

@@ -18,7 +18,6 @@ export async function executeRequestStagePipeline(args) {
         nodeResults: inbound.nodeResults,
         inboundRecorder: inbound.inboundRecorder,
         activeProcessMode: inbound.activeProcessMode,
-        responsesResume: inbound.responsesResume,
         serverToolRequired: inbound.serverToolRequired,
         hasImageAttachment: inbound.hasImageAttachment,
         passthroughAudit: inbound.passthroughAudit,

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

@@ -1,24 +1,6 @@
-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 shouldUseHeavyInputFastpath(metadata: unknown): boolean;
+export declare function markHeavyInputFastpath(options?: unknown): void;
+export declare function buildCapturedChatRequestInput(args: unknown): unknown;
+export declare function roughEstimateInputTokensFromRequest(request: unknown): number;
 export declare function resolveHeavyInputTokenThreshold(): number;