dsh-openrouter-provider-advisor 0.1.0

package/lib/index.js

@@ -0,0 +1,954 @@
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import z from "@deepseek-ai/schemastery";
+
+//#region src/config.ts
+const STRATEGY_WEIGHTS = {
+	price: {
+		quantization: .1,
+		speed: .1,
+		price: .7,
+		context: .1
+	},
+	speed: {
+		quantization: .15,
+		speed: .65,
+		price: .1,
+		context: .1
+	},
+	context: {
+		quantization: .15,
+		speed: .1,
+		price: .1,
+		context: .65
+	}
+};
+const DEFAULT_CONFIG = Object.freeze({
+	minContextTokens: 1e5,
+	cacheTtlMs: 3e5,
+	recommendedCount: 5,
+	weights: Object.freeze({
+		quantization: .3,
+		speed: .3,
+		price: .3,
+		context: .1
+	}),
+	priceBlend: Object.freeze({
+		input: .02,
+		output: .08,
+		cache: .9
+	}),
+	uptimePenaltyThreshold: 99,
+	uptimePenaltyFactor: .85
+});
+function assertUnitSum(label, values) {
+	if (values.some((value) => !Number.isFinite(value) || value < 0) || Math.abs(values.reduce((sum, value) => sum + value, 0) - 1) > .001) throw new Error(`${label} must contain non-negative values summing to 1`);
+}
+function validateConfig(config) {
+	if (!Number.isInteger(config.recommendedCount) || config.recommendedCount < 1 || config.recommendedCount > 10) throw new Error("recommendedCount must be an integer from 1 to 10");
+	if (!Number.isFinite(config.minContextTokens) || config.minContextTokens < 1) throw new Error("minContextTokens must be positive");
+	if (!Number.isFinite(config.cacheTtlMs) || config.cacheTtlMs < 0) throw new Error("cacheTtlMs must be non-negative");
+	if (config.uptimePenaltyThreshold < 0 || config.uptimePenaltyThreshold > 100) throw new Error("uptimePenaltyThreshold must be from 0 to 100");
+	if (config.uptimePenaltyFactor < 0 || config.uptimePenaltyFactor > 1) throw new Error("uptimePenaltyFactor must be from 0 to 1");
+	assertUnitSum("weights", Object.values(config.weights));
+	assertUnitSum("priceBlend", Object.values(config.priceBlend));
+}
+function configForStrategy(config, strategy) {
+	return strategy === "balanced" ? config : {
+		...config,
+		weights: STRATEGY_WEIGHTS[strategy]
+	};
+}
+
+//#endregion
+//#region src/apply-provider.ts
+var ProviderApplyError = class extends Error {
+	constructor(message, stage, partial, options) {
+		super(message, options);
+		this.stage = stage;
+		this.partial = partial;
+		this.name = "ProviderApplyError";
+	}
+};
+function effortFor(models, sourceModel, requested) {
+	const declaration = models.find((model) => model.id === sourceModel)?.reasoningEfforts ?? {
+		off: null,
+		high: "high"
+	};
+	const offered = declaration === false ? [] : Object.keys(declaration);
+	const selected = requested && offered.includes(requested) ? requested : offered[0];
+	return selected === void 0 ? { declaration } : {
+		declaration,
+		selected
+	};
+}
+async function applyProvider(deps, input) {
+	let slug;
+	try {
+		slug = (await deps.upsertPreset(input.openrouterModel, input.endpoint.tag)).slug;
+	} catch (error) {
+		throw new ProviderApplyError("OpenRouter preset 创建失败；DSH 设置未修改", "preset", false, { cause: error });
+	}
+	const modelId = `@preset/${slug}`;
+	let selectedEffort;
+	try {
+		const models = await deps.readModels(input.route);
+		const effort = effortFor(models, input.sourceModel, input.reasoningEffort);
+		selectedEffort = effort.selected;
+		const entry = {
+			id: modelId,
+			name: `${input.openrouterModel.split("/").at(-1)} · ${input.endpoint.provider_name}`,
+			contextWindow: input.endpoint.context_length,
+			compat: { thinkingFormat: "openrouter" },
+			reasoningEfforts: effort.declaration,
+			openrouterModel: input.openrouterModel
+		};
+		const index = models.findIndex((model) => model.id === modelId);
+		const next = [...models];
+		if (index >= 0) next[index] = {
+			...next[index],
+			...entry
+		};
+		else next.push(entry);
+		await deps.writeModels(input.route, next);
+	} catch (error) {
+		throw new ProviderApplyError("DSH 模型设置写入失败；OpenRouter preset 已保留", "settings", true, { cause: error });
+	}
+	const selection = {
+		provider: input.route,
+		model: modelId,
+		...selectedEffort ? { reasoningEffort: selectedEffort } : {}
+	};
+	try {
+		await deps.selectModel({
+			sessionId: input.sessionId,
+			...selection
+		});
+	} catch (error) {
+		throw new ProviderApplyError("当前会话切换失败；模型条目已写入，请用 /model 手动选择新 preset", "select-model", true, { cause: error });
+	}
+	try {
+		await deps.saveDefault(selection);
+	} catch (error) {
+		throw new ProviderApplyError("默认模型保存失败；当前会话已切换", "default", true, { cause: error });
+	}
+	return {
+		ok: true,
+		provider: input.route,
+		model: modelId,
+		tag: input.endpoint.tag,
+		openrouterModel: input.openrouterModel
+	};
+}
+
+//#endregion
+//#region src/resolve-model.ts
+const PROVIDER_SUFFIXES = new Set([
+	"novita",
+	"novitaai",
+	"coreweave",
+	"deepinfra",
+	"silflow",
+	"siliconflow",
+	"or",
+	"openrouter"
+]);
+const separators = /[-_.·・/\s]+/u;
+function normalizeModelName(value) {
+	const withoutPreset = value.trim().replace(/^@preset\//i, "");
+	const tokens = withoutPreset.split(separators).filter(Boolean);
+	if (tokens.length > 1 && PROVIDER_SUFFIXES.has(tokens.at(-1).toLowerCase())) tokens.pop();
+	const delimiter = /[·・\s]/u.test(withoutPreset) ? " " : "-";
+	return tokens.join(delimiter).toLowerCase();
+}
+function compact(value) {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function authorHint(input) {
+	const haystack = `${input.model} ${input.name ?? ""}`.toLowerCase();
+	return [
+		"deepseek",
+		"qwen",
+		"anthropic",
+		"openai",
+		"google",
+		"meta-llama",
+		"mistralai"
+	].find((author) => haystack.includes(author.replace("-llama", "")));
+}
+function resolveOpenRouterModel(input, catalog) {
+	if (!input.model.startsWith("@preset/") && !input.baseURL?.toLowerCase().includes("openrouter.ai")) return { kind: "not-openrouter" };
+	if (input.presetModel) {
+		const preset = catalog.find((item) => item.id.toLowerCase() === input.presetModel.toLowerCase());
+		if (preset) return {
+			kind: "matched",
+			model: preset
+		};
+	}
+	const normalized = normalizeModelName(input.model);
+	const normalizedCompact = compact(normalized);
+	const exact = catalog.filter((item) => {
+		const slug = item.id.split("/").at(-1);
+		return item.id.toLowerCase() === normalized || slug.toLowerCase() === normalized;
+	});
+	if (exact.length === 1) return {
+		kind: "matched",
+		model: exact[0]
+	};
+	if (exact.length > 1) return {
+		kind: "ambiguous",
+		candidates: exact
+	};
+	const hint = authorHint(input);
+	let stable = catalog.filter((item) => {
+		const slugCompact = compact(item.id.split("/").at(-1));
+		return slugCompact.includes(normalizedCompact) || normalizedCompact.includes(slugCompact);
+	});
+	if (hint) {
+		const hinted = stable.filter((item) => item.id.toLowerCase().startsWith(`${hint}/`));
+		if (hinted.length > 0) stable = hinted;
+	}
+	if (stable.length > 1 && input.model.startsWith("@preset/")) {
+		const prefixMatches = stable.filter((item) => normalizedCompact.startsWith(compact(item.id.split("/").at(-1))));
+		const longest = Math.max(0, ...prefixMatches.map((item) => compact(item.id.split("/").at(-1)).length));
+		const longestMatches = prefixMatches.filter((item) => compact(item.id.split("/").at(-1)).length === longest);
+		if (longestMatches.length === 1) return {
+			kind: "matched",
+			model: longestMatches[0]
+		};
+		if (longestMatches.length > 1) stable = longestMatches;
+	}
+	const compactExact = stable.filter((item) => compact(item.id.split("/").at(-1)) === normalizedCompact);
+	if (compactExact.length === 1) return {
+		kind: "matched",
+		model: compactExact[0]
+	};
+	if (compactExact.length > 1) stable = compactExact;
+	if (stable.length === 1) return {
+		kind: "matched",
+		model: stable[0]
+	};
+	if (stable.length > 1) return {
+		kind: "ambiguous",
+		candidates: stable
+	};
+	const display = compact(input.name ?? input.model);
+	const fuzzy = catalog.filter((item) => compact(item.name).includes(display) || display.includes(compact(item.name)));
+	if (fuzzy.length === 1) return {
+		kind: "matched",
+		model: fuzzy[0]
+	};
+	if (fuzzy.length > 1) return {
+		kind: "ambiguous",
+		candidates: fuzzy
+	};
+	return {
+		kind: "not-found",
+		normalized
+	};
+}
+
+//#endregion
+//#region src/score.ts
+const MAX_CONTEXT = 1048576;
+function finite(value) {
+	const number = typeof value === "number" ? value : Number(value ?? 0);
+	return Number.isFinite(number) ? number : 0;
+}
+function scale(value, min, max, invert = false) {
+	if (max === min) return 100;
+	const score = 100 * (value - min) / (max - min);
+	return invert ? 100 - score : score;
+}
+function quantizationScore(value) {
+	switch (value?.toLowerCase()) {
+		case "bf16":
+		case "fp16": return 100;
+		case "fp8": return 80;
+		case "fp4": return 45;
+		default: return 40;
+	}
+}
+function round(value, digits = 2) {
+	const factor = 10 ** digits;
+	return Math.round((value + Number.EPSILON) * factor) / factor;
+}
+function uptimeMultiplier(uptime, config) {
+	const safety = uptime === null ? .7 : uptime >= 99.5 ? 1 : uptime >= 99 ? .85 : uptime >= 97 ? .6 : uptime >= 90 ? .3 : .05;
+	const configured = uptime !== null && uptime < config.uptimePenaltyThreshold ? config.uptimePenaltyFactor : 1;
+	return Math.min(safety, configured);
+}
+function rankEndpoints(endpoints, config, currentTag) {
+	validateConfig(config);
+	const raw = endpoints.filter((endpoint) => endpoint.status === 0 && endpoint.context_length >= config.minContextTokens).map((endpoint) => {
+		const input = finite(endpoint.pricing.prompt) * 1e6;
+		const output = finite(endpoint.pricing.completion) * 1e6;
+		const cache = finite(endpoint.pricing.input_cache_read) * 1e6;
+		return {
+			endpoint,
+			tps: finite(endpoint.throughput_last_30m?.p50),
+			price: {
+				input,
+				output,
+				cache
+			},
+			cost: config.priceBlend.input * input + config.priceBlend.output * output + config.priceBlend.cache * cache
+		};
+	});
+	const speeds = raw.map((item) => item.tps);
+	const costs = raw.map((item) => item.cost);
+	const minSpeed = Math.min(...speeds);
+	const maxSpeed = Math.max(...speeds);
+	const minCost = Math.min(...costs);
+	const maxCost = Math.max(...costs);
+	const ranked = raw.map((item) => {
+		const dimensions = {
+			quantization: quantizationScore(item.endpoint.quantization),
+			speed: scale(item.tps, minSpeed, maxSpeed),
+			price: scale(item.cost, minCost, maxCost, true),
+			context: 100 * Math.min(1, Math.max(0, (item.endpoint.context_length - config.minContextTokens) / (MAX_CONTEXT - config.minContextTokens)))
+		};
+		let score = config.weights.quantization * dimensions.quantization + config.weights.speed * dimensions.speed + config.weights.price * dimensions.price + config.weights.context * dimensions.context;
+		const uptime = item.endpoint.uptime_last_30m ?? null;
+		score *= uptimeMultiplier(uptime, config);
+		const quant = item.endpoint.quantization?.toLowerCase() || "unknown";
+		return {
+			rank: 0,
+			score: round(score, 1),
+			providerName: item.endpoint.provider_name,
+			tag: item.endpoint.tag,
+			quantization: quant,
+			tps: item.tps,
+			latency: item.endpoint.latency_last_30m?.p50 ?? null,
+			price: {
+				input: round(item.price.input, 6),
+				output: round(item.price.output, 6),
+				cache: round(item.price.cache, 6)
+			},
+			contextLength: item.endpoint.context_length,
+			uptime,
+			current: item.endpoint.tag === currentTag,
+			reasons: [
+				quant,
+				`${round(item.tps, 1)} t/s`,
+				`${uptime === null ? "unknown" : round(uptime, 2)}% uptime`
+			],
+			dimensions
+		};
+	}).sort((a, b) => b.score - a.score || b.dimensions.speed - a.dimensions.speed || b.dimensions.price - a.dimensions.price || a.providerName.localeCompare(b.providerName));
+	ranked.forEach((item, index) => {
+		item.rank = index + 1;
+	});
+	return {
+		recommended: ranked.slice(0, config.recommendedCount),
+		rest: ranked.slice(config.recommendedCount)
+	};
+}
+
+//#endregion
+//#region src/directory.ts
+var ProviderDirectoryError = class extends Error {
+	constructor(message, code, details) {
+		super(message);
+		this.code = code;
+		this.details = details;
+		this.name = "ProviderDirectoryError";
+	}
+};
+var OpenRouterProviderDirectory = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async recommend(input, options = {}) {
+		const resolved = resolveOpenRouterModel(input, await this.deps.listModels());
+		if (resolved.kind === "not-openrouter") throw new ProviderDirectoryError("当前模型不在 OpenRouter，无法推荐供应商", "NOT_OPENROUTER");
+		if (resolved.kind === "not-found") throw new ProviderDirectoryError(`无法匹配 OpenRouter 模型：${resolved.normalized}`, "MODEL_NOT_FOUND", { normalized: resolved.normalized });
+		if (resolved.kind === "ambiguous") throw new ProviderDirectoryError("无法唯一匹配 OpenRouter 模型", "MODEL_AMBIGUOUS", { candidates: resolved.candidates.map((item) => item.id) });
+		const ranked = rankEndpoints(await this.deps.getEndpoints(resolved.model.id, options), this.deps.config(), input.currentTag);
+		if (ranked.recommended.length === 0) throw new ProviderDirectoryError("没有满足上下文下限的可用供应商", "NO_ELIGIBLE_ENDPOINTS");
+		return {
+			ok: true,
+			dsh: {
+				provider: input.provider,
+				model: input.model
+			},
+			openrouterModel: resolved.model.id,
+			...input.currentTag === void 0 ? {} : { currentTag: input.currentTag },
+			...ranked
+		};
+	}
+	refresh(input) {
+		return this.recommend(input, { refresh: true });
+	}
+};
+
+//#endregion
+//#region src/controller.ts
+var OpenRouterProviderController = class {
+	state = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async key(provider) {
+		const credential = await this.deps.credential(provider);
+		if (!credential.value) throw new Error(`请在 DSH 模型设置中配置 OpenRouter 凭据 ${credential.ref}`);
+		return {
+			...credential,
+			configured: true,
+			value: credential.value
+		};
+	}
+	async connection() {
+		const entries = Object.entries(this.deps.providerProfiles()).filter(([, profile]) => profile.baseURL?.toLowerCase().includes("openrouter.ai") === true || profile.models?.some((model) => model.id.startsWith("@preset/")) === true);
+		const routes = await Promise.all(entries.map(async ([provider]) => {
+			const credential = await this.deps.credential(provider);
+			return {
+				provider,
+				credentialRef: credential.ref,
+				configured: credential.configured,
+				source: credential.source
+			};
+		}));
+		return {
+			ok: true,
+			configured: routes.some((route) => route.configured),
+			routes
+		};
+	}
+	async models(sessionId) {
+		const directory = await this.deps.sessionDirectory(sessionId);
+		const current = directory.current;
+		const openrouterRoutes = Object.entries(this.deps.providerProfiles()).filter(([, profile]) => profile.baseURL?.toLowerCase().includes("openrouter.ai") === true || profile.models?.some((model) => model.id.startsWith("@preset/")) === true);
+		const targetProvider = openrouterRoutes.some(([provider]) => provider === current.provider) ? current.provider : openrouterRoutes[0]?.[0];
+		const models = targetProvider === void 0 ? [] : directory.groups.flatMap((group) => group.models.map((model) => ({
+			provider: targetProvider,
+			model: model.id,
+			name: model.name,
+			matchName: `${group.id} ${model.name}`,
+			current: group.id === current.provider && model.id === current.model
+		})));
+		if (!models.some((model) => model.current)) {
+			if (this.deps.providerProfile(current.provider)?.baseURL?.toLowerCase().includes("openrouter.ai") || current.model.startsWith("@preset/")) models.unshift({
+				provider: current.provider,
+				model: current.model,
+				name: current.model,
+				matchName: `${current.provider} ${current.model}`,
+				current: true
+			});
+		}
+		const credential = await this.deps.credential(targetProvider ?? current.provider);
+		return {
+			ok: true,
+			credential: {
+				configured: credential.configured,
+				ref: credential.ref,
+				source: credential.source
+			},
+			current: {
+				provider: current.provider,
+				model: current.model
+			},
+			models
+		};
+	}
+	async recommend(sessionId, refresh = false, override = {}) {
+		const selection = {
+			...await this.deps.sessionSelection(sessionId),
+			...override
+		};
+		const credential = await this.key(selection.provider);
+		const profile = this.deps.providerProfile(selection.provider);
+		const presetModel = profile?.models?.find((model) => model.id === selection.model)?.openrouterModel;
+		const input = {
+			...selection,
+			...profile?.baseURL === void 0 ? {} : { baseURL: profile.baseURL },
+			...typeof presetModel === "string" ? { presetModel } : {}
+		};
+		let fetchedEndpoints = [];
+		const response = await new OpenRouterProviderDirectory({
+			config: () => configForStrategy(this.deps.config(), override.strategy ?? "balanced"),
+			listModels: () => this.deps.listModels(credential),
+			getEndpoints: async (modelId) => {
+				fetchedEndpoints = await this.deps.getEndpoints(credential, modelId, refresh);
+				return fetchedEndpoints;
+			}
+		}).recommend(input, { refresh });
+		const suffix = input.model.replace(/^@preset\//i, "").split(/[-_.·・/\s]+/u).at(-1)?.toLowerCase();
+		const inferred = suffix === void 0 ? [] : fetchedEndpoints.filter((endpoint) => endpoint.tag.split("/")[0]?.toLowerCase() === suffix);
+		if (inferred.length === 1) {
+			response.currentTag = inferred[0].tag;
+			for (const row of [...response.recommended, ...response.rest]) row.current = row.tag === response.currentTag;
+		}
+		this.state.set(sessionId, {
+			input,
+			response,
+			endpoints: fetchedEndpoints
+		});
+		return response;
+	}
+	async apply(sessionId, tag, override = {}) {
+		await this.recommend(sessionId, false, override);
+		const state = this.state.get(sessionId);
+		if (![...state.response.recommended, ...state.response.rest].find((item) => item.tag === tag)) throw new Error("所选 tag 不属于该模型当前合格供应商");
+		const endpoint = state.endpoints.find((item) => item.tag === tag);
+		if (!endpoint) throw new Error("所选 tag 的 endpoint 数据已失效，请刷新后重试");
+		const profile = this.deps.providerProfile(state.input.provider);
+		const credential = await this.key(state.input.provider);
+		return applyProvider({
+			upsertPreset: (modelId, providerTag) => this.deps.upsertPreset(credential, modelId, providerTag),
+			readModels: async () => [...profile?.models ?? []],
+			writeModels: this.deps.writeModels,
+			selectModel: this.deps.selectModel,
+			saveDefault: this.deps.saveDefault
+		}, {
+			sessionId,
+			route: state.input.provider,
+			sourceModel: state.input.model,
+			openrouterModel: state.response.openrouterModel,
+			endpoint,
+			...state.input.reasoningEffort === void 0 ? {} : { reasoningEffort: state.input.reasoningEffort }
+		});
+	}
+};
+
+//#endregion
+//#region src/openrouter.ts
+const BASE_URL = "https://openrouter.ai/api/v1";
+var OpenRouterError = class extends Error {
+	constructor(message, status, body) {
+		super(message);
+		this.status = status;
+		this.body = body;
+		this.name = "OpenRouterError";
+	}
+};
+var OpenRouterClient = class {
+	fetchImpl;
+	cache = /* @__PURE__ */ new Map();
+	modelCatalogCache;
+	ttl;
+	now;
+	baseURL;
+	constructor(options) {
+		this.options = options;
+		if (!options.apiKey) throw new Error("请配置 OPENROUTER_API_KEY");
+		this.fetchImpl = options.fetch ?? globalThis.fetch;
+		this.ttl = options.cacheTtlMs ?? 3e5;
+		this.now = options.now ?? Date.now;
+		this.baseURL = (options.baseURL ?? BASE_URL).replace(/\/$/, "");
+	}
+	async request(path, init) {
+		const timeout = AbortSignal.timeout(init?.method === "POST" ? 3e4 : 15e3);
+		const signal = init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
+		const response = await this.fetchImpl(`${this.baseURL}${path}`, {
+			...init,
+			signal,
+			headers: {
+				authorization: `Bearer ${this.options.apiKey}`,
+				"content-type": "application/json",
+				...init?.headers
+			}
+		});
+		const body = await response.json().catch(() => void 0);
+		if (!response.ok) throw new OpenRouterError((body && typeof body === "object" && "error" in body ? body.error?.message : void 0) ?? `OpenRouter request failed with HTTP ${response.status}`, response.status, body);
+		return body;
+	}
+	async listModels() {
+		const cached = this.modelCatalogCache;
+		if (cached && this.now() - cached.fetchedAt < this.ttl) return cached.models;
+		try {
+			const body = await this.request("/models");
+			if (!Array.isArray(body?.data)) throw new OpenRouterError("OpenRouter models response is malformed", 502, body);
+			const models = body.data.filter((item) => Boolean(item && typeof item === "object" && typeof item.id === "string" && typeof item.name === "string"));
+			this.modelCatalogCache = {
+				fetchedAt: this.now(),
+				models
+			};
+			return models;
+		} catch (error) {
+			if (cached) return cached.models;
+			throw error;
+		}
+	}
+	async getEndpoints(modelId, options = {}) {
+		const cached = this.cache.get(modelId);
+		if (!options.refresh && cached && this.now() - cached.fetchedAt < this.ttl) return cached.endpoints;
+		try {
+			const encoded = modelId.split("/").map(encodeURIComponent).join("/");
+			const body = await this.request(`/models/${encoded}/endpoints`);
+			const candidate = Array.isArray(body?.data) ? body.data : body?.data?.endpoints;
+			if (!Array.isArray(candidate)) throw new OpenRouterError("OpenRouter endpoints response is malformed", 502, body);
+			const endpoints = candidate;
+			this.cache.set(modelId, {
+				fetchedAt: this.now(),
+				endpoints
+			});
+			return endpoints;
+		} catch (error) {
+			if (cached) return cached.endpoints;
+			throw error;
+		}
+	}
+	clearEndpoints(modelId) {
+		this.cache.delete(modelId);
+	}
+	async upsertPreset(modelId, tag) {
+		const modelSlug = modelId.split("/").at(-1);
+		const provider = tag.split("/")[0];
+		if (!modelSlug || !provider) throw new Error("modelId and tag must contain non-empty slugs");
+		const slug = `${modelSlug}-${provider}`.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+		return {
+			slug,
+			response: await this.request(`/presets/${encodeURIComponent(slug)}/chat/completions`, {
+				method: "POST",
+				body: JSON.stringify({
+					model: modelId,
+					provider: {
+						order: [tag],
+						allow_fallbacks: false
+					},
+					messages: [{
+						role: "user",
+						content: ""
+					}]
+				})
+			})
+		};
+	}
+};
+
+//#endregion
+//#region src/host-adapter.ts
+function unwrap(operation, response) {
+	if (!response.result.ok) throw new Error(`${operation} failed: ${response.result.error.code}: ${response.result.error.message}`);
+	return response.result.value;
+}
+function createHostController(ctx, config, credentialRef$1) {
+	const clients = /* @__PURE__ */ new Map();
+	const client = (credential) => {
+		let found = clients.get(credential.ref);
+		if (!found || found.value !== credential.value) {
+			found = {
+				value: credential.value,
+				client: new OpenRouterClient({
+					apiKey: credential.value,
+					cacheTtlMs: config().cacheTtlMs
+				})
+			};
+			clients.set(credential.ref, found);
+		}
+		return found.client;
+	};
+	const profiles = () => ctx.settings.get("llm-pi-ai")?.providers ?? {};
+	const fallbackRef = "OPENROUTER_API_KEY";
+	return new OpenRouterProviderController({
+		config,
+		credential: async (provider) => {
+			const providerRef = profiles()[provider]?.apiKeyEnv;
+			if (providerRef !== void 0) {
+				const configured = await ctx.credentials.resolve(credentialRef$1(providerRef));
+				if (configured?.value) return {
+					configured: true,
+					ref: providerRef,
+					value: configured.value,
+					source: "provider"
+				};
+			}
+			const fallback = await ctx.credentials.resolve(credentialRef$1(fallbackRef));
+			if (fallback?.value) return {
+				configured: true,
+				ref: fallbackRef,
+				value: fallback.value,
+				source: "fallback"
+			};
+			return {
+				configured: false,
+				ref: providerRef ?? fallbackRef,
+				source: providerRef === void 0 ? "fallback" : "provider"
+			};
+		},
+		sessionSelection: async (sessionId) => unwrap("session.models", await ctx.apiProxy.sessions.models({ payload: { sessionId } })).current,
+		sessionDirectory: async (sessionId) => {
+			const value = unwrap("session.models", await ctx.apiProxy.sessions.models({ payload: { sessionId } }));
+			return {
+				current: value.current,
+				groups: value.groups ?? []
+			};
+		},
+		providerProfile: (provider) => profiles()[provider],
+		providerProfiles: profiles,
+		listModels: (credential) => client(credential).listModels(),
+		getEndpoints: (credential, modelId, refresh) => client(credential).getEndpoints(modelId, { refresh }),
+		upsertPreset: (credential, modelId, tag) => client(credential).upsertPreset(modelId, tag),
+		writeModels: async (route, models) => ctx.settings.mutate("llm-pi-ai", [{
+			op: "set",
+			path: [
+				"providers",
+				route,
+				"models"
+			],
+			value: models
+		}]),
+		selectModel: async (selection) => {
+			unwrap("session.selectModel", await ctx.apiProxy.sessions.selectModel({ payload: selection }));
+		},
+		saveDefault: (selection) => ctx.agentDefaultModel.saveSelection(selection)
+	});
+}
+
+//#endregion
+//#region src/host-routes.ts
+const STRATEGIES = new Set([
+	"balanced",
+	"price",
+	"speed",
+	"context"
+]);
+const MAX_BODY_BYTES = 64 * 1024;
+var RouteError = class extends Error {
+	constructor(message, status) {
+		super(message);
+		this.status = status;
+	}
+};
+function strategyOf(value) {
+	return typeof value === "string" && STRATEGIES.has(value) ? value : void 0;
+}
+async function bodyOf(req) {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of req) {
+		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		size += buffer.byteLength;
+		if (size > MAX_BODY_BYTES) throw new RouteError("request body is too large", 413);
+		chunks.push(buffer);
+	}
+	if (chunks.length === 0) return {};
+	return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+function header(req, name$1) {
+	const value = req.headers[name$1];
+	return Array.isArray(value) ? value[0] : value;
+}
+function assertMutationRequest(req) {
+	if (header(req, "content-type")?.split(";", 1)[0]?.trim().toLowerCase() !== "application/json") throw new RouteError("content-type must be application/json", 415);
+	const origin = header(req, "origin");
+	const host = header(req, "host");
+	if (origin) {
+		let originHost;
+		try {
+			originHost = new URL(origin).host;
+		} catch {
+			throw new RouteError("cross-origin mutation is forbidden", 403);
+		}
+		if (!host || originHost !== host) throw new RouteError("cross-origin mutation is forbidden", 403);
+	}
+	const declared = Number(header(req, "content-length"));
+	if (Number.isFinite(declared) && declared > MAX_BODY_BYTES) throw new RouteError("request body is too large", 413);
+}
+function send(res, status, body) {
+	res.statusCode = status;
+	res.setHeader("content-type", "application/json; charset=utf-8");
+	res.end(JSON.stringify(body));
+}
+function createProviderRoute(controller) {
+	return async (req, res) => {
+		try {
+			const url = new URL(req.url ?? "/", "http://localhost");
+			const path = url.pathname.replace(/^\/api\/openrouter-providers/, "") || "/";
+			if (req.method === "GET" && path === "/connection") return send(res, 200, await controller.connection());
+			if (req.method === "GET" && path === "/models") {
+				const sessionId = url.searchParams.get("sessionId");
+				if (!sessionId) return send(res, 400, {
+					ok: false,
+					error: "sessionId is required"
+				});
+				return send(res, 200, await controller.models(sessionId));
+			}
+			if (req.method === "GET" && path === "/recommend") {
+				const sessionId = url.searchParams.get("sessionId");
+				if (!sessionId) return send(res, 400, {
+					ok: false,
+					error: "sessionId is required"
+				});
+				const provider = url.searchParams.get("provider") ?? void 0;
+				const model = url.searchParams.get("model") ?? void 0;
+				const name$1 = url.searchParams.get("name") ?? void 0;
+				const rawStrategy = url.searchParams.get("strategy") ?? void 0;
+				const strategy = strategyOf(rawStrategy);
+				if (rawStrategy !== void 0 && strategy === void 0) return send(res, 400, {
+					ok: false,
+					error: "unknown ranking strategy"
+				});
+				return send(res, 200, await controller.recommend(sessionId, false, {
+					...provider ? { provider } : {},
+					...model ? { model } : {},
+					...name$1 ? { name: name$1 } : {},
+					...strategy ? { strategy } : {}
+				}));
+			}
+			if (req.method === "POST" && (path === "/refresh" || path === "/apply")) {
+				assertMutationRequest(req);
+				const body = await bodyOf(req);
+				if (typeof body.sessionId !== "string" || !body.sessionId) return send(res, 400, {
+					ok: false,
+					error: "sessionId is required"
+				});
+				const strategy = strategyOf(body.strategy);
+				if (body.strategy !== void 0 && strategy === void 0) return send(res, 400, {
+					ok: false,
+					error: "unknown ranking strategy"
+				});
+				const override = {
+					...typeof body.provider === "string" && body.provider ? { provider: body.provider } : {},
+					...typeof body.model === "string" && body.model ? { model: body.model } : {},
+					...typeof body.name === "string" && body.name ? { name: body.name } : {},
+					...strategy ? { strategy } : {}
+				};
+				if (path === "/refresh") return send(res, 200, await controller.recommend(body.sessionId, true, override));
+				if (typeof body.tag !== "string" || !body.tag) return send(res, 400, {
+					ok: false,
+					error: "tag is required"
+				});
+				return send(res, 200, await controller.apply(body.sessionId, body.tag, override));
+			}
+			send(res, 404, {
+				ok: false,
+				error: "not found"
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			send(res, error instanceof RouteError ? error.status : 502, {
+				ok: false,
+				error: message
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/tools.ts
+const recommendationSchema = {
+	type: "object",
+	additionalProperties: true
+};
+async function providerToolApproval(exec, next) {
+	const downstream = await next();
+	if (downstream.kind !== "allow" || exec.name !== "switch_openrouter_provider") return downstream;
+	return {
+		kind: "ask",
+		reason: "切换 OpenRouter 供应商将修改当前会话和默认模型"
+	};
+}
+function createProviderTools(defineTool$1, controller) {
+	return [defineTool$1({
+		name: "recommend_openrouter_providers",
+		description: "Recommend ranked OpenRouter upstream providers for the current DSH model.",
+		parameters: {
+			provider: {
+				type: "string",
+				description: "Optional DSH provider route; defaults to current session"
+			},
+			model: {
+				type: "string",
+				description: "Optional DSH model id; defaults to current session"
+			}
+		},
+		output: {
+			schema: recommendationSchema,
+			render: (_args, value) => [{
+				type: "text",
+				text: value.recommended.map((item) => `${item.rank}. ${item.providerName} · ${item.quantization} · ${item.tps} t/s · score ${item.score}`).join("\n")
+			}]
+		},
+		execute: async (args, exec) => {
+			const sessionId = exec.agent?.session?.id;
+			if (!sessionId) throw new Error("工具执行上下文没有当前会话");
+			return controller.recommend(sessionId, false, args);
+		}
+	}), defineTool$1({
+		name: "switch_openrouter_provider",
+		description: "Switch the current DSH session and default model to one eligible OpenRouter provider tag.",
+		parameters: {
+			tag: {
+				type: "string",
+				required: true,
+				description: "Eligible OpenRouter endpoint tag"
+			},
+			sessionId: {
+				type: "string",
+				description: "Optional target session id; defaults to current session"
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: true
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `已切换到 ${value.tag}（${value.provider}/${value.model}）`
+			}]
+		},
+		execute: async (args, exec) => {
+			const sessionId = args.sessionId ?? exec.agent?.session?.id;
+			if (!sessionId) throw new Error("工具执行上下文没有当前会话");
+			return controller.apply(sessionId, args.tag);
+		}
+	})];
+}
+
+//#endregion
+//#region src/index.ts
+const name = "openrouter-providers";
+const inject = [
+	"tools",
+	"settings",
+	"credentials",
+	"agentDefaultModel",
+	"apiProxy",
+	"webServer"
+];
+const NS = settingsNamespace("openrouter-providers");
+const weights = z.object({
+	quantization: z.number().min(0).max(1).default(.3),
+	speed: z.number().min(0).max(1).default(.3),
+	price: z.number().min(0).max(1).default(.3),
+	context: z.number().min(0).max(1).default(.1)
+});
+const Config = z.object({
+	minContextTokens: z.number().step(1).min(1).default(1e5),
+	cacheTtlMs: z.number().step(1).min(0).default(3e5),
+	recommendedCount: z.number().step(1).min(1).max(10).default(5),
+	weights,
+	priceBlend: z.object({
+		input: z.number().min(0).max(1).default(.02),
+		output: z.number().min(0).max(1).default(.08),
+		cache: z.number().min(0).max(1).default(.9)
+	}),
+	uptimePenaltyThreshold: z.number().min(0).max(100).default(99),
+	uptimePenaltyFactor: z.number().min(0).max(1).default(.85)
+});
+function apply(ctx, initial = DEFAULT_CONFIG) {
+	let source = () => initial;
+	installSettingsSection(ctx, NS, Config, initial, {
+		validate: validateConfig,
+		setSource: (current) => {
+			source = current;
+		},
+		onChange: () => {}
+	});
+	const host = ctx;
+	const controller = createHostController(host, () => source(), credentialRef);
+	ctx.effect(() => ctx.on("tools/pre-execute", providerToolApproval), "openrouter-providers: approve provider switch");
+	ctx.effect(() => host.webServer.register({
+		kind: "prefix",
+		path: "/api/openrouter-providers",
+		handler: createProviderRoute(controller)
+	}), "openrouter-providers: host routes");
+	for (const tool of createProviderTools(defineTool, controller)) ctx.effect(() => host.tools.register(tool), "openrouter-providers: tool");
+}
+
+//#endregion
+export { Config, NS, OpenRouterProviderDirectory, apply, inject, name };