@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/router/virtual-router/engine/cooldown-manager.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Cooldown Manager Module
+ *
+ * Manages provider cooldown TTLs and health snapshot persistence.
+ */
+import type { VirtualRouterHealthSnapshot, VirtualRouterHealthStore, ProviderHealthConfig } from '../types.js';
+export declare class CooldownManager {
+    private providerCooldowns;
+    private healthStore?;
+    private healthConfig;
+    private quotaView?;
+    constructor(deps?: {
+        healthStore?: VirtualRouterHealthStore;
+        healthConfig?: ProviderHealthConfig | null;
+        quotaView?: (providerKey: string) => {
+            selectionPenalty?: number;
+        } | undefined;
+    });
+    updateDeps(deps: {
+        healthStore?: VirtualRouterHealthStore | null;
+        healthConfig?: ProviderHealthConfig | null;
+        quotaView?: (providerKey: string) => {
+            selectionPenalty?: number;
+        } | undefined | null;
+    }): void;
+    markProviderCooldown(providerKey: string, cooldownMs: number | undefined): void;
+    clearProviderCooldown(providerKey: string): void;
+    isProviderCoolingDown(providerKey: string): boolean;
+    restoreHealthFromStore(): void;
+    buildHealthSnapshot(): VirtualRouterHealthSnapshot;
+    persistHealthSnapshot(): void;
+    clearAllCooldowns(): void;
+    getCooldownMap(): Map<string, number>;
+}

package/vendor/llmswitch-core/dist/router/virtual-router/engine/cooldown-manager.js

@@ -0,0 +1,118 @@
+/**
+ * Cooldown Manager Module
+ *
+ * Manages provider cooldown TTLs and health snapshot persistence.
+ */
+export class CooldownManager {
+    providerCooldowns = new Map();
+    healthStore;
+    healthConfig = null;
+    quotaView;
+    constructor(deps) {
+        if (deps?.healthStore)
+            this.healthStore = deps.healthStore;
+        if (deps?.healthConfig !== undefined)
+            this.healthConfig = deps.healthConfig;
+        if (deps?.quotaView)
+            this.quotaView = deps.quotaView;
+    }
+    updateDeps(deps) {
+        if ('healthStore' in deps)
+            this.healthStore = deps.healthStore ?? undefined;
+        if ('healthConfig' in deps)
+            this.healthConfig = deps.healthConfig ?? null;
+        if ('quotaView' in deps) {
+            const prevQuotaEnabled = Boolean(this.quotaView);
+            this.quotaView = deps.quotaView ?? undefined;
+            const nextQuotaEnabled = Boolean(this.quotaView);
+            // When quotaView is enabled, cooldown must be driven by quotaView only.
+            if (!prevQuotaEnabled && nextQuotaEnabled) {
+                this.providerCooldowns.clear();
+            }
+            else if (prevQuotaEnabled && !nextQuotaEnabled) {
+                this.providerCooldowns.clear();
+                this.restoreHealthFromStore();
+            }
+        }
+    }
+    markProviderCooldown(providerKey, cooldownMs) {
+        if (!providerKey)
+            return;
+        const ttl = typeof cooldownMs === 'number' ? Math.round(cooldownMs) : Number.NaN;
+        if (!Number.isFinite(ttl) || ttl <= 0)
+            return;
+        this.providerCooldowns.set(providerKey, Date.now() + ttl);
+        this.persistHealthSnapshot();
+    }
+    clearProviderCooldown(providerKey) {
+        if (!providerKey)
+            return;
+        if (this.providerCooldowns.delete(providerKey)) {
+            this.persistHealthSnapshot();
+        }
+    }
+    isProviderCoolingDown(providerKey) {
+        if (!providerKey)
+            return false;
+        const expiry = this.providerCooldowns.get(providerKey);
+        if (!expiry)
+            return false;
+        if (Date.now() >= expiry) {
+            this.providerCooldowns.delete(providerKey);
+            return false;
+        }
+        return true;
+    }
+    restoreHealthFromStore() {
+        if (!this.healthStore || typeof this.healthStore.loadInitialSnapshot !== 'function')
+            return;
+        // When quotaView is enabled, health/cooldown must be driven by quotaView only.
+        if (this.quotaView)
+            return;
+        let snapshot = null;
+        try {
+            snapshot = this.healthStore.loadInitialSnapshot();
+        }
+        catch {
+            snapshot = null;
+        }
+        if (!snapshot)
+            return;
+        const now = Date.now();
+        const byKey = new Map();
+        for (const entry of snapshot.cooldowns || []) {
+            if (!entry?.providerKey || !Number.isFinite(entry.cooldownExpiresAt) || entry.cooldownExpiresAt <= now)
+                continue;
+            byKey.set(entry.providerKey, entry);
+            this.providerCooldowns.set(entry.providerKey, entry.cooldownExpiresAt);
+        }
+        // Note: Provider health manager's state is separate; we only restore local cooldowns.
+    }
+    buildHealthSnapshot() {
+        const cooldowns = [];
+        const now = Date.now();
+        for (const [providerKey, expiry] of this.providerCooldowns.entries()) {
+            if (!expiry || expiry <= now)
+                continue;
+            cooldowns.push({ providerKey, cooldownExpiresAt: expiry });
+        }
+        return { providers: [], cooldowns }; // providers part handled by health manager
+    }
+    persistHealthSnapshot() {
+        if (!this.healthStore || typeof this.healthStore.persistSnapshot !== 'function')
+            return;
+        try {
+            const snapshot = this.buildHealthSnapshot();
+            this.healthStore.persistSnapshot(snapshot);
+        }
+        catch {
+            // persistence failure does not affect routing
+        }
+    }
+    clearAllCooldowns() {
+        this.providerCooldowns.clear();
+    }
+    getCooldownMap() {
+        return this.providerCooldowns;
+    }
+}

