qlogicagent 2.13.5 → 2.13.6

package/dist/runtime/infra/model-registry.js

@@ -1,529 +0,0 @@
-import * as fs from "node:fs";
-import { getUserSettingsPath } from "./agent-paths.js";
-import { KeyPool, } from "./key-pool.js";
-export const ALL_PURPOSES = [
-    "textGeneration",
-    "smallModel",
-    "stt",
-    "tts",
-    "imageGeneration",
-    "imageUnderstanding",
-    "videoGeneration",
-    "videoUnderstanding",
-    "threeDGeneration",
-    "embedding",
-    "voiceClone",
-    "musicGeneration",
-    "realtimeAudio",
-    "realtimeVideo",
-];
-/**
- * 网关注入的 llmrouter 设备账号推理 key(零配置默认模型用)。仅对 provider "llmrouter" 生效;
- * 直接读 env(不持久化 key 明文);仅持久化本地启停/删除偏好。手填 key 由 keyPool 先行,优先级更高。
- */
-function llmrouterEnvInferenceKey(providerId) {
-    if (providerId !== "llmrouter")
-        return undefined;
-    return process.env.QLOGIC_LLMROUTER_INFERENCE_KEY?.trim() || undefined;
-}
-const LLMROUTER_ENV_KEY_ID = "llmrouter-env";
-function llmrouterEnvKeyStatus(state = {}) {
-    if (state.removed)
-        return null;
-    const key = llmrouterEnvInferenceKey("llmrouter");
-    if (!key)
-        return null;
-    const enabled = state.enabled !== false;
-    return {
-        providerId: "llmrouter",
-        strategy: "weighted-round-robin",
-        keys: [{
-                id: LLMROUTER_ENV_KEY_ID,
-                key,
-                label: "Desktop LLMRouter",
-                weight: 1,
-                enabled,
-                inFlight: 0,
-                totalRequests: 0,
-                totalTokens: 0,
-                lastUsedAt: 0,
-                lastErrorAt: 0,
-                consecutiveErrors: 0,
-                cooldownUntil: 0,
-                healthStatus: enabled ? "healthy" : "disabled",
-            }],
-    };
-}
-export class ModelRegistry {
-    keyPool;
-    catalogProviders = new Map();
-    models = new Map();
-    modelEnabledOverrides = new Map();
-    bindings = {};
-    injectedKeyStates = {};
-    settingsPath;
-    changeListeners = [];
-    constructor(config) {
-        this.settingsPath = getUserSettingsPath();
-        this.keyPool = new KeyPool(config?.providers);
-        if (config?.models)
-            this.loadModelState(config.models);
-        if (config?.bindings)
-            this.bindings = { ...config.bindings };
-        if (config?.injectedKeys)
-            this.injectedKeyStates = { ...config.injectedKeys };
-    }
-    getActiveModel(purpose) {
-        const modelId = this.bindings[purpose];
-        if (!modelId)
-            return null;
-        const entry = this.models.get(modelId);
-        if (!entry || !entry.enabled)
-            return null;
-        const technical = this.resolveTechnicalVariant(entry, purpose);
-        const requestProvider = technical?.provider ?? entry.provider;
-        const requestModel = technical?.nativeModelId ?? entry.nativeModelId ?? entry.model;
-        const acquired = this.acquireKeyForProviderVariant(requestProvider);
-        if (!acquired)
-            return null;
-        const { keyHandle, keyProviderId } = acquired;
-        const providerBaseUrl = this.getProviderBaseUrl(requestProvider);
-        const keyProviderBaseUrl = this.getProviderBaseUrl(keyProviderId);
-        return {
-            provider: requestProvider,
-            model: requestModel,
-            apiKey: keyHandle.apiKey,
-            baseUrl: providerBaseUrl ?? (entry.provider === requestProvider ? entry.baseUrl : undefined) ?? keyProviderBaseUrl,
-            keyHandle,
-        };
-    }
-    peekActiveModel(purpose) {
-        const modelId = this.bindings[purpose];
-        return modelId ? (this.models.get(modelId) ?? null) : null;
-    }
-    isAvailable(purpose) {
-        const entry = this.peekActiveModel(purpose);
-        return !!entry?.enabled && this.hasAvailableKeyForProviderVariant(entry.provider);
-    }
-    resolveModelForPurpose(purpose) {
-        const entry = this.peekActiveModel(purpose);
-        if (entry)
-            return entry.model;
-        return null;
-    }
-    addProvider(providerId, opts) {
-        this.keyPool.addProvider(providerId, opts);
-        this.emitChange();
-    }
-    removeProvider(providerId) {
-        this.keyPool.removeProvider(providerId);
-        for (const [id, model] of this.models) {
-            if (model.provider === providerId)
-                this.removeModel(id);
-        }
-        this.emitChange();
-    }
-    addKey(providerId, key, opts) {
-        const keyId = this.keyPool.addKey(providerId, key, opts);
-        this.emitChange();
-        return keyId;
-    }
-    removeKey(keyId) {
-        if (keyId === LLMROUTER_ENV_KEY_ID) {
-            if (!this.hasLlmrouterEnvKey())
-                return false;
-            this.setInjectedKeyState(keyId, { removed: true, enabled: false });
-            return true;
-        }
-        const removed = this.keyPool.removeKey(keyId);
-        if (removed)
-            this.emitChange();
-        return removed;
-    }
-    getKeyById(keyId) {
-        if (keyId === LLMROUTER_ENV_KEY_ID) {
-            if (this.getInjectedKeyState(keyId).removed)
-                return null;
-            return llmrouterEnvInferenceKey("llmrouter") ?? null;
-        }
-        return this.keyPool.getKeyById(keyId);
-    }
-    updateKey(keyId, updates) {
-        if (keyId === LLMROUTER_ENV_KEY_ID) {
-            if (!this.hasLlmrouterEnvKey())
-                return false;
-            if (updates.enabled !== undefined)
-                this.setInjectedKeyState(keyId, { enabled: updates.enabled });
-            return true;
-        }
-        const updated = this.keyPool.updateKey(keyId, updates);
-        if (updated)
-            this.emitChange();
-        return updated;
-    }
-    setKeyHealth(keyId, status) {
-        this.keyPool.setKeyHealth(keyId, status);
-        this.emitChange();
-    }
-    setStrategy(providerId, strategy) {
-        this.keyPool.setStrategy(providerId, strategy);
-        this.emitChange();
-    }
-    addModel(entry) {
-        const id = entry.id ?? `${entry.provider}:${entry.model}`;
-        this.models.set(id, { ...entry, id, enabled: this.modelEnabledOverrides.get(id) ?? entry.enabled });
-        this.emitChange();
-        return id;
-    }
-    replaceCatalogProviders(providers) {
-        this.catalogProviders = new Map(providers.map(provider => [provider.id, provider]));
-    }
-    replaceCatalogModels(entries) {
-        const next = new Map();
-        for (const entry of entries) {
-            next.set(entry.id, { ...entry, enabled: this.modelEnabledOverrides.get(entry.id) ?? entry.enabled });
-        }
-        for (const id of this.modelEnabledOverrides.keys()) {
-            if (!next.has(id))
-                this.modelEnabledOverrides.delete(id);
-        }
-        this.models = next;
-        for (const [purpose, modelId] of Object.entries(this.bindings)) {
-            if (modelId && !this.models.has(modelId))
-                delete this.bindings[purpose];
-        }
-        this.emitChange();
-    }
-    replaceProviderModels(providerId, entries) {
-        const next = new Map();
-        for (const [id, model] of this.models) {
-            if (model.provider !== providerId)
-                next.set(id, model);
-        }
-        for (const entry of entries) {
-            if (entry.provider !== providerId)
-                continue;
-            next.set(entry.id, { ...entry, enabled: this.modelEnabledOverrides.get(entry.id) ?? entry.enabled });
-        }
-        const stalePrefix = `${providerId}:`;
-        for (const id of this.modelEnabledOverrides.keys()) {
-            if (id.startsWith(stalePrefix) && !next.has(id))
-                this.modelEnabledOverrides.delete(id);
-        }
-        this.models = next;
-        for (const [purpose, modelId] of Object.entries(this.bindings)) {
-            if (modelId && !this.models.has(modelId))
-                delete this.bindings[purpose];
-        }
-        this.emitChange();
-    }
-    removeModel(id) {
-        this.models.delete(id);
-        this.modelEnabledOverrides.delete(id);
-        for (const [purpose, boundId] of Object.entries(this.bindings)) {
-            if (boundId === id)
-                delete this.bindings[purpose];
-        }
-        this.emitChange();
-    }
-    enableModel(id) {
-        const model = this.models.get(id);
-        if (model)
-            model.enabled = true;
-        this.modelEnabledOverrides.set(id, true);
-        this.emitChange();
-    }
-    disableModel(id) {
-        const model = this.models.get(id);
-        if (model)
-            model.enabled = false;
-        this.modelEnabledOverrides.set(id, false);
-        this.emitChange();
-    }
-    listModels(filter) {
-        let results = [...this.models.values()];
-        if (filter?.purpose)
-            results = results.filter(m => m.purposes.includes(filter.purpose));
-        if (filter?.provider)
-            results = results.filter(m => m.provider === filter.provider);
-        if (filter?.enabledOnly)
-            results = results.filter(m => m.enabled);
-        return results;
-    }
-    getModel(id) {
-        return this.models.get(id) ?? null;
-    }
-    setBinding(purpose, modelId) {
-        const model = this.models.get(modelId);
-        if (!model)
-            throw new Error(`Model "${modelId}" not found in pool.`);
-        if (!model.purposes.includes(purpose)) {
-            throw new Error(`Model "${modelId}" does not support purpose "${purpose}".`);
-        }
-        this.bindings[purpose] = modelId;
-        this.emitChange();
-    }
-    removeBinding(purpose) {
-        delete this.bindings[purpose];
-        this.emitChange();
-    }
-    getBinding(purpose) {
-        const id = this.bindings[purpose];
-        return id ? (this.models.get(id) ?? null) : null;
-    }
-    getAllBindings() {
-        const result = {};
-        for (const purpose of ALL_PURPOSES) {
-            const id = this.bindings[purpose];
-            result[purpose] = id ? (this.models.get(id) ?? null) : null;
-        }
-        return result;
-    }
-    getProviderStatus(providerId) {
-        return this.keyPool.getPoolStatus(providerId);
-    }
-    getAllProviderStatus() {
-        const statuses = this.keyPool.getAllStatus();
-        const envStatus = llmrouterEnvKeyStatus(this.getInjectedKeyState(LLMROUTER_ENV_KEY_ID));
-        if (!envStatus)
-            return statuses;
-        const existing = statuses.find(status => status.providerId === envStatus.providerId);
-        if (existing) {
-            return statuses.map(status => status.providerId === envStatus.providerId
-                ? { ...status, keys: [...status.keys, ...envStatus.keys] }
-                : status);
-        }
-        return [...statuses, envStatus];
-    }
-    save() {
-        let existing = {};
-        try {
-            if (fs.existsSync(this.settingsPath)) {
-                existing = JSON.parse(fs.readFileSync(this.settingsPath, "utf-8"));
-            }
-        }
-        catch {
-            existing = {};
-        }
-        delete existing.provider;
-        delete existing.apiKey;
-        delete existing.model;
-        delete existing.baseUrl;
-        const output = {
-            ...existing,
-            providers: this.keyPool.exportConfig(),
-            models: this.exportModelState(),
-            bindings: { ...this.bindings },
-            injectedKeys: this.exportInjectedKeyStates(),
-        };
-        const dir = this.settingsPath.replace(/[/\\][^/\\]+$/, "");
-        if (!fs.existsSync(dir))
-            fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(this.settingsPath, JSON.stringify(output, null, 2), "utf-8");
-    }
-    load() {
-        try {
-            if (!fs.existsSync(this.settingsPath))
-                return false;
-            const raw = fs.readFileSync(this.settingsPath, "utf-8");
-            const parsed = JSON.parse(raw);
-            if (parsed.providers)
-                this.keyPool.reloadConfig(parsed.providers);
-            this.models.clear();
-            this.modelEnabledOverrides.clear();
-            if (parsed.models)
-                this.loadModelState(parsed.models);
-            this.bindings = parsed.bindings ?? {};
-            this.injectedKeyStates = parsed.injectedKeys ? { ...parsed.injectedKeys } : {};
-            this.emitChange();
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    exportConfig() {
-        return {
-            providers: this.keyPool.exportConfig(),
-            models: this.exportModelState(),
-            bindings: { ...this.bindings },
-            injectedKeys: this.exportInjectedKeyStates(),
-        };
-    }
-    getTunable(key) {
-        try {
-            if (!fs.existsSync(this.settingsPath))
-                return undefined;
-            const raw = fs.readFileSync(this.settingsPath, "utf-8");
-            const parsed = JSON.parse(raw);
-            const tunables = parsed.tunables;
-            return tunables?.[key];
-        }
-        catch {
-            return undefined;
-        }
-    }
-    getModelInfo(providerId, modelId) {
-        const entry = this.listModels({ provider: providerId }).find(model => model.model === modelId);
-        if (!entry)
-            return undefined;
-        return {
-            id: entry.model,
-            name: entry.displayName,
-            contextWindow: entry.contextWindow,
-            maxOutput: entry.maxOutput,
-            streamRequired: entry.streamRequired,
-        };
-    }
-    getProviderDefaultModel(providerId) {
-        return this.listModels({ provider: providerId, enabledOnly: true })[0]?.model ?? this.listModels({ provider: providerId })[0]?.model;
-    }
-    hasConfiguredKeyForProviderVariant(providerId) {
-        return this.providerVariantKeyCandidates(providerId).some(candidate => {
-            const status = this.keyPool.getPoolStatus(candidate);
-            return !!status?.keys.some(key => key.enabled);
-        }) || this.hasEnabledLlmrouterEnvKey(providerId);
-    }
-    hasAvailableKeyForProviderVariant(providerId) {
-        return this.providerVariantKeyCandidates(providerId).some(candidate => this.keyPool.hasAvailableKey(candidate))
-            || this.hasEnabledLlmrouterEnvKey(providerId);
-    }
-    listProviderDefs() {
-        return this.keyPool.getAllStatus().map(pool => ({
-            id: pool.providerId,
-            name: pool.providerId,
-            transport: "",
-            baseUrl: pool.baseUrl ?? "",
-            defaultModel: this.getProviderDefaultModel(pool.providerId),
-            models: this.listModels({ provider: pool.providerId }).map(model => ({
-                id: model.model,
-                name: model.displayName,
-                contextWindow: model.contextWindow,
-                maxOutput: model.maxOutput,
-                streamRequired: model.streamRequired,
-            })),
-        }));
-    }
-    getKnownProviderDef(providerId) {
-        return this.catalogProviders.get(providerId) ?? null;
-    }
-    resolveProviderApiKey(providerId) {
-        return this.getKeyForProvider(providerId) ?? undefined;
-    }
-    onChange(callback) {
-        this.changeListeners.push(callback);
-        return () => {
-            const idx = this.changeListeners.indexOf(callback);
-            if (idx >= 0)
-                this.changeListeners.splice(idx, 1);
-        };
-    }
-    getKeyForProvider(providerId) {
-        const acquired = this.acquireKeyForProviderVariant(providerId);
-        const handle = acquired?.keyHandle;
-        if (!handle)
-            return null;
-        const key = handle.apiKey;
-        handle.release({ success: true });
-        return key;
-    }
-    snapshotProviderKeys() {
-        const keys = {};
-        for (const pool of this.keyPool.getAllStatus()) {
-            const key = this.getKeyForProvider(pool.providerId);
-            if (key)
-                keys[pool.providerId] = key;
-        }
-        return keys;
-    }
-    getProviderBaseUrl(providerId) {
-        return this.catalogProviders.get(providerId)?.baseUrl ?? this.keyPool.getPoolStatus(providerId)?.baseUrl;
-    }
-    acquireKeyForProviderVariant(providerId) {
-        for (const candidate of this.providerVariantKeyCandidates(providerId)) {
-            const keyHandle = this.keyPool.acquireKey(candidate);
-            if (keyHandle)
-                return { keyHandle, keyProviderId: candidate };
-        }
-        // 零配置回退:llmrouter 无手填 key 时,用网关注入的设备账号推理 key(sk-qllm)。
-        // 不入 keyPool、不持久化 key 明文;本地暂停/删除偏好仍会阻止自动回退。
-        const envKey = this.hasEnabledLlmrouterEnvKey(providerId) ? llmrouterEnvInferenceKey(providerId) : undefined;
-        if (envKey) {
-            return {
-                keyHandle: { keyId: "llmrouter-env", apiKey: envKey, providerId, release: () => { } },
-                keyProviderId: providerId,
-            };
-        }
-        return null;
-    }
-    resolveTechnicalVariant(entry, purpose) {
-        void purpose;
-        return { provider: entry.provider, nativeModelId: entry.nativeModelId ?? entry.model };
-    }
-    providerVariantKeyCandidates(providerId) {
-        return [providerId];
-    }
-    hasLlmrouterEnvKey() {
-        return !this.getInjectedKeyState(LLMROUTER_ENV_KEY_ID).removed
-            && !!llmrouterEnvInferenceKey("llmrouter");
-    }
-    hasEnabledLlmrouterEnvKey(providerId) {
-        if (providerId !== "llmrouter")
-            return false;
-        const state = this.getInjectedKeyState(LLMROUTER_ENV_KEY_ID);
-        return !state.removed && state.enabled !== false && !!llmrouterEnvInferenceKey(providerId);
-    }
-    getInjectedKeyState(keyId) {
-        return this.injectedKeyStates[keyId] ?? {};
-    }
-    setInjectedKeyState(keyId, state) {
-        this.injectedKeyStates = {
-            ...this.injectedKeyStates,
-            [keyId]: {
-                ...this.getInjectedKeyState(keyId),
-                ...state,
-            },
-        };
-        this.emitChange();
-    }
-    loadModelState(models) {
-        for (const model of models) {
-            if (typeof model.id !== "string" || !model.id)
-                continue;
-            if (typeof model.enabled === "boolean")
-                this.modelEnabledOverrides.set(model.id, model.enabled);
-        }
-    }
-    exportModelState() {
-        const state = new Map();
-        for (const [id, enabled] of this.modelEnabledOverrides)
-            state.set(id, enabled);
-        for (const model of this.models.values())
-            state.set(model.id, model.enabled);
-        return [...state.entries()].map(([id, enabled]) => ({ id, enabled }));
-    }
-    exportInjectedKeyStates() {
-        return { ...this.injectedKeyStates };
-    }
-    emitChange() {
-        for (const cb of this.changeListeners) {
-            try {
-                cb();
-            }
-            catch {
-                // Listener errors must not break registry writes.
-            }
-        }
-    }
-}
-let _instance = null;
-export function getModelRegistry() {
-    if (!_instance) {
-        _instance = new ModelRegistry();
-        _instance.load();
-    }
-    return _instance;
-}
-export function resetModelRegistry() {
-    _instance = null;
-}

package/dist/runtime/infra/model-registry.test.d.ts

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