@jsonstudio/llms 0.6.3409 → 0.6.3541

package/dist/conversion/shared/responses-response-utils.js

@@ -1,8 +1,7 @@
-import { extractOutputSegments } from './output-content-normalizer.js';
 import { createBridgeActionState, runBridgeActionPipeline } from '../bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from '../bridge-policies.js';
 import { registerResponsesPayloadSnapshot, registerResponsesPassthrough } from './responses-reasoning-registry.js';
-import { collectToolCallsFromResponsesWithNative, normalizeFunctionCallIdWithNative, resolveFinishReasonWithNative, sanitizeReasoningTaggedTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { buildChatResponseFromResponsesWithNative, collectToolCallsFromResponsesWithNative, normalizeFunctionCallIdWithNative, resolveFinishReasonWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 import { sanitizeResponsesFunctionNameWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
 function selectCallId(entry) {
     const candidates = [
@@ -194,6 +193,9 @@ function cloneSnapshot(value) {
 export function buildChatResponseFromResponses(payload) {
     if (!payload || typeof payload !== 'object')
         return payload;
+    if (typeof buildChatResponseFromResponsesWithNative !== 'function') {
+        throw new Error('[responses-response-utils] native bindings unavailable');
+    }
     const response = unwrapResponsesResponse(payload);
     if (!response) {
         if (Array.isArray(payload.choices)) {
@@ -202,99 +204,46 @@ export function buildChatResponseFromResponses(payload) {
         }
         return payload;
     }
-    const id = typeof response.id === 'string' ? response.id : `resp_${Date.now()}`;
-    const model = response.model;
-    const created = typeof response.created_at === 'number'
-        ? response.created_at
-        : (response.created ?? Math.floor(Date.now() / 1000));
-    const usage = response.usage;
-    const toolCalls = collectToolCallsFromResponses(response);
-    const { textParts, reasoningParts } = extractOutputSegments(response);
-    const rawReasoningSegments = collectRawReasoningSegments(response);
-    const summaryReasoningSegments = collectReasoningSummarySegments(response);
-    const encryptedReasoning = collectReasoningEncryptedContent(response);
-    const outputTextRaw = typeof response.output_text === 'string' && response.output_text.trim().length
-        ? response.output_text
-        : undefined;
-    const explicitOutput = typeof outputTextRaw === 'string'
-        ? sanitizeReasoningTaggedTextWithNative(outputTextRaw)
+    const chat = buildChatResponseFromResponsesWithNative(response);
+    if (!chat || typeof chat !== 'object' || Array.isArray(chat)) {
+        return payload;
+    }
+    const choices = Array.isArray(chat.choices) ? chat.choices : [];
+    const primary = choices[0] && typeof choices[0] === 'object' ? choices[0] : undefined;
+    const message = primary && typeof primary.message === 'object'
+        ? primary.message
         : undefined;
-    const messageContentText = explicitOutput || textParts.join('\n').trim();
-    const messageContent = messageContentText || '';
-    const message = {
-        role: 'assistant',
-        content: messageContent
-    };
     try {
-        const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-responses', moduleType: 'openai-responses' });
-        const policyActions = resolvePolicyActions(bridgePolicy, 'response_inbound');
-        if (policyActions?.length) {
-            const actionState = createBridgeActionState({
-                messages: [message],
-                rawResponse: response
-            });
-            runBridgeActionPipeline({
-                stage: 'response_inbound',
-                actions: policyActions,
-                protocol: bridgePolicy?.protocol ?? 'openai-responses',
-                moduleType: bridgePolicy?.moduleType ?? 'openai-responses',
-                requestId: typeof response?.id === 'string' ? response.id : undefined,
-                state: actionState
-            });
+        if (message) {
+            const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-responses', moduleType: 'openai-responses' });
+            const policyActions = resolvePolicyActions(bridgePolicy, 'response_inbound');
+            if (policyActions?.length) {
+                const actionState = createBridgeActionState({
+                    messages: [message],
+                    rawResponse: response
+                });
+                runBridgeActionPipeline({
+                    stage: 'response_inbound',
+                    actions: policyActions,
+                    protocol: bridgePolicy?.protocol ?? 'openai-responses',
+                    moduleType: bridgePolicy?.moduleType ?? 'openai-responses',
+                    requestId: typeof response?.id === 'string' ? response.id : undefined,
+                    state: actionState
+                });
+            }
         }
     }
     catch {
         // Ignore policy errors
     }
-    if (toolCalls.length) {
-        message.tool_calls = toolCalls;
-    }
-    const reasoningSegments = rawReasoningSegments.length
-        ? rawReasoningSegments
-        : (reasoningParts.length ? reasoningParts : summaryReasoningSegments);
-    if (reasoningSegments.length) {
-        message.reasoning_content = reasoningSegments.join('\n');
+    const id = typeof chat.id === 'string' ? chat.id : undefined;
+    const requestId = typeof chat.request_id === 'string'
+        ? chat.request_id
+        : (typeof response.request_id === 'string' ? response.request_id : undefined);
+    if (id) {
+        registerResponsesPayloadSnapshot(id, response);
     }
-    const finishReason = resolveFinishReason(response, toolCalls);
-    const chat = {
-        id,
-        object: 'chat.completion',
-        created,
-        model,
-        choices: [
-            {
-                index: 0,
-                finish_reason: finishReason,
-                message
-            }
-        ]
-    };
-    const hasOutputTextField = Object.prototype.hasOwnProperty.call(response, 'output_text');
-    const reasoningPayload = buildReasoningPayload({
-        summarySegments: summaryReasoningSegments,
-        contentSegments: rawReasoningSegments.length ? rawReasoningSegments : reasoningParts,
-        encryptedContent: encryptedReasoning
-    });
-    if (reasoningPayload) {
-        chat.__responses_reasoning = reasoningPayload;
-    }
-    chat.__responses_output_text_meta = {
-        hasField: hasOutputTextField,
-        value: typeof outputTextRaw === 'string'
-            ? sanitizeReasoningTaggedTextWithNative(outputTextRaw)
-            : undefined
-    };
-    if (usage !== undefined) {
-        chat.usage = usage;
-    }
-    const requestId = typeof response.request_id === 'string'
-        ? response.request_id
-        : (typeof response.id === 'string' ? response.id : undefined);
     if (requestId) {
-        chat.request_id = requestId;
-    }
-    registerResponsesPayloadSnapshot(id, response);
-    if (requestId && requestId !== id) {
         registerResponsesPayloadSnapshot(requestId, response);
     }
     const snapshot = cloneSnapshot(response);

package/dist/conversion/shared/streaming-text-extractor.d.ts

@@ -11,8 +11,7 @@ export interface StreamingToolExtractorOptions {
 }
 export declare class StreamingTextToolExtractor {
     private opts;
-    private buffer;
-    private idCounter;
+    private state;
     constructor(opts?: StreamingToolExtractorOptions);
     reset(): void;
     feedText(text: string): StreamingToolCall[];

package/dist/conversion/shared/streaming-text-extractor.js

@@ -1,38 +1,37 @@
 // Streaming textual tool intent extractor (对齐)
 // Detects <function=execute> blocks and structured apply_patch payloads
 // and converts them into OpenAI tool_calls incrementally.
-import { extractStreamingToolCallsWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { createStreamingToolExtractorStateWithNative, feedStreamingToolExtractorWithNative, resetStreamingToolExtractorStateWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 function assertStreamingToolExtractorNativeAvailable() {
-    if (typeof extractStreamingToolCallsWithNative !== 'function') {
+    if (typeof createStreamingToolExtractorStateWithNative !== 'function' ||
+        typeof resetStreamingToolExtractorStateWithNative !== 'function' ||
+        typeof feedStreamingToolExtractorWithNative !== 'function') {
         throw new Error('[streaming-text-extractor] native bindings unavailable');
     }
 }
 export class StreamingTextToolExtractor {
     opts;
-    buffer = '';
-    idCounter = 0;
+    state;
     constructor(opts = {}) {
         this.opts = opts;
+        assertStreamingToolExtractorNativeAvailable();
+        this.state = createStreamingToolExtractorStateWithNative(this.opts.idPrefix || 'call');
     }
     reset() {
-        this.buffer = '';
-        this.idCounter = 0;
+        assertStreamingToolExtractorNativeAvailable();
+        this.state = resetStreamingToolExtractorStateWithNative(this.state);
     }
     feedText(text) {
         if (typeof text !== 'string' || !text)
             return [];
         assertStreamingToolExtractorNativeAvailable();
-        const idPrefix = this.opts.idPrefix || 'call';
-        const output = extractStreamingToolCallsWithNative({
-            buffer: this.buffer,
+        const output = feedStreamingToolExtractorWithNative({
+            state: this.state,
             text,
-            idPrefix,
-            idCounter: this.idCounter,
             nowMs: Date.now()
         });
-        this.buffer = typeof output.buffer === 'string' ? output.buffer : this.buffer;
-        this.idCounter = typeof output.idCounter === 'number' ? output.idCounter : this.idCounter;
-        return Array.isArray(output.toolCalls) ? output.toolCalls : [];
+        this.state = output.state;
+        return output.toolCalls;
     }
 }
 export function createStreamingToolExtractor(opts) {

package/dist/quota/quota-state.js

@@ -1,6 +1,7 @@
 const COOLDOWN_SCHEDULE_429_MS = [3_000, 10_000, 31_000, 61_000];
 const COOLDOWN_SCHEDULE_FATAL_MS = [3_000, 10_000, 31_000, 61_000];
 const COOLDOWN_SCHEDULE_DEFAULT_MS = [3_000, 10_000, 31_000, 61_000];
+const COOLDOWN_SCHEDULE_TRANSIENT_KEEP_POOL_MS = [3_000, 5_000, 10_000, 31_000];
 const ERROR_CHAIN_WINDOW_MS = 10 * 60_000;
 const NETWORK_ERROR_CODES = [
     'ECONNRESET',
@@ -84,10 +85,26 @@ function computeCooldownMsBySeries(series, consecutive) {
     const idx = Math.min(consecutive - 1, schedule.length - 1);
     return schedule[idx] ?? null;
 }
+function shouldKeepProviderInPoolDuringCooldown(series, consecutive) {
+    if (consecutive <= 0) {
+        return false;
+    }
+    return (series === 'ENET' || series === 'E5XX' || series === 'EOTHER') && consecutive <= 2;
+}
+function shouldAccumulateBySeries(series) {
+    return series === 'ENET' || series === 'E5XX' || series === 'EOTHER';
+}
+function computeTransientKeepPoolCooldownMs(series, consecutive) {
+    if (!shouldKeepProviderInPoolDuringCooldown(series, consecutive)) {
+        return null;
+    }
+    const idx = Math.min(consecutive - 1, COOLDOWN_SCHEDULE_TRANSIENT_KEEP_POOL_MS.length - 1);
+    return COOLDOWN_SCHEDULE_TRANSIENT_KEEP_POOL_MS[idx] ?? null;
+}
 export function tickQuotaStateTime(state, nowMs) {
     let next = state;
     if (typeof next.cooldownUntil === 'number' && next.cooldownUntil <= nowMs) {
-        next = { ...next, cooldownUntil: null };
+        next = { ...next, cooldownUntil: null, cooldownKeepsPool: undefined };
     }
     if (typeof next.blacklistUntil === 'number' && next.blacklistUntil <= nowMs) {
         next = { ...next, blacklistUntil: null };
@@ -107,14 +124,15 @@ export function tickQuotaStateTime(state, nowMs) {
         return next;
     }
     if (inCooldown) {
-        if (next.inPool !== false || next.reason !== 'cooldown') {
-            next = { ...next, inPool: false, reason: 'cooldown' };
+        const keepInPool = next.cooldownKeepsPool === true;
+        if (next.inPool !== keepInPool || next.reason !== 'cooldown') {
+            next = { ...next, inPool: keepInPool, reason: 'cooldown' };
         }
         return next;
     }
     // TTLs expired: only auto-reset "cooldown/blacklist" back to ok.
     if (next.reason === 'cooldown' || next.reason === 'blacklist') {
-        next = { ...next, inPool: true, reason: 'ok' };
+        next = { ...next, inPool: true, reason: 'ok', cooldownKeepsPool: undefined };
     }
     return next;
 }
@@ -131,7 +149,9 @@ export function applyErrorEvent(state, event, nowMs = event.timestampMs ?? Date.
     const withinChainWindow = typeof lastAt === 'number' &&
         nowMs - lastAt >= 0 &&
         nowMs - lastAt <= ERROR_CHAIN_WINDOW_MS;
-    const sameErrorKey = withinChainWindow && state.lastErrorCode === errorKey;
+    const sameErrorKey = withinChainWindow &&
+        (state.lastErrorCode === errorKey ||
+            (shouldAccumulateBySeries(series) && state.lastErrorSeries === series));
     const schedule = series === 'E429'
         ? COOLDOWN_SCHEDULE_429_MS
         : series === 'EFATAL'
@@ -139,7 +159,7 @@ export function applyErrorEvent(state, event, nowMs = event.timestampMs ?? Date.
             : COOLDOWN_SCHEDULE_DEFAULT_MS;
     const rawNextCount = sameErrorKey ? state.consecutiveErrorCount + 1 : 1;
     const nextCount = rawNextCount > schedule.length ? 1 : rawNextCount;
-    const cooldownMs = computeCooldownMsBySeries(series, nextCount);
+    const cooldownMs = computeTransientKeepPoolCooldownMs(series, nextCount) ?? computeCooldownMsBySeries(series, nextCount);
     const nextUntil = cooldownMs ? nowMs + cooldownMs : null;
     const existingUntil = typeof state.cooldownUntil === 'number' ? state.cooldownUntil : null;
     const cooldownUntil = typeof nextUntil === 'number' && Number.isFinite(nextUntil)
@@ -149,12 +169,14 @@ export function applyErrorEvent(state, event, nowMs = event.timestampMs ?? Date.
         : existingUntil;
     const inCooldown = typeof cooldownUntil === 'number' && cooldownUntil > nowMs;
     const inBlacklist = typeof state.blacklistUntil === 'number' && state.blacklistUntil > nowMs;
-    const inPool = !inCooldown && !inBlacklist;
+    const cooldownKeepsPool = shouldKeepProviderInPoolDuringCooldown(series, nextCount);
+    const inPool = !inBlacklist && (!inCooldown || cooldownKeepsPool);
     return {
         ...state,
         inPool,
         reason: inBlacklist ? 'blacklist' : inCooldown ? 'cooldown' : 'ok',
         cooldownUntil,
+        cooldownKeepsPool: inCooldown ? cooldownKeepsPool : undefined,
         lastErrorSeries: series,
         lastErrorCode: errorKey,
         lastErrorAtMs: nowMs,

package/dist/quota/types.d.ts

@@ -26,6 +26,7 @@ export interface QuotaState {
     authIssue?: QuotaAuthIssue;
     priorityTier: number;
     cooldownUntil: number | null;
+    cooldownKeepsPool?: boolean;
     blacklistUntil: number | null;
     lastErrorSeries: ErrorSeries | null;
     lastErrorCode: string | null;

package/dist/router/virtual-router/bootstrap/routing-config.js

@@ -131,11 +131,11 @@ function normalizeRoutePoolEntry(routeName, entry, index, total) {
         record.isBackup === true ||
         (typeof record.type === 'string' && record.type.toLowerCase() === 'backup');
     const priority = normalizePriorityValue(record.priority, total - index);
-    const targets = normalizeRouteTargets(record);
+    const loadBalancing = normalizeRoutePoolLoadBalancing(record.loadBalancing);
+    const targets = normalizeRouteTargets(record, loadBalancing);
     const mode = normalizeRoutePoolMode(record.mode ?? record.strategy ?? record.routingMode);
     const force = record.force === true ||
         (typeof record.force === 'string' && record.force.trim().toLowerCase() === 'true');
-    const loadBalancing = normalizeRoutePoolLoadBalancing(record.loadBalancing);
     return targets.length
         ? {
             id,
@@ -209,7 +209,7 @@ function normalizeRoutePoolMode(value) {
     }
     return undefined;
 }
-function normalizeRouteTargets(record) {
+function normalizeRouteTargets(record, loadBalancing) {
     const buckets = [record.targets, record.providers, record.pool, record.entries, record.items, record.routes];
     const normalized = [];
     for (const bucket of buckets) {
@@ -227,6 +227,14 @@ function normalizeRouteTargets(record) {
             }
         }
     }
+    if (normalized.length === 0 && loadBalancing?.weights && Object.keys(loadBalancing.weights).length > 0) {
+        for (const target of Object.keys(loadBalancing.weights)) {
+            const trimmed = target.trim();
+            if (trimmed && !normalized.includes(trimmed)) {
+                normalized.push(trimmed);
+            }
+        }
+    }
     return normalized;
 }
 function normalizeTargetList(value) {

package/dist/router/virtual-router/engine-legacy.d.ts

@@ -4,14 +4,13 @@ import { RouteLoadBalancer } from './load-balancer.js';
 import { RoutingClassifier } from './classifier.js';
 import { ContextAdvisor } from './context-advisor.js';
 import type { ProcessedRequest, StandardizedRequest } from '../../conversion/hub/types/standardized.js';
-import { type RoutingPools, type RoutingDecision, type RoutingDiagnostics, type StopMessageStateSnapshot, type PreCommandStateSnapshot, type RoutePoolTier, type RouterMetadataInput, type RoutingFeatures, type VirtualRouterConfig, type VirtualRouterContextRoutingConfig, type TargetMetadata, type ProviderFailureEvent, type ProviderErrorEvent, type ProviderSuccessEvent, type VirtualRouterHealthStore } from './types.js';
+import { type RoutingPools, type RoutingDecision, type RoutingDiagnostics, type StopMessageStateSnapshot, type PreCommandStateSnapshot, type RoutePoolTier, type RouterMetadataInput, type RoutingFeatures, type VirtualRouterConfig, type VirtualRouterContextRoutingConfig, type TargetMetadata, type RoutingStatusSnapshot, type ProviderFailureEvent, type ProviderErrorEvent, type ProviderSuccessEvent, type VirtualRouterHealthStore } from './types.js';
 import type { RoutingInstructionState } from './routing-instructions.js';
 import type { ProviderQuotaView } from './types.js';
 import type { RoutingInstructionStateStoreLike } from './engine/routing-state/store.js';
 import { RouteAnalytics } from './engine/route-analytics.js';
 import { StickySessionManager } from './engine/sticky-session-manager.js';
 import { CooldownManager } from './engine/cooldown-manager.js';
-import { getStatus as getStatusImpl } from './engine-legacy/state-accessors.js';
 export declare class VirtualRouterEngine {
     routing: RoutingPools;
     readonly providerRegistry: ProviderRegistry;
@@ -36,6 +35,7 @@ export declare class VirtualRouterEngine {
     routingStateStore: RoutingInstructionStateStoreLike;
     routingInstructionState: Map<string, RoutingInstructionState>;
     quotaView?: ProviderQuotaView;
+    private readonly nativeEngine;
     /**
      * Backward-compatible test/debug surface used by existing regression scripts.
      * Keep this as a read-only view over StickySessionManager storage.
@@ -62,7 +62,7 @@ export declare class VirtualRouterEngine {
     handleProviderFailure(event: ProviderFailureEvent): void;
     handleProviderError(event: ProviderErrorEvent): void;
     handleProviderSuccess(event: ProviderSuccessEvent): void;
-    getStatus(): ReturnType<typeof getStatusImpl>;
+    getStatus(): RoutingStatusSnapshot;
     normalizeRouteAlias(routeName: string | undefined): string;
     buildRouteCandidates(requestedRoute: string, classificationCandidates: string[] | undefined, features: RoutingFeatures): string[];
     reorderForInlineVision(routeNames: string[]): string[];

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

@@ -9,10 +9,9 @@ import { resolveStickyKey as resolveStickyKeyImpl, resolveSessionScope as resolv
 import { RouteAnalytics } from './engine/route-analytics.js';
 import { StickySessionManager } from './engine/sticky-session-manager.js';
 import { CooldownManager } from './engine/cooldown-manager.js';
-import { routeRequest } from './engine-legacy/routing.js';
+import { VirtualRouterEngine as NativeVirtualRouterEngine } from './engine.js';
 import { updateDeps as updateDepsImpl, initialize as initializeImpl } from './engine-legacy/config.js';
 import { handleProviderError as handleProviderErrorImpl, handleProviderFailure as handleProviderFailureImpl, handleProviderSuccess as handleProviderSuccessImpl, buildHealthSnapshot as buildHealthSnapshotImpl, persistHealthSnapshot as persistHealthSnapshotImpl, markProviderCooldown as markProviderCooldownImpl, clearProviderCooldown as clearProviderCooldownImpl, isProviderCoolingDown as isProviderCoolingDownImpl, getProviderCooldownRemainingMs as getProviderCooldownRemainingMsImpl, restoreHealthFromStore as restoreHealthFromStoreImpl } from './engine-legacy/health.js';
-import { getStopMessageState as getStopMessageStateImpl, getPreCommandState as getPreCommandStateImpl, getStatus as getStatusImpl } from './engine-legacy/state-accessors.js';
 import { selectProvider as selectProviderImpl, selectFromCandidates as selectFromCandidatesImpl, selectFromStickyPool as selectFromStickyPoolImpl, extractExcludedProviderKeySet as extractExcludedProviderKeySetImpl } from './engine-legacy/selection-core.js';
 import { parseDirectProviderModel as parseDirectProviderModelImpl, shouldFallbackDirectModelForMedia as shouldFallbackDirectModelForMediaImpl } from './engine-legacy/direct-model.js';
 import { normalizeRouteAlias as normalizeRouteAliasImpl, buildRouteCandidates as buildRouteCandidatesImpl, reorderForInlineVision as reorderForInlineVisionImpl, reorderForPreferredModel as reorderForPreferredModelImpl, routeSupportsModel as routeSupportsModelImpl, routeSupportsInlineVision as routeSupportsInlineVisionImpl, sortByPriority as sortByPriorityImpl, routeWeight as routeWeightImpl, routeHasForceFlag as routeHasForceFlagImpl, routeHasTargets as routeHasTargetsImpl, hasPrimaryPool as hasPrimaryPoolImpl, sortRoutePools as sortRoutePoolsImpl, flattenPoolTargets as flattenPoolTargetsImpl } from './engine-legacy/route-utils.js';
@@ -42,14 +41,16 @@ export class VirtualRouterEngine {
     };
     routingInstructionState = new Map();
     quotaView;
+    nativeEngine;
     /**
      * Backward-compatible test/debug surface used by existing regression scripts.
      * Keep this as a read-only view over StickySessionManager storage.
      */
     get antigravitySessionAliasStore() {
-        return this.stickySessionManager.getAllStores().sessionAliasStore;
+        return this.nativeEngine.antigravitySessionAliasStore;
     }
     constructor(deps) {
+        this.nativeEngine = new NativeVirtualRouterEngine(deps);
         this.cooldownManager = new CooldownManager({
             healthStore: deps?.healthStore,
             healthConfig: this.healthConfig,
@@ -67,30 +68,35 @@ export class VirtualRouterEngine {
     }
     updateDeps(deps) {
         updateDepsImpl(this, deps);
+        this.nativeEngine.updateDeps(deps);
     }
     initialize(config) {
         initializeImpl(this, config);
+        this.nativeEngine.initialize(config);
     }
     route(request, metadata) {
-        return routeRequest(this, request, metadata);
+        return this.nativeEngine.route(request, metadata);
     }
     getStopMessageState(metadata) {
-        return getStopMessageStateImpl(this, metadata);
+        return this.nativeEngine.getStopMessageState(metadata);
     }
     getPreCommandState(metadata) {
-        return getPreCommandStateImpl(this, metadata);
+        return this.nativeEngine.getPreCommandState(metadata);
     }
     handleProviderFailure(event) {
         handleProviderFailureImpl(this, event);
+        this.nativeEngine.handleProviderFailure(event);
     }
     handleProviderError(event) {
         handleProviderErrorImpl(this, event);
+        this.nativeEngine.handleProviderError(event);
     }
     handleProviderSuccess(event) {
         handleProviderSuccessImpl(this, event);
+        this.nativeEngine.handleProviderSuccess(event);
     }
     getStatus() {
-        return getStatusImpl(this);
+        return this.nativeEngine.getStatus();
     }
     normalizeRouteAlias(routeName) {
         return normalizeRouteAliasImpl(routeName);
@@ -133,9 +139,11 @@ export class VirtualRouterEngine {
     }
     markProviderCooldown(providerKey, cooldownMs) {
         markProviderCooldownImpl(this, providerKey, cooldownMs);
+        this.nativeEngine.markProviderCooldown(providerKey, cooldownMs);
     }
     clearProviderCooldown(providerKey) {
         clearProviderCooldownImpl(this, providerKey);
+        this.nativeEngine.clearProviderCooldown(providerKey);
     }
     isProviderCoolingDown(providerKey) {
         return isProviderCoolingDownImpl(this, providerKey);

package/dist/router/virtual-router/engine-selection/native-compat-action-semantics.d.ts

@@ -4,3 +4,19 @@ export declare function applyRequestRulesWithNative(payload: Record<string, unkn
 export declare function applyResponseBlacklistWithNative(payload: Record<string, unknown>, config?: Record<string, unknown>): Record<string, unknown>;
 export declare function normalizeToolCallIdsWithNative(payload: Record<string, unknown>): Record<string, unknown>;
 export declare function enforceLmstudioResponsesFcToolCallIdsWithNative(payload: Record<string, unknown>): Record<string, unknown>;
+export declare function applyAnthropicClaudeCodeUserIdWithNative(payload: Record<string, unknown>, adapterContext?: Record<string, unknown>): Record<string, unknown>;
+export declare function applyGeminiWebSearchRequestCompatWithNative(payload: Record<string, unknown>, adapterContext?: Record<string, unknown>): Record<string, unknown>;
+export declare function prepareAntigravityThoughtSignatureForGeminiRequestWithNative(payload: Record<string, unknown>, adapterContext?: Record<string, unknown>): Record<string, unknown>;
+export declare function applyIflowToolTextFallbackWithNative(payload: Record<string, unknown>, adapterContext?: Record<string, unknown>, models?: string[]): Record<string, unknown>;
+export declare function applyToolTextRequestGuidanceWithNative(payload: Record<string, unknown>, config?: Record<string, unknown>): Record<string, unknown>;
+export declare function applyUniversalShapeRequestFilterWithNative(payload: Record<string, unknown>, config?: Record<string, unknown>): Record<string, unknown>;
+export declare function applyUniversalShapeResponseFilterWithNative(payload: Record<string, unknown>, config?: Record<string, unknown>, adapterContext?: Record<string, unknown>): Record<string, unknown>;
+export declare function buildOpenAIChatFromAnthropicWithNative(payload: Record<string, unknown>, options?: Record<string, unknown>): Record<string, unknown>;
+export declare function buildAnthropicFromOpenAIChatWithNative(payload: Record<string, unknown>, options?: Record<string, unknown>): Record<string, unknown>;
+export declare function runOpenAIRequestCodecWithNative(payload: Record<string, unknown>, options?: Record<string, unknown>): Record<string, unknown>;
+export declare function runOpenAIResponseCodecWithNative(payload: Record<string, unknown>, options?: Record<string, unknown>): Record<string, unknown>;
+export declare function runResponsesOpenAIRequestCodecWithNative(payload: Record<string, unknown>, options?: Record<string, unknown>): Record<string, unknown>;
+export declare function runResponsesOpenAIResponseCodecWithNative(payload: Record<string, unknown>, context: Record<string, unknown>): Record<string, unknown>;
+export declare function runGeminiOpenAIRequestCodecWithNative(payload: Record<string, unknown>, options?: Record<string, unknown>): Record<string, unknown>;
+export declare function runGeminiOpenAIResponseCodecWithNative(payload: Record<string, unknown>, options?: Record<string, unknown>): Record<string, unknown>;
+export declare function runGeminiFromOpenAIChatCodecWithNative(payload: Record<string, unknown>, options?: Record<string, unknown>): Record<string, unknown>;