@jsonstudio/llms 0.6.3541 → 0.6.3685

package/dist/conversion/hub/pipeline/hub-stage-timing.d.ts

@@ -0,0 +1,6 @@
+export declare function logHubStageTiming(requestId: string, stage: string, phase: 'start' | 'completed' | 'error', details?: Record<string, unknown>): void;
+export declare function measureHubStage<T>(requestId: string, stage: string, fn: () => Promise<T> | T, options?: {
+    startDetails?: Record<string, unknown>;
+    mapCompletedDetails?: (value: T) => Record<string, unknown> | undefined;
+    mapErrorDetails?: (error: unknown) => Record<string, unknown> | undefined;
+}): Promise<T>;

package/dist/conversion/hub/pipeline/hub-stage-timing.js

@@ -0,0 +1,178 @@
+const truthy = new Set(['1', 'true', 'yes', 'on']);
+const falsy = new Set(['0', 'false', 'no', 'off']);
+const REQUEST_TIMELINES = new Map();
+const REQUEST_TIMELINE_TTL_MS = 30 * 60 * 1000;
+const REQUEST_TIMELINE_MAX = 4096;
+const DEFAULT_HUB_STAGE_LOG_MIN_MS = 25;
+function resolveBool(raw, fallback) {
+    if (raw === undefined) {
+        return fallback;
+    }
+    const normalized = String(raw).trim().toLowerCase();
+    if (truthy.has(normalized)) {
+        return true;
+    }
+    if (falsy.has(normalized)) {
+        return false;
+    }
+    return fallback;
+}
+function isHubStageTimingEnabled() {
+    const explicit = process.env.ROUTECODEX_STAGE_TIMING ??
+        process.env.RCC_STAGE_TIMING ??
+        process.env.ROUTECODEX_HUB_STAGE_TIMING ??
+        process.env.RCC_HUB_STAGE_TIMING ??
+        process.env.ROUTECODEX_BUILD_MODE ??
+        process.env.RCC_BUILD_MODE ??
+        process.env.BUILD_MODE ??
+        process.env.LLMSWITCH_BUILD_MODE;
+    if (explicit !== undefined) {
+        return resolveBool(explicit, true);
+    }
+    return true;
+}
+function isHubStageTimingVerboseEnabled() {
+    const explicit = process.env.ROUTECODEX_STAGE_TIMING_VERBOSE ??
+        process.env.RCC_STAGE_TIMING_VERBOSE ??
+        process.env.ROUTECODEX_HUB_STAGE_TIMING_VERBOSE ??
+        process.env.RCC_HUB_STAGE_TIMING_VERBOSE;
+    if (explicit !== undefined) {
+        return resolveBool(explicit, false);
+    }
+    return false;
+}
+function resolveHubStageTimingMinMs() {
+    const raw = process.env.ROUTECODEX_STAGE_TIMING_MIN_MS ??
+        process.env.RCC_STAGE_TIMING_MIN_MS ??
+        process.env.ROUTECODEX_HUB_STAGE_TIMING_MIN_MS ??
+        process.env.RCC_HUB_STAGE_TIMING_MIN_MS;
+    const parsed = Number(raw);
+    if (Number.isFinite(parsed) && parsed >= 0) {
+        return parsed;
+    }
+    return DEFAULT_HUB_STAGE_LOG_MIN_MS;
+}
+function prune(nowMs) {
+    for (const [key, timeline] of REQUEST_TIMELINES.entries()) {
+        if (nowMs - timeline.lastAtMs >= REQUEST_TIMELINE_TTL_MS) {
+            REQUEST_TIMELINES.delete(key);
+        }
+    }
+    while (REQUEST_TIMELINES.size > REQUEST_TIMELINE_MAX) {
+        const oldestKey = REQUEST_TIMELINES.keys().next().value;
+        if (!oldestKey) {
+            break;
+        }
+        REQUEST_TIMELINES.delete(oldestKey);
+    }
+}
+function touchTiming(requestId) {
+    const nowMs = Date.now();
+    prune(nowMs);
+    const existing = REQUEST_TIMELINES.get(requestId);
+    if (!existing) {
+        REQUEST_TIMELINES.set(requestId, {
+            startedAtMs: nowMs,
+            lastAtMs: nowMs
+        });
+        return;
+    }
+    existing.lastAtMs = nowMs;
+}
+function advanceTiming(requestId) {
+    const nowMs = Date.now();
+    prune(nowMs);
+    const existing = REQUEST_TIMELINES.get(requestId);
+    if (!existing) {
+        REQUEST_TIMELINES.set(requestId, {
+            startedAtMs: nowMs,
+            lastAtMs: nowMs
+        });
+        return {
+            label: ' t+0ms Δ0ms',
+            totalMs: 0,
+            deltaMs: 0
+        };
+    }
+    const totalMs = Math.max(0, Math.round(nowMs - existing.startedAtMs));
+    const deltaMs = Math.max(0, Math.round(nowMs - existing.lastAtMs));
+    existing.lastAtMs = nowMs;
+    return {
+        label: ` t+${totalMs}ms Δ${deltaMs}ms`,
+        totalMs,
+        deltaMs
+    };
+}
+function renderDetails(details) {
+    if (!details || Object.keys(details).length === 0) {
+        return '';
+    }
+    try {
+        return ` ${JSON.stringify(details)}`;
+    }
+    catch {
+        return '';
+    }
+}
+export function logHubStageTiming(requestId, stage, phase, details) {
+    if (!isHubStageTimingEnabled() || !requestId || !stage) {
+        return;
+    }
+    if (phase === 'start') {
+        touchTiming(requestId);
+    }
+    if (phase === 'start' && !isHubStageTimingVerboseEnabled()) {
+        return;
+    }
+    const timing = advanceTiming(requestId);
+    if (phase !== 'error') {
+        const forceLog = details?.forceLog === true;
+        if (forceLog) {
+            const detailSuffix = renderDetails(details);
+            const line = `[hub.detail][${requestId}] ${stage}.${phase}${timing.label}${detailSuffix}`;
+            console.log(line);
+            return;
+        }
+        const thresholdMs = resolveHubStageTimingMinMs();
+        const elapsedMs = typeof details?.elapsedMs === 'number'
+            ? details.elapsedMs
+            : typeof details?.nativeMs === 'number'
+                ? details.nativeMs
+                : undefined;
+        if (elapsedMs !== undefined && elapsedMs < thresholdMs) {
+            return;
+        }
+        if (timing.deltaMs < thresholdMs) {
+            return;
+        }
+    }
+    const detailSuffix = renderDetails(details);
+    const line = `[hub.detail][${requestId}] ${stage}.${phase}${timing.label}${detailSuffix}`;
+    if (phase === 'error') {
+        console.error(line);
+        return;
+    }
+    console.log(line);
+}
+export async function measureHubStage(requestId, stage, fn, options) {
+    const startedAt = Date.now();
+    logHubStageTiming(requestId, stage, 'start', options?.startDetails);
+    try {
+        const value = await fn();
+        const elapsedMs = Math.max(0, Date.now() - startedAt);
+        logHubStageTiming(requestId, stage, 'completed', {
+            elapsedMs,
+            ...(options?.mapCompletedDetails?.(value) ?? {})
+        });
+        return value;
+    }
+    catch (error) {
+        const mapped = options?.mapErrorDetails?.(error);
+        const message = error instanceof Error ? error.message : String(error ?? 'unknown');
+        logHubStageTiming(requestId, stage, 'error', mapped ?? {
+            elapsedMs: Math.max(0, Date.now() - startedAt),
+            message
+        });
+        throw error;
+    }
+}

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage1_format_parse/index.js

