@jsonstudio/llms 0.6.3685 → 0.6.3686

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

@@ -1,44 +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 { measureHubStage } from '../../../hub-stage-timing.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);
-    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({
+    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
-    }));
-    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);
+        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);
+    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,59 +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 { 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';
-}
+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) {
-    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 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;
@@ -68,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.
@@ -76,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;
@@ -93,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 {
@@ -127,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_inbound/req_inbound_stage3_context_capture/context-capture-orchestration.d.ts

@@ -1,18 +1,15 @@
 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,8 +13,7 @@ export async function runReqInboundStage3ContextCaptureOrchestration(options) {
         try {
             context = await options.captureContext({
                 rawRequest: options.rawRequest,
-                adapterContext: options.adapterContext,
-                chatEnvelope: options.chatEnvelope
+                adapterContext: options.adapterContext
             });
         }
         catch {

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

@@ -4,7 +4,6 @@ export function createResponsesContextCapture(captureImpl) {
     return (options) => runReqInboundStage3ContextCapture({
         rawRequest: options.rawRequest,
         adapterContext: options.adapterContext,
-        chatEnvelope: options.chatEnvelope,
         stageRecorder: options.stageRecorder,
         captureContext: captureImpl
     });
@@ -14,7 +13,6 @@ 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,7 +9,6 @@ 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,9 +1,8 @@
-import type { AdapterContext, ChatEnvelope } from '../../../../types/chat-envelope.js';
-import { type JsonObject } from '../../../../types/json.js';
+import type { AdapterContext } 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,24 +1,11 @@
-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 = readResponsesContextFromChatEnvelope(options.chatEnvelope) ??
-        captureReqInboundResponsesContextSnapshotWithNative({
-            rawRequest: options.rawRequest,
-            requestId: options.adapterContext.requestId,
-            toolCallIdStyle: options.adapterContext.toolCallIdStyle
-        });
+    const context = 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,2 +1,3 @@
-import type { ChatEnvelope } from '../../../../types/chat-envelope.js';
+import type { AdapterContext, ChatEnvelope } from '../../../../types/chat-envelope.js';
+export declare function applyToolCallIdStyleMetadata(chatEnvelope: ChatEnvelope, adapterContext: AdapterContext, snapshot?: Record<string, unknown>): void;
 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,4 +1,20 @@
+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,53 +1,78 @@
-import { isJsonObject } from '../../../../types/json.js';
 import { applyHubOperationTableOutboundPostMap, applyHubOperationTableOutboundPreMap } from '../../../../operation-table/operation-table-runner.js';
 import { recordStage } from '../../../stages/utils.js';
-import { applyContextSnapshotToChatEnvelope } from './context-merge.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 { 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));
-}
+import { logHubStageTiming } from '../../../hub-stage-timing.js';
 export async function runReqOutboundStage1SemanticMap(options) {
-    const requestId = options.adapterContext.requestId;
-    const chatEnvelope = await measureHubStage(requestId, 'request_stage.req_outbound.semantic_map.native.to_chat_envelope', () => standardizedToChatEnvelopeWithNative({
+    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);
-    const shouldSkipResponsesSnapshotMerge = options.contextMetadataKey === 'responsesContext' &&
-        hasResponsesContextSemantics(chatEnvelope);
-    if (shouldAttachContextSnapshot &&
-        !shouldSkipResponsesSnapshotMerge &&
-        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;
         if (options.contextMetadataKey !== 'responsesContext') {
             chatEnvelope.metadata[options.contextMetadataKey] = snapshot;
         }
-        await measureHubStage(requestId, 'request_stage.req_outbound.semantic_map.context_merge', () => applyContextSnapshotToChatEnvelope(chatEnvelope, 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'
     });
-    await measureHubStage(requestId, 'request_stage.req_outbound.semantic_map.operation_table_pre_map', () => applyHubOperationTableOutboundPreMap({
+    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
-    }));
-    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({
+    });
+    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.d.ts

@@ -7,7 +7,6 @@ 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

@@ -54,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, options.applyPatchToolMode);
+    captureApplyPatchExecutionFailuresFromProcessedRequest(processedRequest);
     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): Promise<ReqProcessStage2RouteSelectResult>;
+export declare function runReqProcessStage2RouteSelect(options: ReqProcessStage2RouteSelectOptions): ReqProcessStage2RouteSelectResult;

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

@@ -1,7 +1,6 @@
 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)) {
@@ -10,20 +9,17 @@ function replaceRecordInPlace(target, source) {
     }
     Object.assign(target, source);
 }
-export async function runReqProcessStage2RouteSelect(options) {
+export function runReqProcessStage2RouteSelect(options) {
     const previousModel = typeof options.request.model === 'string' ? options.request.model : undefined;
-    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({
+    const result = options.routerEngine.route(options.request, options.metadataInput);
+    const nativeApplied = applyReqProcessRouteSelectionWithNative({
         request: options.request,
         normalizedMetadata: options.normalizedMetadata,
         target: result.target,
         routeName: result.decision.routeName,
         originalModel: previousModel
-    }));
-    const cleanedRequest = await measureHubStage(requestId, 'route_select.clean_markers', () => cleanRoutingInstructionMarkersWithNative(nativeApplied.request));
+    });
+    const cleanedRequest = 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

@@ -59,6 +59,9 @@ export function injectContinueExecutionDirectiveIntoUserMessage(request, metadat
     };
 }
 function hasActiveStopMessageStateForContinueExecution(metadata) {
+    if (!isClientInjectReady(metadata)) {
+        return false;
+    }
     const persistedState = resolvePersistedStopMessageState(metadata);
     return isStopMessageStateActiveWithNative(persistedState);
 }

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

@@ -1,4 +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[];