qlogicagent 2.13.4 → 2.13.5

package/dist/cli/handlers/settings-handler.js

@@ -0,0 +1,710 @@
+import { getModelRegistry, ALL_PURPOSES, } from "../../runtime/infra/model-registry.js";
+import { spawn } from "node:child_process";
+import { LLMROUTER_PROVIDER_ID, LLMROUTER_CATALOG_UNAVAILABLE_MESSAGE, LLMROUTER_PROVIDER_NAME, getLlmrouterCatalogProvider, getLlmrouterBaseUrl, getLlmrouterModelsUrl, listLlmrouterCatalogProviders, providerBaseUrl, providerDisplayName, ensureLlmrouterDefaultBinding, refreshRegistryFromLlmrouterApiKey, refreshRegistryFromLlmrouterCatalog, } from "../../runtime/infra/llmrouter-catalog.js";
+import { AGENT_RPC_ERROR_CODES } from "../../protocol/wire/index.js";
+function clipboardCommands() {
+    if (process.platform === "win32") {
+        return [
+            { command: "powershell.exe", args: ["-NoProfile", "-Command", "[Console]::In.ReadToEnd() | Set-Clipboard"] },
+            { command: "pwsh.exe", args: ["-NoProfile", "-Command", "[Console]::In.ReadToEnd() | Set-Clipboard"] },
+        ];
+    }
+    if (process.platform === "darwin")
+        return [{ command: "pbcopy", args: [] }];
+    return [
+        { command: "wl-copy", args: [] },
+        { command: "xclip", args: ["-selection", "clipboard"] },
+        { command: "xsel", args: ["--clipboard", "--input"] },
+    ];
+}
+function writeClipboardWithCommand(spec, text) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(spec.command, spec.args, {
+            stdio: ["pipe", "ignore", "pipe"],
+            windowsHide: true,
+        });
+        let stderr = "";
+        const timer = setTimeout(() => {
+            child.kill();
+            reject(new Error("Clipboard command timed out"));
+        }, 3000);
+        child.stderr?.on("data", chunk => {
+            stderr += String(chunk);
+        });
+        child.on("error", err => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        child.on("close", code => {
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(stderr.trim() || `Clipboard command exited with code ${code}`));
+        });
+        child.stdin.end(text);
+    });
+}
+async function writeSystemClipboard(text) {
+    let lastError;
+    for (const command of clipboardCommands()) {
+        try {
+            await writeClipboardWithCommand(command, text);
+            return;
+        }
+        catch (err) {
+            lastError = err;
+        }
+    }
+    const message = lastError instanceof Error ? lastError.message : "No clipboard command available";
+    throw new Error(`System clipboard unavailable: ${message}`);
+}
+function maskApiKey(key) {
+    if (key.length <= 8)
+        return "****";
+    return `${key.slice(0, 3)}***${key.slice(-4)}`;
+}
+function sendRpcError(ctx, msg, message, code = AGENT_RPC_ERROR_CODES.INTERNAL_ERROR) {
+    if (msg.id === undefined)
+        return;
+    if (typeof ctx.sendError === "function") {
+        ctx.sendError(msg.id, code, message);
+        return;
+    }
+    ctx.sendResponse(msg.id, undefined, { code, message });
+}
+function sendCatalogError(ctx, msg) {
+    sendRpcError(ctx, msg, LLMROUTER_CATALOG_UNAVAILABLE_MESSAGE);
+}
+function groupModels(models) {
+    const grouped = {};
+    for (const model of models) {
+        for (const purpose of model.purposes) {
+            grouped[purpose] ??= [];
+            grouped[purpose].push(model);
+        }
+    }
+    return grouped;
+}
+async function refreshCatalogIntoRegistry() {
+    const registry = getModelRegistry();
+    const entries = await refreshRegistryFromLlmrouterCatalog(registry);
+    ensureLlmrouterDefaultBinding(registry);
+    registry.save();
+    return entries;
+}
+async function refreshCatalogIfAvailable(required) {
+    try {
+        await refreshCatalogIntoRegistry();
+        return true;
+    }
+    catch (err) {
+        if (required)
+            throw err;
+        return false;
+    }
+}
+function getConfiguredLlmrouterBaseUrl(registry = getModelRegistry()) {
+    void registry;
+    return getLlmrouterBaseUrl();
+}
+function providerSettingsId(provider) {
+    return provider.id === LLMROUTER_PROVIDER_ID ? LLMROUTER_PROVIDER_ID : provider.group?.trim() || provider.id;
+}
+function isCanonicalProvider(provider) {
+    return provider.id === providerSettingsId(provider);
+}
+function settingsProviderDisplayName(provider) {
+    const id = providerSettingsId(provider);
+    return providerDisplayName({ ...provider, id });
+}
+function settingsProviderVariantDisplayName(provider) {
+    const displayNames = {
+        volcengine: "常规 Ark API Key",
+        "volcengine-plan": "订阅 / Plan 通道",
+        qwen: "常规 DashScope API Key",
+        "qwen-coding": "Coding Plan 通道",
+        zhipu: "Anthropic 通道",
+        "zhipu-openai": "OpenAI 兼容通道",
+        "zhipu-coding": "Coding 通道",
+    };
+    return displayNames[provider.id] ?? providerDisplayName(provider);
+}
+function isSettingsKeyableProvider(provider) {
+    if (provider.authType === "none")
+        return false;
+    return provider.apiKeyEnvVars === undefined || provider.apiKeyEnvVars.length > 0;
+}
+function toSettingsProviderVariantOption(provider) {
+    return {
+        id: provider.id,
+        displayName: settingsProviderVariantDisplayName(provider),
+        baseUrl: providerBaseUrl(provider) ?? "",
+        modelCount: provider.models?.length ?? 0,
+    };
+}
+function listSettingsProviderOptions(upstreamProviders) {
+    const byProviderId = new Map();
+    for (const provider of upstreamProviders) {
+        if (!isSettingsKeyableProvider(provider))
+            continue;
+        const id = providerSettingsId(provider);
+        if (id === LLMROUTER_PROVIDER_ID)
+            continue;
+        const modelCount = provider.models?.length ?? 0;
+        const variant = toSettingsProviderVariantOption(provider);
+        const existing = byProviderId.get(id);
+        if (!existing) {
+            byProviderId.set(id, {
+                id,
+                displayName: settingsProviderDisplayName(provider),
+                baseUrl: providerBaseUrl(provider) ?? "",
+                modelCount,
+                variants: [variant],
+            });
+            continue;
+        }
+        existing.modelCount += modelCount;
+        existing.variants ??= [];
+        if (!existing.variants.some(item => item.id === variant.id))
+            existing.variants.push(variant);
+        if (isCanonicalProvider(provider)) {
+            existing.displayName = settingsProviderDisplayName(provider);
+            existing.baseUrl = providerBaseUrl(provider) ?? existing.baseUrl;
+        }
+    }
+    return Array.from(byProviderId.values()).map(({ variants, ...provider }) => ({
+        ...provider,
+        ...(variants && variants.length > 1 ? { variants } : {}),
+    }));
+}
+async function refreshLlmrouterModelsFromConfiguredKey(required, forceCatalog = false) {
+    const registry = getModelRegistry();
+    const apiKey = registry.getKeyForProvider(LLMROUTER_PROVIDER_ID);
+    if (!apiKey) {
+        if (required)
+            throw new Error("LLMRouter API Key is required to fetch available models.");
+        return false;
+    }
+    const baseUrl = registry.getProviderStatus(LLMROUTER_PROVIDER_ID)?.baseUrl ?? getConfiguredLlmrouterBaseUrl(registry);
+    try {
+        const entries = await refreshRegistryFromLlmrouterApiKey(registry, { baseUrl, apiKey, forceCatalog });
+        if (entries.length === 0) {
+            if (required)
+                throw new Error("LLMRouter did not return any available models for this API Key.");
+            return false;
+        }
+        registry.save();
+        return true;
+    }
+    catch (err) {
+        if (required)
+            throw err;
+        return false;
+    }
+}
+async function refreshAvailableModels(required = false) {
+    const registry = getModelRegistry();
+    const llmrouterConfigured = !!registry.getProviderStatus(LLMROUTER_PROVIDER_ID)?.keys.length;
+    if (llmrouterConfigured) {
+        if (await refreshLlmrouterModelsFromConfiguredKey(false))
+            return true;
+        return refreshCatalogIfAvailable(true);
+    }
+    void required;
+    return refreshCatalogIfAvailable(true);
+}
+function providerValidationModel(provider) {
+    return provider.defaultModel ?? provider.models?.find(model => !!model.id)?.id;
+}
+function uniqueUrls(urls) {
+    return [...new Set(urls)];
+}
+function openAiCompatibleModelsUrls(baseUrl) {
+    const root = baseUrl.replace(/\/+$/, "");
+    return uniqueUrls([
+        `${root}/models`,
+        /\/v\d+$/.test(root) ? `${root}/models` : `${root}/v1/models`,
+    ]);
+}
+function endpointUnavailable(status) {
+    return status === 404 || status === 405 || status === 410 || status === 501;
+}
+async function resolveProviderValidationDef(providerId) {
+    const catalogProvider = await getLlmrouterCatalogProvider(providerId);
+    if (!catalogProvider)
+        return undefined;
+    return {
+        id: catalogProvider.id,
+        transport: catalogProvider.transport,
+        baseUrl: providerBaseUrl(catalogProvider),
+        authType: catalogProvider.authType,
+        models: catalogProvider.models,
+    };
+}
+function bearerHeaders(apiKey) {
+    return {
+        accept: "application/json",
+        Authorization: `Bearer ${apiKey}`,
+    };
+}
+function buildProviderValidationProbes(providerId, apiKey, baseUrl, provider) {
+    if (providerId === LLMROUTER_PROVIDER_ID) {
+        return [{
+                method: "GET",
+                url: getLlmrouterModelsUrl(baseUrl),
+                headers: bearerHeaders(apiKey),
+            }];
+    }
+    const root = providerValidationBaseUrl(baseUrl, provider).replace(/\/+$/, "");
+    const transport = provider?.transport;
+    const model = providerValidationModel(provider ?? { id: providerId });
+    const probes = [];
+    if (transport === "anthropic-messages") {
+        if (/\/anthropic$/.test(root)) {
+            probes.push({
+                method: "GET",
+                url: `${root.replace(/\/anthropic$/, "")}/models`,
+                headers: bearerHeaders(apiKey),
+            });
+        }
+        if (model) {
+            probes.push({
+                method: "POST",
+                url: `${root}/v1/messages`,
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-api-key": apiKey,
+                    "anthropic-version": "2023-06-01",
+                },
+                body: {
+                    model,
+                    messages: [{ role: "user", content: "ping" }],
+                    max_tokens: 1,
+                    stream: false,
+                },
+            });
+        }
+        return probes;
+    }
+    if (transport === "gemini-generatecontent") {
+        if (!model)
+            return probes;
+        return [{
+                method: "POST",
+                url: `${root}/models/${encodeURIComponent(model)}:generateContent`,
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-goog-api-key": apiKey,
+                },
+                body: {
+                    contents: [{ role: "user", parts: [{ text: "ping" }] }],
+                    generationConfig: { maxOutputTokens: 1 },
+                },
+            }];
+    }
+    if (transport === "volcengine-responses") {
+        if (!model)
+            return probes;
+        const base = root.replace(/\/v\d+$/, "");
+        return [{
+                method: "POST",
+                url: `${base}/v3/responses`,
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: {
+                    model,
+                    input: [{ role: "user", content: [{ type: "input_text", text: "ping" }] }],
+                    max_output_tokens: 1,
+                    stream: false,
+                    store: false,
+                },
+            }];
+    }
+    for (const url of openAiCompatibleModelsUrls(root)) {
+        probes.push({
+            method: "GET",
+            url,
+            headers: bearerHeaders(apiKey),
+        });
+    }
+    return probes;
+}
+function providerValidationBaseUrl(baseUrl, provider) {
+    const requested = baseUrl.trim();
+    const catalogBaseUrl = provider?.baseUrl?.trim();
+    if (provider?.transport === "anthropic-messages" &&
+        catalogBaseUrl &&
+        /\/anthropic\/?$/.test(catalogBaseUrl) &&
+        !/\/anthropic\/?$/.test(requested)) {
+        return catalogBaseUrl;
+    }
+    return requested;
+}
+async function runValidationProbe(probe) {
+    try {
+        const resp = await fetch(probe.url, {
+            method: probe.method,
+            headers: probe.headers,
+            body: probe.body ? JSON.stringify(probe.body) : undefined,
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (resp.ok)
+            return { valid: true, status: resp.status, url: probe.url };
+        const body = await resp.text().catch(() => "");
+        return { valid: false, status: resp.status, error: body.slice(0, 500), url: probe.url };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { valid: false, status: 0, error: message, url: probe.url };
+    }
+}
+async function validateProviderApiKey(providerId, apiKey, baseUrl) {
+    const provider = await resolveProviderValidationDef(providerId);
+    const probes = buildProviderValidationProbes(providerId, apiKey, baseUrl, provider);
+    if (probes.length === 0) {
+        return {
+            valid: false,
+            status: 0,
+            error: `No validation probe is available for provider "${providerId}".`,
+        };
+    }
+    let lastUnavailable;
+    for (const probe of probes) {
+        const result = await runValidationProbe(probe);
+        if (result.valid)
+            return result;
+        if (endpointUnavailable(result.status)) {
+            lastUnavailable = result;
+            continue;
+        }
+        return result;
+    }
+    return lastUnavailable ?? {
+        valid: false,
+        status: 0,
+        error: `No validation probe succeeded for provider "${providerId}".`,
+    };
+}
+async function assertProviderApiKeyValid(providerId, apiKey, baseUrl) {
+    const validation = await validateProviderApiKey(providerId, apiKey, baseUrl);
+    if (!validation.valid) {
+        const detail = validation.error ? `: ${validation.error}` : "";
+        throw new Error(`API Key validation failed (${validation.status})${detail}`);
+    }
+}
+export async function handleSettingsListProviders(msg) {
+    try {
+        const upstreamProviders = await listLlmrouterCatalogProviders();
+        const llmrouterProvider = upstreamProviders.find(provider => provider.id === LLMROUTER_PROVIDER_ID);
+        if (!llmrouterProvider)
+            throw new Error(LLMROUTER_CATALOG_UNAVAILABLE_MESSAGE);
+        const providers = listSettingsProviderOptions(upstreamProviders);
+        providers.unshift({
+            id: LLMROUTER_PROVIDER_ID,
+            displayName: LLMROUTER_PROVIDER_NAME,
+            baseUrl: providerBaseUrl(llmrouterProvider) ?? getConfiguredLlmrouterBaseUrl(),
+            modelCount: upstreamProviders.reduce((count, provider) => count + (provider.models?.length ?? 0), 0),
+        });
+        if (msg.id !== undefined)
+            this.sendResponse(msg.id, { providers });
+    }
+    catch (err) {
+        sendRpcError(this, msg, err instanceof Error ? err.message : String(err));
+    }
+}
+export async function handleSettingsAddKey(msg) {
+    const params = msg.params;
+    if (!params?.providerId || !params?.key) {
+        sendRpcError(this, msg, "Required: providerId (string), key (string)", AGENT_RPC_ERROR_CODES.INVALID_PARAMS);
+        return;
+    }
+    const { providerId, key, label } = params;
+    const registry = getModelRegistry();
+    let keyId;
+    let createdProvider = false;
+    try {
+        const baseUrl = await resolveProviderBaseUrl(providerId);
+        if (!baseUrl) {
+            sendRpcError(this, msg, `Unknown provider: ${providerId}`, AGENT_RPC_ERROR_CODES.INVALID_PARAMS);
+            return;
+        }
+        const existingStatus = registry.getProviderStatus(providerId);
+        if (existingStatus?.keys.some(item => item.key === key)) {
+            if (msg.id !== undefined)
+                this.sendResponse(msg.id, { ok: false, error: "该 Key 已存在，无需重复添加" });
+            return;
+        }
+        createdProvider = !existingStatus;
+        const existingKeyIds = existingStatus?.keys.map(item => item.id) ?? [];
+        registry.addProvider(providerId, { baseUrl });
+        keyId = registry.addKey(providerId, key, { label });
+        if (providerId === LLMROUTER_PROVIDER_ID) {
+            const entries = await refreshRegistryFromLlmrouterApiKey(registry, { baseUrl, apiKey: key });
+            if (entries.length === 0)
+                throw new Error("LLMRouter did not return any available models for this API Key.");
+        }
+        else {
+            await assertProviderApiKeyValid(providerId, key, baseUrl);
+            await refreshRegistryFromLlmrouterCatalog(registry);
+        }
+        for (const purpose of ALL_PURPOSES) {
+            if (!registry.getBinding(purpose)) {
+                let candidates = registry.listModels({ purpose, provider: providerId, enabledOnly: true });
+                if (candidates.length === 0) {
+                    candidates = registry.listModels({ purpose, provider: providerId });
+                    if (candidates[0])
+                        registry.enableModel(candidates[0].id);
+                }
+                if (candidates.length > 0)
+                    registry.setBinding(purpose, candidates[0].id);
+            }
+        }
+        registry.setKeyHealth(keyId, "healthy");
+        if (params.replaceExisting === true) {
+            for (const existingKeyId of existingKeyIds) {
+                registry.updateKey(existingKeyId, { enabled: false });
+            }
+        }
+        registry.save();
+        if (msg.id !== undefined)
+            this.sendResponse(msg.id, { ok: true, keyId, providerId });
+    }
+    catch (err) {
+        if (keyId) {
+            registry.removeKey(keyId);
+            if (createdProvider)
+                registry.removeProvider(providerId);
+        }
+        const message = err instanceof Error ? err.message : LLMROUTER_CATALOG_UNAVAILABLE_MESSAGE;
+        sendRpcError(this, msg, message);
+    }
+}
+export function handleSettingsRemoveKey(msg) {
+    const params = msg.params;
+    if (!params?.keyId) {
+        sendRpcError(this, msg, "Required: keyId (string)", AGENT_RPC_ERROR_CODES.INVALID_PARAMS);
+        return;
+    }
+    const registry = getModelRegistry();
+    if (!registry.removeKey(params.keyId)) {
+        sendRpcError(this, msg, "API Key not found", AGENT_RPC_ERROR_CODES.INVALID_PARAMS);
+        return;
+    }
+    registry.save();
+    if (msg.id !== undefined)
+        this.sendResponse(msg.id, { ok: true });
+}
+export function handleSettingsGetKey(msg) {
+    const params = msg.params;
+    if (!params?.keyId) {
+        sendRpcError(this, msg, "Required: keyId (string)", AGENT_RPC_ERROR_CODES.INVALID_PARAMS);
+        return;
+    }
+    const key = getModelRegistry().getKeyById(params.keyId);
+    if (!key) {
+        sendRpcError(this, msg, "API Key not found", AGENT_RPC_ERROR_CODES.INVALID_PARAMS);
+        return;
+    }
+    if (msg.id !== undefined)
+        this.sendResponse(msg.id, { key });
+}
+export async function handleSettingsCopyKey(msg) {
+    const params = msg.params;
+    if (!params?.keyId) {
+        sendRpcError(this, msg, "Required: keyId (string)", AGENT_RPC_ERROR_CODES.INVALID_PARAMS);
+        return;
+    }
+    const key = getModelRegistry().getKeyById(params.keyId);
+    if (!key) {
+        sendRpcError(this, msg, "API Key not found", AGENT_RPC_ERROR_CODES.INVALID_PARAMS);
+        return;
+    }
+    try {
+        await (this.writeClipboard ? this.writeClipboard(key) : writeSystemClipboard(key));
+        if (msg.id !== undefined)
+            this.sendResponse(msg.id, { ok: true });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "复制 Key 失败";
+        sendRpcError(this, msg, message);
+    }
+}
+export function handleSettingsToggleKey(msg) {
+    const params = msg.params;
+    if (!params?.keyId || typeof params.enabled !== "boolean") {
+        sendRpcError(this, msg, "Required: keyId (string), enabled (boolean)", AGENT_RPC_ERROR_CODES.INVALID_PARAMS);
+        return;
+    }
+    const registry = getModelRegistry();
+    if (!registry.updateKey(params.keyId, { enabled: params.enabled })) {
+        sendRpcError(this, msg, "API Key not found", AGENT_RPC_ERROR_CODES.INVALID_PARAMS);
+        return;
+    }
+    registry.save();
+    if (msg.id !== undefined)
+        this.sendResponse(msg.id, { ok: true });
+}
+export function handleSettingsToggleModel(msg) {
+    const params = msg.params;
+    if (!params?.modelId || typeof params.enabled !== "boolean") {
+        sendRpcError(this, msg, "Required: modelId (string), enabled (boolean)", AGENT_RPC_ERROR_CODES.INVALID_PARAMS);
+        return;
+    }
+    const registry = getModelRegistry();
+    if (params.enabled)
+        registry.enableModel(params.modelId);
+    else
+        registry.disableModel(params.modelId);
+    registry.save();
+    if (msg.id !== undefined)
+        this.sendResponse(msg.id, { ok: true });
+}
+export async function handleSettingsListModels(msg) {
+    const params = msg.params;
+    try {
+        await refreshAvailableModels(false);
+        const registry = getModelRegistry();
+        const configuredProviderIds = new Set(registry
+            .getAllProviderStatus()
+            .filter(pool => pool.keys.length > 0)
+            .map(pool => pool.providerId));
+        const models = registry.listModels({
+            purpose: params?.purpose,
+            provider: params?.provider,
+        })
+            .filter(model => registry.hasConfiguredKeyForProviderVariant(model.provider));
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, {
+                models,
+                grouped: groupModels(models),
+                configuredProviderIds: [...configuredProviderIds],
+            });
+        }
+    }
+    catch {
+        sendCatalogError(this, msg);
+    }
+}
+export function handleSettingsSetActiveModel(msg) {
+    const params = msg.params;
+    if (!params?.purpose || !params?.modelId) {
+        sendRpcError(this, msg, "Required: purpose (string), modelId (string)", AGENT_RPC_ERROR_CODES.INVALID_PARAMS);
+        return;
+    }
+    try {
+        const registry = getModelRegistry();
+        registry.setBinding(params.purpose, params.modelId);
+        registry.save();
+        if (msg.id !== undefined)
+            this.sendResponse(msg.id, { ok: true });
+    }
+    catch (err) {
+        sendRpcError(this, msg, err instanceof Error ? err.message : String(err), AGENT_RPC_ERROR_CODES.INVALID_PARAMS);
+    }
+}
+export function handleSettingsGetActiveModel(msg) {
+    const params = msg.params;
+    if (!params?.purpose) {
+        sendRpcError(this, msg, "Required: purpose (string)", AGENT_RPC_ERROR_CODES.INVALID_PARAMS);
+        return;
+    }
+    const registry = getModelRegistry();
+    const entry = registry.getBinding(params.purpose);
+    if (msg.id !== undefined) {
+        this.sendResponse(msg.id, {
+            model: entry ? {
+                id: entry.id,
+                provider: entry.provider,
+                model: entry.model,
+                displayName: entry.displayName,
+                purposes: entry.purposes,
+                enabled: entry.enabled,
+            } : null,
+            available: registry.isAvailable(params.purpose),
+        });
+    }
+}
+export async function handleSettingsGetOverview(msg) {
+    try {
+        await refreshAvailableModels(false);
+        const registry = getModelRegistry();
+        const providers = registry.getAllProviderStatus().map(pool => ({
+            providerId: pool.providerId,
+            displayName: pool.providerId === LLMROUTER_PROVIDER_ID ? LLMROUTER_PROVIDER_NAME : pool.providerId,
+            baseUrl: pool.baseUrl,
+            keyCount: pool.keys.length,
+            healthyKeys: pool.keys.filter(key => key.healthStatus === "healthy" && key.enabled).length,
+            totalKeys: pool.keys.length,
+            keys: pool.keys.map(key => ({
+                id: key.id,
+                label: key.label,
+                maskedKey: maskApiKey(key.key),
+                enabled: key.enabled,
+                health: key.healthStatus,
+            })),
+        }));
+        const bindings = registry.getAllBindings();
+        const purposes = {};
+        for (const purpose of ALL_PURPOSES) {
+            const entry = bindings[purpose];
+            purposes[purpose] = {
+                bound: !!entry,
+                modelId: entry?.id,
+                modelName: entry?.displayName,
+                available: registry.isAvailable(purpose),
+            };
+        }
+        if (msg.id !== undefined)
+            this.sendResponse(msg.id, { providers, purposes });
+    }
+    catch {
+        sendCatalogError(this, msg);
+    }
+}
+export async function handleSettingsRefreshModels(msg) {
+    try {
+        const registry = getModelRegistry();
+        registry.load();
+        if (!await refreshLlmrouterModelsFromConfiguredKey(false, true)) {
+            await refreshRegistryFromLlmrouterCatalog(registry, undefined, { force: true });
+        }
+        registry.save();
+        if (msg.id !== undefined)
+            this.sendResponse(msg.id, { ok: true, catalogRefreshed: true });
+    }
+    catch {
+        sendCatalogError(this, msg);
+    }
+}
+export async function handleSettingsValidateKey(msg) {
+    const params = msg.params;
+    if (!params?.providerId || !params?.apiKey) {
+        sendRpcError(this, msg, "providerId and apiKey required", AGENT_RPC_ERROR_CODES.INVALID_PARAMS);
+        return;
+    }
+    try {
+        const baseUrl = params.baseUrl || await resolveProviderBaseUrl(params.providerId);
+        if (!baseUrl) {
+            sendRpcError(this, msg, `Unknown provider: ${params.providerId}`, AGENT_RPC_ERROR_CODES.INVALID_PARAMS);
+            return;
+        }
+        const result = await validateProviderApiKey(params.providerId, params.apiKey, baseUrl);
+        if (msg.id !== undefined)
+            this.sendResponse(msg.id, result);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (msg.id !== undefined)
+            this.sendResponse(msg.id, { valid: false, status: 0, error: message });
+    }
+}
+async function resolveProviderBaseUrl(providerId) {
+    if (providerId === LLMROUTER_PROVIDER_ID)
+        return getConfiguredLlmrouterBaseUrl();
+    const provider = await getLlmrouterCatalogProvider(providerId);
+    return provider ? providerBaseUrl(provider) : undefined;
+}