@fonlan/dsh-model-router 0.1.0

package/lib/index.js

@@ -0,0 +1,626 @@
+import z from "@deepseek-ai/schemastery";
+import { settingsNamespace } from "@deepseek-ai/dsh-settings";
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { LlmAdapter, LlmError } from "@deepseek-ai/dsh-llm";
+//#region src/shared/config.ts
+const ROUTER_PROVIDER_ID = "model-router";
+const ROUTER_SETTINGS_NS = "model-router";
+/** Merge every provider's models into one entry per exact model id. */
+function mergeModels(providers) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const provider of providers) for (const model of provider.models) {
+		let merged = byId.get(model.id);
+		if (merged === void 0) {
+			merged = {
+				id: model.id,
+				providers: []
+			};
+			byId.set(model.id, merged);
+		}
+		merged.providers.push({
+			provider: provider.id,
+			id: model.id,
+			name: model.name,
+			contextWindow: model.contextWindow,
+			maxTokens: model.maxTokens
+		});
+	}
+	return [...byId.values()];
+}
+/** The provider view a merged model should display for (follows active). */
+function displayProvider(merged, active) {
+	if (merged.providers.length === 0) return null;
+	return merged.providers.find((p) => p.provider === active) ?? merged.providers[0];
+}
+/** Initial config for a model the user never configured: first in order wins. */
+function initialConfigFor(providerIds) {
+	if (providerIds.length === 0) return null;
+	return {
+		order: [...providerIds],
+		active: providerIds[0]
+	};
+}
+/**
+* Effective active provider for a model id.
+*
+* Rules: a stored active still present in the catalog wins; otherwise the
+* first stored order entry still present wins; otherwise the first provider
+* of the catalog wins; an empty catalog yields null.
+*/
+function resolveActive(config, modelId, catalogProviderIds) {
+	if (catalogProviderIds.length === 0) return null;
+	const stored = config.models[modelId];
+	if (stored !== void 0) {
+		if (catalogProviderIds.includes(stored.active)) return stored.active;
+		const firstRemaining = stored.order.find((id) => catalogProviderIds.includes(id));
+		if (firstRemaining !== void 0) return firstRemaining;
+	}
+	return catalogProviderIds[0];
+}
+/**
+* Reconcile one model's config against the live catalog: prune vanished
+* providers, append newly discovered ones, and repair a vanished active by
+* falling back to the first remaining provider. Returns the new config, or
+* undefined when the catalog leaves nothing to route to.
+*/
+function syncConfig(config, modelId, catalogProviderIds) {
+	const next = { ...config.models };
+	let changed = false;
+	const existing = next[modelId];
+	if (catalogProviderIds.length === 0) {
+		if (existing !== void 0) {
+			delete next[modelId];
+			changed = true;
+		}
+		return {
+			models: next,
+			changed
+		};
+	}
+	if (existing === void 0) {
+		const initial = initialConfigFor(catalogProviderIds);
+		if (initial !== null) {
+			next[modelId] = initial;
+			changed = true;
+		}
+		return {
+			models: next,
+			changed
+		};
+	}
+	const catalog = new Set(catalogProviderIds);
+	const order = existing.order.filter((id) => catalog.has(id));
+	if (order.length !== existing.order.length) changed = true;
+	for (const id of catalogProviderIds) if (!order.includes(id)) {
+		order.push(id);
+		changed = true;
+	}
+	let active = existing.active;
+	if (!catalog.has(active)) {
+		active = order[0];
+		changed = true;
+	}
+	if (changed) next[modelId] = {
+		order,
+		active
+	};
+	return {
+		models: next,
+		changed
+	};
+}
+/** Switch a model's active provider (no-op when already active). */
+function setActive(config, modelId, providerId, catalogProviderIds) {
+	if (!catalogProviderIds.includes(providerId)) throw new Error(`provider ${providerId} is not in the catalog for model ${modelId}`);
+	const synced = syncConfig(config, modelId, catalogProviderIds);
+	const next = synced.models;
+	const entry = next[modelId];
+	if (entry === void 0) return {
+		models: next,
+		changed: synced.changed
+	};
+	if (entry.active === providerId) return {
+		models: next,
+		changed: synced.changed
+	};
+	next[modelId] = {
+		...entry,
+		active: providerId
+	};
+	return {
+		models: next,
+		changed: true
+	};
+}
+/** Replace a model's provider preference order (active left untouched). */
+function setOrder(config, modelId, order, catalogProviderIds) {
+	const catalog = new Set(catalogProviderIds);
+	const clean = order.filter((id) => catalog.has(id));
+	for (const id of catalogProviderIds) if (!clean.includes(id)) clean.push(id);
+	const synced = syncConfig(config, modelId, catalogProviderIds);
+	const next = synced.models;
+	const entry = next[modelId];
+	if (entry === void 0) return {
+		models: next,
+		changed: synced.changed
+	};
+	if (entry.order.length === clean.length && entry.order.every((id, i) => id === clean[i])) return {
+		models: next,
+		changed: synced.changed
+	};
+	next[modelId] = {
+		...entry,
+		order: [...clean]
+	};
+	return {
+		models: next,
+		changed: true
+	};
+}
+/** Shape-validate an unknown value as a RouterConfigShape (lenient). */
+function normalizeConfig(value) {
+	const models = {};
+	if (typeof value !== "object" || value === null) return { models };
+	const raw = value.models;
+	if (typeof raw !== "object" || raw === null) return { models };
+	for (const [id, entry] of Object.entries(raw)) {
+		if (typeof entry !== "object" || entry === null) continue;
+		const e = entry;
+		const order = Array.isArray(e.order) ? e.order.filter((x) => typeof x === "string") : [];
+		const active = typeof e.active === "string" ? e.active : order[0] ?? "";
+		if (active === "") continue;
+		models[id] = {
+			order,
+			active
+		};
+	}
+	return { models };
+}
+//#endregion
+//#region src/server/catalog.ts
+/** Read the resolved value of another plugin's settings section, if registered. */
+function settingsSection(ctx, ns) {
+	try {
+		return ctx.settings.get(ns);
+	} catch {
+		return;
+	}
+}
+/**
+* Determine whether one provider has usable credentials. Generic: the
+* configurable-provider directory names the settings section + path where the
+* provider's profile (and its optional apiKeyEnv) lives; the credentials seam
+* answers whether that reference currently resolves. Providers without a
+* directory entry or without an apiKeyEnv answer "configured" (unknown —
+* never gray out what we cannot verify).
+*/
+async function detectCredentialConfigured(ctx, entry) {
+	if (entry === void 0) return true;
+	let profile = settingsSection(ctx, entry.settingsNs);
+	for (const key of entry.settingsPath) {
+		if (typeof profile !== "object" || profile === null) {
+			profile = void 0;
+			break;
+		}
+		profile = profile[key];
+	}
+	const apiKeyEnv = typeof profile === "object" && profile !== null ? profile.apiKeyEnv : void 0;
+	if (typeof apiKeyEnv !== "string" || apiKeyEnv.trim() === "") return true;
+	let credentials;
+	try {
+		credentials = ctx.get("credentials");
+	} catch {
+		credentials = void 0;
+	}
+	if (credentials === void 0) return true;
+	try {
+		return (await credentials.describe(credentialRef(apiKeyEnv.trim()))).configured;
+	} catch {
+		return true;
+	}
+}
+/** Rebuild the live router catalog from the LLM registry. */
+async function buildCatalog(ctx) {
+	const routes = ctx.llm.listProviders().filter((provider) => provider.id !== ROUTER_PROVIDER_ID);
+	const directory = new Map(ctx.llm.listConfigurableProviders().map((entry) => [entry.provider, {
+		provider: entry.provider,
+		displayName: entry.displayName,
+		settingsNs: entry.settingsNs,
+		settingsPath: entry.settingsPath
+	}]));
+	const providers = [];
+	const providerNames = /* @__PURE__ */ new Map();
+	const credentialConfigured = /* @__PURE__ */ new Map();
+	for (const route of routes) {
+		const entry = directory.get(route.id);
+		providerNames.set(route.id, entry?.displayName || route.name || route.id);
+		const seen = /* @__PURE__ */ new Set();
+		const models = [];
+		try {
+			for (const model of await ctx.llm.listModels(route.id)) {
+				if (seen.has(model.id)) continue;
+				seen.add(model.id);
+				models.push({
+					id: model.id,
+					name: model.name
+				});
+			}
+		} catch {}
+		providers.push({
+			id: route.id,
+			name: route.name,
+			models
+		});
+		credentialConfigured.set(route.id, await detectCredentialConfigured(ctx, entry));
+	}
+	const models = mergeModels(providers);
+	return {
+		providers,
+		providerNames,
+		models,
+		byId: new Map(models.map((model) => [model.id, model])),
+		credentialConfigured
+	};
+}
+//#endregion
+//#region src/server/adapter.ts
+/**
+* The virtual `model-router` LLM adapter. Registered for the single provider
+* route `model-router`, it advertises the merged catalog and, at request time,
+* rewrites the provider field to the model's currently active provider and
+* delegates in-process to `ctx.llm.stream` — credentials, retry, streaming
+* and metering all stay inside the real adapter's pipeline.
+*/
+/**
+* Resolve the effective route for one model id: the stored active provider
+* when still present, otherwise the first remaining order entry, otherwise
+* the catalog head. Unadvertised model ids do not route.
+*/
+function routeFor(facts, modelId) {
+	const merged = facts.catalog().byId.get(modelId);
+	if (merged === void 0) return null;
+	const ids = merged.providers.map((provider) => provider.provider);
+	const active = resolveActive(facts.config(), modelId, ids);
+	return active === null ? null : { provider: active };
+}
+var ModelRouterAdapter = class extends LlmAdapter {
+	facts;
+	constructor(facts) {
+		super();
+		this.facts = facts;
+	}
+	providerInfo(provider) {
+		return {
+			id: provider,
+			name: "Model Router"
+		};
+	}
+	async listModels(_provider) {
+		const { models } = this.facts.catalog();
+		const names = this.facts.providerNames();
+		const out = [];
+		for (const merged of models) {
+			const display = displayProvider(merged, routeFor(this.facts, merged.id)?.provider);
+			if (display === null) continue;
+			out.push({
+				provider: ROUTER_PROVIDER_ID,
+				id: merged.id,
+				name: display.name,
+				description: `via ${names.get(display.provider) ?? display.provider}`
+			});
+		}
+		return out;
+	}
+	async resolveModel(_provider, model, signal) {
+		const route = routeFor(this.facts, model);
+		if (route === null) throw new LlmError(`model-router: no provider serves model "${model}"`, "NO_ADAPTER");
+		return {
+			...await this.facts.llm().resolveModelInfo(route.provider, model, signal),
+			provider: ROUTER_PROVIDER_ID
+		};
+	}
+	async *stream(options) {
+		const route = routeFor(this.facts, options.model);
+		if (route === null) throw new LlmError(`model-router: no provider serves model "${options.model}"`, "NO_ADAPTER");
+		yield* this.facts.llm().stream({
+			...options,
+			provider: route.provider
+		});
+	}
+};
+//#endregion
+//#region src/server/service.ts
+const NS = settingsNamespace(ROUTER_SETTINGS_NS);
+/** Settings document schema: one entry per model id. */
+const RouterConfigSchema = z.object({ models: z.dict(z.object({
+	order: z.array(z.string()),
+	active: z.string()
+})) });
+const EMPTY_CONFIG = { models: {} };
+var ModelRouterService = class {
+	ctx;
+	cached = {
+		providers: [],
+		providerNames: /* @__PURE__ */ new Map(),
+		models: [],
+		byId: /* @__PURE__ */ new Map(),
+		credentialConfigured: /* @__PURE__ */ new Map()
+	};
+	inflight = null;
+	scope;
+	registration;
+	constructor(ctx) {
+		this.ctx = ctx;
+	}
+	/** Register settings + adapter and wire topology listeners. */
+	start() {
+		this.ctx.inject(["settings"], (sctx) => {
+			this.scope = sctx.settings.register(NS, RouterConfigSchema);
+		});
+		const adapter = new ModelRouterAdapter(this);
+		this.registration = this.ctx.llm.registerAdapter([ROUTER_PROVIDER_ID], adapter);
+		this.ctx.on("llm/adapters-updated", () => {
+			this.refreshAndReconcile();
+		});
+		this.refreshAndReconcile();
+	}
+	stop() {
+		this.registration?.();
+		this.registration = void 0;
+	}
+	catalog() {
+		return {
+			models: this.cached.models,
+			byId: this.cached.byId
+		};
+	}
+	config() {
+		if (this.scope === void 0) return EMPTY_CONFIG;
+		try {
+			return normalizeConfig(this.scope.get());
+		} catch {
+			return EMPTY_CONFIG;
+		}
+	}
+	providerNames() {
+		return this.cached.providerNames;
+	}
+	llm() {
+		return this.ctx.llm;
+	}
+	/** Rebuild the catalog (in-flight dedupe; failures keep the last good one). */
+	refreshCatalog() {
+		if (this.inflight !== null) return this.inflight;
+		this.inflight = buildCatalog(this.ctx).then((catalog) => {
+			this.cached = catalog;
+			return catalog;
+		}).catch((error) => {
+			this.ctx.logger.warn(`model-router: catalog refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+			return this.cached;
+		}).finally(() => {
+			this.inflight = null;
+		});
+		return this.inflight;
+	}
+	/** Refresh, then persist any config drift (new providers/models, vanish). */
+	async refreshAndReconcile() {
+		const catalog = await this.refreshCatalog();
+		if (this.scope === void 0) return;
+		const current = this.config();
+		const next = { ...current.models };
+		let changed = false;
+		for (const model of catalog.models) {
+			const ids = model.providers.map((provider) => provider.provider);
+			const result = syncConfig(current, model.id, ids);
+			if (result.changed) changed = true;
+			for (const [id, entry] of Object.entries(result.models)) if (entry === void 0) delete next[id];
+			else next[id] = entry;
+		}
+		for (const id of Object.keys(next)) if (!catalog.byId.has(id)) {
+			delete next[id];
+			changed = true;
+		}
+		if (!changed) return;
+		try {
+			await this.scope.replace({ models: next });
+		} catch (error) {
+			this.ctx.logger.warn(`model-router: reconcile persist failed: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	/** Effective active provider for one model id (null when unroutable). */
+	activeFor(modelId) {
+		const ids = this.cached.byId.get(modelId)?.providers.map((provider) => provider.provider) ?? [];
+		return resolveActive(this.config(), modelId, ids);
+	}
+	/** The complete state view for the settings page. */
+	async state() {
+		await this.refreshCatalog();
+		const catalog = this.cached;
+		const config = this.config();
+		const names = catalog.providerNames;
+		const creds = catalog.credentialConfigured;
+		return {
+			providers: catalog.providers.map((provider) => ({
+				id: provider.id,
+				name: names.get(provider.id) ?? provider.id,
+				credentialConfigured: creds.get(provider.id) ?? true
+			})),
+			models: catalog.models.map((model) => {
+				const ids = model.providers.map((provider) => provider.provider);
+				const stored = config.models[model.id] ?? initialConfigFor(ids);
+				const active = resolveActive(config, model.id, ids);
+				const activeEntry = model.providers.find((provider) => provider.provider === active) ?? model.providers[0];
+				return {
+					id: model.id,
+					name: activeEntry?.name ?? model.id,
+					active,
+					order: stored?.order ?? [...ids],
+					providers: model.providers.map((provider) => ({
+						id: provider.provider,
+						name: names.get(provider.provider) ?? provider.provider,
+						credentialConfigured: creds.get(provider.provider) ?? true
+					}))
+				};
+			})
+		};
+	}
+	/** Switch the active provider for one model (persisted, live on next request). */
+	async switchActive(modelId, providerId) {
+		await this.refreshCatalog();
+		const ids = this.cached.byId.get(modelId)?.providers.map((provider) => provider.provider);
+		if (ids === void 0 || ids.length === 0) throw new Error(`model-router: model "${modelId}" is not served by any provider`);
+		const { models, changed } = setActive(this.config(), modelId, providerId, ids);
+		if (!changed) return;
+		await this.persist(models);
+	}
+	/** Replace the preference order for one model (active left untouched). */
+	async reorder(modelId, order) {
+		await this.refreshCatalog();
+		const ids = this.cached.byId.get(modelId)?.providers.map((provider) => provider.provider);
+		if (ids === void 0 || ids.length === 0) throw new Error(`model-router: model "${modelId}" is not served by any provider`);
+		const { models, changed } = setOrder(this.config(), modelId, order, ids);
+		if (!changed) return;
+		await this.persist(models);
+	}
+	async persist(models) {
+		if (this.scope === void 0) throw new Error("model-router: settings service is not available in this profile");
+		await this.scope.replace({ models });
+	}
+};
+//#endregion
+//#region src/server/rpc.ts
+const API_PREFIX = "/plugins/@fonlan/dsh-model-router/api";
+function header(headers, name) {
+	const value = headers[name];
+	return typeof value === "string" ? value : void 0;
+}
+function isLoopbackHostname(hostname) {
+	if (hostname === "localhost" || hostname === "[::1]") return true;
+	const parts = hostname.split(".");
+	return parts.length === 4 && parts[0] === "127" && parts.every((p) => /^\d{1,3}$/.test(p) && Number(p) <= 255);
+}
+function isTrustedApiRequest(req, trustedHosts) {
+	const host = header(req.headers, "host");
+	if (host === void 0) return false;
+	let hostUrl;
+	try {
+		hostUrl = new URL(`http://${host}`);
+	} catch {
+		return false;
+	}
+	if (!isLoopbackHostname(hostUrl.hostname) && !trustedHosts.includes(hostUrl.host) && !trustedHosts.includes(hostUrl.hostname)) return false;
+	if (header(req.headers, "sec-fetch-site") === "cross-site") return false;
+	const origin = header(req.headers, "origin");
+	if (origin === void 0) return true;
+	try {
+		return new URL(origin).host === hostUrl.host;
+	} catch {
+		return false;
+	}
+}
+function trustedHostsOf(ctx) {
+	for (const entry of ctx.get("loader")?.entries?.() ?? []) if (entry.options?.name === "connection") return entry.options.config?.trustedHosts ?? [];
+	return [];
+}
+function writeJson(res, body) {
+	res.writeHead(200, {
+		"content-type": "application/json; charset=utf-8",
+		"cache-control": "no-store"
+	});
+	res.end(JSON.stringify(body));
+}
+function writeError(res, code, message, status = 400) {
+	res.writeHead(status, {
+		"content-type": "application/json; charset=utf-8",
+		"cache-control": "no-store"
+	});
+	res.end(JSON.stringify({
+		ok: false,
+		error: {
+			code,
+			message
+		}
+	}));
+}
+async function readJsonBody(req) {
+	const chunks = [];
+	for await (const chunk of req) chunks.push(chunk);
+	const raw = Buffer.concat(chunks).toString("utf8");
+	if (raw.trim() === "") return {};
+	try {
+		const parsed = JSON.parse(raw);
+		return typeof parsed === "object" && parsed !== null ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+function registerApiRoutes(ctx, service) {
+	const fence = (req) => isTrustedApiRequest(req, trustedHostsOf(ctx));
+	const disposers = [];
+	const route = (name, handler) => {
+		disposers.push(ctx.webServer.register({
+			kind: "prefix",
+			path: `${API_PREFIX}/${name}`,
+			handler: async (req, res) => {
+				if (!fence(req)) {
+					writeError(res, "forbidden", "forbidden", 403);
+					return;
+				}
+				if (req.method !== "POST" && req.method !== "GET") {
+					writeError(res, "method", "method not allowed", 405);
+					return;
+				}
+				const payload = await readJsonBody(req);
+				try {
+					writeJson(res, {
+						ok: true,
+						value: await handler(payload)
+					});
+				} catch (error) {
+					writeError(res, "error", error instanceof Error ? error.message : String(error));
+				}
+			}
+		}));
+	};
+	route("state", async () => service.state());
+	route("switch-active", async (p) => {
+		const modelId = requireString(p.modelId, "modelId");
+		const providerId = requireString(p.providerId, "providerId");
+		await service.switchActive(modelId, providerId);
+		return service.state();
+	});
+	route("reorder", async (p) => {
+		const modelId = requireString(p.modelId, "modelId");
+		if (!Array.isArray(p.order) || !p.order.every((id) => typeof id === "string")) throw new Error("order 必须是提供商 id 数组");
+		await service.reorder(modelId, p.order);
+		return service.state();
+	});
+	route("refresh", async () => {
+		await service.refreshAndReconcile();
+		return service.state();
+	});
+	return () => {
+		for (const dispose of disposers) dispose();
+	};
+}
+function requireString(value, name) {
+	if (typeof value !== "string" || value.trim() === "") throw new Error(`${name} 不能为空`);
+	return value;
+}
+//#endregion
+//#region src/index.ts
+const name = "@fonlan/dsh-model-router";
+const inject = ["llm"];
+const Config = z.object({});
+function apply(ctx) {
+	const service = new ModelRouterService(ctx);
+	ctx.effect(() => {
+		service.start();
+		return () => service.stop();
+	}, "model-router: service");
+	ctx.inject(["webServer"], (sctx) => {
+		sctx.effect(() => registerApiRoutes(sctx, service), "model-router: api routes");
+	});
+}
+//#endregion
+export { Config, apply, inject, name };

package/lib/types/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @fonlan/dsh-model-router host half: the virtual model-router provider.
+ *
+ * Registers one `model-router` LLM adapter that aggregates every configured
+ * provider and model (strict model-id merge), routes each request to the
+ * model's currently active provider by in-process delegation, persists the
+ * per-model provider order/active config in the `model-router` settings
+ * namespace, and serves the fenced JSON API the web settings page calls.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+export declare const name = "@fonlan/dsh-model-router";
+export declare const inject: string[];
+export declare const Config: z<Schemastery.ObjectS<{}>, Schemastery.ObjectT<{}>>;
+export declare function apply(ctx: Context): void;

package/lib/types/server/adapter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The virtual `model-router` LLM adapter. Registered for the single provider
+ * route `model-router`, it advertises the merged catalog and, at request time,
+ * rewrites the provider field to the model's currently active provider and
+ * delegates in-process to `ctx.llm.stream` — credentials, retry, streaming
+ * and metering all stay inside the real adapter's pipeline.
+ */
+import { LlmAdapter, type LlmRuntime } from '@deepseek-ai/dsh-llm';
+import type { GenerateOptions, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, StreamChunk } from '@deepseek-ai/dsh-llm';
+import { type MergedModel, type RouterConfigShape } from '../shared/config.js';
+/** Facts the adapter reads from the owning service (live, per request). */
+export interface RouterFacts {
+    /** Current merged catalog (refreshed on topology changes). */
+    catalog(): {
+        models: readonly MergedModel[];
+        byId: ReadonlyMap<string, MergedModel>;
+    };
+    /** Current stored router config. */
+    config(): RouterConfigShape;
+    /** Provider display names by id. */
+    providerNames(): ReadonlyMap<string, string>;
+    /** The LLM runtime to delegate to. */
+    llm(): LlmRuntime;
+}
+/** One resolved route for a model id. */
+export interface ResolvedRoute {
+    provider: string;
+}
+/**
+ * Resolve the effective route for one model id: the stored active provider
+ * when still present, otherwise the first remaining order entry, otherwise
+ * the catalog head. Unadvertised model ids do not route.
+ */
+export declare function routeFor(facts: RouterFacts, modelId: string): ResolvedRoute | null;
+export declare class ModelRouterAdapter extends LlmAdapter {
+    private readonly facts;
+    constructor(facts: RouterFacts);
+    providerInfo(provider: string): LlmProviderInfo;
+    listModels(_provider: string): Promise<readonly LlmModelInfo[]>;
+    resolveModel(_provider: string, model: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+}

package/lib/types/server/catalog.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Provider discovery for the router: every registered LLM provider route
+ * (minus the router itself) becomes a ProviderInfo, models merge by exact id
+ * through the shared core, and per-provider credential status is detected
+ * generically through the configurable-provider directory + the credentials
+ * seam.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type MergedModel, type ProviderInfo } from '../shared/config.js';
+/** Live router catalog: everything the router can advertise and route to. */
+export interface RouterCatalog {
+    /** All providers (minus the router) in registration order. */
+    providers: ProviderInfo[];
+    /** Provider id → human display name (configurable-directory name when known). */
+    providerNames: Map<string, string>;
+    /** Models merged by exact id across providers. */
+    models: MergedModel[];
+    /** Model id → merged model. */
+    byId: Map<string, MergedModel>;
+    /** Provider id → whether the provider currently has usable credentials. */
+    credentialConfigured: Map<string, boolean>;
+}
+/** Rebuild the live router catalog from the LLM registry. */
+export declare function buildCatalog(ctx: Context): Promise<RouterCatalog>;