@jsonstudio/rcc 0.90.876 → 0.90.1270

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/features.js

@@ -1,6 +1,6 @@
 import { analyzeMediaAttachments, detectExtendedThinkingKeyword, detectKeyword, extractMessageText, getLatestMessageRole, } from './message-utils.js';
 import { extractAntigravityGeminiSessionIdWithNative } from './engine-selection/native-router-hotpath.js';
-import { detectCodingTool, detectLastAssistantToolCategory, detectVisionTool, detectWebSearchToolDeclared, detectWebTool, extractMeaningfulDeclaredToolNames } from './tool-signals.js';
+import { chooseHigherPriorityToolCategory, classifyToolCallForReport, detectCodingTool, detectLastAssistantToolCategory, detectVisionTool, detectWebSearchToolDeclared, detectWebTool, extractMeaningfulDeclaredToolNames } from './tool-signals.js';
 import { computeRequestTokens } from './token-estimator.js';
 const THINKING_KEYWORDS = ['let me think', 'chain of thought', 'cot', 'reason step', 'deliberate'];
 function asRecord(value) {
@@ -8,40 +8,192 @@ function asRecord(value) {
         ? value
         : null;
 }
-function getLatestResponsesContextMessage(request) {
+function getResponsesContextInput(request) {
     const contextInput = asRecord(request.semantics)?.responses;
     const context = asRecord(contextInput)?.context;
     const input = Array.isArray(asRecord(context)?.input) ? asRecord(context)?.input : [];
-    for (let idx = input.length - 1; idx >= 0; idx -= 1) {
-        const entry = asRecord(input[idx]);
-        if (!entry) {
-            continue;
+    return input
+        .map((entry) => asRecord(entry))
+        .filter((entry) => Boolean(entry));
+}
+function normalizeResponsesEntryType(entry) {
+    return typeof entry.type === 'string' && entry.type.trim()
+        ? entry.type.trim().toLowerCase()
+        : 'message';
+}
+function getResponsesMessageRole(entry) {
+    const role = typeof entry.role === 'string' && entry.role.trim()
+        ? entry.role.trim().toLowerCase()
+        : 'user';
+    return role === 'user' || role === 'assistant' || role === 'tool'
+        ? role
+        : undefined;
+}
+function getResponsesEntryRole(entry) {
+    const entryType = normalizeResponsesEntryType(entry);
+    if (entryType === 'message') {
+        return getResponsesMessageRole(entry);
+    }
+    if (entryType === 'function_call') {
+        return 'assistant';
+    }
+    if (entryType === 'function_call_output'
+        || entryType === 'tool_result'
+        || entryType === 'tool_message') {
+        return 'tool';
+    }
+    return undefined;
+}
+function toResponsesContextMessage(entry, role) {
+    if (!role || normalizeResponsesEntryType(entry) !== 'message') {
+        return undefined;
+    }
+    const content = entry.content;
+    if (typeof content !== 'string' && !Array.isArray(content)) {
+        return undefined;
+    }
+    return {
+        role,
+        content: content
+    };
+}
+function collectResponsesToolSignals(entries) {
+    let lastAssistantTool;
+    let hasToolCallResponses = false;
+    for (const entry of entries) {
+        const entryType = normalizeResponsesEntryType(entry);
+        if (entryType === 'function_call'
+            || entryType === 'function_call_output'
+            || entryType === 'tool_result'
+            || entryType === 'tool_message') {
+            hasToolCallResponses = true;
         }
-        const entryType = typeof entry.type === 'string' && entry.type.trim()
-            ? entry.type.trim().toLowerCase()
-            : 'message';
-        if (entryType !== 'message') {
+        if (entryType !== 'function_call') {
             continue;
         }
-        const role = typeof entry.role === 'string' && entry.role.trim()
-            ? entry.role.trim().toLowerCase()
-            : 'user';
-        if (role !== 'user' && role !== 'assistant' && role !== 'tool') {
+        const toolName = typeof entry.name === 'string' ? entry.name.trim() : '';
+        if (!toolName) {
             continue;
         }
-        const content = entry.content;
-        if (typeof content !== 'string' && !Array.isArray(content)) {
+        const candidate = classifyToolCallForReport({
+            type: 'function',
+            id: typeof entry.id === 'string' ? entry.id : undefined,
+            function: {
+                name: toolName,
+                arguments: typeof entry.arguments === 'string' || typeof entry.arguments === 'object'
+                    ? entry.arguments
+                    : undefined
+            }
+        });
+        lastAssistantTool = chooseHigherPriorityToolCategory(lastAssistantTool, candidate);
+    }
+    return {
+        hasToolCallResponses,
+        lastAssistantTool
+    };
+}
+function getResponsesContextTurnState(request) {
+    const input = getResponsesContextInput(request);
+    let latestRole;
+    let latestMessage;
+    for (let idx = input.length - 1; idx >= 0; idx -= 1) {
+        const entry = input[idx];
+        const entryRole = getResponsesEntryRole(entry);
+        if (!entryRole) {
             continue;
         }
-        return {
-            role,
-            message: {
-                role: role,
-                content: content
+        latestRole = entryRole;
+        latestMessage = toResponsesContextMessage(entry, entryRole);
+        break;
+    }
+    let latestUserIndex = -1;
+    for (let idx = input.length - 1; idx >= 0; idx -= 1) {
+        const entry = input[idx];
+        if (normalizeResponsesEntryType(entry) === 'message' && getResponsesMessageRole(entry) === 'user') {
+            latestUserIndex = idx;
+            break;
+        }
+    }
+    let segmentStart = 0;
+    let segmentEnd = input.length;
+    if (latestUserIndex >= 0) {
+        if (latestRole === 'user') {
+            let previousUserIndex = -1;
+            for (let idx = latestUserIndex - 1; idx >= 0; idx -= 1) {
+                const entry = input[idx];
+                if (normalizeResponsesEntryType(entry) === 'message' && getResponsesMessageRole(entry) === 'user') {
+                    previousUserIndex = idx;
+                    break;
+                }
             }
-        };
+            segmentStart = previousUserIndex + 1;
+            segmentEnd = latestUserIndex;
+        }
+        else {
+            segmentStart = latestUserIndex + 1;
+        }
+    }
+    const toolSignals = collectResponsesToolSignals(input.slice(segmentStart, segmentEnd));
+    return {
+        latestRole,
+        latestMessage,
+        ...toolSignals
+    };
+}
+function getMessageTurnState(messages) {
+    const normalizedMessages = Array.isArray(messages) ? messages : [];
+    const latestMessage = normalizedMessages.length
+        ? normalizedMessages[normalizedMessages.length - 1]
+        : undefined;
+    const latestRole = latestMessage?.role === 'user' || latestMessage?.role === 'assistant' || latestMessage?.role === 'tool'
+        ? latestMessage.role
+        : undefined;
+    let latestUserIndex = -1;
+    for (let idx = normalizedMessages.length - 1; idx >= 0; idx -= 1) {
+        if (normalizedMessages[idx]?.role === 'user') {
+            latestUserIndex = idx;
+            break;
+        }
     }
-    return null;
+    let segmentStart = 0;
+    let segmentEnd = normalizedMessages.length;
+    if (latestUserIndex >= 0) {
+        if (latestRole === 'user') {
+            let previousUserIndex = -1;
+            for (let idx = latestUserIndex - 1; idx >= 0; idx -= 1) {
+                if (normalizedMessages[idx]?.role === 'user') {
+                    previousUserIndex = idx;
+                    break;
+                }
+            }
+            segmentStart = previousUserIndex + 1;
+            segmentEnd = latestUserIndex;
+        }
+        else {
+            segmentStart = latestUserIndex + 1;
+        }
+    }
+    const assistantSegment = [];
+    let hasToolCallResponses = false;
+    for (const msg of normalizedMessages.slice(segmentStart, segmentEnd)) {
+        if (msg.role === 'tool') {
+            hasToolCallResponses = true;
+            continue;
+        }
+        if (msg.role !== 'assistant') {
+            continue;
+        }
+        assistantSegment.push(msg);
+        if (Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+            hasToolCallResponses = true;
+        }
+    }
+    return {
+        latestRole,
+        latestMessage,
+        hasToolCallResponses,
+        lastAssistantTool: detectLastAssistantToolCategory(assistantSegment)
+    };
 }
 export function buildRoutingFeatures(request, metadata) {
     const antigravitySessionId = (() => {
@@ -58,19 +210,31 @@ export function buildRoutingFeatures(request, metadata) {
             return undefined;
         }
     })();
-    const responsesLatestMessage = getLatestResponsesContextMessage(request);
-    const latestMessageRole = responsesLatestMessage?.role || getLatestMessageRole(request.messages);
-    const latestMessage = responsesLatestMessage?.message || (Array.isArray(request.messages) && request.messages.length
-        ? request.messages[request.messages.length - 1]
-        : undefined);
-    const assistantMessages = request.messages.filter((msg) => msg.role === 'assistant');
+    const messageTurnState = getMessageTurnState(request.messages);
+    const responsesTurnState = getResponsesContextTurnState(request);
+    const currentUserFromMessages = messageTurnState.latestRole === 'user';
+    const currentUserFromResponses = !currentUserFromMessages && responsesTurnState.latestRole === 'user';
+    const latestMessageRole = currentUserFromMessages || currentUserFromResponses
+        ? 'user'
+        : responsesTurnState.latestRole || messageTurnState.latestRole || getLatestMessageRole(request.messages);
+    const latestMessage = currentUserFromMessages
+        ? messageTurnState.latestMessage
+        : currentUserFromResponses
+            ? responsesTurnState.latestMessage
+            : responsesTurnState.latestMessage || messageTurnState.latestMessage;
     const latestUserText = latestMessageRole === 'user' && latestMessage
         ? extractMessageText(latestMessage)
         : '';
     const normalizedUserText = latestUserText.toLowerCase();
     const meaningfulDeclaredTools = extractMeaningfulDeclaredToolNames(request.tools);
     const hasTools = meaningfulDeclaredTools.length > 0;
-    const hasToolCallResponses = assistantMessages.some((msg) => Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0);
+    const hasToolCallResponses = currentUserFromMessages
+        ? messageTurnState.hasToolCallResponses
+        : currentUserFromResponses
+            ? responsesTurnState.hasToolCallResponses
+            : responsesTurnState.latestRole
+                ? responsesTurnState.hasToolCallResponses
+                : messageTurnState.hasToolCallResponses;
     const estimatedTokens = computeRequestTokens(request, latestUserText);
     const hasThinking = detectKeyword(normalizedUserText, THINKING_KEYWORDS);
     const hasVisionTool = detectVisionTool(request);
@@ -81,7 +245,11 @@ export function buildRoutingFeatures(request, metadata) {
     const hasCodingTool = detectCodingTool(request);
     const hasWebTool = detectWebTool(request);
     const hasThinkingKeyword = hasThinking || detectExtendedThinkingKeyword(normalizedUserText);
-    const lastAssistantTool = detectLastAssistantToolCategory(assistantMessages);
+    const lastAssistantTool = currentUserFromMessages
+        ? messageTurnState.lastAssistantTool
+        : currentUserFromResponses
+            ? responsesTurnState.lastAssistantTool
+            : responsesTurnState.lastAssistantTool || messageTurnState.lastAssistantTool;
     const lastAssistantToolLabel = (() => {
         if (!lastAssistantTool) {
             return undefined;

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/health-manager.js

@@ -35,8 +35,13 @@ export class ProviderHealthManager {
         if (reason) {
             state.reason = reason;
         }
-        // 在新版策略中，普通失败仅用于监控；不再根据 failureThreshold 自动熔断。
-        // 只有显式 fatal 或 tripProvider 调用时才会进入 tripped 状态。
+        // Aggressive ban: auto-trip when reaching threshold (3 consecutive failures = 3 cycles cooldown)
+        const threshold = this.config.failureThreshold;
+        const cooldownUnit = this.config.cooldownMs;
+        if (state.failureCount >= threshold) {
+            state.state = 'tripped';
+            state.cooldownExpiresAt = Date.now() + cooldownUnit * 3;
+        }
         return state;
     }
     /**

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/load-balancer.d.ts

@@ -16,6 +16,8 @@ export interface GroupedLoadBalancingOptions {
 export declare class RouteLoadBalancer {
     private policy;
     private readonly states;
+    private readonly stickyTtlMs;
+    private readonly stickyMaxEntries;
     constructor(policy?: LoadBalancingPolicy);
     updatePolicy(policy?: LoadBalancingPolicy): void;
     getPolicy(): LoadBalancingPolicy;
@@ -24,5 +26,6 @@ export declare class RouteLoadBalancer {
     private selectRoundRobin;
     private selectWeighted;
     private selectSticky;
+    private pruneStickyEntries;
     private getState;
 }

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/load-balancer.js

@@ -1,8 +1,30 @@
+const DEFAULT_STICKY_TTL_MS = 30 * 60_000;
+const DEFAULT_STICKY_MAX_ENTRIES = 4096;
+function resolveStickyTtlMs() {
+    const raw = process.env.ROUTECODEX_VR_STICKY_TTL_MS ?? process.env.RCC_VR_STICKY_TTL_MS;
+    const parsed = Number.parseInt(String(raw ?? '').trim(), 10);
+    if (Number.isFinite(parsed) && parsed >= 60_000) {
+        return parsed;
+    }
+    return DEFAULT_STICKY_TTL_MS;
+}
+function resolveStickyMaxEntries() {
+    const raw = process.env.ROUTECODEX_VR_STICKY_MAX_ENTRIES ?? process.env.RCC_VR_STICKY_MAX_ENTRIES;
+    const parsed = Number.parseInt(String(raw ?? '').trim(), 10);
+    if (Number.isFinite(parsed) && parsed >= 16) {
+        return parsed;
+    }
+    return DEFAULT_STICKY_MAX_ENTRIES;
+}
 export class RouteLoadBalancer {
     policy;
     states = new Map();
+    stickyTtlMs;
+    stickyMaxEntries;
     constructor(policy) {
         this.policy = policy ?? { strategy: 'round-robin' };
+        this.stickyTtlMs = resolveStickyTtlMs();
+        this.stickyMaxEntries = resolveStickyMaxEntries();
     }
     updatePolicy(policy) {
         if (policy) {
@@ -113,16 +135,38 @@ export class RouteLoadBalancer {
             return this.selectRoundRobin(routeName, candidates);
         }
         const state = this.getState(routeName);
+        const nowMs = Date.now();
+        this.pruneStickyEntries(state, nowMs);
         const pinned = state.stickyMap.get(stickyKey);
-        if (pinned && candidates.includes(pinned)) {
-            return pinned;
+        if (pinned && candidates.includes(pinned.providerKey)) {
+            pinned.updatedAtMs = nowMs;
+            return pinned.providerKey;
         }
         const choice = weights && Object.keys(weights).length > 0
             ? this.selectWeighted(`${routeName}:sticky`, candidates, weights)
             : this.selectRoundRobin(routeName, candidates);
-        state.stickyMap.set(stickyKey, choice);
+        state.stickyMap.set(stickyKey, {
+            providerKey: choice,
+            updatedAtMs: nowMs
+        });
+        this.pruneStickyEntries(state, nowMs);
         return choice;
     }
+    pruneStickyEntries(state, nowMs) {
+        for (const [key, entry] of state.stickyMap.entries()) {
+            if (!entry || typeof entry.providerKey !== 'string' || nowMs - entry.updatedAtMs >= this.stickyTtlMs) {
+                state.stickyMap.delete(key);
+            }
+        }
+        if (state.stickyMap.size <= this.stickyMaxEntries) {
+            return;
+        }
+        const sorted = Array.from(state.stickyMap.entries()).sort((a, b) => a[1].updatedAtMs - b[1].updatedAtMs);
+        while (state.stickyMap.size > this.stickyMaxEntries && sorted.length > 0) {
+            const [oldestKey] = sorted.shift();
+            state.stickyMap.delete(oldestKey);
+        }
+    }
     getState(routeName) {
         if (!this.states.has(routeName)) {
             this.states.set(routeName, { pointer: 0, stickyMap: new Map(), weighted: { currentWeights: new Map() } });

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/native-error.d.ts

@@ -0,0 +1,11 @@
+import { VirtualRouterError, VirtualRouterErrorCode } from './types.js';
+export declare const VIRTUAL_ROUTER_ERROR_PREFIX = "VIRTUAL_ROUTER_ERROR:";
+type ParsedVirtualRouterNativeError = {
+    code: VirtualRouterErrorCode;
+    message: string;
+    details?: Record<string, unknown>;
+};
+export declare function extractVirtualRouterNativeErrorMessage(error: unknown): string;
+export declare function parseVirtualRouterNativeErrorPayload(message: string): ParsedVirtualRouterNativeError | null;
+export declare function parseVirtualRouterNativeError(error: unknown): VirtualRouterError | null;
+export {};

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/native-error.js

@@ -0,0 +1,71 @@
+import { VirtualRouterError, VirtualRouterErrorCode } from './types.js';
+export const VIRTUAL_ROUTER_ERROR_PREFIX = 'VIRTUAL_ROUTER_ERROR:';
+export function extractVirtualRouterNativeErrorMessage(error) {
+    if (typeof error === 'string')
+        return error;
+    if (error instanceof Error)
+        return error.message;
+    if (error && typeof error === 'object' && typeof error.message === 'string') {
+        return error.message;
+    }
+    return String(error ?? 'unknown error');
+}
+export function parseVirtualRouterNativeErrorPayload(message) {
+    if (!message) {
+        return null;
+    }
+    const normalized = message.startsWith('Error:') ? message.replace(/^Error:\s*/, '') : message;
+    if (!normalized.startsWith(VIRTUAL_ROUTER_ERROR_PREFIX)) {
+        return null;
+    }
+    const remainder = normalized.slice(VIRTUAL_ROUTER_ERROR_PREFIX.length);
+    const index = remainder.indexOf(':');
+    if (index <= 0) {
+        return null;
+    }
+    const code = remainder.slice(0, index);
+    if (!Object.values(VirtualRouterErrorCode).includes(code)) {
+        return null;
+    }
+    const rawPayload = remainder.slice(index + 1).trim();
+    const fallbackMessage = rawPayload || 'Virtual router error';
+    if (!rawPayload.startsWith('{')) {
+        return {
+            code: code,
+            message: fallbackMessage
+        };
+    }
+    try {
+        const parsed = JSON.parse(rawPayload);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return {
+                code: code,
+                message: fallbackMessage
+            };
+        }
+        const parsedMessage = typeof parsed.message === 'string' && parsed.message.trim()
+            ? parsed.message.trim()
+            : fallbackMessage;
+        const details = parsed.details && typeof parsed.details === 'object' && !Array.isArray(parsed.details)
+            ? parsed.details
+            : undefined;
+        return {
+            code: code,
+            message: parsedMessage,
+            ...(details ? { details } : {})
+        };
+    }
+    catch {
+        return {
+            code: code,
+            message: fallbackMessage
+        };
+    }
+}
+export function parseVirtualRouterNativeError(error) {
+    const parsed = parseVirtualRouterNativeErrorPayload(extractVirtualRouterNativeErrorMessage(error));
+    if (!parsed) {
+        return null;
+    }
+    return new VirtualRouterError(parsed.message, parsed.code, parsed.details);
+}

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/provider-registry.js

@@ -1,4 +1,27 @@
 import { VirtualRouterError, VirtualRouterErrorCode } from './types.js';
+const NON_BLOCKING_WARN_THROTTLE_MS = 60_000;
+const nonBlockingWarnByStage = new Map();
+function shouldLogNonBlockingStage(stage) {
+    const now = Date.now();
+    const lastAt = nonBlockingWarnByStage.get(stage) ?? 0;
+    if (now - lastAt < NON_BLOCKING_WARN_THROTTLE_MS) {
+        return false;
+    }
+    nonBlockingWarnByStage.set(stage, now);
+    return true;
+}
+function logProviderRegistryNonBlocking(stage, operation, details) {
+    if (!shouldLogNonBlockingStage(stage)) {
+        return;
+    }
+    try {
+        const suffix = details && Object.keys(details).length > 0 ? ` details=${JSON.stringify(details)}` : '';
+        console.warn(`[provider-registry] stage=${stage} operation=${operation} returned empty${suffix}`);
+    }
+    catch {
+        void 0;
+    }
+}
 export class ProviderRegistry {
     providers = new Map();
     constructor(profiles) {
@@ -31,10 +54,18 @@ export class ProviderRegistry {
     getModelCapabilities(providerKey) {
         const profile = this.providers.get(providerKey);
         if (!profile) {
+            logProviderRegistryNonBlocking('capability_lookup', 'get_model_capabilities', {
+                providerKey,
+                cause: 'provider_not_registered'
+            });
             return new Set();
         }
         const modelId = profile.modelId ?? deriveModelId(providerKey);
         if (!modelId) {
+            logProviderRegistryNonBlocking('capability_lookup', 'get_model_capabilities', {
+                providerKey,
+                cause: 'missing_model_id'
+            });
             return new Set();
         }
         const capabilities = profile.modelCapabilities?.[modelId];
@@ -47,21 +78,46 @@ export class ProviderRegistry {
         return this.getModelCapabilities(providerKey).has(capability);
     }
     resolveRuntimeKeyByAlias(providerId, keyAlias) {
+        if (!providerId || !keyAlias) {
+            logProviderRegistryNonBlocking('runtime_key_alias', 'resolve_runtime_key_by_alias', {
+                providerId,
+                keyAlias,
+                cause: 'invalid_input'
+            });
+            return null;
+        }
         const pattern = new RegExp(`^${providerId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\.${keyAlias.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:\\.|$)`);
         for (const key of this.providers.keys()) {
             if (pattern.test(key)) {
                 return key;
             }
         }
+        logProviderRegistryNonBlocking('runtime_key_alias', 'resolve_runtime_key_by_alias', {
+            providerId,
+            keyAlias,
+            cause: this.listProviderKeys(providerId).length > 0 ? 'alias_not_found' : 'provider_not_registered'
+        });
         return null;
     }
     resolveRuntimeKeyByIndex(providerId, keyIndex) {
         const index = keyIndex - 1;
-        if (index < 0)
+        if (index < 0) {
+            logProviderRegistryNonBlocking('runtime_key_index', 'resolve_runtime_key_by_index', {
+                providerId,
+                keyIndex,
+                cause: 'invalid_index'
+            });
             return null;
+        }
         const keys = this.listProviderKeys(providerId);
-        if (index >= keys.length)
+        if (index >= keys.length) {
+            logProviderRegistryNonBlocking('runtime_key_index', 'resolve_runtime_key_by_index', {
+                providerId,
+                keyIndex,
+                cause: keys.length > 0 ? 'index_out_of_range' : 'provider_not_registered'
+            });
             return null;
+        }
         return keys[index];
     }
     listProviderKeys(providerId) {
@@ -70,13 +126,31 @@ export class ProviderRegistry {
     }
     resolveRuntimeKeyByModel(providerId, modelId) {
         if (!providerId || !modelId) {
+            logProviderRegistryNonBlocking('runtime_key_model', 'resolve_runtime_key_by_model', {
+                providerId,
+                modelId,
+                cause: 'invalid_input'
+            });
             return null;
         }
         const normalizedModel = modelId.trim();
         if (!normalizedModel) {
+            logProviderRegistryNonBlocking('runtime_key_model', 'resolve_runtime_key_by_model', {
+                providerId,
+                modelId,
+                cause: 'empty_model_id'
+            });
             return null;
         }
         const providerKeys = this.listProviderKeys(providerId);
+        if (providerKeys.length === 0) {
+            logProviderRegistryNonBlocking('runtime_key_model', 'resolve_runtime_key_by_model', {
+                providerId,
+                modelId: normalizedModel,
+                cause: 'provider_not_registered'
+            });
+            return null;
+        }
         for (const key of providerKeys) {
             const profile = this.providers.get(key);
             const candidate = profile?.modelId ?? deriveModelId(key);
@@ -84,6 +158,11 @@ export class ProviderRegistry {
                 return key;
             }
         }
+        logProviderRegistryNonBlocking('runtime_key_model', 'resolve_runtime_key_by_model', {
+            providerId,
+            modelId: normalizedModel,
+            cause: 'model_not_found'
+        });
         return null;
     }
     buildTarget(providerKey) {

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/provider-runtime-ingress.d.ts

@@ -0,0 +1,24 @@
+import type { ProviderErrorEvent, ProviderSuccessEvent } from './types.js';
+type RuntimeRouterHooks = {
+    handleProviderError?: (event: ProviderErrorEvent) => void;
+    handleProviderSuccess?: (event: ProviderSuccessEvent) => void;
+};
+type RuntimeQuotaHooks = {
+    onProviderError?: (event: ProviderErrorEvent) => void;
+    onProviderSuccess?: (event: ProviderSuccessEvent) => void;
+};
+type RuntimeProviderQuotaHooks = {
+    onProviderError?: (event: ProviderErrorEvent) => void;
+};
+type RuntimeObserverHooks = {
+    onProviderErrorReported?: (event: ProviderErrorEvent) => void;
+    onProviderSuccessReported?: (event: ProviderSuccessEvent) => void;
+};
+export declare function setVirtualRouterPolicyRuntimeRouterHooks(owner: unknown, hooks?: RuntimeRouterHooks): void;
+export declare function setProviderRuntimeQuotaHooks(owner: unknown, hooks?: RuntimeQuotaHooks): void;
+export declare function setProviderRuntimeProviderQuotaHooks(owner: unknown, hooks?: RuntimeProviderQuotaHooks): void;
+export declare function setProviderRuntimeObserverHooks(owner: unknown, hooks?: RuntimeObserverHooks): void;
+export declare function reportProviderErrorToRouterPolicy(event: ProviderErrorEvent): ProviderErrorEvent;
+export declare function reportProviderSuccessToRouterPolicy(event: ProviderSuccessEvent): ProviderSuccessEvent;
+export declare function resetProviderRuntimeIngressForTests(): void;
+export {};