@@ -2,6 +2,7 @@ import { recordStage } from '../../../stages/utils.js';
 import { sanitizeReqInboundFormatEnvelopeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 import { parseReqInboundFormatEnvelopeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
 import { normalizeReasoningInAnthropicPayload, normalizeReasoningInChatPayload, normalizeReasoningInGeminiPayload, normalizeReasoningInResponsesPayload } from '../../../../../shared/reasoning-normalizer.js';
+import { measureHubStage } from '../../../hub-stage-timing.js';
 function resolveProtocolToken(adapterContext) {
     const candidate = typeof adapterContext.providerProtocol === 'string' && adapterContext.providerProtocol.trim().length
         ? adapterContext.providerProtocol.trim().toLowerCase()
@@ -31,12 +32,13 @@ function applyReasoningNormalization(rawRequest, protocol) {
 }
 export async function runReqInboundStage1FormatParse(options) {
     const protocol = resolveProtocolToken(options.adapterContext);
-    applyReasoningNormalization(options.rawRequest, protocol);
-    const envelopeRaw = parseReqInboundFormatEnvelopeWithNative({
+    const requestId = options.adapterContext.requestId;
+    await measureHubStage(requestId, 'request_stage.req_inbound.format_parse.reasoning_normalize', () => applyReasoningNormalization(options.rawRequest, protocol));
+    const envelopeRaw = await measureHubStage(requestId, 'request_stage.req_inbound.format_parse.native_parse', () => parseReqInboundFormatEnvelopeWithNative({
         rawRequest: options.rawRequest,
         protocol
-    });
-    const envelope = sanitizeReqInboundFormatEnvelopeWithNative(envelopeRaw);
+    }));
+    const envelope = await measureHubStage(requestId, 'request_stage.req_inbound.format_parse.native_sanitize', () => sanitizeReqInboundFormatEnvelopeWithNative(envelopeRaw));
     recordStage(options.stageRecorder, 'chat_process.req.stage1.format_parse', envelope);
     return envelope;
 }

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage2_semantic_map/index.js

@@ -4,7 +4,53 @@ import { recordStage } from '../../../stages/utils.js';
 import { liftReqInboundSemantics } from './semantic-lift.js';
 import { validateChatEnvelopeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
 import { chatEnvelopeToStandardizedWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+import { runResponsesOpenAIReqInboundSemanticMapWithNative } from '../../../../../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
+import { logHubStageTiming, measureHubStage } from '../../../hub-stage-timing.js';
+function logNativeResponsesSemanticMapBreakdown(requestId, timings) {
+    if (!requestId || !timings) {
+        return;
+    }
+    const stages = [
+        ['captureContextMs', 'request_stage.req_inbound.semantic_map.native.capture_context'],
+        ['buildRequestMs', 'request_stage.req_inbound.semantic_map.native.build_request'],
+        ['mapChatMs', 'request_stage.req_inbound.semantic_map.native.map_chat'],
+        ['toStandardizedMs', 'request_stage.req_inbound.semantic_map.native.to_standardized']
+    ];
+    for (const [key, stage] of stages) {
+        const value = timings[key];
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            logHubStageTiming(requestId, stage, 'completed', { nativeMs: value, elapsedMs: value });
+        }
+    }
+}
+function isResponsesCreateFastPathCandidate(options) {
+    if (options.responsesResume) {
+        return false;
+    }
+    const protocol = options.formatEnvelope.protocol?.trim().toLowerCase();
+    if (protocol !== 'openai-responses') {
+        return false;
+    }
+    const endpoint = options.adapterContext.entryEndpoint?.trim().toLowerCase();
+    return endpoint !== '/v1/responses.submit_tool_outputs';
+}
 export async function runReqInboundStage2SemanticMap(options) {
+    if (isResponsesCreateFastPathCandidate(options)) {
+        const nativeResult = await measureHubStage(options.adapterContext.requestId, 'request_stage.req_inbound.semantic_map.native.fast_path', () => runResponsesOpenAIReqInboundSemanticMapWithNative(options.formatEnvelope.payload, {
+            requestId: options.adapterContext.requestId,
+            entryEndpoint: options.adapterContext.entryEndpoint,
+            adapterContext: options.adapterContext
+        }));
+        logNativeResponsesSemanticMapBreakdown(options.adapterContext.requestId, nativeResult.timings);
+        const chatEnvelope = nativeResult.chatEnvelope;
+        const standardizedRequest = nativeResult.standardizedRequest;
+        validateChatEnvelopeWithNative(chatEnvelope, {
+            stage: 'req_inbound',
+            direction: 'request'
+        });
+        recordStage(options.stageRecorder, 'chat_process.req.stage2.semantic_map', chatEnvelope);
+        return { chatEnvelope, standardizedRequest };
+    }
     const chatEnvelope = await options.semanticMapper.toChat(options.formatEnvelope, options.adapterContext);
     const preservedResponsesContext = (() => {
         if (!chatEnvelope.semantics || typeof chatEnvelope.semantics !== 'object') {

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/context-capture-orchestration.d.ts

@@ -1,15 +1,18 @@
 import type { AdapterContext } from '../../../../types/chat-envelope.js';
+import type { ChatEnvelope } from '../../../../types/chat-envelope.js';
 import type { StageRecorder } from '../../../../format-adapters/index.js';
 import type { JsonObject } from '../../../../types/json.js';
 export interface ContextCaptureOptions {
     rawRequest: JsonObject;
     adapterContext: AdapterContext;
+    chatEnvelope?: ChatEnvelope;
     stageRecorder?: StageRecorder;
 }
 export type ContextCaptureHandler = (options: ContextCaptureOptions) => Promise<Record<string, unknown> | undefined> | Record<string, unknown> | undefined;
 export interface ReqInboundStage3ContextCaptureOptions {
     rawRequest: JsonObject;
     adapterContext: AdapterContext;
+    chatEnvelope?: ChatEnvelope;
     captureContext?: ContextCaptureHandler;
     stageRecorder?: StageRecorder;
 }

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/context-capture-orchestration.js

@@ -13,7 +13,8 @@ export async function runReqInboundStage3ContextCaptureOrchestration(options) {
         try {
             context = await options.captureContext({
                 rawRequest: options.rawRequest,
-                adapterContext: options.adapterContext
+                adapterContext: options.adapterContext,
+                chatEnvelope: options.chatEnvelope
             });
         }
         catch {

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/context-factories.js

@@ -4,6 +4,7 @@ export function createResponsesContextCapture(captureImpl) {
     return (options) => runReqInboundStage3ContextCapture({
         rawRequest: options.rawRequest,
         adapterContext: options.adapterContext,
+        chatEnvelope: options.chatEnvelope,
         stageRecorder: options.stageRecorder,
         captureContext: captureImpl
     });
@@ -13,6 +14,7 @@ export function createNoopContextCapture(label) {
     return (options) => runReqInboundStage3ContextCapture({
         rawRequest: options.rawRequest,
         adapterContext: options.adapterContext,
+        chatEnvelope: options.chatEnvelope,
         stageRecorder: options.stageRecorder,
         captureContext: () => ({ stage: normalizedLabel })
     });

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/index.js

@@ -9,6 +9,7 @@ export function runChatContextCapture(options) {
     return runReqInboundStage3ContextCapture({
         rawRequest: options.rawRequest,
         adapterContext: options.adapterContext,
+        chatEnvelope: options.chatEnvelope,
         stageRecorder: options.stageRecorder,
         captureContext: captureChatContextSnapshot
     });

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/responses-context-snapshot.d.ts

@@ -1,8 +1,9 @@
-import type { AdapterContext } from '../../../../types/chat-envelope.js';
-import type { JsonObject } from '../../../../types/json.js';
+import type { AdapterContext, ChatEnvelope } from '../../../../types/chat-envelope.js';
+import { type JsonObject } from '../../../../types/json.js';
 import type { ResponsesRequestContext } from '../../../../../responses/responses-openai-bridge.js';
 export interface ResponsesContextCaptureOptions {
     rawRequest: JsonObject;
     adapterContext: AdapterContext;
+    chatEnvelope?: ChatEnvelope;
 }
 export declare function captureResponsesContextSnapshot(options: ResponsesContextCaptureOptions): ResponsesRequestContext;

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/responses-context-snapshot.js

@@ -1,11 +1,24 @@
+import { isJsonObject } from '../../../../types/json.js';
 import { captureResponsesRequestContext } from '../../../../../shared/responses-conversation-store.js';
 import { captureReqInboundResponsesContextSnapshotWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+function readResponsesContextFromChatEnvelope(chatEnvelope) {
+    if (!chatEnvelope?.semantics || typeof chatEnvelope.semantics !== 'object') {
+        return undefined;
+    }
+    const responsesNode = isJsonObject(chatEnvelope.semantics.responses)
+        ? chatEnvelope.semantics.responses
+        : undefined;
+    return responsesNode && isJsonObject(responsesNode.context)
+        ? responsesNode.context
+        : undefined;
+}
 export function captureResponsesContextSnapshot(options) {
-    const context = captureReqInboundResponsesContextSnapshotWithNative({
-        rawRequest: options.rawRequest,
-        requestId: options.adapterContext.requestId,
-        toolCallIdStyle: options.adapterContext.toolCallIdStyle
-    });
+    const context = readResponsesContextFromChatEnvelope(options.chatEnvelope) ??
+        captureReqInboundResponsesContextSnapshotWithNative({
+            rawRequest: options.rawRequest,
+            requestId: options.adapterContext.requestId,
+            toolCallIdStyle: options.adapterContext.toolCallIdStyle
+        });
     // OpenAI Responses tool loop: store the request context keyed by requestId so that
     // `/v1/responses/:id/submit_tool_outputs` can resume the conversation later.
     //

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/context-merge.d.ts

@@ -1,3 +1,2 @@
-import type { AdapterContext, ChatEnvelope } from '../../../../types/chat-envelope.js';
-export declare function applyToolCallIdStyleMetadata(chatEnvelope: ChatEnvelope, adapterContext: AdapterContext, snapshot?: Record<string, unknown>): void;
+import type { ChatEnvelope } from '../../../../types/chat-envelope.js';
 export declare function applyContextSnapshotToChatEnvelope(chatEnvelope: ChatEnvelope, snapshot: Record<string, unknown>): void;

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/context-merge.js

@@ -1,20 +1,4 @@
-import { selectToolCallIdStyleWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-inbound-outbound-semantics.js';
 import { applyReqOutboundContextSnapshotWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
-export function applyToolCallIdStyleMetadata(chatEnvelope, adapterContext, snapshot) {
-    const metadata = chatEnvelope.metadata || (chatEnvelope.metadata = { context: adapterContext });
-    const current = typeof metadata.toolCallIdStyle === 'string'
-        ? String(metadata.toolCallIdStyle).trim()
-        : '';
-    const resolved = selectToolCallIdStyleWithNative(adapterContext, snapshot ?? {}, current || undefined);
-    if (!resolved) {
-        return;
-    }
-    // Always honor the route-selected AdapterContext toolCallIdStyle when present.
-    // This prevents cross-provider leakage (e.g. LM Studio "preserve" contaminating OpenAI "fc").
-    if (!current || current !== resolved) {
-        metadata.toolCallIdStyle = resolved;
-    }
-}
 export function applyContextSnapshotToChatEnvelope(chatEnvelope, snapshot) {
     const hasExistingTools = Array.isArray(chatEnvelope.tools) && chatEnvelope.tools.length > 0;
     const patch = applyReqOutboundContextSnapshotWithNative({

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/index.d.ts

@@ -1,6 +1,6 @@
 import type { AdapterContext, ChatEnvelope } from '../../../../types/chat-envelope.js';
 import type { FormatEnvelope } from '../../../../types/format-envelope.js';
-import type { JsonObject } from '../../../../types/json.js';
+import { type JsonObject } from '../../../../types/json.js';
 import type { StageRecorder, SemanticMapper } from '../../../../format-adapters/index.js';
 import type { ProcessedRequest, StandardizedRequest } from '../../../../types/standardized.js';
 export interface ReqOutboundStage1SemanticMapOptions {

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/index.js

@@ -1,35 +1,53 @@
+import { isJsonObject } from '../../../../types/json.js';
 import { applyHubOperationTableOutboundPostMap, applyHubOperationTableOutboundPreMap } from '../../../../operation-table/operation-table-runner.js';
 import { recordStage } from '../../../stages/utils.js';
-import { applyContextSnapshotToChatEnvelope, applyToolCallIdStyleMetadata } from './context-merge.js';
+import { applyContextSnapshotToChatEnvelope } from './context-merge.js';
 import { shouldAttachReqOutboundContextSnapshotWithNative, standardizedToChatEnvelopeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
 import { validateChatEnvelopeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
+import { measureHubStage } from '../../../hub-stage-timing.js';
+function hasResponsesContextSemantics(chatEnvelope) {
+    if (!chatEnvelope?.semantics || typeof chatEnvelope.semantics !== 'object') {
+        return false;
+    }
+    const responsesNode = isJsonObject(chatEnvelope.semantics.responses)
+        ? chatEnvelope.semantics.responses
+        : undefined;
+    return Boolean(responsesNode && isJsonObject(responsesNode.context));
+}
 export async function runReqOutboundStage1SemanticMap(options) {
-    const chatEnvelope = standardizedToChatEnvelopeWithNative({
+    const requestId = options.adapterContext.requestId;
+    const chatEnvelope = await measureHubStage(requestId, 'request_stage.req_outbound.semantic_map.native.to_chat_envelope', () => standardizedToChatEnvelopeWithNative({
         request: options.request,
         adapterContext: options.adapterContext
-    });
-    applyToolCallIdStyleMetadata(chatEnvelope, options.adapterContext, options.contextSnapshot);
+    }));
     const shouldAttachContextSnapshot = shouldAttachReqOutboundContextSnapshotWithNative(Boolean(options.contextSnapshot), options.contextMetadataKey);
-    if (shouldAttachContextSnapshot && options.contextSnapshot && options.contextMetadataKey) {
+    const shouldSkipResponsesSnapshotMerge = options.contextMetadataKey === 'responsesContext' &&
+        hasResponsesContextSemantics(chatEnvelope);
+    if (shouldAttachContextSnapshot &&
+        !shouldSkipResponsesSnapshotMerge &&
+        options.contextSnapshot &&
+        options.contextMetadataKey) {
         const snapshot = options.contextSnapshot;
-        chatEnvelope.metadata[options.contextMetadataKey] = snapshot;
-        applyContextSnapshotToChatEnvelope(chatEnvelope, snapshot);
+        if (options.contextMetadataKey !== 'responsesContext') {
+            chatEnvelope.metadata[options.contextMetadataKey] = snapshot;
+        }
+        await measureHubStage(requestId, 'request_stage.req_outbound.semantic_map.context_merge', () => applyContextSnapshotToChatEnvelope(chatEnvelope, snapshot));
     }
     validateChatEnvelopeWithNative(chatEnvelope, {
         stage: 'req_outbound',
         direction: 'request'
     });
-    await applyHubOperationTableOutboundPreMap({
+    await measureHubStage(requestId, 'request_stage.req_outbound.semantic_map.operation_table_pre_map', () => applyHubOperationTableOutboundPreMap({
         protocol: options.adapterContext.providerProtocol,
         chatEnvelope,
         adapterContext: options.adapterContext
-    });
-    const formatEnvelope = (await options.semanticMapper.fromChat(chatEnvelope, options.adapterContext));
-    applyHubOperationTableOutboundPostMap({
+    }));
+    const formatEnvelope = await measureHubStage(requestId, 'request_stage.req_outbound.semantic_map.mapper.from_chat', async () => (await options.semanticMapper.fromChat(chatEnvelope, options.adapterContext)));
+    await measureHubStage(requestId, 'request_stage.req_outbound.semantic_map.operation_table_post_map', () => applyHubOperationTableOutboundPostMap({
         chatEnvelope,
         formatEnvelope,
         adapterContext: options.adapterContext
-    });
+    }));
     recordStage(options.stageRecorder, 'chat_process.req.stage6.outbound.semantic_map', chatEnvelope);
     return { chatEnvelope, formatEnvelope };
 }

package/dist/conversion/hub/pipeline/stages/req_process/req_process_stage1_tool_governance/index.d.ts

@@ -7,6 +7,7 @@ export interface ReqProcessStage1ToolGovernanceOptions {
     metadata: Record<string, unknown>;
     entryEndpoint: string;
     requestId: string;
+    applyPatchToolMode?: 'schema' | 'freeform';
     stageRecorder?: StageRecorder;
 }
 export interface ReqProcessStage1ToolGovernanceResult {

package/dist/conversion/hub/pipeline/stages/req_process/req_process_stage1_tool_governance/index.js

@@ -2,6 +2,7 @@ import { recordStage } from '../../../stages/utils.js';
 import { captureApplyPatchExecutionFailuresFromProcessedRequest } from '../../../../../../tools/apply-patch/execution-capturer.js';
 import { applyReqProcessToolGovernanceWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-process-semantics.js';
 import { maybeInjectClockRemindersAndApplyDirectives } from '../../../../process/chat-process-clock-reminders.js';
+import { resolveHasActiveStopMessageForContinueExecution } from '../../../../process/chat-process-continue-execution.js';
 function isRecord(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
@@ -28,12 +29,14 @@ function parseNodeResult(value) {
     return value;
 }
 export async function runReqProcessStage1ToolGovernance(options) {
+    const hasActiveStopMessageForContinueExecution = resolveHasActiveStopMessageForContinueExecution(options.metadata);
     const nativeResult = applyReqProcessToolGovernanceWithNative({
         request: options.request,
         rawPayload: options.rawPayload,
         metadata: options.metadata,
         entryEndpoint: options.entryEndpoint,
-        requestId: options.requestId
+        requestId: options.requestId,
+        hasActiveStopMessageForContinueExecution
     });
     let processedRequest = parseProcessedRequest(nativeResult.processedRequest);
     const nodeResult = parseNodeResult(nativeResult.nodeResult);
@@ -51,7 +54,7 @@ export async function runReqProcessStage1ToolGovernance(options) {
     recordStage(options.stageRecorder, 'chat_process.req.stage4.tool_governance', processedRequest);
     // Best-effort: capture apply_patch execution failures reported by tool role messages.
     // This is for errorsamples collection only and must not affect runtime behavior.
-    captureApplyPatchExecutionFailuresFromProcessedRequest(processedRequest);
+    captureApplyPatchExecutionFailuresFromProcessedRequest(processedRequest, options.applyPatchToolMode);
     return {
         processedRequest,
         nodeResult

package/dist/conversion/hub/pipeline/stages/req_process/req_process_stage2_route_select/index.d.ts

@@ -14,4 +14,4 @@ export interface ReqProcessStage2RouteSelectResult {
     decision: RoutingDecision;
     diagnostics: RoutingDiagnostics;
 }
-export declare function runReqProcessStage2RouteSelect(options: ReqProcessStage2RouteSelectOptions): ReqProcessStage2RouteSelectResult;
+export declare function runReqProcessStage2RouteSelect(options: ReqProcessStage2RouteSelectOptions): Promise<ReqProcessStage2RouteSelectResult>;

package/dist/conversion/hub/pipeline/stages/req_process/req_process_stage2_route_select/index.js

@@ -1,6 +1,7 @@
 import { recordStage } from '../../../stages/utils.js';
 import { applyReqProcessRouteSelectionWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-process-semantics.js';
 import { cleanRoutingInstructionMarkersWithNative } from '../../../../../../router/virtual-router/engine-selection/native-virtual-router-routing-instructions-semantics.js';
+import { measureHubStage } from '../../../hub-stage-timing.js';
 function replaceRecordInPlace(target, source) {
     for (const key of Object.keys(target)) {
         if (!Object.prototype.hasOwnProperty.call(source, key)) {
@@ -9,17 +10,20 @@ function replaceRecordInPlace(target, source) {
     }
     Object.assign(target, source);
 }
-export function runReqProcessStage2RouteSelect(options) {
+export async function runReqProcessStage2RouteSelect(options) {
     const previousModel = typeof options.request.model === 'string' ? options.request.model : undefined;
-    const result = options.routerEngine.route(options.request, options.metadataInput);
-    const nativeApplied = applyReqProcessRouteSelectionWithNative({
+    const requestId = typeof options.metadataInput.requestId === 'string' && options.metadataInput.requestId.trim()
+        ? options.metadataInput.requestId.trim()
+        : 'unknown';
+    const result = await measureHubStage(requestId, 'route_select.engine_route', () => options.routerEngine.route(options.request, options.metadataInput));
+    const nativeApplied = await measureHubStage(requestId, 'route_select.native_apply', () => applyReqProcessRouteSelectionWithNative({
         request: options.request,
         normalizedMetadata: options.normalizedMetadata,
         target: result.target,
         routeName: result.decision.routeName,
         originalModel: previousModel
-    });
-    const cleanedRequest = cleanRoutingInstructionMarkersWithNative(nativeApplied.request);
+    }));
+    const cleanedRequest = await measureHubStage(requestId, 'route_select.clean_markers', () => cleanRoutingInstructionMarkersWithNative(nativeApplied.request));
     replaceRecordInPlace(options.request, cleanedRequest);
     replaceRecordInPlace(options.normalizedMetadata, nativeApplied.normalizedMetadata);
     recordStage(options.stageRecorder, 'chat_process.req.stage5.route_select', {

package/dist/conversion/hub/process/chat-process-continue-execution.js

@@ -1,7 +1,7 @@
 import { readRuntimeMetadata } from '../../runtime-metadata.js';
 import { loadRoutingInstructionStateSync } from '../../../router/virtual-router/sticky-session-store.js';
 import { logContinueExecution } from '../../../servertool/continue-execution/log.js';
-import { buildContinueExecutionOperationsWithNative, injectContinueExecutionDirectiveWithNative, planContinueExecutionOperationsWithNative, resolveHasActiveStopMessageForContinueExecutionWithNative, resolveStopMessageSessionScopeWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';
+import { buildContinueExecutionOperationsWithNative, injectContinueExecutionDirectiveWithNative, planContinueExecutionOperationsWithNative, isStopMessageStateActiveWithNative, resolveStopMessageSessionScopeWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';
 import { isClientInjectReady } from './client-inject-readiness.js';
 const CONTINUE_EXECUTION_INJECTION_MARKER = '[routecodex:continue_execution_injection]';
 const CONTINUE_EXECUTION_INJECTION_TEXT = '继续执行';
@@ -59,10 +59,8 @@ export function injectContinueExecutionDirectiveIntoUserMessage(request, metadat
     };
 }
 function hasActiveStopMessageStateForContinueExecution(metadata) {
-    const rt = (readRuntimeMetadata(metadata) ?? {});
-    const runtimeState = rt?.stopMessageState;
     const persistedState = resolvePersistedStopMessageState(metadata);
-    return resolveHasActiveStopMessageForContinueExecutionWithNative(runtimeState, persistedState);
+    return isStopMessageStateActiveWithNative(persistedState);
 }
 export function resolveHasActiveStopMessageForContinueExecution(metadata) {
     return hasActiveStopMessageStateForContinueExecution(metadata);

package/dist/conversion/hub/process/chat-process-governance-orchestration.js

@@ -1,6 +1,7 @@
 import { applyReqProcessToolGovernanceWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-process-semantics.js';
 import { maybeInjectClockRemindersAndApplyDirectives } from './chat-process-clock-reminders.js';
 import { finalizeGovernedRequest } from './chat-process-governance-finalize.js';
+import { resolveHasActiveStopMessageForContinueExecution } from './chat-process-continue-execution.js';
 function isRecord(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
@@ -32,7 +33,8 @@ export async function applyRequestToolGovernance(request, context, governanceEng
         rawPayload: context.rawPayload ?? request,
         metadata: context.metadata,
         entryEndpoint: context.entryEndpoint,
-        requestId: context.requestId
+        requestId: context.requestId,
+        hasActiveStopMessageForContinueExecution: resolveHasActiveStopMessageForContinueExecution(context.metadata)
     });
     const governedRequest = parseGovernedRequest(nativeResult.processedRequest);
     const requestAfterInject = await maybeInjectClockRemindersAndApplyDirectives(governedRequest, context.metadata, context.requestId);

package/dist/conversion/hub/process/chat-process-media.d.ts

@@ -1,3 +1,4 @@
 import type { StandardizedMessage } from '../types/standardized.js';
 export declare function stripHistoricalImageAttachments(messages: StandardizedMessage[]): StandardizedMessage[];
+export declare function stripHistoricalVisualToolOutputs(messages: StandardizedMessage[]): StandardizedMessage[];
 export declare function containsImageAttachment(messages: StandardizedMessage[]): boolean;