@jsonstudio/rcc 0.90.323 → 0.90.364

package/vendor/@jsonstudio/llms/dist/conversion/hub/pipeline/hub-stage-timing.d.ts

@@ -0,0 +1,8 @@
+export declare function isHubStageTimingDetailEnabled(): boolean;
+export declare function clearHubStageTiming(requestId: string | undefined | null): void;
+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/vendor/@jsonstudio/llms/dist/conversion/hub/pipeline/hub-stage-timing.js

@@ -0,0 +1,211 @@
+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 = 50;
+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;
+    if (explicit !== undefined) {
+        return resolveBool(explicit, false);
+    }
+    return false;
+}
+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;
+}
+export function isHubStageTimingDetailEnabled() {
+    const explicit = process.env.ROUTECODEX_STAGE_TIMING_DETAIL ??
+        process.env.RCC_STAGE_TIMING_DETAIL ??
+        process.env.ROUTECODEX_HUB_STAGE_TIMING_DETAIL ??
+        process.env.RCC_HUB_STAGE_TIMING_DETAIL;
+    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 clearHubStageTiming(requestId) {
+    if (!requestId) {
+        return;
+    }
+    REQUEST_TIMELINES.delete(requestId);
+}
+export function logHubStageTiming(requestId, stage, phase, details) {
+    if (!isHubStageTimingEnabled() || !requestId || !stage) {
+        return;
+    }
+    if (phase === 'start') {
+        touchTiming(requestId);
+    }
+    // Skip start phases in non-verbose mode (they don't have elapsedMs anyway)
+    if (phase === 'start' && !isHubStageTimingVerboseEnabled()) {
+        return;
+    }
+    const timing = advanceTiming(requestId);
+    const thresholdMs = resolveHubStageTimingMinMs();
+    // Only gate non-error phases
+    if (phase !== 'error') {
+        const forceLog = details?.forceLog === true;
+        // forceLog with detail mode: check elapsedMs if available, otherwise allow
+        if (forceLog && isHubStageTimingDetailEnabled()) {
+            const elapsedMs = typeof details?.elapsedMs === 'number'
+                ? details.elapsedMs
+                : typeof details?.nativeMs === 'number'
+                    ? details.nativeMs
+                    : undefined;
+            // Even forceLog respects elapsedMs threshold if provided
+            if (elapsedMs !== undefined && elapsedMs < thresholdMs) {
+                return;
+            }
+            const detailSuffix = renderDetails(details);
+            const line = `[hub.detail][${requestId}] ${stage}.${phase}${timing.label}${detailSuffix}`;
+            console.log(line);
+            return;
+        }
+        // For completed phases: use elapsedMs if available (actual stage duration)
+        // This is the PRIMARY gating mechanism for completed stages
+        const elapsedMs = typeof details?.elapsedMs === 'number'
+            ? details.elapsedMs
+            : typeof details?.nativeMs === 'number'
+                ? details.nativeMs
+                : undefined;
+        if (elapsedMs !== undefined) {
+            // Has elapsedMs: gate by elapsedMs (stage's actual duration)
+            if (elapsedMs < thresholdMs) {
+                return;
+            }
+        }
+        else {
+            // No elapsedMs: gate by deltaMs (time since last log)
+            // This handles start phases and any completed phases without elapsedMs
+            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/vendor/@jsonstudio/llms/dist/conversion/hub/pipeline/session-identifiers.d.ts

@@ -0,0 +1,9 @@
+export interface SessionIdentifiers {
+    sessionId?: string;
+    conversationId?: string;
+}
+export declare function extractSessionIdentifiersFromMetadata(metadata: Record<string, unknown> | undefined): SessionIdentifiers;
+export declare function coerceClientHeaders(raw: unknown): Record<string, string> | undefined;
+export declare function pickHeader(headers: Record<string, string>, candidates: string[]): string | undefined;
+export declare function findHeaderValue(headers: Record<string, string>, target: string): string | undefined;
+export declare function normalizeHeaderKey(value: string): string;

package/vendor/@jsonstudio/llms/dist/conversion/hub/pipeline/session-identifiers.js

@@ -0,0 +1,16 @@
+import { coerceClientHeadersWithNative, extractSessionIdentifiersFromMetadataWithNative, findHeaderValueWithNative, normalizeHeaderKeyWithNative, pickHeaderWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-session-identifiers-semantics.js';
+export function extractSessionIdentifiersFromMetadata(metadata) {
+    return extractSessionIdentifiersFromMetadataWithNative(metadata);
+}
+export function coerceClientHeaders(raw) {
+    return coerceClientHeadersWithNative(raw);
+}
+export function pickHeader(headers, candidates) {
+    return pickHeaderWithNative(headers, candidates);
+}
+export function findHeaderValue(headers, target) {
+    return findHeaderValueWithNative(headers, target);
+}
+export function normalizeHeaderKey(value) {
+    return normalizeHeaderKeyWithNative(value);
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage1_format_parse/index.d.ts

@@ -0,0 +1,10 @@
+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;
+    stageRecorder?: StageRecorder;
+}
+export declare function runReqInboundStage1FormatParse(options: ReqInboundStage1FormatParseOptions): Promise<FormatEnvelope<JsonObject>>;

package/vendor/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage1_format_parse/index.js

@@ -0,0 +1,236 @@
+import { valueMayContainReasoningMarkup } from "../../../../../shared/reasoning-normalizer.js";
+import { recordStage } from "../../../stages/utils.js";
+import { normalizeReqInboundReasoningPayloadWithNative, 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 { logHubStageTiming } from "../../../hub-stage-timing.js";
+function resolveProtocolToken(adapterContext) {
+    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") {
+        return candidate;
+    }
+    return "openai-chat";
+}
+function shouldNormalizeReqInboundReasoningPayload(payload, protocol) {
+    if (!payload || typeof payload !== "object") {
+        return false;
+    }
+    switch (protocol) {
+        case "openai-chat":
+            return (valueMayContainReasoningMarkup(payload.messages) ||
+                valueMayContainReasoningMarkup(payload.choices));
+        case "openai-responses":
+            return responsesPayloadMayContainReasoningMarkup(payload);
+        case "anthropic-messages":
+            return (valueMayContainReasoningMarkup(payload.messages) ||
+                valueMayContainReasoningMarkup(payload.content));
+        case "gemini-chat":
+            return (valueMayContainReasoningMarkup(payload.contents) ||
+                valueMayContainReasoningMarkup(payload.candidates));
+        default:
+            return valueMayContainReasoningMarkup(payload);
+    }
+}
+function responsesPayloadMayContainReasoningMarkup(payload) {
+    const latestOutputTarget = findLatestResponsesReasoningTarget(payload.output, "output");
+    if (latestOutputTarget) {
+        const outputItems = payload.output;
+        if (responsesItemMayContainReasoningMarkup(outputItems[latestOutputTarget.index])) {
+            return true;
+        }
+    }
+    const latestInputTarget = findLatestResponsesReasoningTarget(payload.input, "input");
+    if (latestInputTarget) {
+        const inputItems = payload.input;
+        if (responsesItemMayContainReasoningMarkup(inputItems[latestInputTarget.index])) {
+            return true;
+        }
+    }
+    return (valueMayContainReasoningMarkup(payload.instructions) ||
+        valueMayContainReasoningMarkup(payload.required_action));
+}
+function findLatestResponsesReasoningTarget(value, field) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    for (let index = value.length - 1; index >= 0; index -= 1) {
+        if (responsesItemIsReasoningCarrier(value[index])) {
+            return { field, index };
+        }
+    }
+    return undefined;
+}
+function responsesItemIsReasoningCarrier(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const record = value;
+    const type = typeof record.type === "string" ? record.type.toLowerCase() : "";
+    const role = typeof record.role === "string" ? record.role.toLowerCase() : "";
+    return (type === "message" ||
+        type === "reasoning" ||
+        type === "output_text" ||
+        type === "text" ||
+        role === "assistant" ||
+        role === "model" ||
+        role === "system");
+}
+function responsesItemMayContainReasoningMarkup(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const record = value;
+    if (responsesContentMayContainReasoningMarkup(record.content) ||
+        responsesContentMayContainReasoningMarkup(record.text)) {
+        return true;
+    }
+    const type = typeof record.type === "string" ? record.type.toLowerCase() : "";
+    if (type !== "reasoning") {
+        return false;
+    }
+    return (responsesContentMayContainReasoningMarkup(record.summary) ||
+        responsesContentMayContainReasoningMarkup(record.reasoning));
+}
+function responsesContentMayContainReasoningMarkup(value) {
+    if (typeof value === "string") {
+        return valueMayContainReasoningMarkup(value);
+    }
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            if (responsesContentMayContainReasoningMarkup(entry)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    const record = value;
+    if (typeof record.text === "string" && valueMayContainReasoningMarkup(record.text)) {
+        return true;
+    }
+    if (typeof record.content === "string" && valueMayContainReasoningMarkup(record.content)) {
+        return true;
+    }
+    if (Array.isArray(record.content)) {
+        return responsesContentMayContainReasoningMarkup(record.content);
+    }
+    return false;
+}
+function normalizeLatestResponsesReasoningTarget(payload, target) {
+    const sourceItems = payload[target.field];
+    if (!Array.isArray(sourceItems)) {
+        return payload;
+    }
+    const current = sourceItems[target.index];
+    if (!current || typeof current !== "object") {
+        return payload;
+    }
+    const normalizedSlice = normalizeReqInboundReasoningPayloadWithNative({
+        payload: {
+            [target.field]: [current],
+        },
+        protocol: "openai-responses",
+    });
+    const normalizedItems = normalizedSlice[target.field];
+    if (!Array.isArray(normalizedItems) || normalizedItems.length === 0) {
+        return payload;
+    }
+    const nextItems = [...sourceItems];
+    nextItems[target.index] = normalizedItems[0];
+    return {
+        ...payload,
+        [target.field]: nextItems,
+    };
+}
+function normalizeReqInboundReasoningPayload(payload, protocol) {
+    if (!shouldNormalizeReqInboundReasoningPayload(payload, protocol)) {
+        return {
+            normalizedRequest: payload,
+            strategy: "fast_path",
+        };
+    }
+    if (protocol === "openai-responses") {
+        const latestOutputTarget = findLatestResponsesReasoningTarget(payload.output, "output");
+        if (latestOutputTarget) {
+            const outputItems = payload.output;
+            if (responsesItemMayContainReasoningMarkup(outputItems[latestOutputTarget.index])) {
+                return {
+                    normalizedRequest: normalizeLatestResponsesReasoningTarget(payload, latestOutputTarget),
+                    strategy: "native",
+                    target: `output[${latestOutputTarget.index}]`,
+                };
+            }
+        }
+        const latestInputTarget = findLatestResponsesReasoningTarget(payload.input, "input");
+        if (latestInputTarget) {
+            const inputItems = payload.input;
+            if (responsesItemMayContainReasoningMarkup(inputItems[latestInputTarget.index])) {
+                return {
+                    normalizedRequest: normalizeLatestResponsesReasoningTarget(payload, latestInputTarget),
+                    strategy: "native",
+                    target: `input[${latestInputTarget.index}]`,
+                };
+            }
+        }
+    }
+    return {
+        normalizedRequest: normalizeReqInboundReasoningPayloadWithNative({
+            payload: payload,
+            protocol,
+        }),
+        strategy: "native",
+    };
+}
+function approximateJsonBytes(value) {
+    try {
+        return JSON.stringify(value)?.length;
+    }
+    catch {
+        return undefined;
+    }
+}
+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();
+    const reasoningNormalize = normalizeReqInboundReasoningPayload(options.rawRequest, protocol);
+    const normalizedRequest = reasoningNormalize.normalizedRequest;
+    logHubStageTiming(requestId, "req_inbound.stage1_reasoning_normalize", "completed", {
+        elapsedMs: Date.now() - normalizeStart,
+        protocol,
+        strategy: reasoningNormalize.strategy,
+        target: reasoningNormalize.target,
+        approxBytes: approximateJsonBytes(options.rawRequest),
+        inputItems: Array.isArray(options.rawRequest.input)
+            ? options.rawRequest.input.length
+            : undefined,
+        outputItems: Array.isArray(options.rawRequest.output)
+            ? options.rawRequest.output.length
+            : undefined,
+    });
+    logHubStageTiming(requestId, "req_inbound.stage1_native_parse", "start");
+    const parseStart = Date.now();
+    const envelopeRaw = parseReqInboundFormatEnvelopeWithNative({
+        rawRequest: normalizedRequest,
+        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/vendor/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage2_semantic_map/index.d.ts

@@ -0,0 +1,24 @@
+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">;
+    /**
+     * Mappable cross-protocol semantics (e.g. /v1/responses submit resume) must be
+     * lifted into chat semantics before entering chat_process.
+     *
+     * This must never be stored in metadata/AdapterContext.
+     */
+    responsesResume?: JsonObject;
+    stageRecorder?: StageRecorder;
+}
+export interface ReqInboundStage2SemanticMapResult {
+    chatEnvelope: ChatEnvelope;
+    standardizedRequest: StandardizedRequest;
+    responsesContext?: JsonObject;
+}
+export declare function runReqInboundStage2SemanticMap(options: ReqInboundStage2SemanticMapOptions): Promise<ReqInboundStage2SemanticMapResult>;

package/vendor/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage2_semantic_map/index.js

@@ -0,0 +1,132 @@
+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 { isHubStageTimingDetailEnabled, logHubStageTiming, } from "../../../hub-stage-timing.js";
+export async function runReqInboundStage2SemanticMap(options) {
+    const requestId = options.adapterContext.requestId || "unknown";
+    const forceDetailLog = isHubStageTimingDetailEnabled();
+    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") {
+            return undefined;
+        }
+        const semantics = chatEnvelope.semantics;
+        const responsesNode = isJsonObject(semantics.responses)
+            ? semantics.responses
+            : undefined;
+        const contextNode = responsesNode && isJsonObject(responsesNode.context)
+            ? responsesNode.context
+            : undefined;
+        return contextNode ? jsonClone(contextNode) : undefined;
+    })();
+    logHubStageTiming(requestId, "req_inbound.stage2_operation_table_inbound", "start");
+    const operationTableStart = Date.now();
+    applyHubOperationTableInbound({
+        formatEnvelope: options.formatEnvelope,
+        chatEnvelope,
+        adapterContext: options.adapterContext,
+    });
+    logHubStageTiming(requestId, "req_inbound.stage2_operation_table_inbound", "completed", {
+        elapsedMs: Date.now() - operationTableStart,
+        forceLog: forceDetailLog,
+    });
+    // Semantic Gate (request): before entering chat_process, lift any mappable protocol semantics
+    // into ChatEnvelope.semantics. Do not persist these in metadata.
+    logHubStageTiming(requestId, "req_inbound.stage2_semantic_lift", "start");
+    const semanticLiftStart = Date.now();
+    liftReqInboundSemantics({
+        chatEnvelope,
+        formatEnvelope: options.formatEnvelope,
+        adapterContext: options.adapterContext,
+        responsesResume: options.responsesResume,
+    });
+    logHubStageTiming(requestId, "req_inbound.stage2_semantic_lift", "completed", {
+        elapsedMs: Date.now() - semanticLiftStart,
+        forceLog: forceDetailLog,
+    });
+    if (preservedResponsesContext) {
+        const currentSemantics = chatEnvelope.semantics;
+        if (!currentSemantics || typeof currentSemantics !== "object") {
+            chatEnvelope.semantics = {
+                responses: { context: jsonClone(preservedResponsesContext) },
+            };
+        }
+        else {
+            const semantics = currentSemantics;
+            const responsesNode = isJsonObject(semantics.responses)
+                ? semantics.responses
+                : {};
+            if (!isJsonObject(responsesNode.context)) {
+                chatEnvelope.semantics = {
+                    ...semantics,
+                    responses: {
+                        ...responsesNode,
+                        context: jsonClone(preservedResponsesContext),
+                    },
+                };
+            }
+        }
+    }
+    logHubStageTiming(requestId, "req_inbound.stage2_validate_chat_envelope", "start");
+    const validateStart = Date.now();
+    validateChatEnvelopeWithNative(chatEnvelope, {
+        stage: "req_inbound",
+        direction: "request",
+    });
+    logHubStageTiming(requestId, "req_inbound.stage2_validate_chat_envelope", "completed", {
+        elapsedMs: Date.now() - validateStart,
+        forceLog: forceDetailLog,
+    });
+    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,
+    });
+    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") {
+        const envelopeSemantics = chatEnvelope.semantics;
+        const existing = standardizedRequest.semantics;
+        if (!existing || typeof existing !== "object") {
+            standardizedRequest.semantics = jsonClone(envelopeSemantics);
+        }
+        else {
+            const existingObj = existing;
+            const envelopeResponses = isJsonObject(envelopeSemantics.responses)
+                ? envelopeSemantics.responses
+                : undefined;
+            const envelopeContext = envelopeResponses && isJsonObject(envelopeResponses.context)
+                ? envelopeResponses.context
+                : undefined;
+            if (envelopeContext) {
+                const nextResponses = {
+                    ...(isJsonObject(existingObj.responses)
+                        ? existingObj.responses
+                        : {}),
+                    context: jsonClone(envelopeContext),
+                };
+                standardizedRequest.semantics = {
+                    ...existingObj,
+                    responses: nextResponses,
+                };
+            }
+        }
+    }
+    return {
+        chatEnvelope,
+        standardizedRequest,
+        ...(preservedResponsesContext
+            ? { responsesContext: preservedResponsesContext }
+            : {}),
+    };
+}

package/vendor/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage2_semantic_map/semantic-lift.d.ts

@@ -0,0 +1,14 @@
+import type { AdapterContext, ChatEnvelope } from '../../../../types/chat-envelope.js';
+import type { FormatEnvelope } from '../../../../types/format-envelope.js';
+import type { JsonObject } from '../../../../types/json.js';
+export interface ReqInboundSemanticLiftOptions {
+    chatEnvelope: ChatEnvelope;
+    formatEnvelope: FormatEnvelope<JsonObject>;
+    adapterContext: AdapterContext;
+    responsesResume?: JsonObject;
+}
+export declare function liftReqInboundSemantics(options: ReqInboundSemanticLiftOptions): void;
+export declare function mapResumeToolOutputsDetailed(responsesResume: JsonObject): Array<{
+    tool_call_id: string;
+    content: string;
+}>;