qlogicagent 2.13.5 → 2.13.7

package/dist/runtime/infra/key-pool.js

@@ -1,378 +0,0 @@
-/**
- * Key Pool — commercial-grade multi-key load balancing per provider.
- *
- * Supports: weighted-round-robin, least-busy, random strategies.
- * Features: RPM/TPM sliding window, failure cooldown, health detection, auto-failover.
- *
- * Runtime state (inFlight, counters, health) is in-memory only — resets on restart.
- * Persistent config (keys, weights, strategy) is managed by the caller (settings.json).
- */
-// ── Constants ────────────────────────────────────────────────────────────────
-const DEGRADED_THRESHOLD = 3;
-const COOLDOWN_THRESHOLD = 5;
-const DEFAULT_COOLDOWN_MS = 60_000;
-const RATE_LIMIT_COOLDOWN_MS = 30_000;
-const SLIDING_WINDOW_MS = 60_000;
-const RPM_PREEMPTIVE_RATIO = 0.9; // Start avoiding key at 90% of RPM limit
-// ── KeyPool Class ────────────────────────────────────────────────────────────
-export class KeyPool {
-    pools = new Map();
-    runtimeStates = new Map();
-    constructor(configs) {
-        if (configs) {
-            for (const pool of configs) {
-                this.pools.set(pool.providerId, pool);
-                for (const key of pool.keys) {
-                    this.runtimeStates.set(key.id, this.createInitialState());
-                }
-            }
-        }
-    }
-    // ── Core: Acquire & Release ──────────────────────────────────────────
-    /**
-     * Acquire the next available key for a provider.
-     * Returns a KeyHandle with release() that MUST be called when the request completes.
-     * Returns null if no healthy key is available.
-     */
-    acquireKey(providerId) {
-        const pool = this.pools.get(providerId);
-        if (!pool || pool.keys.length === 0)
-            return null;
-        const now = Date.now();
-        const candidates = this.getHealthyCandidates(pool, now);
-        if (candidates.length === 0)
-            return null;
-        const selected = this.selectByStrategy(candidates, pool.strategy, now);
-        if (!selected)
-            return null;
-        const state = this.runtimeStates.get(selected.id);
-        state.inFlight++;
-        state.totalRequests++;
-        state.lastUsedAt = now;
-        state.requestTimestamps.push(now);
-        let released = false;
-        return {
-            keyId: selected.id,
-            apiKey: selected.key,
-            providerId,
-            release: (result) => {
-                if (released)
-                    return;
-                released = true;
-                this.releaseKey(selected.id, result);
-            },
-        };
-    }
-    /**
-     * Release a key after request completion. Updates health/stats.
-     */
-    releaseKey(keyId, result) {
-        const state = this.runtimeStates.get(keyId);
-        if (!state)
-            return;
-        state.inFlight = Math.max(0, state.inFlight - 1);
-        if (result.success) {
-            state.consecutiveErrors = 0;
-            state.healthStatus = "healthy";
-            if (result.tokens) {
-                state.totalTokens += result.tokens;
-                state.tokenCounts.push({ timestamp: Date.now(), tokens: result.tokens });
-            }
-        }
-        else {
-            state.consecutiveErrors++;
-            state.lastErrorAt = Date.now();
-            if (result.errorCode === 429) {
-                // Rate limited — respect retryAfter or use default
-                const cooldownMs = result.retryAfter
-                    ? result.retryAfter * 1000
-                    : RATE_LIMIT_COOLDOWN_MS;
-                state.cooldownUntil = Date.now() + cooldownMs;
-                state.healthStatus = "cooldown";
-            }
-            else if (state.consecutiveErrors >= COOLDOWN_THRESHOLD) {
-                state.cooldownUntil = Date.now() + DEFAULT_COOLDOWN_MS;
-                state.healthStatus = "cooldown";
-            }
-            else if (state.consecutiveErrors >= DEGRADED_THRESHOLD) {
-                state.healthStatus = "degraded";
-            }
-        }
-    }
-    // ── Management ───────────────────────────────────────────────────────
-    addProvider(providerId, opts) {
-        if (this.pools.has(providerId))
-            return;
-        this.pools.set(providerId, {
-            providerId,
-            baseUrl: opts?.baseUrl,
-            strategy: opts?.strategy ?? "weighted-round-robin",
-            keys: [],
-            rateLimit: opts?.rateLimit,
-        });
-    }
-    removeProvider(providerId) {
-        const pool = this.pools.get(providerId);
-        if (pool) {
-            for (const key of pool.keys) {
-                this.runtimeStates.delete(key.id);
-            }
-            this.pools.delete(providerId);
-        }
-    }
-    addKey(providerId, key, opts) {
-        let pool = this.pools.get(providerId);
-        if (!pool) {
-            pool = { providerId, strategy: "weighted-round-robin", keys: [] };
-            this.pools.set(providerId, pool);
-        }
-        const id = opts?.id ?? crypto.randomUUID();
-        const entry = {
-            id,
-            key,
-            label: opts?.label,
-            weight: opts?.weight ?? 1,
-            enabled: opts?.enabled ?? true,
-        };
-        pool.keys.push(entry);
-        this.runtimeStates.set(id, this.createInitialState());
-        return id;
-    }
-    removeKey(keyId) {
-        for (const [providerId, pool] of this.pools) {
-            const idx = pool.keys.findIndex(k => k.id === keyId);
-            if (idx !== -1) {
-                pool.keys.splice(idx, 1);
-                if (pool.keys.length === 0) {
-                    this.pools.delete(providerId);
-                }
-                this.runtimeStates.delete(keyId);
-                return true;
-            }
-        }
-        return false;
-    }
-    getKeyById(keyId) {
-        for (const pool of this.pools.values()) {
-            const entry = pool.keys.find(k => k.id === keyId);
-            if (entry)
-                return entry.key;
-        }
-        return null;
-    }
-    updateKey(keyId, updates) {
-        for (const pool of this.pools.values()) {
-            const entry = pool.keys.find(k => k.id === keyId);
-            if (entry) {
-                if (updates.label !== undefined)
-                    entry.label = updates.label;
-                if (updates.weight !== undefined)
-                    entry.weight = updates.weight;
-                if (updates.enabled !== undefined) {
-                    entry.enabled = updates.enabled;
-                    const state = this.runtimeStates.get(keyId);
-                    if (state) {
-                        state.healthStatus = updates.enabled ? "healthy" : "disabled";
-                    }
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-    /** Explicitly set a key's health status (e.g. after background validation). */
-    setKeyHealth(keyId, status) {
-        const state = this.runtimeStates.get(keyId);
-        if (state) {
-            state.healthStatus = status;
-        }
-    }
-    setStrategy(providerId, strategy) {
-        const pool = this.pools.get(providerId);
-        if (pool)
-            pool.strategy = strategy;
-    }
-    setRateLimit(providerId, rateLimit) {
-        const pool = this.pools.get(providerId);
-        if (pool)
-            pool.rateLimit = rateLimit;
-    }
-    // ── Status Queries ───────────────────────────────────────────────────
-    getPoolStatus(providerId) {
-        const pool = this.pools.get(providerId);
-        if (!pool)
-            return null;
-        return this.buildPoolStatus(pool);
-    }
-    getAllStatus() {
-        return [...this.pools.values()].map(p => this.buildPoolStatus(p));
-    }
-    getProviderIds() {
-        return [...this.pools.keys()];
-    }
-    hasProvider(providerId) {
-        return this.pools.has(providerId);
-    }
-    hasAvailableKey(providerId) {
-        const pool = this.pools.get(providerId);
-        if (!pool)
-            return false;
-        return this.getHealthyCandidates(pool, Date.now()).length > 0;
-    }
-    /** Export persistent config (for saving to settings.json). */
-    exportConfig() {
-        return [...this.pools.values()];
-    }
-    /** Reload from config (e.g., after settings.json changes on disk). */
-    reloadConfig(configs) {
-        const existingKeyIds = new Set();
-        for (const config of configs) {
-            this.pools.set(config.providerId, config);
-            for (const key of config.keys) {
-                existingKeyIds.add(key.id);
-                if (!this.runtimeStates.has(key.id)) {
-                    this.runtimeStates.set(key.id, this.createInitialState());
-                }
-            }
-        }
-        // Remove pools no longer in config
-        for (const pid of [...this.pools.keys()]) {
-            if (!configs.some(c => c.providerId === pid)) {
-                this.pools.delete(pid);
-            }
-        }
-        // Remove orphan runtime states
-        for (const kid of [...this.runtimeStates.keys()]) {
-            if (!existingKeyIds.has(kid)) {
-                this.runtimeStates.delete(kid);
-            }
-        }
-    }
-    // ── Internal ─────────────────────────────────────────────────────────
-    createInitialState() {
-        return {
-            inFlight: 0,
-            totalRequests: 0,
-            totalTokens: 0,
-            lastUsedAt: 0,
-            lastErrorAt: 0,
-            consecutiveErrors: 0,
-            cooldownUntil: 0,
-            healthStatus: "healthy",
-            requestTimestamps: [],
-            tokenCounts: [],
-        };
-    }
-    getHealthyCandidates(pool, now) {
-        const candidates = [];
-        for (const key of pool.keys) {
-            if (!key.enabled)
-                continue;
-            const state = this.runtimeStates.get(key.id);
-            if (!state)
-                continue;
-            // Check cooldown expiry
-            if (state.healthStatus === "cooldown") {
-                if (now >= state.cooldownUntil) {
-                    state.healthStatus = "healthy";
-                    state.consecutiveErrors = 0;
-                }
-                else {
-                    continue;
-                }
-            }
-            if (state.healthStatus === "disabled")
-                continue;
-            // Check RPM preemptive avoidance
-            if (pool.rateLimit?.rpm) {
-                this.pruneWindow(state.requestTimestamps, now);
-                if (state.requestTimestamps.length >= pool.rateLimit.rpm * RPM_PREEMPTIVE_RATIO) {
-                    continue;
-                }
-            }
-            // Check TPM preemptive avoidance
-            if (pool.rateLimit?.tpm) {
-                this.pruneTokenWindow(state.tokenCounts, now);
-                const recentTokens = state.tokenCounts.reduce((sum, sample) => sum + sample.tokens, 0);
-                if (recentTokens >= pool.rateLimit.tpm * RPM_PREEMPTIVE_RATIO) {
-                    continue;
-                }
-            }
-            candidates.push(key);
-        }
-        return candidates;
-    }
-    selectByStrategy(candidates, strategy, _now) {
-        if (candidates.length === 0)
-            return null;
-        if (candidates.length === 1)
-            return candidates[0];
-        switch (strategy) {
-            case "weighted-round-robin":
-                return this.weightedRandom(candidates);
-            case "least-busy":
-                return this.leastBusy(candidates);
-            case "random":
-                return candidates[Math.floor(Math.random() * candidates.length)];
-            default:
-                return this.weightedRandom(candidates);
-        }
-    }
-    weightedRandom(candidates) {
-        const totalWeight = candidates.reduce((sum, k) => sum + k.weight, 0);
-        let rand = Math.random() * totalWeight;
-        for (const key of candidates) {
-            rand -= key.weight;
-            if (rand <= 0)
-                return key;
-        }
-        return candidates[candidates.length - 1];
-    }
-    leastBusy(candidates) {
-        let minInFlight = Infinity;
-        let best = candidates[0];
-        for (const key of candidates) {
-            const state = this.runtimeStates.get(key.id);
-            const inFlight = state?.inFlight ?? 0;
-            if (inFlight < minInFlight || (inFlight === minInFlight && key.weight > best.weight)) {
-                minInFlight = inFlight;
-                best = key;
-            }
-        }
-        return best;
-    }
-    pruneWindow(timestamps, now) {
-        const cutoff = now - SLIDING_WINDOW_MS;
-        while (timestamps.length > 0 && timestamps[0] < cutoff) {
-            timestamps.shift();
-        }
-    }
-    pruneTokenWindow(samples, now) {
-        const cutoff = now - SLIDING_WINDOW_MS;
-        while (samples.length > 0 && samples[0].timestamp < cutoff) {
-            samples.shift();
-        }
-    }
-    buildPoolStatus(pool) {
-        return {
-            providerId: pool.providerId,
-            baseUrl: pool.baseUrl,
-            strategy: pool.strategy,
-            rateLimit: pool.rateLimit,
-            keys: pool.keys.map(k => {
-                const state = this.runtimeStates.get(k.id) ?? this.createInitialState();
-                return {
-                    ...k,
-                    inFlight: state.inFlight,
-                    totalRequests: state.totalRequests,
-                    totalTokens: state.totalTokens,
-                    lastUsedAt: state.lastUsedAt,
-                    lastErrorAt: state.lastErrorAt,
-                    consecutiveErrors: state.consecutiveErrors,
-                    cooldownUntil: state.cooldownUntil,
-                    healthStatus: k.enabled ? state.healthStatus : "disabled",
-                };
-            }),
-        };
-    }
-}

package/dist/runtime/infra/key-pool.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/runtime/infra/key-pool.test.js

@@ -1,36 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { KeyPool } from "./key-pool.js";
-afterEach(() => {
-    vi.useRealTimers();
-});
-describe("KeyPool", () => {
-    it("keeps released token usage in the TPM sliding window", () => {
-        vi.useFakeTimers();
-        vi.setSystemTime(1_000_000);
-        const pool = new KeyPool([{
-                providerId: "provider",
-                strategy: "weighted-round-robin",
-                rateLimit: { tpm: 100 },
-                keys: [{ id: "key-1", key: "secret", weight: 1, enabled: true }],
-            }]);
-        const first = pool.acquireKey("provider");
-        expect(first).not.toBeNull();
-        first?.release({ success: true, tokens: 95 });
-        expect(pool.acquireKey("provider")).toBeNull();
-        vi.advanceTimersByTime(60_001);
-        expect(pool.acquireKey("provider")).not.toBeNull();
-    });
-    it("makes a key handle release idempotent", () => {
-        const pool = new KeyPool([{
-                providerId: "provider",
-                strategy: "weighted-round-robin",
-                keys: [{ id: "key-1", key: "secret", weight: 1, enabled: true }],
-            }]);
-        const handle = pool.acquireKey("provider");
-        handle?.release({ success: true, tokens: 10 });
-        handle?.release({ success: true, tokens: 10 });
-        const status = pool.getPoolStatus("provider")?.keys[0];
-        expect(status?.inFlight).toBe(0);
-        expect(status?.totalTokens).toBe(10);
-    });
-});

package/dist/runtime/infra/llmrouter-catalog.d.ts

@@ -1,84 +0,0 @@
-import type { ModelEntry, ModelRegistry, ReasoningMode } from "./model-registry.js";
-import type { ConfigPort } from "../ports/index.js";
-export declare const LLMROUTER_CATALOG_UNAVAILABLE_MESSAGE = "\u65E0\u6CD5\u8FDE\u63A5 llmrouter \u6A21\u578B\u76EE\u5F55";
-export declare const LLMROUTER_PROVIDER_ID = "llmrouter";
-export declare const LLMROUTER_PROVIDER_NAME = "LLMRouter";
-interface CatalogFetchOptions {
-    force?: boolean;
-}
-export declare class LlmrouterCatalogUnavailableError extends Error {
-    constructor(message?: string);
-}
-export interface LlmrouterCatalogProvider {
-    id: string;
-    name?: string;
-    displayName?: string;
-    group?: string;
-    baseUrl?: string;
-    base_url?: string;
-    transport?: string;
-    authType?: string;
-    apiKeyEnvVars?: string[];
-    models?: Array<{
-        id?: string;
-    }>;
-}
-export interface LlmrouterCatalogModel {
-    id: string;
-    public_model?: string;
-    publicModel?: string;
-    provider?: string;
-    owned_by?: string;
-    native_model_id?: string;
-    nativeModelId?: string;
-    display_name?: string;
-    displayName?: string;
-    name?: string;
-    category?: string;
-    purposes?: string[];
-    baseUrl?: string;
-    base_url?: string;
-    provider_transport?: string;
-    providerTransport?: string;
-    context_window?: number;
-    contextWindow?: number;
-    max_output?: number;
-    maxOutput?: number;
-    stream_required?: boolean;
-    streamRequired?: boolean;
-    tool_call?: boolean;
-    toolCall?: boolean;
-    reasoning_mode?: ReasoningMode;
-    reasoningMode?: ReasoningMode;
-    media_type?: string | null;
-    mediaType?: string | null;
-    capabilities?: string[];
-    pricing?: Record<string, unknown>;
-}
-export declare function getLlmrouterBaseUrl(configPort?: ConfigPort): string;
-export declare function getLlmrouterModelsUrl(baseUrl: string): string;
-export declare function listLlmrouterCatalogProviders(configPort?: ConfigPort, options?: CatalogFetchOptions): Promise<LlmrouterCatalogProvider[]>;
-export declare function listLlmrouterCatalogModels(configPort?: ConfigPort, options?: CatalogFetchOptions): Promise<LlmrouterCatalogModel[]>;
-export declare function listLlmrouterModelsByApiKey(baseUrl: string, apiKey: string): Promise<LlmrouterCatalogModel[]>;
-export declare function providerDisplayName(provider: LlmrouterCatalogProvider): string;
-export declare function providerBaseUrl(provider: LlmrouterCatalogProvider): string | undefined;
-export declare function getLlmrouterCatalogProvider(providerId: string, configPort?: ConfigPort, options?: CatalogFetchOptions): Promise<LlmrouterCatalogProvider | null>;
-export declare function refreshRegistryFromLlmrouterCatalog(registry: ModelRegistry, configPort?: ConfigPort, options?: CatalogFetchOptions): Promise<ModelEntry[]>;
-export declare function refreshRegistryFromLlmrouterApiKey(registry: ModelRegistry, options: {
-    baseUrl: string;
-    apiKey: string;
-    configPort?: ConfigPort;
-    forceCatalog?: boolean;
-}): Promise<ModelEntry[]>;
-export declare function resetLlmrouterCatalogClientCache(): void;
-/**
- * 零配置默认模型:全新安装(无 textGeneration binding)且网关注入了设备账号推理 key 时,
- * 自动把默认文本模型设为一个 DeepSeek(经 llmrouter)。调用方需先刷新过目录(this.models 里要有
- * `llmrouter:deepseek-*` 条目)。已有 binding 则尊重用户配置、不覆盖。返回是否设置了默认。
- *
- * key 不在此注册 —— ModelRegistry 取 llmrouter key 时会回退到 QLOGIC_LLMROUTER_INFERENCE_KEY env。
- */
-export declare function ensureLlmrouterDefaultBinding(registry: ModelRegistry, configPort?: ConfigPort): boolean;
-export declare function toModelEntry(model: LlmrouterCatalogModel): ModelEntry | null;
-export declare function toModelEntries(model: LlmrouterCatalogModel): ModelEntry[];
-export {};