@jsonstudio/llms 0.6.3551 → 0.6.3686

package/dist/router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js

@@ -1,9 +1,11 @@
-import { failNativeRequired, isNativeDisabledByEnv } from './native-router-hotpath-policy.js';
-import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+import { failNativeRequired, isNativeDisabledByEnv, } from "./native-router-hotpath-policy.js";
+import { loadNativeRouterHotpathBindingForInternalUse } from "./native-router-hotpath.js";
 function readNativeFunction(name) {
     const binding = loadNativeRouterHotpathBindingForInternalUse();
     const fn = binding?.[name];
-    return typeof fn === 'function' ? fn : null;
+    return typeof fn === "function"
+        ? fn
+        : null;
 }
 function safeStringify(value) {
     try {
@@ -16,7 +18,7 @@ function safeStringify(value) {
 function parseRecord(raw) {
     try {
         const parsed = JSON.parse(raw);
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
             return null;
         }
         return parsed;
@@ -28,27 +30,31 @@ function parseRecord(raw) {
 function parseFormatEnvelopePayload(raw, direction, fallbackProtocol, fallbackPayload) {
     try {
         const parsed = JSON.parse(raw);
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
             return null;
         }
         const row = parsed;
         const envelope = row.envelope;
-        if (!envelope || typeof envelope !== 'object' || Array.isArray(envelope)) {
+        if (!envelope || typeof envelope !== "object" || Array.isArray(envelope)) {
             return null;
         }
         const env = envelope;
-        const protocol = typeof env.format === 'string' && env.format.trim().length
+        const protocol = typeof env.format === "string" && env.format.trim().length
             ? env.format.trim()
             : fallbackProtocol;
-        const payload = env.payload && typeof env.payload === 'object' && !Array.isArray(env.payload)
+        const payload = env.payload &&
+            typeof env.payload === "object" &&
+            !Array.isArray(env.payload)
             ? env.payload
             : fallbackPayload;
         const out = {
             protocol,
             direction,
-            payload
+            payload,
         };
-        if (env.metadata && typeof env.metadata === 'object' && !Array.isArray(env.metadata)) {
+        if (env.metadata &&
+            typeof env.metadata === "object" &&
+            !Array.isArray(env.metadata)) {
             out.meta = env.metadata;
         }
         return out;
@@ -63,7 +69,7 @@ function parseOptionalString(raw) {
         if (parsed === null) {
             return undefined;
         }
-        if (typeof parsed !== 'string') {
+        if (typeof parsed !== "string") {
             return null;
         }
         const trimmed = parsed.trim();
@@ -76,149 +82,149 @@ function parseOptionalString(raw) {
 function parseBoolean(raw) {
     try {
         const parsed = JSON.parse(raw);
-        return typeof parsed === 'boolean' ? parsed : null;
+        return typeof parsed === "boolean" ? parsed : null;
     }
     catch {
         return null;
     }
 }
 export function sanitizeFormatEnvelopeWithNative(candidate) {
-    const capability = 'sanitizeFormatEnvelopeJson';
+    const capability = "sanitizeFormatEnvelopeJson";
     const fail = (reason) => failNativeRequired(capability, reason);
     if (isNativeDisabledByEnv()) {
-        return fail('native disabled');
+        return fail("native disabled");
     }
-    const fn = readNativeFunction('sanitizeFormatEnvelopeJson');
+    const fn = readNativeFunction("sanitizeFormatEnvelopeJson");
     if (!fn) {
         return fail();
     }
     const candidateJson = safeStringify(candidate);
     if (!candidateJson) {
-        return fail('json stringify failed');
+        return fail("json stringify failed");
     }
     try {
         const raw = fn(candidateJson);
-        if (typeof raw !== 'string' || !raw) {
-            return fail('empty result');
+        if (typeof raw !== "string" || !raw) {
+            return fail("empty result");
         }
         const parsed = parseRecord(raw);
-        return parsed ?? fail('invalid payload');
+        return parsed ?? fail("invalid payload");
     }
     catch (error) {
-        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        const reason = error instanceof Error ? error.message : String(error ?? "unknown");
         return fail(reason);
     }
 }
 export function sanitizeChatCompletionLikeWithNative(candidate) {
-    const capability = 'sanitizeChatCompletionLikeJson';
+    const capability = "sanitizeChatCompletionLikeJson";
     const fail = (reason) => failNativeRequired(capability, reason);
     if (isNativeDisabledByEnv()) {
-        return fail('native disabled');
+        return fail("native disabled");
     }
-    const fn = readNativeFunction('sanitizeChatCompletionLikeJson');
+    const fn = readNativeFunction("sanitizeChatCompletionLikeJson");
     if (!fn) {
         return fail();
     }
     const candidateJson = safeStringify(candidate);
     if (!candidateJson) {
-        return fail('json stringify failed');
+        return fail("json stringify failed");
     }
     try {
         const raw = fn(candidateJson);
-        if (typeof raw !== 'string' || !raw) {
-            return fail('empty result');
+        if (typeof raw !== "string" || !raw) {
+            return fail("empty result");
         }
         const parsed = parseRecord(raw);
-        return parsed ?? fail('invalid payload');
+        return parsed ?? fail("invalid payload");
     }
     catch (error) {
-        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        const reason = error instanceof Error ? error.message : String(error ?? "unknown");
         return fail(reason);
     }
 }
 export function stripPrivateFieldsWithNative(payload) {
-    const capability = 'stripPrivateFieldsJson';
+    const capability = "stripPrivateFieldsJson";
     const fail = (reason) => failNativeRequired(capability, reason);
     if (isNativeDisabledByEnv()) {
-        return fail('native disabled');
+        return fail("native disabled");
     }
-    const fn = readNativeFunction('stripPrivateFieldsJson');
+    const fn = readNativeFunction("stripPrivateFieldsJson");
     if (!fn) {
         return fail();
     }
     const payloadJson = safeStringify(payload);
     if (!payloadJson) {
-        return fail('json stringify failed');
+        return fail("json stringify failed");
     }
     try {
         const raw = fn(payloadJson);
-        if (typeof raw !== 'string' || !raw) {
-            return fail('empty result');
+        if (typeof raw !== "string" || !raw) {
+            return fail("empty result");
         }
         const parsed = parseRecord(raw);
-        return parsed ?? fail('invalid payload');
+        return parsed ?? fail("invalid payload");
     }
     catch (error) {
-        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        const reason = error instanceof Error ? error.message : String(error ?? "unknown");
         return fail(reason);
     }
 }
 export function resolveCompatProfileWithNative(adapterContext, explicitProfile) {
-    const capability = 'resolveCompatProfileJson';
+    const capability = "resolveCompatProfileJson";
     const fail = (reason) => failNativeRequired(capability, reason);
     if (isNativeDisabledByEnv()) {
-        return fail('native disabled');
+        return fail("native disabled");
     }
-    const fn = readNativeFunction('resolveCompatProfileJson');
+    const fn = readNativeFunction("resolveCompatProfileJson");
     if (!fn) {
         return fail();
     }
     const adapterContextJson = safeStringify(adapterContext);
     const explicitJson = safeStringify(explicitProfile ?? null);
     if (!adapterContextJson || !explicitJson) {
-        return fail('json stringify failed');
+        return fail("json stringify failed");
     }
     try {
         const raw = fn(adapterContextJson, explicitJson);
-        if (typeof raw !== 'string' || !raw) {
-            return fail('empty result');
+        if (typeof raw !== "string" || !raw) {
+            return fail("empty result");
         }
         const parsed = parseOptionalString(raw);
-        return parsed === null ? fail('invalid payload') : parsed;
+        return parsed === null ? fail("invalid payload") : parsed;
     }
     catch (error) {
-        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        const reason = error instanceof Error ? error.message : String(error ?? "unknown");
         return fail(reason);
     }
 }
 export function resolveSseStreamModeWithNative(wantsStream, clientProtocol) {
-    const capability = 'resolveSseStreamModeJson';
+    const capability = "resolveSseStreamModeJson";
     const fail = (reason) => failNativeRequired(capability, reason);
     if (isNativeDisabledByEnv()) {
-        return fail('native disabled');
+        return fail("native disabled");
     }
-    const fn = readNativeFunction('resolveSseStreamModeJson');
+    const fn = readNativeFunction("resolveSseStreamModeJson");
     if (!fn) {
         return fail();
     }
     try {
-        const raw = fn(Boolean(wantsStream), String(clientProtocol || ''));
-        if (typeof raw !== 'string' || !raw) {
-            return fail('empty result');
+        const raw = fn(Boolean(wantsStream), String(clientProtocol || ""));
+        if (typeof raw !== "string" || !raw) {
+            return fail("empty result");
         }
         const parsed = parseBoolean(raw);
-        return parsed === null ? fail('invalid payload') : parsed;
+        return parsed === null ? fail("invalid payload") : parsed;
     }
     catch (error) {
-        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        const reason = error instanceof Error ? error.message : String(error ?? "unknown");
         return fail(reason);
     }
 }
 export function parseReqInboundFormatEnvelopeWithNative(input) {
-    const capability = 'parseFormatEnvelopeJson';
+    const capability = "parseFormatEnvelopeJson";
     const fail = (reason) => failNativeRequired(capability, reason);
     if (isNativeDisabledByEnv()) {
-        return fail('native disabled');
+        return fail("native disabled");
     }
     const fn = readNativeFunction(capability);
     if (!fn) {
@@ -226,26 +232,33 @@ export function parseReqInboundFormatEnvelopeWithNative(input) {
     }
     const inputJson = safeStringify(input);
     if (!inputJson) {
-        return fail('json stringify failed');
+        return fail("json stringify failed");
     }
     try {
         const raw = fn(inputJson);
-        if (typeof raw !== 'string' || !raw) {
-            return fail('empty result');
+        if (typeof raw !== "string" || !raw) {
+            return fail("empty result");
         }
-        const parsed = parseFormatEnvelopePayload(raw, 'request', input.protocol, input.rawRequest);
-        return parsed ?? fail('invalid payload');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return fail("invalid envelope structure");
+        }
+        const result = parsed;
+        if (!result.envelope || typeof result.envelope !== "object") {
+            return fail("missing envelope in result");
+        }
+        return result.envelope;
     }
     catch (error) {
-        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        const reason = error instanceof Error ? error.message : String(error ?? "unknown");
         return fail(reason);
     }
 }
 export function parseRespInboundFormatEnvelopeWithNative(input) {
-    const capability = 'parseRespFormatEnvelopeJson';
+    const capability = "parseRespFormatEnvelopeJson";
     const fail = (reason) => failNativeRequired(capability, reason);
     if (isNativeDisabledByEnv()) {
-        return fail('native disabled');
+        return fail("native disabled");
     }
     const fn = readNativeFunction(capability);
     if (!fn) {
@@ -253,26 +266,26 @@ export function parseRespInboundFormatEnvelopeWithNative(input) {
     }
     const inputJson = safeStringify(input);
     if (!inputJson) {
-        return fail('json stringify failed');
+        return fail("json stringify failed");
     }
     try {
         const raw = fn(inputJson);
-        if (typeof raw !== 'string' || !raw) {
-            return fail('empty result');
+        if (typeof raw !== "string" || !raw) {
+            return fail("empty result");
         }
-        const parsed = parseFormatEnvelopePayload(raw, 'response', input.protocol, input.payload);
-        return parsed ?? fail('invalid payload');
+        const parsed = parseFormatEnvelopePayload(raw, "response", input.protocol, input.payload);
+        return parsed ?? fail("invalid payload");
     }
     catch (error) {
-        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        const reason = error instanceof Error ? error.message : String(error ?? "unknown");
         return fail(reason);
     }
 }
 export function validateChatEnvelopeWithNative(chatEnvelope, options) {
-    const capability = 'validateChatEnvelopeJson';
+    const capability = "validateChatEnvelopeJson";
     const fail = (reason) => failNativeRequired(capability, reason);
     if (isNativeDisabledByEnv()) {
-        return fail('native disabled');
+        return fail("native disabled");
     }
     const fn = readNativeFunction(capability);
     if (!fn) {
@@ -280,35 +293,38 @@ export function validateChatEnvelopeWithNative(chatEnvelope, options) {
     }
     const envelopeJson = safeStringify(chatEnvelope);
     if (!envelopeJson) {
-        return fail('json stringify failed');
+        return fail("json stringify failed");
     }
-    const isChatEnvelopeValidationError = (message) => typeof message === 'string' && message.includes('ChatEnvelopeValidationError(');
+    const isChatEnvelopeValidationError = (message) => typeof message === "string" &&
+        message.includes("ChatEnvelopeValidationError(");
     try {
-        const raw = fn(envelopeJson, String(options.stage || ''), String(options.direction || ''), options.source);
+        const raw = fn(envelopeJson, String(options.stage || ""), String(options.direction || ""), options.source);
         const nativeErrorMessage = raw instanceof Error
             ? raw.message
-            : raw && typeof raw === 'object' && 'message' in raw
+            : raw &&
+                typeof raw === "object" &&
+                "message" in raw
                 ? (() => {
                     const candidate = raw.message;
-                    return typeof candidate === 'string' ? candidate : '';
+                    return typeof candidate === "string" ? candidate : "";
                 })()
-                : '';
+                : "";
         if (nativeErrorMessage) {
             if (isChatEnvelopeValidationError(nativeErrorMessage)) {
                 throw new Error(nativeErrorMessage);
             }
             return fail(nativeErrorMessage);
         }
-        if (typeof raw !== 'string' || !raw) {
-            return fail('empty result');
+        if (typeof raw !== "string" || !raw) {
+            return fail("empty result");
         }
         const parsed = parseBoolean(raw);
         if (parsed !== true) {
-            return fail('invalid payload');
+            return fail("invalid payload");
         }
     }
     catch (error) {
-        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        const reason = error instanceof Error ? error.message : String(error ?? "unknown");
         if (isChatEnvelopeValidationError(reason)) {
             throw error instanceof Error ? error : new Error(reason);
         }

package/dist/router/virtual-router/engine-selection/native-hub-pipeline-req-process-semantics.d.ts

@@ -4,6 +4,7 @@ export interface NativeReqProcessToolGovernanceInput {
     metadata: Record<string, unknown>;
     entryEndpoint: string;
     requestId: string;
+    hasActiveStopMessageForContinueExecution?: boolean;
 }
 export interface NativeReqProcessToolGovernanceOutput {
     processedRequest: Record<string, unknown>;

package/dist/router/virtual-router/engine.js

@@ -6,6 +6,7 @@ import { ProviderRegistry } from './provider-registry.js';
 import { resolveStopMessageScope } from './engine/routing-state/store.js';
 import { loadRoutingInstructionStateSync } from './sticky-session-store.js';
 import { mergeStopMessageFromPersisted } from './stop-message-state-sync.js';
+import { resolveSessionColor } from './engine-logging.js';
 export class VirtualRouterEngine {
     nativeProxy;
     registry;
@@ -72,6 +73,7 @@ export class VirtualRouterEngine {
             parseLog?.scopedTypes.some((type) => type === 'stopMessageSet' || type === 'stopMessageMode' || type === 'stopMessageClear'));
         emitVirtualRouterHitLog(parsed, {
             requestId: metadata.requestId,
+            sessionId: resolveVirtualRouterLogSessionId(metadata),
             stopScope,
             stopState,
             forceStopStatusLabel
@@ -176,6 +178,12 @@ function extractNativeErrorMessage(error) {
     if (error instanceof Error) {
         return error.message;
     }
+    if (error && typeof error === 'object') {
+        const message = error.message;
+        if (typeof message === 'string') {
+            return message;
+        }
+    }
     return '';
 }
 function parseVirtualRouterErrorMessage(message) {
@@ -225,6 +233,11 @@ function buildRoutingInstructionParseLog(request, metadata) {
     }
     const latest = getLatestUserMessage(messages);
     const latestText = latest ? extractMessageText(latest).trim() : '';
+    const latestHasMarker = /<\*\*[\s\S]*?\*\*>/.test(latestText);
+    const hasStopKeyword = /stopmessage/i.test(latestText);
+    if (!hasStopKeyword && !latestHasMarker) {
+        return null;
+    }
     const parsedKinds = parseRoutingInstructionKindsWithNative(request);
     const stopMessageTypes = parsedKinds.filter((type) => type === 'stopMessageSet' || type === 'stopMessageMode' || type === 'stopMessageClear');
     const scopedTypes = parsedKinds.filter((type) => type === 'stopMessageSet' ||
@@ -232,20 +245,12 @@ function buildRoutingInstructionParseLog(request, metadata) {
         type === 'stopMessageClear' ||
         type === 'preCommandSet' ||
         type === 'preCommandClear');
-    const markerDetected = messages.some((message) => {
-        if (!message || typeof message !== 'object') {
-            return false;
-        }
-        const record = message;
-        return record.role === 'user' && typeof record.content === 'string' && /<\*\*[\s\S]*?\*\*>/.test(record.content);
-    });
-    const hasStopKeyword = /stopmessage/i.test(latestText);
     if (!hasStopKeyword && stopMessageTypes.length === 0 && scopedTypes.length === 0) {
         return null;
     }
     return {
         requestId: metadata.requestId || 'n/a',
-        markerDetected,
+        markerDetected: latestHasMarker,
         preview: latestText.replace(/\s+/g, ' ').slice(0, 120),
         stopMessageTypes,
         scopedTypes,
@@ -274,30 +279,37 @@ function emitVirtualRouterHitLog(result, options) {
     const prefixColor = '\x1b[38;5;208m';
     const timeColor = '\x1b[90m';
     const stopColor = '\x1b[38;5;214m';
-    const routeColorMap = {
-        multimodal: '\x1b[38;5;45m',
-        tools: '\x1b[38;5;214m',
-        thinking: '\x1b[34m',
-        coding: '\x1b[35m',
-        longcontext: '\x1b[38;5;141m',
-        web_search: '\x1b[32m',
-        search: '\x1b[38;5;34m',
-        vision: '\x1b[38;5;207m',
-        background: '\x1b[90m'
-    };
     const now = new Date();
     const timestamp = `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}`;
     const routeLabel = result.decision.poolId
         ? `${result.decision.routeName}/${result.decision.poolId}`
         : result.decision.routeName;
-    const routeColor = routeColorMap[result.decision.routeName] ?? '\x1b[36m';
+    const routeColor = resolveSessionColor(options?.sessionId);
     const providerKey = result.decision.providerKey || result.target.providerKey;
     const modelSuffix = result.target.modelId ? `.${result.target.modelId}` : '';
     const reason = result.decision.reasoning ? ` reason=${result.decision.reasoning}` : '';
     const stopStatusLabel = formatStopMessageStatusLabel(options?.stopState ?? null, options?.stopScope, Boolean(options?.forceStopStatusLabel));
     const requestId = typeof options?.requestId === 'string' ? options.requestId : '';
     const requestLabel = requestId && !requestId.includes('unknown') ? ` req=${requestId}` : '';
-    console.log(`${prefixColor}[virtual-router-hit]${reset} ${timeColor}${timestamp}${reset}${requestLabel} ${routeColor}${routeLabel} -> ${providerKey}${modelSuffix}${reason}${reset}${stopStatusLabel ? ` ${stopColor}${stopStatusLabel}${reset}` : ''}`);
+    const sessionId = typeof options?.sessionId === 'string' ? options.sessionId.trim() : '';
+    const sessionLabel = sessionId ? ` sid=${sessionId}` : '';
+    console.log(`${prefixColor}[virtual-router-hit]${reset} ${timeColor}${timestamp}${reset}${requestLabel}${sessionLabel} ${routeColor}${routeLabel} -> ${providerKey}${modelSuffix}${reason}${reset}${stopStatusLabel ? ` ${stopColor}${stopStatusLabel}${reset}` : ''}`);
+}
+function resolveVirtualRouterLogSessionId(metadata) {
+    const candidates = [
+        metadata.sessionId,
+        metadata.clientTmuxSessionId,
+        metadata.client_tmux_session_id,
+        metadata.tmuxSessionId,
+        metadata.tmux_session_id,
+        metadata.conversationId
+    ];
+    for (const value of candidates) {
+        if (typeof value === 'string' && value.trim()) {
+            return value.trim();
+        }
+    }
+    return undefined;
 }
 function formatStopMessageStatusLabel(snapshot, scope, forceShow) {
     const scopeLabel = scope && scope.trim() ? scope.trim() : 'none';

package/dist/router/virtual-router/provider-registry.js

@@ -97,6 +97,7 @@ export class ProviderRegistry {
             providerType: profile.providerType,
             endpoint: profile.endpoint,
             auth: profile.auth,
+            ...(profile.enabled !== undefined ? { enabled: profile.enabled } : {}),
             outboundProfile: profile.outboundProfile,
             compatibilityProfile: profile.compatibilityProfile,
             runtimeKey: profile.runtimeKey,

package/dist/router/virtual-router/routing-instructions/state.js

@@ -27,7 +27,11 @@ export function applyRoutingInstructions(instructions, currentState) {
             : undefined,
         preCommandSource: currentState.preCommandSource,
         preCommandScriptPath: currentState.preCommandScriptPath,
-        preCommandUpdatedAt: currentState.preCommandUpdatedAt
+        preCommandUpdatedAt: currentState.preCommandUpdatedAt,
+        chatProcessLastTotalTokens: currentState.chatProcessLastTotalTokens,
+        chatProcessLastInputTokens: currentState.chatProcessLastInputTokens,
+        chatProcessLastMessageCount: currentState.chatProcessLastMessageCount,
+        chatProcessLastUpdatedAt: currentState.chatProcessLastUpdatedAt
     };
     let allowReset = false;
     let disableReset = false;
@@ -186,7 +190,19 @@ export function serializeRoutingInstructionState(state) {
             models: Array.from(models)
         })),
         ...serializeStopMessageState(state),
-        ...serializePreCommandState(state)
+        ...serializePreCommandState(state),
+        ...(typeof state.chatProcessLastTotalTokens === 'number'
+            ? { chatProcessLastTotalTokens: state.chatProcessLastTotalTokens }
+            : {}),
+        ...(typeof state.chatProcessLastInputTokens === 'number'
+            ? { chatProcessLastInputTokens: state.chatProcessLastInputTokens }
+            : {}),
+        ...(typeof state.chatProcessLastMessageCount === 'number'
+            ? { chatProcessLastMessageCount: state.chatProcessLastMessageCount }
+            : {}),
+        ...(typeof state.chatProcessLastUpdatedAt === 'number'
+            ? { chatProcessLastUpdatedAt: state.chatProcessLastUpdatedAt }
+            : {})
     };
 }
 export function deserializeRoutingInstructionState(data) {
@@ -208,7 +224,11 @@ export function deserializeRoutingInstructionState(data) {
         stopMessageAiHistory: undefined,
         preCommandSource: undefined,
         preCommandScriptPath: undefined,
-        preCommandUpdatedAt: undefined
+        preCommandUpdatedAt: undefined,
+        chatProcessLastTotalTokens: undefined,
+        chatProcessLastInputTokens: undefined,
+        chatProcessLastMessageCount: undefined,
+        chatProcessLastUpdatedAt: undefined
     };
     if (data.forcedTarget && typeof data.forcedTarget === 'object') {
         state.forcedTarget = data.forcedTarget;
@@ -241,5 +261,17 @@ export function deserializeRoutingInstructionState(data) {
     }
     deserializeStopMessageState(data, state);
     deserializePreCommandState(data, state);
+    if (typeof data.chatProcessLastTotalTokens === 'number' && Number.isFinite(data.chatProcessLastTotalTokens)) {
+        state.chatProcessLastTotalTokens = Math.max(0, Math.round(data.chatProcessLastTotalTokens));
+    }
+    if (typeof data.chatProcessLastInputTokens === 'number' && Number.isFinite(data.chatProcessLastInputTokens)) {
+        state.chatProcessLastInputTokens = Math.max(0, Math.round(data.chatProcessLastInputTokens));
+    }
+    if (typeof data.chatProcessLastMessageCount === 'number' && Number.isFinite(data.chatProcessLastMessageCount)) {
+        state.chatProcessLastMessageCount = Math.max(0, Math.round(data.chatProcessLastMessageCount));
+    }
+    if (typeof data.chatProcessLastUpdatedAt === 'number' && Number.isFinite(data.chatProcessLastUpdatedAt)) {
+        state.chatProcessLastUpdatedAt = Math.max(0, Math.round(data.chatProcessLastUpdatedAt));
+    }
     return state;
 }

package/dist/router/virtual-router/routing-instructions/types.d.ts

@@ -67,4 +67,8 @@ export interface RoutingInstructionState {
     preCommandSource?: string;
     preCommandScriptPath?: string;
     preCommandUpdatedAt?: number;
+    chatProcessLastTotalTokens?: number;
+    chatProcessLastInputTokens?: number;
+    chatProcessLastMessageCount?: number;
+    chatProcessLastUpdatedAt?: number;
 }

package/dist/router/virtual-router/types.d.ts

@@ -17,6 +17,11 @@ export interface RoutePoolLoadBalancingPolicy {
      * Optional pool-local weights. Keys may target runtime keys, provider.model groups, or provider ids.
      */
     weights?: Record<string, number>;
+    responsesResume?: {
+        previousRequestId?: string;
+        restoredFromResponseId?: string;
+        [key: string]: unknown;
+    };
 }
 export interface RoutePoolTier {
     id: string;
@@ -69,6 +74,7 @@ export interface ProviderProfile {
     providerType: string;
     endpoint: string;
     auth: ProviderAuthConfig;
+    enabled?: boolean;
     outboundProfile: string;
     compatibilityProfile?: string;
     runtimeKey?: string;
@@ -95,6 +101,7 @@ export interface ProviderRuntimeProfile {
     endpoint: string;
     headers?: Record<string, string>;
     auth: ProviderAuthConfig;
+    enabled?: boolean;
     outboundProfile: string;
     compatibilityProfile?: string;
     modelId?: string;