package/vendor/llmswitch-core/dist/router/virtual-router/engine/health/index.d.ts

@@ -0,0 +1,23 @@
+import { ProviderHealthManager } from '../../health-manager.js';
+import { ProviderRegistry } from '../../provider-registry.js';
+import type { ProviderErrorEvent, ProviderFailureEvent, ProviderHealthConfig } from '../../types.js';
+type DebugLike = {
+    log?: (...args: unknown[]) => void;
+} | Console | undefined;
+export declare function resetRateLimitBackoffForProvider(providerKey: string): void;
+export declare function applyAntigravityRiskPolicyImpl(event: ProviderErrorEvent, providerRegistry: ProviderRegistry, healthManager: ProviderHealthManager, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void, debug?: DebugLike): void;
+export declare function handleProviderFailureImpl(event: ProviderFailureEvent, healthManager: ProviderHealthManager, healthConfig: Required<ProviderHealthConfig>, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void): void;
+export declare function mapProviderErrorImpl(event: ProviderErrorEvent, healthConfig: Required<ProviderHealthConfig>): ProviderFailureEvent | null;
+export declare function applySeriesCooldownImpl(event: ProviderErrorEvent, providerRegistry: ProviderRegistry, healthManager: ProviderHealthManager, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void, debug?: DebugLike): void;
+/**
+ * 处理来自 Host 侧的配额恢复事件：
+ * - 清除指定 providerKey 在健康管理器中的熔断/冷却状态；
+ * - 清理对应的速率退避计数；
+ * - 调用调用方提供的 clearProviderCooldown 回调移除显式 cooldown TTL。
+ *
+ * 返回值表示是否已处理（true=已处理且后续应跳过常规错误映射逻辑）。
+ */
+export declare function applyQuotaRecoveryImpl(event: ProviderErrorEvent, healthManager: ProviderHealthManager, clearProviderCooldown: (providerKey: string) => void, debug?: DebugLike): boolean;
+export declare function applyQuotaDepletedImpl(event: ProviderErrorEvent, healthManager: ProviderHealthManager, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void, debug?: DebugLike): boolean;
+export declare function deriveReason(code: string, stage: string, statusCode?: number): string;
+export {};