dsh-openrouter-provider-advisor 0.1.0

package/lib/client.js

@@ -0,0 +1,1369 @@
+window.__ModuleLoader__.load({ id: "dsh-openrouter-provider-advisor", factory: (require) => {
+var module = { exports: {} }; var exports = module.exports;
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let react = require("react");
+react = __toESM(react);
+
+//#region src/client/provider-panel-store.ts
+async function responseJson(response) {
+	const body = await response.json();
+	if (!response.ok) throw new Error(body.error ?? `HTTP ${response.status}`);
+	return body;
+}
+function createProviderPanelStore(fetchImpl = fetch) {
+	let snapshot = {
+		open: false,
+		status: "idle",
+		sessionId: null,
+		data: null,
+		models: [],
+		selected: null,
+		strategy: "balanced",
+		error: null,
+		credential: null
+	};
+	const listeners = /* @__PURE__ */ new Set();
+	let generation = 0;
+	let controller = null;
+	const publish = (patch) => {
+		snapshot = {
+			...snapshot,
+			...patch
+		};
+		for (const listener of listeners) listener();
+	};
+	const begin = () => {
+		controller?.abort();
+		controller = new AbortController();
+		return {
+			id: ++generation,
+			signal: controller.signal
+		};
+	};
+	const load = async (sessionId, refresh, selected = snapshot.selected, strategy = snapshot.strategy) => {
+		const operation = begin();
+		publish({
+			open: true,
+			status: "loading",
+			sessionId,
+			error: null
+		});
+		try {
+			const selection = selected ?? void 0;
+			const data = await responseJson(refresh ? await fetchImpl("/api/openrouter-providers/refresh", {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify({
+					sessionId,
+					...selection,
+					strategy
+				}),
+				signal: operation.signal
+			}) : await fetchImpl(`/api/openrouter-providers/recommend?${new URLSearchParams({
+				sessionId,
+				...selection ?? {},
+				strategy
+			}).toString()}`, { signal: operation.signal }));
+			if (operation.id !== generation) return;
+			publish({
+				status: "ready",
+				data,
+				error: null
+			});
+		} catch (error) {
+			if (operation.id !== generation || operation.signal.aborted) return;
+			publish({
+				status: "error",
+				data: null,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			throw error;
+		}
+	};
+	const store = {
+		getSnapshot: () => snapshot,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		async toggle(sessionId) {
+			if (snapshot.open) store.close();
+			else await store.open(sessionId);
+		},
+		async open(sessionId) {
+			const operation = begin();
+			publish({
+				open: true,
+				status: "loading",
+				sessionId,
+				strategy: "balanced",
+				data: null,
+				models: [],
+				selected: null,
+				credential: null,
+				error: null
+			});
+			try {
+				const catalog = await responseJson(await fetchImpl(`/api/openrouter-providers/models?sessionId=${encodeURIComponent(sessionId)}`, { signal: operation.signal }));
+				if (operation.id !== generation) return;
+				const currentModel = catalog.models.find((model) => model.current);
+				const selected = currentModel ? {
+					provider: currentModel.provider,
+					model: currentModel.model,
+					name: currentModel.matchName
+				} : catalog.current;
+				publish({
+					models: catalog.models,
+					selected,
+					credential: catalog.credential
+				});
+				if (!catalog.credential.configured) {
+					publish({
+						status: "ready",
+						data: null,
+						error: null
+					});
+					return;
+				}
+				await load(sessionId, false, selected, "balanced");
+			} catch (error) {
+				if (operation.id !== generation || operation.signal.aborted) return;
+				publish({
+					status: "error",
+					data: null,
+					error: error instanceof Error ? error.message : String(error)
+				});
+				throw error;
+			}
+		},
+		close() {
+			controller?.abort();
+			controller = null;
+			generation += 1;
+			publish({
+				open: false,
+				status: snapshot.data ? "ready" : "idle",
+				strategy: "balanced",
+				error: null
+			});
+		},
+		refresh: (sessionId) => load(sessionId, true),
+		async selectModel(sessionId, provider, model, name) {
+			const selected = {
+				provider,
+				model,
+				name
+			};
+			publish({
+				selected,
+				data: null
+			});
+			await load(sessionId, false, selected);
+		},
+		async setStrategy(sessionId, strategy) {
+			publish({ strategy });
+			await load(sessionId, false, snapshot.selected, strategy);
+		},
+		async apply(sessionId, tag) {
+			const operation = begin();
+			publish({
+				open: true,
+				status: "applying",
+				sessionId,
+				error: null
+			});
+			try {
+				await responseJson(await fetchImpl("/api/openrouter-providers/apply", {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({
+						sessionId,
+						tag,
+						...snapshot.selected ?? {},
+						strategy: snapshot.strategy
+					}),
+					signal: operation.signal
+				}));
+				if (operation.id !== generation) return;
+				store.close();
+			} catch (error) {
+				if (operation.id !== generation || operation.signal.aborted) return;
+				publish({
+					open: true,
+					status: "error",
+					error: error instanceof Error ? error.message : String(error)
+				});
+				throw error;
+			}
+		},
+		dispose() {
+			controller?.abort();
+			controller = null;
+			generation += 1;
+			listeners.clear();
+		}
+	};
+	return store;
+}
+
+//#endregion
+//#region src/client/i18n.ts
+const messages = {
+	"zh-CN": {
+		"panel.title": "OpenRouter 供应商",
+		"panel.currentModelLoading": "正在读取当前模型…",
+		"panel.modelSelect": "选择 DSH 模型",
+		"panel.strategyGroup": "推荐策略",
+		"panel.refresh": "刷新",
+		"panel.close": "关闭",
+		"panel.loading": "正在加载供应商…",
+		"panel.titleTrigger": "OpenRouter 供应商",
+		"panel.unavailable": "当前会话不可切换供应商",
+		"panel.group.recommended": "推荐 Top 5",
+		"panel.group.rest": "其他合格供应商",
+		"panel.column.provider": "供应商",
+		"panel.column.details": "规格详情",
+		"panel.column.score": "分数",
+		"panel.current": "当前",
+		"panel.credentialMissing": "未检测到 OpenRouter 凭据“{ref}”。请前往 DSH 设置 → 模型完成配置；推荐、刷新和供应商切换暂不可用。",
+		"panel.switchHint": "点击供应商即可实时切换；当前会话与默认模型会立即更新。",
+		"panel.uptime": "可用率",
+		"panel.uptimeDelayHint": "可用率来自 OpenRouter 近 30 分钟统计，故障与恢复可能存在检测延迟。",
+		"panel.strategy.balanced": "综合最佳",
+		"panel.strategy.price": "价格优先",
+		"panel.strategy.speed": "速度优先",
+		"panel.strategy.context": "上下文优先",
+		"settings.title": "OpenRouter 供应商",
+		"settings.summary": "推荐数量、综合最佳权重与全局价格模型。",
+		"settings.action.weights": "应用综合权重",
+		"settings.action.priceBlend": "应用价格占比",
+		"settings.action.reset": "恢复默认",
+		"settings.action.lock": "锁定 {name}",
+		"settings.action.unlock": "解锁 {name}",
+		"settings.expand": "展开",
+		"settings.collapse": "收起",
+		"settings.row.minContextTokens": "最小上下文 tokens",
+		"settings.row.recommendedCount": "推荐数量（1–10）",
+		"settings.row.cacheTtlMs": "缓存 TTL（毫秒）",
+		"settings.row.weights.quantization": "量化权重",
+		"settings.row.weights.speed": "速度权重",
+		"settings.row.weights.price": "价格权重",
+		"settings.row.weights.context": "上下文权重",
+		"settings.row.priceBlend.input": "输入价格占比",
+		"settings.row.priceBlend.output": "输出价格占比",
+		"settings.row.priceBlend.cache": "缓存价格占比",
+		"settings.row.uptimePenaltyThreshold": "Uptime 降权阈值（%）",
+		"settings.row.uptimePenaltyFactor": "Uptime 降权系数",
+		"settings.group.weights.title": "综合最佳评分权重",
+		"settings.group.weights.scope": "仅影响“综合最佳”推荐策略；调整一项时，其他未锁定项会按比例联动。",
+		"settings.group.priceBlend.title": "价格计算占比",
+		"settings.group.priceBlend.scope": "所有推荐策略共用。Code Agent 默认按 95% 以上缓存流量优化。",
+		"settings.group.advanced.title": "筛选与可靠性",
+		"settings.group.strategies.title": "查看其他策略权重",
+		"settings.group.strategies.scope": "以下策略使用内置权重；价格维度仍使用上方全局价格占比。",
+		"settings.dimension.quantization": "量化",
+		"settings.dimension.speed": "速度",
+		"settings.dimension.price": "价格",
+		"settings.dimension.context": "上下文",
+		"settings.dimension.input": "输入",
+		"settings.dimension.output": "输出",
+		"settings.dimension.cache": "缓存",
+		"settings.connection.title": "OpenRouter 连接",
+		"settings.connection.loading": "正在检查 DSH OpenRouter 配置…",
+		"settings.connection.configured": "已复用 DSH 中配置的 OpenRouter 凭据",
+		"settings.connection.missing": "尚未检测到可用的 OpenRouter 凭据",
+		"settings.connection.error": "暂时无法读取连接状态",
+		"settings.connection.guide": "请前往 DSH 设置 → 模型，为 OpenRouter provider 配置 API Key。插件不会读取或显示密钥内容。"
+	},
+	"en-US": {
+		"panel.title": "OpenRouter Providers",
+		"panel.currentModelLoading": "Loading current model…",
+		"panel.modelSelect": "Select DSH model",
+		"panel.strategyGroup": "Ranking strategy",
+		"panel.refresh": "Refresh",
+		"panel.close": "Close",
+		"panel.loading": "Loading providers…",
+		"panel.titleTrigger": "OpenRouter Providers",
+		"panel.unavailable": "Provider switching is unavailable for this session",
+		"panel.group.recommended": "Top 5 Recommendations",
+		"panel.group.rest": "Other Eligible Providers",
+		"panel.column.provider": "Provider",
+		"panel.column.details": "Specs & Performance",
+		"panel.column.score": "Score",
+		"panel.current": "Current",
+		"panel.credentialMissing": "OpenRouter credential “{ref}” is not configured. Configure it in DSH Settings → Models; recommendations, refresh, and provider switching are disabled for now.",
+		"panel.switchHint": "Click a provider to switch immediately; the current session and default model update together.",
+		"panel.uptime": "uptime",
+		"panel.uptimeDelayHint": "Uptime comes from OpenRouter's trailing 30-minute statistics, so failures and recoveries may be detected with a delay.",
+		"panel.strategy.balanced": "Best overall",
+		"panel.strategy.price": "Price first",
+		"panel.strategy.speed": "Speed first",
+		"panel.strategy.context": "Context first",
+		"settings.title": "OpenRouter Providers",
+		"settings.summary": "Recommended count, ranking weights, and price blend.",
+		"settings.action.weights": "Apply ranking weights",
+		"settings.action.priceBlend": "Apply price blend",
+		"settings.action.reset": "Reset defaults",
+		"settings.action.lock": "Lock {name}",
+		"settings.action.unlock": "Unlock {name}",
+		"settings.expand": "Expand",
+		"settings.collapse": "Collapse",
+		"settings.row.minContextTokens": "Minimum context tokens",
+		"settings.row.recommendedCount": "Recommended count (1-10)",
+		"settings.row.cacheTtlMs": "Cache TTL (ms)",
+		"settings.row.weights.quantization": "Quantization weight",
+		"settings.row.weights.speed": "Speed weight",
+		"settings.row.weights.price": "Price weight",
+		"settings.row.weights.context": "Context weight",
+		"settings.row.priceBlend.input": "Input price share",
+		"settings.row.priceBlend.output": "Output price share",
+		"settings.row.priceBlend.cache": "Cache price share",
+		"settings.row.uptimePenaltyThreshold": "Uptime penalty threshold (%)",
+		"settings.row.uptimePenaltyFactor": "Uptime penalty factor",
+		"settings.group.weights.title": "Best-overall scoring weights",
+		"settings.group.weights.scope": "Affects only Best overall. Changing one item proportionally redistributes the other unlocked items.",
+		"settings.group.priceBlend.title": "Price calculation blend",
+		"settings.group.priceBlend.scope": "Shared by all ranking strategies. The Code Agent default is optimized for 95%+ cached traffic.",
+		"settings.group.advanced.title": "Filtering & reliability",
+		"settings.group.strategies.title": "View other strategy weights",
+		"settings.group.strategies.scope": "These strategies use built-in weights; their price dimension still uses the global price blend above.",
+		"settings.dimension.quantization": "Quality",
+		"settings.dimension.speed": "Speed",
+		"settings.dimension.price": "Price",
+		"settings.dimension.context": "Context",
+		"settings.dimension.input": "Input",
+		"settings.dimension.output": "Output",
+		"settings.dimension.cache": "Cache",
+		"settings.connection.title": "OpenRouter connection",
+		"settings.connection.loading": "Checking the DSH OpenRouter configuration…",
+		"settings.connection.configured": "Reusing the OpenRouter credential configured in DSH",
+		"settings.connection.missing": "No usable OpenRouter credential was found",
+		"settings.connection.error": "Connection status is temporarily unavailable",
+		"settings.connection.guide": "Open DSH Settings → Models and configure an API key for the OpenRouter provider. The plugin never reads or displays the key in the client."
+	}
+};
+const zh = messages["zh-CN"];
+const en = messages["en-US"];
+const LOCALE_NS = "openrouterProviders";
+let localeService;
+function attachLocale(service) {
+	localeService = service;
+}
+function normalizeLocale(input) {
+	return input?.toLowerCase().startsWith("zh") ? "zh-CN" : "en-US";
+}
+function getLocaleSnapshot() {
+	const active = localeService?.getSnapshot().active;
+	const browserLang = typeof navigator === "undefined" ? void 0 : navigator.language;
+	return normalizeLocale(active ?? browserLang);
+}
+function createI18n(locale) {
+	const normalized = normalizeLocale(locale);
+	return {
+		locale: normalized,
+		t(key, params) {
+			let text = messages[normalized][key];
+			for (const [name, value] of Object.entries(params ?? {})) text = text.replaceAll(`{${name}}`, String(value));
+			return text;
+		}
+	};
+}
+function subscribeLocale(listener) {
+	return localeService?.subscribe(listener) ?? (() => {});
+}
+function useUiI18n() {
+	return createI18n((0, react.useSyncExternalStore)(subscribeLocale, getLocaleSnapshot, () => "en-US"));
+}
+
+//#endregion
+//#region src/client/provider-panel.ts
+const STRATEGY_OPTIONS = [
+	{
+		id: "balanced",
+		labelKey: "panel.strategy.balanced"
+	},
+	{
+		id: "price",
+		labelKey: "panel.strategy.price"
+	},
+	{
+		id: "speed",
+		labelKey: "panel.strategy.speed"
+	},
+	{
+		id: "context",
+		labelKey: "panel.strategy.context"
+	}
+];
+function providerRows(data, i18n = createI18n("zh-CN")) {
+	const map = (group) => (row) => ({
+		group,
+		tag: row.tag,
+		providerName: row.providerName,
+		current: row.current,
+		score: row.score,
+		detail: `${row.quantization} · ${row.tps} t/s · $${row.price.input}/$${row.price.output} · ${row.contextLength.toLocaleString()} ctx · ${row.uptime === null ? "N/A" : `${row.uptime.toFixed(2)}%`} ${i18n.t("panel.uptime")}`,
+		scoreLabel: row.current ? `${i18n.t("panel.current")} · ${row.score.toFixed(1)}` : row.score.toFixed(1)
+	});
+	return [...data.recommended.map(map(i18n.t("panel.group.recommended"))), ...data.rest.map(map(i18n.t("panel.group.rest")))];
+}
+function providerTableColumns(i18n = createI18n("zh-CN")) {
+	return [
+		i18n.t("panel.column.provider"),
+		i18n.t("panel.column.details"),
+		i18n.t("panel.column.score")
+	];
+}
+function providerTriggerState(state) {
+	if (state.current === void 0 || state.currentAddress !== void 0) return {
+		sessionId: null,
+		disabled: true
+	};
+	return {
+		sessionId: state.current,
+		disabled: false
+	};
+}
+const triggerStyle = {
+	display: "flex",
+	alignItems: "center",
+	gap: 8,
+	border: 0,
+	background: "transparent",
+	color: "inherit",
+	cursor: "pointer",
+	minHeight: 36,
+	padding: "0 10px",
+	borderRadius: 8,
+	fontSize: 14
+};
+function providerTriggerLayout(wide) {
+	return wide ? {
+		flex: "1 0 100%",
+		width: "100%",
+		whiteSpace: "nowrap",
+		justifyContent: "flex-start"
+	} : {
+		flex: "0 0 36px",
+		width: 36,
+		whiteSpace: "nowrap",
+		justifyContent: "center"
+	};
+}
+function consume(operation) {
+	operation.catch(() => {});
+}
+function ProviderSidebarTrigger(props) {
+	const i18n = useUiI18n();
+	const current = props.useSessions((state) => state.current);
+	const currentAddress = props.useSessions((state) => state.currentAddress);
+	const panel = (0, react.useSyncExternalStore)(props.store.subscribe, props.store.getSnapshot, props.store.getSnapshot);
+	const target = providerTriggerState({
+		current,
+		currentAddress
+	});
+	return (0, react.createElement)(react.Fragment, null, (0, react.createElement)("style", null, "div:has(> div[data-slot=\"sidebar.footer.action\"] > button[data-openrouter-provider-trigger]){flex-wrap:wrap;row-gap:4px}"), (0, react.createElement)("button", {
+		type: "button",
+		disabled: target.disabled,
+		"aria-label": i18n.t("panel.titleTrigger"),
+		"aria-pressed": panel.open,
+		"data-openrouter-provider-trigger": "",
+		title: target.disabled ? i18n.t("panel.unavailable") : i18n.t("panel.titleTrigger"),
+		style: {
+			...triggerStyle,
+			...providerTriggerLayout(props.wide),
+			opacity: target.disabled ? .45 : 1
+		},
+		onClick: () => {
+			if (target.sessionId) consume(props.store.toggle(target.sessionId));
+		}
+	}, (0, react.createElement)("span", { "aria-hidden": true }, "⇄"), props.wide ? (0, react.createElement)("span", null, i18n.t("panel.titleTrigger")) : null));
+}
+const backdrop = {
+	position: "fixed",
+	inset: 0,
+	zIndex: 90,
+	background: "rgba(0,0,0,.52)",
+	display: "flex",
+	alignItems: "center",
+	justifyContent: "center",
+	padding: 24
+};
+const panelStyle = {
+	width: "min(720px, 100%)",
+	maxHeight: "min(760px, calc(100vh - 48px))",
+	overflow: "hidden",
+	display: "flex",
+	flexDirection: "column",
+	border: "1px solid rgba(255,255,255,.12)",
+	borderRadius: 16,
+	background: "#18181b",
+	color: "#f4f4f5",
+	boxShadow: "0 24px 80px rgba(0,0,0,.5)"
+};
+const providerGridColumns = "minmax(110px,1fr) minmax(0,2fr) minmax(54px,auto)";
+function ProviderOverlay(props) {
+	const i18n = useUiI18n();
+	const current = props.useSessions((state$1) => state$1.current);
+	const currentAddress = props.useSessions((state$1) => state$1.currentAddress);
+	const state = (0, react.useSyncExternalStore)(props.store.subscribe, props.store.getSnapshot, props.store.getSnapshot);
+	const target = providerTriggerState({
+		current,
+		currentAddress
+	});
+	(0, react.useEffect)(() => {
+		if (!state.open) return;
+		if (!target.sessionId) props.store.close();
+		else if (state.sessionId !== target.sessionId) consume(props.store.open(target.sessionId));
+	}, [
+		state.open,
+		state.sessionId,
+		target.sessionId,
+		props.store
+	]);
+	if (!state.open) return null;
+	const rows = state.data ? providerRows(state.data, i18n) : [];
+	const credentialReady = state.credential?.configured === true;
+	const columns = providerTableColumns(i18n);
+	const selectedValue = state.selected ? JSON.stringify([state.selected.provider, state.selected.model]) : "";
+	let lastGroup = null;
+	return (0, react.createElement)("div", {
+		style: backdrop,
+		role: "presentation",
+		onMouseDown: (event) => {
+			if (event.target === event.currentTarget) props.store.close();
+		}
+	}, (0, react.createElement)("section", {
+		role: "dialog",
+		"aria-modal": true,
+		"aria-label": i18n.t("panel.title"),
+		style: panelStyle
+	}, (0, react.createElement)("header", { style: {
+		display: "flex",
+		alignItems: "start",
+		justifyContent: "space-between",
+		padding: "20px 22px 16px",
+		borderBottom: "1px solid rgba(255,255,255,.1)"
+	} }, (0, react.createElement)("div", null, (0, react.createElement)("h2", { style: {
+		margin: 0,
+		fontSize: 20
+	} }, i18n.t("panel.title")), (0, react.createElement)("p", { style: {
+		margin: "6px 0 10px",
+		color: "#a1a1aa",
+		fontSize: 13
+	} }, state.data ? state.data.openrouterModel : i18n.t("panel.currentModelLoading")), (0, react.createElement)("select", {
+		"aria-label": i18n.t("panel.modelSelect"),
+		value: selectedValue,
+		disabled: !credentialReady || state.models.length === 0 || state.status === "applying",
+		style: {
+			minWidth: 300,
+			maxWidth: "min(460px, 60vw)",
+			padding: "7px 10px",
+			borderRadius: 8,
+			border: "1px solid rgba(255,255,255,.16)",
+			background: "#27272a",
+			color: "#f4f4f5"
+		},
+		onChange: (event) => {
+			if (!target.sessionId) return;
+			const [provider, model] = JSON.parse(event.currentTarget.value);
+			const selected = state.models.find((item) => item.provider === provider && item.model === model);
+			if (selected) consume(props.store.selectModel(target.sessionId, provider, model, selected.matchName));
+		}
+	}, ...state.models.map((model) => (0, react.createElement)("option", {
+		key: `${model.provider}\0${model.model}`,
+		value: JSON.stringify([model.provider, model.model])
+	}, `${model.name}${model.current ? ` (${i18n.t("panel.current")})` : ""}`))), (0, react.createElement)("div", {
+		role: "group",
+		"aria-label": i18n.t("panel.strategyGroup"),
+		style: {
+			display: "grid",
+			gridTemplateColumns: "repeat(4, minmax(0, 1fr))",
+			gap: 6,
+			width: "min(560px, 70vw)",
+			marginTop: 12,
+			padding: 4,
+			borderRadius: 10,
+			background: "rgba(255,255,255,.05)"
+		}
+	}, ...STRATEGY_OPTIONS.map((option) => {
+		const active = state.strategy === option.id;
+		return (0, react.createElement)("button", {
+			key: option.id,
+			type: "button",
+			"aria-pressed": active,
+			disabled: !credentialReady || state.status === "loading" || state.status === "applying",
+			onClick: () => {
+				if (target.sessionId && !active) consume(props.store.setStrategy(target.sessionId, option.id));
+			},
+			style: {
+				border: active ? "1px solid #3b82f6" : "1px solid transparent",
+				borderRadius: 7,
+				padding: "7px 10px",
+				background: active ? "rgba(37,99,235,.2)" : "transparent",
+				color: active ? "#93c5fd" : "#d4d4d8",
+				cursor: active ? "default" : "pointer",
+				whiteSpace: "nowrap"
+			}
+		}, i18n.t(option.labelKey));
+	}))), (0, react.createElement)("div", { style: {
+		display: "flex",
+		gap: 8
+	} }, (0, react.createElement)("button", {
+		type: "button",
+		disabled: !credentialReady || !target.sessionId || state.status === "loading" || state.status === "applying",
+		onClick: () => {
+			if (target.sessionId) consume(props.store.refresh(target.sessionId));
+		}
+	}, i18n.t("panel.refresh")), (0, react.createElement)("button", {
+		type: "button",
+		"aria-label": i18n.t("panel.close"),
+		onClick: () => props.store.close()
+	}, "×"))), state.credential !== null && !state.credential.configured ? (0, react.createElement)("p", {
+		role: "status",
+		style: {
+			margin: "14px 22px 0",
+			padding: 12,
+			borderRadius: 8,
+			color: "#fdba74",
+			background: "rgba(124,45,18,.28)",
+			border: "1px solid rgba(249,115,22,.25)",
+			fontSize: 13,
+			lineHeight: 1.5
+		}
+	}, i18n.t("panel.credentialMissing", { ref: state.credential.ref })) : null, state.error ? (0, react.createElement)("p", {
+		role: "alert",
+		style: {
+			margin: "14px 22px 0",
+			padding: 12,
+			borderRadius: 8,
+			color: "#fca5a5",
+			background: "rgba(127,29,29,.35)"
+		}
+	}, state.error) : null, state.status === "loading" && rows.length === 0 ? (0, react.createElement)("p", { style: {
+		padding: 22,
+		color: "#a1a1aa"
+	} }, i18n.t("panel.loading")) : null, credentialReady && rows.length > 0 ? (0, react.createElement)("div", { style: {
+		display: "grid",
+		gap: 2,
+		margin: "12px 22px 0",
+		color: "#71717a",
+		fontSize: 11,
+		lineHeight: 1.5
+	} }, (0, react.createElement)("span", null, i18n.t("panel.switchHint")), (0, react.createElement)("span", { style: {
+		color: "#52525b",
+		fontSize: 10
+	} }, i18n.t("panel.uptimeDelayHint"))) : null, (0, react.createElement)("div", { style: {
+		overflowY: "auto",
+		padding: "12px 14px 20px"
+	} }, ...rows.flatMap((row) => {
+		const nodes = [];
+		if (lastGroup !== row.group) {
+			lastGroup = row.group;
+			nodes.push((0, react.createElement)("h3", {
+				key: `group-${row.group}`,
+				style: {
+					margin: "14px 8px 8px",
+					color: "#a1a1aa",
+					fontSize: 12,
+					textTransform: "uppercase",
+					letterSpacing: ".06em"
+				}
+			}, row.group));
+			nodes.push((0, react.createElement)("div", {
+				key: `columns-${row.group}`,
+				style: {
+					display: "grid",
+					gridTemplateColumns: providerGridColumns,
+					gap: 14,
+					padding: "0 14px 8px",
+					color: "#71717a",
+					fontSize: 11,
+					letterSpacing: ".04em",
+					textTransform: "uppercase"
+				}
+			}, (0, react.createElement)("span", null, columns[0]), (0, react.createElement)("span", null, columns[1]), (0, react.createElement)("span", { style: { textAlign: "right" } }, columns[2])));
+		}
+		nodes.push((0, react.createElement)("button", {
+			key: row.tag,
+			type: "button",
+			disabled: row.current || state.status === "applying",
+			onClick: () => {
+				if (target.sessionId) consume(props.store.apply(target.sessionId, row.tag));
+			},
+			style: {
+				width: "100%",
+				display: "grid",
+				gridTemplateColumns: providerGridColumns,
+				gap: 14,
+				alignItems: "center",
+				padding: "12px 14px",
+				marginBottom: 6,
+				borderRadius: 10,
+				border: row.current ? "1px solid #3b82f6" : "1px solid rgba(255,255,255,.08)",
+				background: row.current ? "rgba(37,99,235,.14)" : "rgba(255,255,255,.035)",
+				color: "inherit",
+				textAlign: "left",
+				cursor: row.current ? "default" : "pointer"
+			}
+		}, (0, react.createElement)("strong", null, row.providerName), (0, react.createElement)("span", {
+			title: row.detail,
+			style: {
+				color: "#a1a1aa",
+				fontSize: 13,
+				overflow: "hidden",
+				textOverflow: "ellipsis",
+				whiteSpace: "nowrap"
+			}
+		}, row.detail), (0, react.createElement)("span", { style: {
+			color: row.current ? "#60a5fa" : "#d4d4d8",
+			fontSize: 12,
+			textAlign: "right"
+		} }, row.scoreLabel)));
+		return nodes;
+	}))));
+}
+
+//#endregion
+//#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
+});
+
+//#endregion
+//#region src/client/linked-weights.ts
+const PRECISION = 1e6;
+function round(value) {
+	return Math.round((value + Number.EPSILON) * PRECISION) / PRECISION;
+}
+function rebalanceWeights(values, changedKey, requestedValue, lockedKeys) {
+	const keys = Object.keys(values);
+	const lockedPeers = keys.filter((key) => key !== changedKey && lockedKeys.has(key));
+	const adjustablePeers = keys.filter((key) => key !== changedKey && !lockedKeys.has(key));
+	const lockedTotal = lockedPeers.reduce((sum, key) => sum + values[key], 0);
+	const capacity = Math.max(0, 1 - lockedTotal);
+	const changed = adjustablePeers.length === 0 ? capacity : Math.min(capacity, Math.max(0, Number.isFinite(requestedValue) ? requestedValue : values[changedKey]));
+	const remainder = Math.max(0, capacity - changed);
+	const peerTotal = adjustablePeers.reduce((sum, key) => sum + Math.max(0, values[key]), 0);
+	const result = {
+		...values,
+		[changedKey]: round(changed)
+	};
+	adjustablePeers.forEach((key, index) => {
+		if (index === adjustablePeers.length - 1) {
+			const assigned = keys.reduce((sum, item) => item === key ? sum : sum + result[item], 0);
+			result[key] = round(Math.max(0, 1 - assigned));
+		} else result[key] = round(remainder * (peerTotal === 0 ? 1 / adjustablePeers.length : Math.max(0, values[key]) / peerTotal));
+	});
+	return result;
+}
+function percent(value) {
+	const amount = Math.round(value * 1e3) / 10;
+	return `${Number.isInteger(amount) ? amount.toFixed(0) : amount.toFixed(1)}%`;
+}
+
+//#endregion
+//#region src/client/weight-group.ts
+const cardStyle = {
+	display: "grid",
+	gap: 14,
+	padding: 16,
+	borderRadius: 12,
+	border: "1px solid var(--dsw-alias-border-l2, rgba(255,255,255,.12))",
+	background: "var(--dsw-alias-bg-layer-3, rgba(255,255,255,.025))"
+};
+function WeightGroup(props) {
+	const [locked, setLocked] = (0, react.useState)(() => /* @__PURE__ */ new Set());
+	const unlockedCount = props.items.reduce((count, item) => count + (locked.has(item.key) ? 0 : 1), 0);
+	const dirty = props.items.some((item) => Math.abs(props.values[item.key] - props.defaults[item.key]) > 1e-6);
+	const total = (0, react.useMemo)(() => props.items.reduce((sum, item) => sum + props.values[item.key], 0), [props.items, props.values]);
+	const update = (key, percentage) => {
+		props.onChange(rebalanceWeights(props.values, key, percentage / 100, locked));
+	};
+	const toggleLock = (key) => {
+		setLocked((current) => {
+			const next = new Set(current);
+			if (next.has(key)) next.delete(key);
+			else next.add(key);
+			return next;
+		});
+	};
+	return (0, react.createElement)("section", { style: cardStyle }, (0, react.createElement)("div", { style: {
+		display: "flex",
+		alignItems: "start",
+		justifyContent: "space-between",
+		gap: 16
+	} }, (0, react.createElement)("div", null, (0, react.createElement)("h4", { style: {
+		margin: 0,
+		fontSize: 15,
+		fontWeight: 650
+	} }, props.title), (0, react.createElement)("p", { style: {
+		margin: "5px 0 0",
+		color: "var(--dsw-alias-label-tertiary, #a1a1aa)",
+		fontSize: 12,
+		lineHeight: 1.55
+	} }, props.scope)), (0, react.createElement)("span", { style: {
+		flex: "0 0 auto",
+		padding: "3px 8px",
+		borderRadius: 999,
+		fontSize: 11,
+		color: "#86efac",
+		background: "rgba(34,197,94,.12)"
+	} }, `${percent(total)} ✓`)), (0, react.createElement)("div", {
+		"aria-hidden": true,
+		style: {
+			display: "flex",
+			height: 8,
+			overflow: "hidden",
+			borderRadius: 999,
+			background: "rgba(255,255,255,.06)"
+		}
+	}, ...props.items.map((item) => (0, react.createElement)("span", {
+		key: item.key,
+		style: {
+			width: `${props.values[item.key] * 100}%`,
+			background: item.color,
+			transition: "width .12s ease"
+		}
+	}))), (0, react.createElement)("div", { style: {
+		display: "grid",
+		gap: 12
+	} }, ...props.items.map((item) => {
+		const isLocked = locked.has(item.key);
+		return (0, react.createElement)("div", {
+			key: item.key,
+			style: {
+				display: "grid",
+				gridTemplateColumns: "minmax(84px, .7fr) minmax(150px, 2fr) 70px 34px",
+				gap: 10,
+				alignItems: "center"
+			}
+		}, (0, react.createElement)("span", { style: {
+			display: "flex",
+			alignItems: "center",
+			gap: 8,
+			fontSize: 13
+		} }, (0, react.createElement)("i", {
+			"aria-hidden": true,
+			style: {
+				width: 8,
+				height: 8,
+				borderRadius: 2,
+				background: item.color
+			}
+		}), item.label), (0, react.createElement)("input", {
+			type: "range",
+			min: 0,
+			max: 100,
+			step: 1,
+			value: Math.round(props.values[item.key] * 100),
+			disabled: !props.writable || isLocked,
+			"aria-label": item.label,
+			style: {
+				width: "100%",
+				accentColor: item.color
+			},
+			onChange: (event) => update(item.key, event.currentTarget.valueAsNumber)
+		}), (0, react.createElement)("div", { style: {
+			display: "flex",
+			alignItems: "center",
+			gap: 3
+		} }, (0, react.createElement)("input", {
+			type: "number",
+			min: 0,
+			max: 100,
+			step: 1,
+			value: Math.round(props.values[item.key] * 1e3) / 10,
+			disabled: !props.writable || isLocked,
+			"aria-label": `${item.label} %`,
+			style: {
+				width: 50,
+				padding: "5px 6px",
+				borderRadius: 6,
+				textAlign: "right"
+			},
+			onChange: (event) => update(item.key, event.currentTarget.valueAsNumber)
+		}), (0, react.createElement)("span", { style: {
+			color: "#a1a1aa",
+			fontSize: 12
+		} }, "%")), (0, react.createElement)("button", {
+			type: "button",
+			disabled: !props.writable || !isLocked && unlockedCount <= 1,
+			"aria-label": props.t(isLocked ? "settings.action.unlock" : "settings.action.lock", { name: item.label }),
+			title: props.t(isLocked ? "settings.action.unlock" : "settings.action.lock", { name: item.label }),
+			onClick: () => toggleLock(item.key),
+			style: {
+				width: 30,
+				height: 30,
+				padding: 0,
+				borderRadius: 7,
+				border: "1px solid rgba(255,255,255,.1)",
+				background: isLocked ? "rgba(59,130,246,.16)" : "transparent",
+				color: isLocked ? "#93c5fd" : "#a1a1aa",
+				cursor: "pointer"
+			}
+		}, isLocked ? "🔒" : "🔓"));
+	})), (0, react.createElement)("div", { style: {
+		display: "flex",
+		justifyContent: "flex-end",
+		gap: 8
+	} }, (0, react.createElement)("button", {
+		type: "button",
+		disabled: !props.writable || !dirty,
+		onClick: () => props.onChange({ ...props.defaults }),
+		style: { padding: "6px 10px" }
+	}, props.resetLabel), (0, react.createElement)("button", {
+		type: "button",
+		disabled: !props.writable,
+		onClick: props.onApply,
+		style: { padding: "6px 12px" }
+	}, props.applyLabel)));
+}
+
+//#endregion
+//#region src/client/settings-card.ts
+function ConnectionStatus({ t }) {
+	const [state, setState] = (0, react.useState)({ status: "loading" });
+	(0, react.useEffect)(() => {
+		const controller = new AbortController();
+		fetch("/api/openrouter-providers/connection", { signal: controller.signal }).then(async (response) => {
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+			setState({
+				status: "ready",
+				value: await response.json()
+			});
+		}).catch((error) => {
+			if (!controller.signal.aborted) setState({ status: "error" });
+		});
+		return () => controller.abort();
+	}, []);
+	const configured = state.value?.configured === true;
+	const label = state.status === "loading" ? t("settings.connection.loading") : state.status === "error" ? t("settings.connection.error") : t(configured ? "settings.connection.configured" : "settings.connection.missing");
+	const color = configured ? "#22c55e" : state.status === "error" ? "#f59e0b" : "#f97316";
+	return (0, react.createElement)("section", { style: {
+		display: "grid",
+		gap: 8,
+		padding: 14,
+		borderRadius: 10,
+		border: `1px solid color-mix(in srgb, ${color} 35%, transparent)`,
+		background: `color-mix(in srgb, ${color} 8%, transparent)`
+	} }, (0, react.createElement)("div", { style: {
+		display: "flex",
+		alignItems: "center",
+		gap: 9
+	} }, (0, react.createElement)("span", {
+		"aria-hidden": true,
+		style: {
+			width: 8,
+			height: 8,
+			borderRadius: 99,
+			background: color,
+			boxShadow: `0 0 0 4px color-mix(in srgb, ${color} 15%, transparent)`
+		}
+	}), (0, react.createElement)("strong", { style: { fontSize: 13 } }, t("settings.connection.title")), (0, react.createElement)("span", { style: {
+		color: "#a1a1aa",
+		fontSize: 12
+	} }, label)), state.status === "ready" && !configured ? (0, react.createElement)("p", { style: {
+		margin: 0,
+		color: "#a1a1aa",
+		fontSize: 12,
+		lineHeight: 1.55
+	} }, t("settings.connection.guide")) : null, state.value?.routes.length ? (0, react.createElement)("div", { style: {
+		display: "flex",
+		flexWrap: "wrap",
+		gap: 6
+	} }, ...state.value.routes.map((route) => (0, react.createElement)("code", {
+		key: route.provider,
+		style: {
+			padding: "3px 7px",
+			borderRadius: 6,
+			fontSize: 11,
+			background: "rgba(127,127,127,.1)",
+			color: route.configured ? "#86efac" : "#fdba74"
+		}
+	}, `${route.provider} · ${route.credentialRef}`))) : null);
+}
+async function setConfigField(scope, config, field, value) {
+	const [group, nested] = field.split(".");
+	if (nested === void 0) return scope.set(group, value);
+	if (group === "weights") return scope.set(group, {
+		...config.weights,
+		[nested]: value
+	});
+	if (group === "priceBlend") return scope.set(group, {
+		...config.priceBlend,
+		[nested]: value
+	});
+	throw new Error(`unknown config field: ${field}`);
+}
+async function setConfigGroup(scope, group, value) {
+	const sum = Object.values(value).reduce((total, item) => total + item, 0);
+	if (Object.values(value).some((item) => !Number.isFinite(item) || item < 0) || Math.abs(sum - 1) > .001) throw new Error(`${group} must sum to 1`);
+	await scope.set(group, value);
+}
+function settingsDisclosureLabel(open, locale = "zh-CN") {
+	const i18n = createI18n(locale);
+	return `${open ? i18n.t("settings.collapse") : i18n.t("settings.expand")}: ${i18n.t("settings.title")}`;
+}
+const scalarRows = [
+	{
+		field: "minContextTokens",
+		labelKey: "settings.row.minContextTokens",
+		min: 1,
+		step: 1e3
+	},
+	{
+		field: "recommendedCount",
+		labelKey: "settings.row.recommendedCount",
+		min: 1,
+		max: 10,
+		step: 1
+	},
+	{
+		field: "cacheTtlMs",
+		labelKey: "settings.row.cacheTtlMs",
+		min: 0,
+		step: 1e3
+	},
+	{
+		field: "uptimePenaltyThreshold",
+		labelKey: "settings.row.uptimePenaltyThreshold",
+		min: 0,
+		max: 100,
+		step: .1
+	},
+	{
+		field: "uptimePenaltyFactor",
+		labelKey: "settings.row.uptimePenaltyFactor",
+		min: 0,
+		max: 1,
+		step: .05
+	}
+];
+function strategyWeightRows(locale = "zh-CN") {
+	const i18n = createI18n(locale);
+	const dimensions = [
+		["quantization", i18n.t("settings.dimension.quantization")],
+		["speed", i18n.t("settings.dimension.speed")],
+		["price", i18n.t("settings.dimension.price")],
+		["context", i18n.t("settings.dimension.context")]
+	];
+	return [
+		"price",
+		"speed",
+		"context"
+	].map((strategy) => ({
+		name: i18n.t(`panel.strategy.${strategy}`),
+		values: dimensions.map(([key, label]) => `${label} ${STRATEGY_WEIGHTS[strategy][key] * 100}%`).join(" · ")
+	}));
+}
+function valueAt(config, field) {
+	const [group, nested] = field.split(".");
+	if (nested === void 0) return config[group];
+	return config[group][nested];
+}
+function OpenRouterProvidersSettingsCard({ scope }) {
+	const i18n = useUiI18n();
+	const snapshot = (0, react.useSyncExternalStore)(scope.subscribe.bind(scope), scope.getSnapshot.bind(scope), scope.getSnapshot.bind(scope));
+	const config = snapshot.value ?? DEFAULT_CONFIG;
+	const [open, setOpen] = (0, react.useState)(false);
+	const [draftWeights, setDraftWeights] = (0, react.useState)({ ...config.weights });
+	const [draftPriceBlend, setDraftPriceBlend] = (0, react.useState)({ ...config.priceBlend });
+	const [error, setError] = (0, react.useState)(null);
+	(0, react.useEffect)(() => {
+		setDraftWeights({ ...config.weights });
+		setDraftPriceBlend({ ...config.priceBlend });
+	}, [config]);
+	const displayed = {
+		...config,
+		weights: draftWeights,
+		priceBlend: draftPriceBlend
+	};
+	const saveGroup = (group, value) => {
+		setConfigGroup(scope, group, value).then(() => setError(null), (failure) => setError(failure instanceof Error ? failure.message : String(failure)));
+	};
+	const weightItems = [
+		{
+			key: "quantization",
+			label: i18n.t("settings.dimension.quantization"),
+			color: "#60a5fa"
+		},
+		{
+			key: "speed",
+			label: i18n.t("settings.dimension.speed"),
+			color: "#34d399"
+		},
+		{
+			key: "price",
+			label: i18n.t("settings.dimension.price"),
+			color: "#fbbf24"
+		},
+		{
+			key: "context",
+			label: i18n.t("settings.dimension.context"),
+			color: "#a78bfa"
+		}
+	];
+	const priceItems = [
+		{
+			key: "input",
+			label: i18n.t("settings.dimension.input"),
+			color: "#60a5fa"
+		},
+		{
+			key: "output",
+			label: i18n.t("settings.dimension.output"),
+			color: "#f59e0b"
+		},
+		{
+			key: "cache",
+			label: i18n.t("settings.dimension.cache"),
+			color: "#34d399"
+		}
+	];
+	const strategyRows = strategyWeightRows(i18n.locale);
+	const body = (0, react.createElement)("div", { style: {
+		display: "grid",
+		gap: 14,
+		margin: "0 16px",
+		padding: "16px 0 12px",
+		borderTop: "1px solid var(--dsw-alias-border-l2, rgba(255,255,255,.12))"
+	} }, (0, react.createElement)(ConnectionStatus, { t: i18n.t }), (0, react.createElement)(WeightGroup, {
+		title: i18n.t("settings.group.weights.title"),
+		scope: i18n.t("settings.group.weights.scope"),
+		values: draftWeights,
+		defaults: { ...DEFAULT_CONFIG.weights },
+		items: weightItems,
+		writable: snapshot.writable,
+		applyLabel: i18n.t("settings.action.weights"),
+		resetLabel: i18n.t("settings.action.reset"),
+		t: i18n.t,
+		onChange: setDraftWeights,
+		onApply: () => saveGroup("weights", draftWeights)
+	}), (0, react.createElement)(WeightGroup, {
+		title: i18n.t("settings.group.priceBlend.title"),
+		scope: i18n.t("settings.group.priceBlend.scope"),
+		values: draftPriceBlend,
+		defaults: { ...DEFAULT_CONFIG.priceBlend },
+		items: priceItems,
+		writable: snapshot.writable,
+		applyLabel: i18n.t("settings.action.priceBlend"),
+		resetLabel: i18n.t("settings.action.reset"),
+		t: i18n.t,
+		onChange: setDraftPriceBlend,
+		onApply: () => saveGroup("priceBlend", draftPriceBlend)
+	}), (0, react.createElement)("details", { style: {
+		padding: "11px 14px",
+		borderRadius: 10,
+		border: "1px solid var(--dsw-alias-border-l2, rgba(255,255,255,.1))"
+	} }, (0, react.createElement)("summary", { style: {
+		cursor: "pointer",
+		fontSize: 13,
+		fontWeight: 600
+	} }, i18n.t("settings.group.strategies.title")), (0, react.createElement)("p", { style: {
+		margin: "10px 0",
+		color: "#a1a1aa",
+		fontSize: 12
+	} }, i18n.t("settings.group.strategies.scope")), ...strategyRows.map((row) => (0, react.createElement)("div", {
+		key: row.name,
+		style: {
+			display: "grid",
+			gridTemplateColumns: "110px 1fr",
+			gap: 12,
+			padding: "7px 0",
+			borderTop: "1px solid rgba(255,255,255,.06)",
+			fontSize: 12
+		}
+	}, (0, react.createElement)("strong", null, row.name), (0, react.createElement)("span", { style: { color: "#a1a1aa" } }, row.values)))), (0, react.createElement)("section", { style: {
+		display: "grid",
+		gap: 10,
+		padding: 14,
+		borderRadius: 10,
+		border: "1px solid var(--dsw-alias-border-l2, rgba(255,255,255,.1))"
+	} }, (0, react.createElement)("h4", { style: {
+		margin: "0 0 2px",
+		fontSize: 14
+	} }, i18n.t("settings.group.advanced.title")), ...scalarRows.map((row) => (0, react.createElement)("label", {
+		key: row.field,
+		style: {
+			display: "grid",
+			gridTemplateColumns: "minmax(180px, 1fr) 140px",
+			alignItems: "center",
+			gap: 12
+		}
+	}, (0, react.createElement)("span", { style: { fontSize: 13 } }, i18n.t(row.labelKey)), (0, react.createElement)("input", {
+		type: "number",
+		value: valueAt(displayed, row.field),
+		min: row.min,
+		max: row.max,
+		step: row.step,
+		disabled: !snapshot.writable,
+		onChange: (event) => void setConfigField(scope, config, row.field, event.currentTarget.valueAsNumber)
+	})))), error === null ? null : (0, react.createElement)("p", {
+		role: "alert",
+		style: {
+			color: "#b42318",
+			margin: 0
+		}
+	}, error));
+	return (0, react.createElement)("li", { style: {
+		listStyle: "none",
+		border: "1px solid var(--dsw-alias-border-l2, rgba(255,255,255,.12))",
+		borderRadius: 12,
+		background: open ? "var(--dsw-alias-bg-layer-2, rgba(255,255,255,.04))" : "var(--dsw-alias-bg-layer-3, rgba(255,255,255,.025))"
+	} }, (0, react.createElement)("button", {
+		type: "button",
+		"aria-expanded": open,
+		"aria-label": settingsDisclosureLabel(open, i18n.locale),
+		onClick: () => setOpen((value) => !value),
+		style: {
+			width: "100%",
+			appearance: "none",
+			border: 0,
+			background: "none",
+			color: "inherit",
+			textAlign: "left",
+			cursor: "pointer",
+			display: "flex",
+			alignItems: "center",
+			gap: 12,
+			padding: "14px 16px",
+			borderRadius: 12,
+			font: "inherit"
+		}
+	}, (0, react.createElement)("span", { style: {
+		flex: 1,
+		minWidth: 0,
+		display: "flex",
+		flexDirection: "column",
+		gap: 4
+	} }, (0, react.createElement)("span", { style: {
+		fontSize: 15,
+		fontWeight: 600,
+		lineHeight: 1.4
+	} }, i18n.t("settings.title")), (0, react.createElement)("span", { style: {
+		fontSize: 13,
+		lineHeight: 1.5,
+		color: "var(--dsw-alias-label-tertiary, #a1a1aa)"
+	} }, i18n.t("settings.summary"))), (0, react.createElement)("span", {
+		"aria-hidden": true,
+		style: {
+			color: "var(--dsw-alias-label-tertiary, #a1a1aa)",
+			transform: open ? "rotate(180deg)" : "none",
+			transition: "transform .16s",
+			fontSize: 18
+		}
+	}, "⌄")), open ? body : null);
+}
+
+//#endregion
+//#region src/client/index.ts
+const inject = [
+	"sessions",
+	"slots",
+	"settingsScope",
+	"locale"
+];
+function apply(ctx) {
+	const client = ctx;
+	attachLocale(client.locale);
+	ctx.effect(() => {
+		const offZh = client.locale.register(LOCALE_NS, "zh", zh);
+		const offEn = client.locale.register(LOCALE_NS, "en", en);
+		return () => {
+			offZh();
+			offEn();
+			attachLocale(void 0);
+		};
+	}, "openrouter-providers: locale dictionaries");
+	const panelStore = createProviderPanelStore();
+	const BoundTrigger = (props) => (0, react.createElement)(ProviderSidebarTrigger, {
+		...props,
+		store: panelStore
+	});
+	const BoundOverlay = (props) => (0, react.createElement)(ProviderOverlay, {
+		...props,
+		store: panelStore
+	});
+	client.slots.inject("sidebar.footer.action", () => client.slots.register({
+		name: "sidebar.footer.action",
+		id: "openrouter-providers-trigger",
+		order: 20
+	}, BoundTrigger));
+	client.slots.inject("shell.overlay", () => client.slots.register({
+		name: "shell.overlay",
+		id: "openrouter-providers-overlay",
+		order: 20
+	}, BoundOverlay));
+	ctx.effect(() => () => panelStore.dispose(), "openrouter-providers: provider panel store");
+	const scope = client.settingsScope.bind({ namespace: "openrouter-providers" });
+	client.slots.inject("settings.plugin.item", () => client.slots.register({
+		name: "settings.plugin.item",
+		key: "openrouter-providers",
+		locale: "openrouter-providers",
+		inject: () => ({ scope })
+	}, OpenRouterProvidersSettingsCard));
+}
+
+//#endregion
+exports.apply = apply;
+exports.inject = inject;
+return module.exports; } });
+//# sourceMappingURL=client.js.map