@jsonstudio/llms 0.6.3551 → 0.6.3686

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.d.ts

@@ -1,7 +1,7 @@
-import type { AdapterContext } from '../../../../types/chat-envelope.js';
-import type { FormatEnvelope } from '../../../../types/format-envelope.js';
-import type { JsonObject } from '../../../../types/json.js';
-import type { StageRecorder } from '../../../../format-adapters/index.js';
+import type { AdapterContext } from "../../../../types/chat-envelope.js";
+import type { FormatEnvelope } from "../../../../types/format-envelope.js";
+import type { JsonObject } from "../../../../types/json.js";
+import type { StageRecorder } from "../../../../format-adapters/index.js";
 export interface ReqInboundStage1FormatParseOptions {
     rawRequest: JsonObject;
     adapterContext: AdapterContext;

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

@@ -1,42 +1,61 @@
-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 { 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 { logHubStageTiming } from "../../../hub-stage-timing.js";
 function resolveProtocolToken(adapterContext) {
-    const candidate = typeof adapterContext.providerProtocol === 'string' && adapterContext.providerProtocol.trim().length
+    const candidate = typeof adapterContext.providerProtocol === "string" &&
+        adapterContext.providerProtocol.trim().length
         ? adapterContext.providerProtocol.trim().toLowerCase()
-        : '';
-    if (candidate === 'openai-chat' || candidate === 'openai-responses' || candidate === 'anthropic-messages' || candidate === 'gemini-chat') {
+        : "";
+    if (candidate === "openai-chat" ||
+        candidate === "openai-responses" ||
+        candidate === "anthropic-messages" ||
+        candidate === "gemini-chat") {
         return candidate;
     }
-    return 'openai-chat';
+    return "openai-chat";
 }
 function applyReasoningNormalization(rawRequest, protocol) {
-    if (protocol === 'openai-responses') {
+    if (protocol === "openai-responses") {
         normalizeReasoningInResponsesPayload(rawRequest, {
             includeInput: true,
-            includeInstructions: true
+            includeInstructions: true,
         });
         return;
     }
-    if (protocol === 'anthropic-messages') {
+    if (protocol === "anthropic-messages") {
         normalizeReasoningInAnthropicPayload(rawRequest);
         return;
     }
-    if (protocol === 'gemini-chat') {
+    if (protocol === "gemini-chat") {
         normalizeReasoningInGeminiPayload(rawRequest);
         return;
     }
     normalizeReasoningInChatPayload(rawRequest);
 }
 export async function runReqInboundStage1FormatParse(options) {
+    const requestId = options.adapterContext.requestId || "unknown";
     const protocol = resolveProtocolToken(options.adapterContext);
+    logHubStageTiming(requestId, "req_inbound.stage1_reasoning_normalize", "start", { protocol });
+    const normalizeStart = Date.now();
     applyReasoningNormalization(options.rawRequest, protocol);
+    logHubStageTiming(requestId, "req_inbound.stage1_reasoning_normalize", "completed", { elapsedMs: Date.now() - normalizeStart, protocol });
+    logHubStageTiming(requestId, "req_inbound.stage1_native_parse", "start");
+    const parseStart = Date.now();
     const envelopeRaw = parseReqInboundFormatEnvelopeWithNative({
         rawRequest: options.rawRequest,
-        protocol
+        protocol,
     });
+    logHubStageTiming(requestId, "req_inbound.stage1_native_parse", "completed", {
+        elapsedMs: Date.now() - parseStart,
+    });
+    logHubStageTiming(requestId, "req_inbound.stage1_sanitize", "start");
+    const sanitizeStart = Date.now();
     const envelope = sanitizeReqInboundFormatEnvelopeWithNative(envelopeRaw);
-    recordStage(options.stageRecorder, 'chat_process.req.stage1.format_parse', envelope);
+    logHubStageTiming(requestId, "req_inbound.stage1_sanitize", "completed", {
+        elapsedMs: Date.now() - sanitizeStart,
+    });
+    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.d.ts

@@ -1,12 +1,12 @@
-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 { SemanticMapper, StageRecorder } from '../../../../format-adapters/index.js';
-import type { StandardizedRequest } from '../../../../types/standardized.js';
+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 { SemanticMapper, StageRecorder } from "../../../../format-adapters/index.js";
+import type { StandardizedRequest } from "../../../../types/standardized.js";
 export interface ReqInboundStage2SemanticMapOptions {
     adapterContext: AdapterContext;
     formatEnvelope: FormatEnvelope<JsonObject>;
-    semanticMapper: Pick<SemanticMapper, 'toChat'>;
+    semanticMapper: Pick<SemanticMapper, "toChat">;
     /**
      * Mappable cross-protocol semantics (e.g. /v1/responses submit resume) must be
      * lifted into chat semantics before entering chat_process.
@@ -19,5 +19,6 @@ export interface ReqInboundStage2SemanticMapOptions {
 export interface ReqInboundStage2SemanticMapResult {
     chatEnvelope: ChatEnvelope;
     standardizedRequest: StandardizedRequest;
+    responsesContext?: JsonObject;
 }
 export declare function runReqInboundStage2SemanticMap(options: ReqInboundStage2SemanticMapOptions): Promise<ReqInboundStage2SemanticMapResult>;

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

@@ -1,13 +1,18 @@
-import { isJsonObject, jsonClone } from '../../../../types/json.js';
-import { applyHubOperationTableInbound } from '../../../../operation-table/operation-table-runner.js';
-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 { isJsonObject, jsonClone, } from "../../../../types/json.js";
+import { applyHubOperationTableInbound } from "../../../../operation-table/operation-table-runner.js";
+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 { logHubStageTiming } from "../../../hub-stage-timing.js";
 export async function runReqInboundStage2SemanticMap(options) {
+    const requestId = options.adapterContext.requestId || "unknown";
+    logHubStageTiming(requestId, "req_inbound.stage2_semantic_mapper_toChat", "start");
+    const toChatStart = Date.now();
     const chatEnvelope = await options.semanticMapper.toChat(options.formatEnvelope, options.adapterContext);
+    logHubStageTiming(requestId, "req_inbound.stage2_semantic_mapper_toChat", "completed", { elapsedMs: Date.now() - toChatStart });
     const preservedResponsesContext = (() => {
-        if (!chatEnvelope.semantics || typeof chatEnvelope.semantics !== 'object') {
+        if (!chatEnvelope.semantics || typeof chatEnvelope.semantics !== "object") {
             return undefined;
         }
         const semantics = chatEnvelope.semantics;
@@ -22,7 +27,7 @@ export async function runReqInboundStage2SemanticMap(options) {
     applyHubOperationTableInbound({
         formatEnvelope: options.formatEnvelope,
         chatEnvelope,
-        adapterContext: options.adapterContext
+        adapterContext: options.adapterContext,
     });
     // Semantic Gate (request): before entering chat_process, lift any mappable protocol semantics
     // into ChatEnvelope.semantics. Do not persist these in metadata.
@@ -30,12 +35,14 @@ export async function runReqInboundStage2SemanticMap(options) {
         chatEnvelope,
         formatEnvelope: options.formatEnvelope,
         adapterContext: options.adapterContext,
-        responsesResume: options.responsesResume
+        responsesResume: options.responsesResume,
     });
     if (preservedResponsesContext) {
         const currentSemantics = chatEnvelope.semantics;
-        if (!currentSemantics || typeof currentSemantics !== 'object') {
-            chatEnvelope.semantics = { responses: { context: jsonClone(preservedResponsesContext) } };
+        if (!currentSemantics || typeof currentSemantics !== "object") {
+            chatEnvelope.semantics = {
+                responses: { context: jsonClone(preservedResponsesContext) },
+            };
         }
         else {
             const semantics = currentSemantics;
@@ -47,28 +54,31 @@ export async function runReqInboundStage2SemanticMap(options) {
                     ...semantics,
                     responses: {
                         ...responsesNode,
-                        context: jsonClone(preservedResponsesContext)
-                    }
+                        context: jsonClone(preservedResponsesContext),
+                    },
                 };
             }
         }
     }
     validateChatEnvelopeWithNative(chatEnvelope, {
-        stage: 'req_inbound',
-        direction: 'request'
+        stage: "req_inbound",
+        direction: "request",
     });
-    recordStage(options.stageRecorder, 'chat_process.req.stage2.semantic_map', chatEnvelope);
+    recordStage(options.stageRecorder, "chat_process.req.stage2.semantic_map", chatEnvelope);
+    logHubStageTiming(requestId, "req_inbound.stage2_to_standardized", "start");
+    const stdStart = Date.now();
     const standardizedRequest = chatEnvelopeToStandardizedWithNative({
         chatEnvelope: chatEnvelope,
         adapterContext: options.adapterContext,
         endpoint: options.adapterContext.entryEndpoint,
-        requestId: options.adapterContext.requestId
+        requestId: options.adapterContext.requestId,
     });
+    logHubStageTiming(requestId, "req_inbound.stage2_to_standardized", "completed", { elapsedMs: Date.now() - stdStart });
     // Ensure responses semantics (context) survive into standardized request for VirtualRouter parsing.
-    if (chatEnvelope.semantics && typeof chatEnvelope.semantics === 'object') {
+    if (chatEnvelope.semantics && typeof chatEnvelope.semantics === "object") {
         const envelopeSemantics = chatEnvelope.semantics;
         const existing = standardizedRequest.semantics;
-        if (!existing || typeof existing !== 'object') {
+        if (!existing || typeof existing !== "object") {
             standardizedRequest.semantics = jsonClone(envelopeSemantics);
         }
         else {
@@ -81,15 +91,23 @@ export async function runReqInboundStage2SemanticMap(options) {
                 : undefined;
             if (envelopeContext) {
                 const nextResponses = {
-                    ...(isJsonObject(existingObj.responses) ? existingObj.responses : {}),
-                    context: jsonClone(envelopeContext)
+                    ...(isJsonObject(existingObj.responses)
+                        ? existingObj.responses
+                        : {}),
+                    context: jsonClone(envelopeContext),
                 };
                 standardizedRequest.semantics = {
                     ...existingObj,
-                    responses: nextResponses
+                    responses: nextResponses,
                 };
             }
         }
     }
-    return { chatEnvelope, standardizedRequest };
+    return {
+        chatEnvelope,
+        standardizedRequest,
+        ...(preservedResponsesContext
+            ? { responsesContext: preservedResponsesContext }
+            : {}),
+    };
 }

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

@@ -3,33 +3,76 @@ import { recordStage } from '../../../stages/utils.js';
 import { applyContextSnapshotToChatEnvelope, applyToolCallIdStyleMetadata } 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 { logHubStageTiming } from '../../../hub-stage-timing.js';
 export async function runReqOutboundStage1SemanticMap(options) {
+    const requestId = options.adapterContext.requestId || 'unknown';
+    const forceDetailLog = String(process.env.ROUTECODEX_HUB_STAGE_TIMING_DETAIL || '')
+        .trim()
+        .toLowerCase() === '1';
+    logHubStageTiming(requestId, 'req_outbound.stage1_native_to_chat_envelope', 'start');
+    const toChatStart = Date.now();
     const chatEnvelope = standardizedToChatEnvelopeWithNative({
         request: options.request,
         adapterContext: options.adapterContext
     });
+    logHubStageTiming(requestId, 'req_outbound.stage1_native_to_chat_envelope', 'completed', {
+        elapsedMs: Date.now() - toChatStart,
+        forceLog: forceDetailLog
+    });
     applyToolCallIdStyleMetadata(chatEnvelope, options.adapterContext, options.contextSnapshot);
     const shouldAttachContextSnapshot = shouldAttachReqOutboundContextSnapshotWithNative(Boolean(options.contextSnapshot), options.contextMetadataKey);
     if (shouldAttachContextSnapshot && options.contextSnapshot && options.contextMetadataKey) {
+        logHubStageTiming(requestId, 'req_outbound.stage1_context_merge', 'start');
+        const contextMergeStart = Date.now();
         const snapshot = options.contextSnapshot;
-        chatEnvelope.metadata[options.contextMetadataKey] = snapshot;
+        if (options.contextMetadataKey !== 'responsesContext') {
+            chatEnvelope.metadata[options.contextMetadataKey] = snapshot;
+        }
         applyContextSnapshotToChatEnvelope(chatEnvelope, snapshot);
+        logHubStageTiming(requestId, 'req_outbound.stage1_context_merge', 'completed', {
+            elapsedMs: Date.now() - contextMergeStart,
+            forceLog: forceDetailLog
+        });
     }
+    logHubStageTiming(requestId, 'req_outbound.stage1_validate_chat_envelope', 'start');
+    const validateStart = Date.now();
     validateChatEnvelopeWithNative(chatEnvelope, {
         stage: 'req_outbound',
         direction: 'request'
     });
+    logHubStageTiming(requestId, 'req_outbound.stage1_validate_chat_envelope', 'completed', {
+        elapsedMs: Date.now() - validateStart,
+        forceLog: forceDetailLog
+    });
+    logHubStageTiming(requestId, 'req_outbound.stage1_operation_table_pre_map', 'start');
+    const preMapStart = Date.now();
     await applyHubOperationTableOutboundPreMap({
         protocol: options.adapterContext.providerProtocol,
         chatEnvelope,
         adapterContext: options.adapterContext
     });
+    logHubStageTiming(requestId, 'req_outbound.stage1_operation_table_pre_map', 'completed', {
+        elapsedMs: Date.now() - preMapStart,
+        forceLog: forceDetailLog
+    });
+    logHubStageTiming(requestId, 'req_outbound.stage1_mapper_from_chat', 'start');
+    const fromChatStart = Date.now();
     const formatEnvelope = (await options.semanticMapper.fromChat(chatEnvelope, options.adapterContext));
+    logHubStageTiming(requestId, 'req_outbound.stage1_mapper_from_chat', 'completed', {
+        elapsedMs: Date.now() - fromChatStart,
+        forceLog: forceDetailLog
+    });
+    logHubStageTiming(requestId, 'req_outbound.stage1_operation_table_post_map', 'start');
+    const postMapStart = Date.now();
     applyHubOperationTableOutboundPostMap({
         chatEnvelope,
         formatEnvelope,
         adapterContext: options.adapterContext
     });
+    logHubStageTiming(requestId, 'req_outbound.stage1_operation_table_post_map', 'completed', {
+        elapsedMs: Date.now() - postMapStart,
+        forceLog: forceDetailLog
+    });
     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.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);

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,11 @@ export function injectContinueExecutionDirectiveIntoUserMessage(request, metadat
     };
 }
 function hasActiveStopMessageStateForContinueExecution(metadata) {
-    const rt = (readRuntimeMetadata(metadata) ?? {});
-    const runtimeState = rt?.stopMessageState;
+    if (!isClientInjectReady(metadata)) {
+        return false;
+    }
     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,5 @@
-import type { StandardizedMessage } from '../types/standardized.js';
+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;
+export declare function repairIncompleteToolCalls(messages: StandardizedMessage[]): StandardizedMessage[];