qlogicagent 2.13.3 → 2.13.5

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

@@ -0,0 +1,529 @@
+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

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