@jsonstudio/llms 0.6.3405 → 0.6.3539

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/conversion/shared/tool-call-id-manager.js

@@ -35,11 +35,9 @@ export class ToolCallIdManager {
      */
     generateId() {
         assertToolCallIdManagerNativeAvailable();
-        if (this.options.style === 'fc') {
-            const next = transformToolCallIdWithNative(this.state, '').id;
-            return next;
-        }
-        return normalizeIdValueWithNative(undefined, true);
+        const output = transformToolCallIdWithNative(this.state, '');
+        this.state = output.state;
+        return output.id;
     }
     /**
      * 规范化工具调用 ID
@@ -50,13 +48,9 @@ export class ToolCallIdManager {
     normalizeId(id) {
         assertToolCallIdManagerNativeAvailable();
         const raw = typeof id === 'string' ? id : '';
-        if (this.options.style === 'fc') {
-            const output = transformToolCallIdWithNative(this.state, raw);
-            this.state = output.state;
-            return output.id;
-        }
-        const trimmed = raw.trim();
-        return trimmed ? trimmed : normalizeIdValueWithNative(undefined, true);
+        const output = transformToolCallIdWithNative(this.state, raw);
+        this.state = output.state;
+        return output.id;
     }
     /**
      * 规范化工具调用 ID（带别名注册）
@@ -68,18 +62,21 @@ export class ToolCallIdManager {
     normalizeIdWithAlias(id, aliasMap) {
         assertToolCallIdManagerNativeAvailable();
         const raw = typeof id === 'string' ? id : '';
-        if (this.options.style !== 'preserve') {
-            return this.normalizeId(raw);
-        }
         const trimmed = raw.trim();
-        if (trimmed && aliasMap && aliasMap.has(trimmed)) {
-            return aliasMap.get(trimmed);
+        if (this.options.style === 'preserve' && trimmed && aliasMap?.has(trimmed)) {
+            const existing = aliasMap.get(trimmed);
+            const aliasState = this.state.aliasMap;
+            if (aliasState && typeof aliasState === 'object') {
+                aliasState[trimmed] = existing;
+            }
+            return existing;
         }
-        const value = trimmed || normalizeIdValueWithNative(undefined, true);
-        if (trimmed && aliasMap) {
-            aliasMap.set(trimmed, value);
+        const output = transformToolCallIdWithNative(this.state, raw);
+        this.state = output.state;
+        if (this.options.style === 'preserve' && trimmed && aliasMap) {
+            aliasMap.set(trimmed, output.id);
         }
-        return value;
+        return output.id;
     }
     /**
      * 批量规范化工具调用 ID

package/dist/router/virtual-router/bootstrap/routing-config.d.ts

@@ -1,4 +1,4 @@
-import { type RoutingPools } from '../types.js';
+import { type RoutingPools, type RoutePoolLoadBalancingPolicy } from '../types.js';
 export interface NormalizedRoutePoolConfig {
     id: string;
     priority: number;
@@ -6,6 +6,7 @@ export interface NormalizedRoutePoolConfig {
     targets: string[];
     mode?: 'round-robin' | 'priority';
     force?: boolean;
+    loadBalancing?: RoutePoolLoadBalancingPolicy;
 }
 export declare function normalizeRouting(source: Record<string, unknown>): Record<string, NormalizedRoutePoolConfig[]>;
 export declare function expandRoutingTable(routingSource: Record<string, NormalizedRoutePoolConfig[]>, aliasIndex: Map<string, string[]>, modelIndex: Map<string, {

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

@@ -91,7 +91,8 @@ export function expandRoutingTable(routingSource, aliasIndex, modelIndex) {
                     backup: pool.backup,
                     targets: sortedTargets,
                     ...(pool.mode ? { mode: pool.mode } : {}),
-                    ...(pool.force ? { force: true } : {})
+                    ...(pool.force ? { force: true } : {}),
+                    ...(pool.loadBalancing ? { loadBalancing: pool.loadBalancing } : {})
                 });
             }
         }
@@ -130,7 +131,8 @@ 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');
@@ -141,10 +143,53 @@ function normalizeRoutePoolEntry(routeName, entry, index, total) {
             backup,
             targets,
             ...(mode ? { mode } : {}),
-            ...(force ? { force: true } : {})
+            ...(force ? { force: true } : {}),
+            ...(loadBalancing ? { loadBalancing } : {})
         }
         : null;
 }
+function normalizeRoutePoolLoadBalancing(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        return undefined;
+    }
+    const record = input;
+    const strategy = normalizeWeightedStrategy(record.strategy);
+    const weightsRaw = record.weights && typeof record.weights === 'object' && !Array.isArray(record.weights)
+        ? record.weights
+        : {};
+    const weights = {};
+    for (const [key, value] of Object.entries(weightsRaw)) {
+        if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+            weights[key] = value;
+        }
+    }
+    if (!strategy && Object.keys(weights).length === 0) {
+        return undefined;
+    }
+    return {
+        ...(strategy ? { strategy } : {}),
+        ...(Object.keys(weights).length ? { weights } : {})
+    };
+}
+function normalizeWeightedStrategy(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized === 'weighted') {
+        return 'weighted';
+    }
+    if (normalized === 'sticky') {
+        return 'sticky';
+    }
+    if (normalized === 'round-robin' || normalized === 'round_robin' || normalized === 'roundrobin' || normalized === 'rr') {
+        return 'round-robin';
+    }
+    return undefined;
+}
 function normalizeRoutePoolMode(value) {
     if (typeof value !== 'string') {
         return undefined;
@@ -164,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) {
@@ -182,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>;