@router-ai/dsh-plugin-routerai 0.0.0-stage → 0.1.0

package/lib/index.js

@@ -0,0 +1,1354 @@
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
+import { LlmError, assertUsableApiKey, resolveImageAttachmentAccess, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
+import z from "@deepseek-ai/schemastery";
+import { PiAiAdapter } from "@deepseek-ai/dsh-llm-pi-ai";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { InMemoryCredentialStore, createProvider } from "@earendil-works/pi-ai";
+import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+// src/links.ts
+const API_BASE = "https://routerai.ru/api/v1";
+const KEYS_PAGE = "https://routerai.ru/settings/keys";
+const BILLING_PAGE = "https://routerai.ru/settings/billing";
+/** Идентификатор маршрута в harness: так провайдер называется в пикере и конфигурации. */
+const ROUTE = "routerai";
+// src/failures.ts
+const SIGNS = [
+	["key-off", /api key is disabled/i],
+	["key-cap", /spending limit exceeded/i],
+	["no-funds", /недостаточно средств|insufficient balance/i]
+];
+function recognize(failure) {
+	for (const [kind, pattern] of SIGNS) if (pattern.test(failure.message)) return kind;
+	return failure.status === 402 ? "no-funds" : void 0;
+}
+function explain(kind, original) {
+	switch (kind) {
+		case "no-funds": return `На балансе RouterAI закончились деньги. Пополнить счёт: ${BILLING_PAGE}`;
+		case "key-off": return `Этот ключ RouterAI отключён. Включить его можно на ${KEYS_PAGE}, получить новый — командой /routerai login`;
+		case "key-cap": {
+			const numbers = /exceeded:\s*([\d.]+)\s*\/\s*([\d.]+)/i.exec(original);
+			return `Ключ RouterAI упёрся в свой лимит расходов${numbers === null ? "" : ` (потрачено ${numbers[1]} ₽ из ${numbers[2]} ₽)`}. Лимит меняется на ${KEYS_PAGE}; команда /routerai login выдаст ключ с новым лимитом`;
+		}
+	}
+}
+function describeProblem(failure) {
+	const kind = recognize(failure);
+	return kind === void 0 ? void 0 : {
+		kind,
+		text: explain(kind, failure.message),
+		at: Date.now()
+	};
+}
+// src/adapter.ts
+var RouterAiAdapter = class extends PiAiAdapter {
+	observer;
+	constructor(options, observer) {
+		super(options);
+		this.observer = observer;
+	}
+	async listModels(provider) {
+		const listed = [];
+		for (const model of await super.listModels(provider)) {
+			if (!this.observer.offered(model.id)) continue;
+			const caption = this.observer.caption(model.id);
+			listed.push(caption === "" ? model : {
+				...model,
+				description: caption
+			});
+		}
+		return listed;
+	}
+	stream(options) {
+		return this.watch(options, super.stream(options));
+	}
+	/** Агент «замораживает» вызов на шаг через prepareCall — наблюдать нужно и этот путь. */
+	async prepareCall(provider, model, signal) {
+		const call = await super.prepareCall(provider, model, signal);
+		return {
+			...call,
+			stream: (options) => this.watch(options, call.stream(options))
+		};
+	}
+	async *watch(options, source) {
+		try {
+			for await (const chunk of source) {
+				if (chunk.type === "usage") this.observer.spent(options, chunk.usage);
+				else if (chunk.type === "finish" && chunk.reason.kind === "error") {
+					const problem = describeProblem(chunk.reason.failure);
+					if (problem !== void 0) {
+						this.observer.refused(problem);
+						yield {
+							...chunk,
+							reason: {
+								kind: "error",
+								failure: {
+									...chunk.reason.failure,
+									code: "QUOTA",
+									message: problem.text
+								}
+							}
+						};
+						continue;
+					}
+				}
+				yield chunk;
+			}
+		} catch (error) {
+			const problem = error instanceof LlmError ? describeProblem({
+				message: error.message,
+				status: error.status
+			}) : void 0;
+			if (problem === void 0) throw error;
+			this.observer.refused(problem);
+			throw new LlmError(problem.text, "QUOTA", { cause: error });
+		}
+	}
+};
+// src/account.ts
+/** Ключи RouterAI начинаются с `sk-`, дальше — urlsafe-base64. */
+function looksLikeApiKey(text) {
+	return /^sk-[\w-]{16,200}$/.test(text);
+}
+/** Ключ для показа: начало и конец, середина скрыта. */
+function maskApiKey(key) {
+	return key.length < 14 ? "sk-…" : `${key.slice(0, 7)}…${key.slice(-4)}`;
+}
+function number(value) {
+	const parsed = typeof value === "string" ? Number(value) : value;
+	return typeof parsed === "number" && Number.isFinite(parsed) ? parsed : 0;
+}
+function keyFacts(data) {
+	const facts = {
+		label: typeof data["name"] === "string" ? data["name"] : "",
+		disabled: data["disabled"] === true,
+		spent: number(data["usage"]),
+		spentThisMonth: number(data["usage_monthly"])
+	};
+	const amount = number(data["limit"]);
+	if (amount > 0) {
+		const period = data["limit_reset"];
+		facts.cap = {
+			amount,
+			left: Math.max(0, number(data["limit_remaining"])),
+			period: period === "daily" || period === "weekly" || period === "monthly" ? period : "other"
+		};
+	}
+	return facts;
+}
+async function ask(apiBase, path, apiKey) {
+	try {
+		const response = await fetch(`${apiBase}${path}`, {
+			headers: {
+				authorization: `Bearer ${apiKey}`,
+				accept: "application/json"
+			},
+			signal: AbortSignal.timeout(15e3)
+		});
+		if (!response.ok) return {
+			ok: false,
+			status: response.status,
+			note: `${path} → HTTP ${response.status}`
+		};
+		const body = await response.json();
+		return {
+			ok: true,
+			data: typeof body.data === "object" && body.data !== null ? body.data : {}
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			status: void 0,
+			note: `${path} → ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+async function loadAccount(apiBase, apiKey) {
+	const [credits, key] = await Promise.all([ask(apiBase, "/credits", apiKey), ask(apiBase, "/key", apiKey)]);
+	const view = {
+		state: "ok",
+		notes: []
+	};
+	if (credits.ok) view.balance = number(credits.data["credits"]);
+	if (key.ok) view.key = keyFacts(key.data);
+	const failed = [credits, key].filter((reply) => !reply.ok);
+	view.notes = failed.map((reply) => reply.note);
+	if (failed.some((reply) => reply.status === 401 || reply.status === 403)) view.state = "rejected";
+	else if (failed.length === 2) view.state = "offline";
+	else if (failed.length === 1) view.state = "partial";
+	return view;
+}
+// src/storage.ts
+/** Коды, с которыми Windows отказывает в подмене файла, пока его держит другой процесс. */
+const BUSY_CODES = [
+	"EBUSY",
+	"EPERM",
+	"EACCES"
+];
+const RENAME_ATTEMPTS = 10;
+let sequence = 0;
+async function swapIn(temporary, target) {
+	for (let attempt = 1;; attempt += 1) try {
+		await rename(temporary, target);
+		return;
+	} catch (error) {
+		const code = error.code;
+		if (!(process.platform === "win32" && code !== void 0 && BUSY_CODES.includes(code)) || attempt === RENAME_ATTEMPTS) throw error;
+		await new Promise((resolve) => setTimeout(resolve, 40 * attempt));
+	}
+}
+var JsonFile = class {
+	path;
+	accept;
+	/** Записи одного файла выстраиваются в очередь: последняя запись побеждает предсказуемо. */
+	queue = Promise.resolve();
+	/**
+	* @param path - путь к файлу.
+	* @param accept - проверка прочитанного: возвращает значение или undefined, если документ не годится.
+	*/
+	constructor(path, accept) {
+		this.path = path;
+		this.accept = accept;
+	}
+	/** Прочитать документ; undefined, если файла нет, он повреждён или не прошёл проверку. */
+	async read() {
+		let text;
+		try {
+			text = await readFile(this.path, "utf8");
+		} catch {
+			return;
+		}
+		try {
+			return this.accept(JSON.parse(text));
+		} catch {
+			return;
+		}
+	}
+	write(value) {
+		const body = `${JSON.stringify(value, null, 1)}\n`;
+		const job = this.queue.then(() => this.replace(body));
+		this.queue = job.catch(() => {});
+		return job;
+	}
+	async replace(body) {
+		await mkdir(dirname(this.path), { recursive: true });
+		sequence += 1;
+		const temporary = `${this.path}.${process.pid}-${sequence}.part`;
+		try {
+			await writeFile(temporary, body, "utf8");
+			await swapIn(temporary, this.path);
+		} catch (error) {
+			await unlink(temporary).catch(() => {});
+			throw error;
+		}
+	}
+};
+// src/costs.ts
+/** Стоимость одного вызова по цене модели; undefined, если цены нет. */
+function priceCall(card, tokens) {
+	const price = card?.price;
+	if (price === void 0) return void 0;
+	return ((tokens.inputTokens ?? 0) * price.input + (tokens.cacheReadTokens ?? 0) * (price.cachedInput ?? price.input) + (tokens.cacheWriteTokens ?? 0) * (price.cacheWrite ?? price.input) + (tokens.outputTokens ?? 0) * price.output) / 1e6;
+}
+/** Какая часть входа пришла из кэша; undefined, пока входа не было. */
+function cachedShare(tokens) {
+	const input = tokens.input + tokens.cached + tokens.cacheWrites;
+	return input > 0 ? tokens.cached / input : void 0;
+}
+const KEEP_SESSIONS = 300;
+const FLUSH_AFTER_MS = 1500;
+function blank() {
+	return {
+		total: 0,
+		calls: 0,
+		unpriced: 0,
+		last: null,
+		tokens: {
+			input: 0,
+			cached: 0,
+			cacheWrites: 0,
+			output: 0
+		},
+		perModel: {},
+		touchedAt: 0
+	};
+}
+var CostBook = class {
+	onWriteError;
+	sessions = /* @__PURE__ */ new Map();
+	flushTimer;
+	file;
+	constructor(path, onWriteError = () => {}) {
+		this.onWriteError = onWriteError;
+		this.file = new JsonFile(path, (raw) => typeof raw === "object" && raw !== null ? raw : void 0);
+	}
+	async restore() {
+		const saved = await this.file.read();
+		if (saved !== void 0) this.sessions = new Map(Object.entries(saved));
+	}
+	of(sessionId) {
+		return this.sessions.get(sessionId);
+	}
+	/** Учесть вызов чат-модели. */
+	addCall(sessionId, model, card, tokens) {
+		const rub = priceCall(card, tokens);
+		const entry = this.open(sessionId);
+		entry.calls += 1;
+		if (rub === void 0) entry.unpriced += 1;
+		entry.total += rub ?? 0;
+		entry.last = {
+			model,
+			rub: rub ?? 0
+		};
+		entry.tokens.input += tokens.inputTokens ?? 0;
+		entry.tokens.cached += tokens.cacheReadTokens ?? 0;
+		entry.tokens.cacheWrites += tokens.cacheWriteTokens ?? 0;
+		entry.tokens.output += tokens.outputTokens ?? 0;
+		const share = entry.perModel[model] ?? {
+			calls: 0,
+			rub: 0
+		};
+		entry.perModel[model] = {
+			calls: share.calls + 1,
+			rub: share.rub + (rub ?? 0)
+		};
+		this.close(sessionId, entry);
+	}
+	open(sessionId) {
+		const existing = this.sessions.get(sessionId);
+		return existing === void 0 ? blank() : structuredClone(existing);
+	}
+	close(sessionId, entry) {
+		entry.touchedAt = Date.now();
+		this.sessions.delete(sessionId);
+		this.sessions.set(sessionId, entry);
+		for (const stale of this.sessions.keys()) {
+			if (this.sessions.size <= KEEP_SESSIONS) break;
+			this.sessions.delete(stale);
+		}
+		clearTimeout(this.flushTimer);
+		this.flushTimer = setTimeout(() => {
+			this.flush();
+		}, FLUSH_AFTER_MS);
+	}
+	async flush() {
+		clearTimeout(this.flushTimer);
+		try {
+			await this.file.write(Object.fromEntries(this.sessions));
+		} catch (error) {
+			this.onWriteError(error);
+		}
+	}
+};
+// src/signin.ts
+/**
+* Под этим именем приложение видно пользователю на странице согласия. RouterAI привязывает
+* выданный ключ к имени приложения и при повторном входе перевыпускает его, а не создаёт новый,
+* поэтому имя должно оставаться постоянным.
+*/
+const CLIENT_NAME = "DeepSeek Harness";
+const WAIT_LIMIT_MS = 9e5;
+const RETURN_PATH = "/routerai/return";
+const urlSafe = (bytes) => bytes.toString("base64url");
+function newChallenge() {
+	const secret = urlSafe(randomBytes(40));
+	return {
+		secret,
+		digest: urlSafe(createHash("sha256").update(secret).digest()),
+		ticket: urlSafe(randomBytes(18))
+	};
+}
+/** Адрес страницы согласия. Она живёт на сайте, а не под /api. */
+function consentUrl(apiBase, challenge, returnTo) {
+	const page = new URL("/auth", apiBase);
+	page.search = new URLSearchParams({
+		app_name: CLIENT_NAME,
+		key_label: CLIENT_NAME,
+		callback_url: returnTo,
+		code_challenge: challenge.digest,
+		code_challenge_method: "S256",
+		state: challenge.ticket
+	}).toString();
+	return page.href;
+}
+async function redeemCode(apiBase, code, challenge, returnTo) {
+	const response = await fetch(`${apiBase}/auth/keys`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			accept: "application/json"
+		},
+		body: JSON.stringify({
+			code,
+			code_verifier: challenge.secret,
+			code_challenge_method: "S256",
+			callback_url: returnTo
+		}),
+		signal: AbortSignal.timeout(2e4)
+	});
+	const reply = await response.json().catch(() => ({}));
+	if (response.ok && typeof reply["key"] === "string" && reply["key"] !== "") return reply["key"];
+	const reason = reply["error_description"] ?? reply["error"] ?? `HTTP ${response.status}`;
+	throw new Error(`RouterAI не выдал ключ: ${String(reason)}`);
+}
+function answer(response, status, headline, detail) {
+	const safe = (text) => text.replace(/[<>&"]/g, (symbol) => `&#${symbol.charCodeAt(0)};`);
+	response.writeHead(status, {
+		"content-type": "text/html; charset=utf-8",
+		"cache-control": "no-store"
+	});
+	response.end(`<!doctype html><html lang="ru"><meta charset="utf-8"><title>RouterAI</title>
+<body style="margin:0;min-height:100vh;display:grid;place-items:center;font-family:system-ui,sans-serif;background:#f5f7fb;color:#1b2333">
+<main style="max-width:28rem;padding:2rem;text-align:center"><h1 style="font-size:1.4rem">${safe(headline)}</h1><p>${safe(detail)}</p></main></body></html>`);
+}
+/** Начать вход: поднять локальный приёмник ответа и вернуть адрес страницы согласия. */
+async function startSignIn(apiBase) {
+	const challenge = newChallenge();
+	let returnTo = "";
+	let finish = () => {};
+	const key = new Promise((resolve, reject) => {
+		finish = (outcome) => "key" in outcome ? resolve(outcome.key) : reject(outcome.error);
+	});
+	key.catch(() => {});
+	const handle = async (request, response) => {
+		const target = new URL(request.url ?? "/", returnTo);
+		if (target.pathname !== RETURN_PATH) {
+			answer(response, 404, "Страница не найдена", "Этот адрес служит только для возврата со страницы входа RouterAI.");
+			return;
+		}
+		try {
+			if (target.searchParams.get("state") !== challenge.ticket) throw new Error("Ответ не относится к начатому входу. Запустите вход ещё раз.");
+			if (target.searchParams.get("error") === "access_denied") throw new Error("Вы отклонили доступ на странице RouterAI.");
+			const code = target.searchParams.get("code");
+			if (code === null || code === "") throw new Error(`RouterAI вернул ошибку: ${target.searchParams.get("error") ?? "нет кода авторизации"}`);
+			const issued = await redeemCode(apiBase, code, challenge, returnTo);
+			answer(response, 200, "Готово", "Ключ RouterAI сохранён в DeepSeek Harness. Эту вкладку можно закрыть.");
+			finish({ key: issued });
+		} catch (error) {
+			const problem = error instanceof Error ? error : new Error(String(error));
+			answer(response, 400, "Войти не получилось", problem.message);
+			finish({ error: problem });
+		}
+	};
+	const server = createServer((request, response) => {
+		handle(request, response);
+	});
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(0, "127.0.0.1", resolve);
+	});
+	returnTo = `http://127.0.0.1:${server.address().port}${RETURN_PATH}`;
+	const timeout = setTimeout(() => {
+		finish({ error: /* @__PURE__ */ new Error("Вход не был подтверждён за 15 минут.") });
+	}, WAIT_LIMIT_MS);
+	const shutdown = () => {
+		clearTimeout(timeout);
+		server.close();
+		server.closeAllConnections();
+	};
+	key.then(shutdown, shutdown);
+	return {
+		url: consentUrl(apiBase, challenge, returnTo),
+		key,
+		cancel: () => {
+			finish({ error: /* @__PURE__ */ new Error("Вход отменён.") });
+		}
+	};
+}
+/** Как на этой системе открыть адрес в браузере по умолчанию. */
+function browserLauncher(url, platform = process.platform) {
+	if (platform === "win32") return {
+		program: "explorer.exe",
+		args: [url]
+	};
+	return {
+		program: platform === "darwin" ? "open" : "xdg-open",
+		args: [url]
+	};
+}
+/** Попытаться открыть браузер. Не получилось — не беда: адрес показан пользователю. */
+function openBrowser(url) {
+	const { program, args } = browserLauncher(url);
+	try {
+		const child = spawn(program, args, {
+			detached: true,
+			stdio: "ignore",
+			windowsHide: true
+		});
+		child.once("error", () => {});
+		child.unref();
+	} catch {}
+}
+// src/bridge.ts
+const BRIDGE_ROOT = "/api/routerai";
+const ACCOUNT_FRESH_MS = 3e4;
+const PROBLEM_SHOWN_MS = 12e5;
+const BODY_LIMIT = 1e5;
+var Bridge = class {
+	deps;
+	signIn = { stage: "idle" };
+	pending;
+	accountCache;
+	problem = null;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/** RouterAI отказал из-за денег — интерфейс покажет предупреждение. */
+	noteProblem(problem) {
+		this.problem = problem;
+		this.accountCache = void 0;
+	}
+	/** Вызов прошёл — предупреждение о деньгах больше не актуально. */
+	noteSuccess() {
+		this.problem = null;
+	}
+	async overview(fresh) {
+		const key = await this.deps.readKey();
+		const preferences = this.deps.preferences;
+		return {
+			connected: key !== void 0,
+			keyMask: key === void 0 ? null : maskApiKey(key),
+			signIn: this.signIn,
+			account: key === void 0 ? null : await this.account(key, fresh),
+			picker: {
+				models: [...preferences.pickerModels()],
+				custom: preferences.customized
+			},
+			utilityModel: preferences.current.utilityModel,
+			lowBalance: preferences.current.lowBalance,
+			problem: this.problem !== null && Date.now() - this.problem.at < PROBLEM_SHOWN_MS ? this.problem : null
+		};
+	}
+	async account(key, fresh) {
+		const cached = this.accountCache;
+		if (!fresh && cached !== void 0 && cached.forKey === key && Date.now() - cached.at < ACCOUNT_FRESH_MS) return cached.view;
+		const view = await loadAccount(this.deps.apiBase, key);
+		this.accountCache = {
+			forKey: key,
+			at: Date.now(),
+			view
+		};
+		return view;
+	}
+	async beginSignIn() {
+		this.pending?.cancel();
+		const attempt = await startSignIn(this.deps.apiBase);
+		this.pending = attempt;
+		this.signIn = {
+			stage: "waiting",
+			url: attempt.url
+		};
+		openBrowser(attempt.url);
+		attempt.key.then(async (key) => {
+			await this.deps.storeKey(key);
+			this.accountCache = void 0;
+			this.problem = null;
+			if (this.pending === attempt) this.signIn = { stage: "idle" };
+		}, (error) => {
+			if (this.pending !== attempt) return;
+			const reason = error instanceof Error ? error.message : String(error);
+			this.signIn = {
+				stage: "failed",
+				reason
+			};
+			this.deps.warn(`вход не завершён: ${reason}`);
+		}).finally(() => {
+			if (this.pending === attempt) this.pending = void 0;
+		});
+		return { url: attempt.url };
+	}
+	abandonSignIn() {
+		const attempt = this.pending;
+		this.pending = void 0;
+		this.signIn = { stage: "idle" };
+		attempt?.cancel();
+	}
+	endpoints() {
+		const reply = (body, status = 200) => Response.json(body, {
+			status,
+			headers: { "cache-control": "no-store" }
+		});
+		const input = async (request) => {
+			const text = await request.text();
+			if (text.length > BODY_LIMIT) throw new Error("Слишком большой запрос");
+			const parsed = text === "" ? {} : JSON.parse(text);
+			if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("Ожидался JSON-объект");
+			return parsed;
+		};
+		const param = (request, name) => new URL(request.url).searchParams.get(name);
+		return Object.entries({
+			overview: ["GET", (request) => this.overview(param(request, "fresh") === "1")],
+			catalog: ["GET", async () => {
+				await this.deps.catalog.sync();
+				return { models: this.deps.catalog.all() };
+			}],
+			"session-cost": ["GET", async (request) => {
+				const cost = this.deps.costs.of(param(request, "id") ?? "");
+				return { cost: cost === void 0 ? null : {
+					...cost,
+					cachedShare: cachedShare(cost.tokens) ?? null
+				} };
+			}],
+			"sign-in": ["POST", () => this.beginSignIn()],
+			"sign-in/cancel": ["POST", async () => {
+				this.abandonSignIn();
+				return {};
+			}],
+			"sign-out": ["POST", async () => {
+				this.abandonSignIn();
+				await this.deps.forgetKey();
+				this.accountCache = void 0;
+				return {};
+			}],
+			key: ["POST", async (request) => {
+				const key = String((await input(request))["key"] ?? "").trim();
+				if (!looksLikeApiKey(key)) throw new Error("Это не похоже на ключ RouterAI: он начинается с sk-");
+				await this.deps.storeKey(key);
+				this.accountCache = void 0;
+				this.problem = null;
+				return {};
+			}],
+			preferences: ["POST", async (request) => {
+				await this.deps.preferences.change(await input(request));
+				return {};
+			}]
+		}).map(([name, [method, handler]]) => ({
+			path: `${BRIDGE_ROOT}/${name}`,
+			methods: [method],
+			fetch: async (request) => {
+				try {
+					return reply(await handler(request));
+				} catch (error) {
+					return reply({ error: error instanceof Error ? error.message : String(error) }, 400);
+				}
+			}
+		}));
+	}
+};
+// src/catalog.ts
+const SLUG = /^~?[a-z0-9][\w.-]*\/[a-z0-9][\w.:-]*$/i;
+function isModelSlug(value) {
+	return typeof value === "string" && value.length <= 160 && SLUG.test(value);
+}
+function bag(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function strings(value) {
+	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function amount(value) {
+	const parsed = typeof value === "string" ? Number(value) : value;
+	return typeof parsed === "number" && Number.isFinite(parsed) && parsed >= 0 ? parsed : void 0;
+}
+/** Каталог отдаёт цену за единицу; в «рубли за миллион» переводим только то, что тарифицируется по токенам. */
+function tokenPrice(pricing, units) {
+	const perMillion = (field) => {
+		const unit = units[field];
+		if (unit !== void 0 && unit !== "token") return void 0;
+		const value = amount(pricing[field]);
+		return value === void 0 ? void 0 : value * 1e6;
+	};
+	const input = perMillion("prompt");
+	const output = perMillion("completion");
+	if (input === void 0 || output === void 0) return void 0;
+	const price = {
+		input,
+		output
+	};
+	const cachedInput = perMillion("input_cache_read");
+	const cacheWrite = perMillion("input_cache_write");
+	if (cachedInput !== void 0) price.cachedInput = cachedInput;
+	if (cacheWrite !== void 0) price.cacheWrite = cacheWrite;
+	return price;
+}
+/** «Anthropic: Claude Sonnet 5.5» → производитель и название по отдельности. */
+function splitName(name, slug) {
+	const colon = name.indexOf(": ");
+	if (colon > 0 && colon <= 40) return {
+		maker: name.slice(0, colon),
+		title: name.slice(colon + 2).trim() || slug
+	};
+	const vendor = slug.replace(/^~/, "").split("/")[0] ?? "";
+	return {
+		maker: vendor.charAt(0).toUpperCase() + vendor.slice(1),
+		title: name.trim() || slug
+	};
+}
+/** Одна запись ответа; undefined для повреждённых записей и моделей без текстового вывода. */
+function readModelCard(entry) {
+	const raw = bag(entry);
+	if (!isModelSlug(raw["id"])) return void 0;
+	const architecture = bag(raw["architecture"]);
+	const produces = strings(architecture["output_modalities"]);
+	if (produces.length > 0 && !produces.includes("text")) return void 0;
+	const parameters = strings(raw["supported_parameters"]);
+	const slug = raw["id"];
+	const card = {
+		slug,
+		...splitName(typeof raw["name"] === "string" ? raw["name"] : "", slug),
+		alias: slug.startsWith("~"),
+		tools: parameters.includes("tools"),
+		reasoning: parameters.includes("reasoning") || parameters.includes("reasoning_effort"),
+		vision: strings(architecture["input_modalities"]).includes("image")
+	};
+	const window = amount(raw["context_length"]);
+	if (window !== void 0 && window > 0) card.window = window;
+	const price = tokenPrice(bag(raw["pricing"]), bag(raw["pricing_units"]));
+	if (price !== void 0) card.price = price;
+	return card;
+}
+/** Ответ `GET /models` целиком. */
+function readModelList(payload) {
+	const entries = bag(payload)["data"];
+	if (!Array.isArray(entries)) return [];
+	const cards = [];
+	for (const entry of entries) {
+		const card = readModelCard(entry);
+		if (card !== void 0) cards.push(card);
+	}
+	return cards;
+}
+async function downloadModelList(apiBase, signal) {
+	const deadline = AbortSignal.timeout(6e4);
+	const response = await fetch(`${apiBase}/models`, {
+		headers: { accept: "application/json" },
+		signal: signal === void 0 ? deadline : AbortSignal.any([signal, deadline])
+	});
+	if (!response.ok) throw new Error(`каталог RouterAI недоступен: HTTP ${response.status}`);
+	const cards = readModelList(await response.json());
+	if (cards.length === 0) throw new Error("каталог RouterAI вернул пустой список моделей");
+	return cards;
+}
+function acceptSnapshot(raw) {
+	const value = bag(raw);
+	if (value["format"] !== 1 || typeof value["source"] !== "string" || typeof value["savedAt"] !== "number") return void 0;
+	if (!Array.isArray(value["cards"])) return void 0;
+	const cards = value["cards"].filter((card) => isModelSlug(bag(card)["slug"]));
+	return {
+		format: 1,
+		source: value["source"],
+		savedAt: value["savedAt"],
+		cards
+	};
+}
+/**
+* Копия каталога в памяти. Чтение всегда мгновенное: маршрут собирает список моделей
+* на каждый запрос и ждать сеть не может. Сеть трогает только `sync()`.
+*/
+var ModelCatalog = class {
+	options;
+	index = /* @__PURE__ */ new Map();
+	stamp = 0;
+	running;
+	listeners = /* @__PURE__ */ new Set();
+	disk;
+	download;
+	clock;
+	/** Последняя ошибка обновления — для диагностики в интерфейсе и логе. */
+	lastError;
+	constructor(options) {
+		this.options = options;
+		this.disk = options.file === void 0 ? void 0 : new JsonFile(options.file, acceptSnapshot);
+		this.download = options.download ?? ((apiBase) => downloadModelList(apiBase));
+		this.clock = options.clock ?? Date.now;
+	}
+	get size() {
+		return this.index.size;
+	}
+	all() {
+		return [...this.index.values()];
+	}
+	find(slug) {
+		return this.index.get(slug);
+	}
+	/** Подписка на замену содержимого; возвращает функцию отписки. */
+	watch(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	/** Поднять копию с диска (если она от того же API). */
+	async restore() {
+		const saved = await this.disk?.read();
+		if (saved === void 0 || saved.source !== this.options.apiBase || saved.cards.length === 0) return;
+		this.adopt(saved.cards, saved.savedAt);
+	}
+	/** Обновить из сети, если копия устарела или её нет. Сбой оставляет прежнюю копию. */
+	sync(force = false) {
+		if (this.index.size > 0 && this.clock() - this.stamp < this.options.maxAgeMs && !force) return Promise.resolve();
+		this.running ??= this.pull().finally(() => {
+			this.running = void 0;
+		});
+		return this.running;
+	}
+	async pull() {
+		try {
+			const cards = await this.download(this.options.apiBase);
+			this.lastError = void 0;
+			this.adopt(cards, this.clock());
+			await this.disk?.write({
+				format: 1,
+				source: this.options.apiBase,
+				savedAt: this.stamp,
+				cards
+			});
+		} catch (error) {
+			this.lastError = error instanceof Error ? error.message : String(error);
+		}
+	}
+	adopt(cards, stamp) {
+		this.index = new Map(cards.map((card) => [card.slug, card]));
+		this.stamp = stamp;
+		for (const listener of this.listeners) listener();
+	}
+};
+// src/money.ts
+/** Сколько знаков после запятой показать, чтобы сумма не выглядела нулём и не шумела копейками. */
+function fractionDigits(amount) {
+	const size = Math.abs(amount);
+	if (size === 0 || size >= 100) return 0;
+	if (size >= 1) return 2;
+	if (size >= .01) return 3;
+	return 4;
+}
+function rub(amount) {
+	if (amount === null || amount === void 0 || !Number.isFinite(amount)) return "—";
+	const digits = fractionDigits(amount);
+	return `${new Intl.NumberFormat("ru-RU", {
+		minimumFractionDigits: digits,
+		maximumFractionDigits: digits
+	}).format(amount)} ₽`;
+}
+/** «216 ₽ / 1 079 ₽» — вход и выход за миллион токенов. */
+function pricePair(price) {
+	return price === void 0 ? "" : `${rub(price.input)} / ${rub(price.output)}`;
+}
+/** Размер контекстного окна: 1048576 → «1M», 200000 → «200K». */
+function windowLabel(tokens) {
+	if (tokens === void 0) return "";
+	if (tokens >= 1e6) return `${Math.round(tokens / 1e5) / 10}M`;
+	return `${Math.round(tokens / 1e3)}K`;
+}
+const INITIAL = {
+	utilityModel: "deepseek/deepseek-v4.1-flash",
+	lowBalance: 100
+};
+/** Привести список моделей к каноническому виду или объяснить, что с ним не так. */
+function cleanModelList(value) {
+	if (!Array.isArray(value)) throw new Error("Список моделей должен быть массивом");
+	const seen = /* @__PURE__ */ new Set();
+	for (const item of value) {
+		if (!isModelSlug(item)) throw new Error(`«${String(item)}» не похоже на идентификатор модели вида vendor/model`);
+		seen.add(item);
+	}
+	if (seen.size > 150) throw new Error(`В пикере может быть не больше 150 моделей`);
+	return [...seen];
+}
+function fromDisk(raw) {
+	if (typeof raw !== "object" || raw === null) return void 0;
+	const stored = raw;
+	const result = { ...INITIAL };
+	try {
+		if (stored["models"] !== void 0) result.models = cleanModelList(stored["models"]);
+	} catch {}
+	if (stored["utilityModel"] === null || isModelSlug(stored["utilityModel"])) result.utilityModel = stored["utilityModel"];
+	if (typeof stored["lowBalance"] === "number" && stored["lowBalance"] >= 0) result.lowBalance = stored["lowBalance"];
+	return result;
+}
+var PreferenceStore = class {
+	configuredModels;
+	value = { ...INITIAL };
+	file;
+	listeners = /* @__PURE__ */ new Set();
+	constructor(path, configuredModels) {
+		this.configuredModels = configuredModels;
+		this.file = new JsonFile(path, fromDisk);
+	}
+	get current() {
+		return this.value;
+	}
+	/** Модели пикера: выбор пользователя или, если его нет, список из конфигурации. */
+	pickerModels() {
+		return this.value.models ?? this.configuredModels();
+	}
+	get customized() {
+		return this.value.models !== void 0;
+	}
+	watch(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	async restore() {
+		const saved = await this.file.read();
+		if (saved === void 0) return;
+		this.value = saved;
+		this.notify();
+	}
+	/** Применить изменения из интерфейса; неверные значения отклоняются с понятной ошибкой. */
+	async change(patch) {
+		const next = { ...this.value };
+		if ("models" in patch) next.models = cleanModelList(patch["models"]);
+		if ("utilityModel" in patch) {
+			const model = patch["utilityModel"];
+			if (model !== null && !isModelSlug(model)) throw new Error("Служебная модель: ожидался идентификатор vendor/model или null");
+			next.utilityModel = model;
+		}
+		if ("lowBalance" in patch) {
+			const threshold = patch["lowBalance"];
+			if (typeof threshold !== "number" || !Number.isFinite(threshold) || threshold < 0) throw new Error("Порог баланса: ожидалось неотрицательное число");
+			next.lowBalance = threshold;
+		}
+		await this.file.write(next);
+		this.value = next;
+		this.notify();
+		return next;
+	}
+	notify() {
+		for (const listener of this.listeners) listener();
+	}
+};
+// src/provider.ts
+const PROVIDER_NAME = "RouterAI";
+/** Каталог не сообщает предел вывода; этого хватает на длинные правки и не упирается в лимиты апстримов. */
+const OUTPUT_CEILING = 32768;
+/** Окно для модели, о которой каталог ещё ничего не сказал. */
+const UNKNOWN_WINDOW = 128e3;
+function wireDialect(slug) {
+	const dialect = {
+		thinkingFormat: "openrouter",
+		supportsReasoningEffort: true,
+		supportsUsageInStreaming: true,
+		maxTokensField: "max_tokens",
+		supportsStore: false,
+		supportsDeveloperRole: false
+	};
+	if (/^~?anthropic\//.test(slug)) dialect.cacheControlFormat = "anthropic";
+	return dialect;
+}
+/** RouterAI принимает усилия low/medium/high; прочие уровни harness модели не предлагает. */
+function thinkingLevels() {
+	return {
+		off: null,
+		minimal: null,
+		low: "low",
+		medium: "medium",
+		high: "high",
+		xhigh: null,
+		max: null
+	};
+}
+function describeModel(card, apiBase) {
+	const window = card.window ?? UNKNOWN_WINDOW;
+	return {
+		id: card.slug,
+		name: card.title,
+		provider: ROUTE,
+		api: "openai-completions",
+		baseUrl: apiBase,
+		input: card.vision ? ["text", "image"] : ["text"],
+		contextWindow: window,
+		maxTokens: Math.min(OUTPUT_CEILING, window),
+		reasoning: card.reasoning,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		compat: wireDialect(card.slug),
+		...card.reasoning ? { thinkingLevelMap: thinkingLevels() } : {}
+	};
+}
+/** Модель из списка пользователя, пока каталог не загрузился: консервативные возможности. */
+function describeUnknownModel(slug, apiBase) {
+	return describeModel({
+		slug,
+		title: slug,
+		maker: "",
+		alias: slug.startsWith("~"),
+		tools: true,
+		reasoning: false,
+		vision: false
+	}, apiBase);
+}
+/**
+* pi-ai умеет сам искать ключи в окружении и на диске. Этому маршруту это не нужно и вредно:
+* ключ всегда выдаёт harness, поэтому pi-ai получает пустое хранилище и «слепой» контекст.
+*/
+const isolatedAuth = {
+	credentials: new InMemoryCredentialStore(),
+	authContext: {
+		env: async () => void 0,
+		fileExists: async () => false
+	}
+};
+function buildRoute(models, apiBase, credential) {
+	const provider = createProvider({
+		id: ROUTE,
+		name: PROVIDER_NAME,
+		baseUrl: apiBase,
+		models: [...models],
+		api: openAICompletionsApi(),
+		auth: { apiKey: {
+			name: PROVIDER_NAME,
+			resolve: async ({ credential: given }) => ({
+				auth: given?.key === void 0 ? {} : { apiKey: given.key },
+				source: PROVIDER_NAME
+			})
+		} }
+	});
+	return {
+		provider: ROUTE,
+		displayName: PROVIDER_NAME,
+		apiKeyEnv: credential,
+		piProvider: provider,
+		retryPolicy: resolveRetryPolicy(void 0, "llm-routerai.retryPolicy"),
+		streamIdleTimeoutMs: 3e5,
+		maxRequestImages: 50,
+		maxRequestImageBytes: 20971520,
+		requestImageMaxBytes: 1048576,
+		requestImagePixelBudget: 4194304,
+		imageOffloadCountQuantum: 10,
+		modelErrors: /* @__PURE__ */ new Map(),
+		configuredMaxTokens: /* @__PURE__ */ new Map()
+	};
+}
+// src/slash.ts
+const USAGE = `Команда /routerai:
+  login            войти через routerai.ru — ключ выдаст сайт
+  key sk-…         сохранить ключ, созданный вручную
+  logout           удалить сохранённый ключ
+  status           баланс аккаунта и состояние ключа
+  models           модели, которые показывает пикер
+  find <текст>     поиск по каталогу RouterAI`;
+const PERIODS = {
+	daily: "в сутки",
+	weekly: "в неделю",
+	monthly: "в месяц",
+	other: ""
+};
+/** Состояние аккаунта текстом — для чата. */
+function accountReport(account) {
+	if (account.state === "rejected") return "RouterAI не принимает этот ключ: его отозвали или удалили. Получите новый командой /routerai login.";
+	if (account.state === "offline") return `Не удалось связаться с RouterAI (${account.notes.join("; ")}).`;
+	const lines = [];
+	if (account.balance !== void 0) lines.push(`На счёте ${rub(account.balance)}.`);
+	const key = account.key;
+	if (key !== void 0) {
+		const name = key.label === "" ? "Ключ" : `Ключ «${key.label}»`;
+		if (key.disabled) lines.push(`${name} отключён — включить можно на ${KEYS_PAGE}.`);
+		lines.push(key.cap === void 0 ? `${name} без лимита расходов.` : `${name}: лимит ${rub(key.cap.amount)} ${PERIODS[key.cap.period]}`.trimEnd() + `, осталось ${rub(key.cap.left)}.`);
+		lines.push(`Потрачено по ключу: ${rub(key.spent)}, за месяц ${rub(key.spentThisMonth)}.`);
+	}
+	lines.push(...account.notes.map((note) => `Часть данных недоступна: ${note}`));
+	lines.push(`Пополнение: ${BILLING_PAGE}`);
+	return lines.join("\n");
+}
+function modelLine(card) {
+	return [
+		card.slug,
+		pricePair(card.price) && `${pricePair(card.price)} за 1М токенов`,
+		windowLabel(card.window),
+		card.tools ? "" : "без инструментов"
+	].filter((fact) => fact !== "").join(" · ");
+}
+function registerSlashCommand(ctx, deps) {
+	const good = (text) => ({
+		kind: "success",
+		text
+	});
+	const bad = (text) => ({
+		kind: "error",
+		text
+	});
+	async function run(verb, argument, signal) {
+		switch (verb) {
+			case "login": {
+				const attempt = await startSignIn(deps.apiBase);
+				signal.addEventListener("abort", attempt.cancel, { once: true });
+				openBrowser(attempt.url);
+				ctx.logger.info(`[routerai] страница входа: ${attempt.url}`);
+				const key = await attempt.key;
+				await deps.storeKey(key);
+				return good(`Вы вошли в RouterAI, ключ сохранён как ${deps.credentialName}.\n${accountReport(await loadAccount(deps.apiBase, key))}`);
+			}
+			case "key":
+				if (!looksLikeApiKey(argument)) return bad(`Нужен ключ RouterAI вида sk-… Создать его можно на ${KEYS_PAGE}`);
+				await deps.storeKey(argument);
+				return good(`Ключ сохранён как ${deps.credentialName}.`);
+			case "logout":
+				await deps.forgetKey();
+				return good(`Ключ ${deps.credentialName} удалён из DeepSeek Harness. Если он задан переменной окружения или в .env, уберите его и оттуда.`);
+			case "status": {
+				const key = await deps.readKey();
+				if (key === void 0) return bad("Ключа RouterAI пока нет. Войдите: /routerai login");
+				return good(accountReport(await loadAccount(deps.apiBase, key)));
+			}
+			case "models": {
+				await deps.catalog.sync();
+				const lines = deps.pickerModels().map((slug) => {
+					const card = deps.catalog.find(slug);
+					return card === void 0 ? `${slug} · в каталоге не найдена` : modelLine(card);
+				});
+				return good(`${lines.join("\n")}\n\nСписок меняется в Настройках → RouterAI.`);
+			}
+			case "find": {
+				await deps.catalog.sync();
+				const needle = argument.toLowerCase();
+				const hits = deps.catalog.all().filter((card) => `${card.slug} ${card.maker} ${card.title}`.toLowerCase().includes(needle));
+				if (hits.length === 0) return bad(`По запросу «${argument}» в каталоге RouterAI ничего нет.`);
+				const shown = hits.slice(0, 30).map(modelLine);
+				if (hits.length > shown.length) shown.push(`…и ещё ${hits.length - shown.length}. Уточните запрос.`);
+				return good(shown.join("\n"));
+			}
+			default: return good(USAGE);
+		}
+	}
+	ctx.commands.register({
+		name: "routerai",
+		description: "RouterAI: вход, баланс, модели",
+		input: { hint: "login | key sk-… | logout | status | models | find <текст>" },
+		recordInput: false,
+		handler: async ({ rawInput, signal }) => {
+			const text = rawInput.trim();
+			const gap = text.search(/\s/);
+			const verb = (gap === -1 ? text : text.slice(0, gap)).toLowerCase();
+			const argument = gap === -1 ? "" : text.slice(gap).trim();
+			try {
+				return await run(verb, argument, signal);
+			} catch (error) {
+				return bad(error instanceof Error ? error.message : String(error));
+			}
+		}
+	});
+}
+/** Что видит в пикере новый пользователь. */
+const STARTER_MODELS = [
+	{
+		key: "everyday",
+		models: [
+			"anthropic/claude-sonnet-5.5",
+			"deepseek/deepseek-v4.1-flash",
+			"openai/gpt-6.1-sol",
+			"google/gemini-4-argon",
+			"anthropic/claude-opus-5.5",
+			"moonshotai/kimi-k3.1-pro",
+			"z-ai/glm-5.3-flash"
+		]
+	},
+	{
+		key: "coding",
+		models: [
+			"anthropic/claude-opus-5.5",
+			"google/gemini-4-argon",
+			"z-ai/glm-5.3-flash",
+			"openai/gpt-6.1-sol",
+			"moonshotai/kimi-k3.1-pro"
+		]
+	},
+	{
+		key: "budget",
+		models: ["deepseek/deepseek-v4.1-flash", "z-ai/glm-5.3-flash"]
+	}
+][0].models;
+// src/index.ts
+/**
+* RouterAI — провайдер моделей для DeepSeek Harness.
+*
+* Плагин регистрирует маршрут `routerai`: запросы уходят в OpenAI-совместимый API RouterAI
+* через штатный адаптер pi-ai. Сверх этого плагин следит за каталогом моделей и ценами,
+* помогает получить ключ через браузер, показывает баланс и считает стоимость сессий.
+*
+* Настройка из файла (обычно всё делается в Настройках → RouterAI):
+*
+* ```yaml
+* - id: llm-routerai
+*   config:
+*     models: [anthropic/claude-sonnet-5.5, deepseek/deepseek-v4.1-flash]
+* ```
+*
+* @module @router-ai/dsh-plugin-routerai
+*/
+const name = "llm-routerai";
+const inject = ["llm"];
+const Config = z.object({
+	models: z.array(z.string()).default([...STARTER_MODELS]).volatile().description("Модели RouterAI в пикере, по порядку. Выбор в Настройках → RouterAI имеет приоритет."),
+	apiKeyEnv: z.string().default("ROUTERAI_API_KEY").description("Имя, под которым хранится ключ RouterAI (sk-…): учётные данные harness, переменная окружения или .env."),
+	baseURL: z.string().default(API_BASE).description("Адрес API RouterAI."),
+	catalogRefreshHours: z.number().min(.25).default(4).description("Как часто обновлять каталог моделей и цены, в часах.")
+});
+/** Каталог состояния плагина внутри дома harness. */
+function stateDir() {
+	return join(process.env["DSH_HOME"] ?? join(homedir(), ".dsh"), "routerai");
+}
+/** Запросы на заголовок сессии и сжатие контекста: им хватает недорогой модели. */
+const UTILITY_PURPOSES = /* @__PURE__ */ new Set(["session-title", "compaction"]);
+function apply(ctx, config) {
+	const apiBase = config.baseURL.replace(/\/+$/, "");
+	const credential = credentialRef(config.apiKeyEnv);
+	const home = stateDir();
+	const hours = (value) => value * 36e5;
+	const catalog = new ModelCatalog({
+		apiBase,
+		file: join(home, "catalog.json"),
+		maxAgeMs: hours(config.catalogRefreshHours)
+	});
+	const preferences = new PreferenceStore(join(home, "preferences.json"), () => config.models.get() ?? []);
+	const costs = new CostBook(join(home, "costs.json"), (error) => ctx.logger.warn("[routerai] не удалось сохранить расход: %s", String(error)));
+	const optional = {};
+	const adopt = (service) => {
+		ctx.inject([service], (scope) => {
+			scope.effect(() => {
+				optional[service] = scope.get(service);
+				return () => {
+					delete optional[service];
+				};
+			}, `routerai: ${service}`);
+		});
+	};
+	adopt("credentials");
+	adopt("attachments");
+	adopt("fs");
+	let route;
+	const warnedAbout = /* @__PURE__ */ new Set();
+	const routeChanged = () => {
+		route = void 0;
+		ctx.emit("llm/models-updated", ROUTE);
+	};
+	const currentRoute = () => {
+		if (route !== void 0) return route;
+		const wanted = new Set(preferences.pickerModels());
+		const utility = preferences.current.utilityModel;
+		if (utility !== null) wanted.add(utility);
+		const models = [];
+		for (const slug of wanted) {
+			const card = catalog.find(slug);
+			if (card !== void 0) models.push(describeModel(card, apiBase));
+			else if (catalog.size === 0) models.push(describeUnknownModel(slug, apiBase));
+			else if (!warnedAbout.has(slug)) {
+				warnedAbout.add(slug);
+				ctx.logger.warn(`[routerai] модели ${slug} нет в каталоге RouterAI — в пикер она не попадёт`);
+			}
+		}
+		route = /* @__PURE__ */ new Map([[ROUTE, buildRoute(models, apiBase, credential)]]);
+		return route;
+	};
+	const readKey = async () => {
+		const value = (optional.credentials !== void 0 ? await optional.credentials.resolve(credential) : launchEnvironmentOf(ctx).get(credential))?.value;
+		return value === void 0 || value === "" ? void 0 : assertUsableApiKey(value, name, config.apiKeyEnv);
+	};
+	const keyVault = () => {
+		if (optional.credentials === void 0) throw new Error("В этом режиме DeepSeek Harness нет хранилища ключей — задайте ключ переменной окружения.");
+		return optional.credentials;
+	};
+	const storeKey = async (key) => {
+		await keyVault().set(credential, key);
+		ctx.emit("llm/models-updated", ROUTE);
+	};
+	const forgetKey = async () => {
+		await keyVault().unset(credential);
+		ctx.emit("llm/models-updated", ROUTE);
+	};
+	const bridge = new Bridge({
+		apiBase,
+		readKey,
+		storeKey,
+		forgetKey,
+		catalog,
+		preferences,
+		costs,
+		warn: (message) => ctx.logger.warn(`[routerai] ${message}`)
+	});
+	const adapter = new RouterAiAdapter({
+		profiles: currentRoute,
+		auth: isolatedAuth,
+		resolveApiKey: async () => {
+			const key = await readKey();
+			if (key === void 0) throw new LlmError(`Нет ключа RouterAI (${config.apiKeyEnv}). Войдите командой /routerai login или создайте ключ на ${KEYS_PAGE} и сохраните его: /routerai key sk-…`, "MISSING_CREDENTIAL");
+			return key;
+		},
+		prepareHeaders: (_request, headers) => {
+			headers.set("X-Title", "DeepSeek Harness");
+			headers.set("HTTP-Referer", "https://github.com/router-ai/dsh-plugin-routerai");
+			return headers;
+		},
+		resolveAttachments: () => optional.attachments,
+		resolveImageAccess: (store, ref) => resolveImageAttachmentAccess(store, (path) => optional.fs?.processPathFromHostPath(path), ref),
+		onReplayDegrade: ({ model, reason }) => {
+			ctx.logger.warn(`[routerai] ${model}: служебные данные прошлых ответов переданы упрощённо (${reason})`);
+		}
+	}, {
+		caption: (slug) => {
+			const card = catalog.find(slug);
+			if (card === void 0) return "";
+			const price = pricePair(card.price);
+			return [price && `${price} за 1М токенов`, card.window && `контекст ${windowLabel(card.window)}`].filter(Boolean).join(" · ");
+		},
+		offered: (slug) => preferences.pickerModels().includes(slug),
+		spent: (call, tokens) => {
+			bridge.noteSuccess();
+			if (call.sessionId !== void 0) costs.addCall(String(call.sessionId), call.model, catalog.find(call.model), tokens);
+		},
+		refused: (problem) => bridge.noteProblem(problem)
+	});
+	ctx.llm.registerAdapter([ROUTE], adapter);
+	const rerouted = /* @__PURE__ */ new WeakSet();
+	ctx.on("llm/stream", (options, next) => {
+		const utility = preferences.current.utilityModel;
+		const purpose = options.purpose;
+		if (!(utility !== null && options.provider === "routerai" && options.model !== utility && purpose !== void 0 && UTILITY_PURPOSES.has(purpose) && !rerouted.has(options) && catalog.find(utility) !== void 0)) return next();
+		const { reasoningEffort: _dropped, ...rest } = options;
+		const replacement = {
+			...rest,
+			model: utility
+		};
+		rerouted.add(replacement);
+		return ctx.llm.stream(replacement);
+	});
+	ctx.on("loader/volatile-update", routeChanged);
+	ctx.on("credentials/reference-updated", (ref) => {
+		if (ref === credential) ctx.emit("llm/models-updated", ROUTE);
+	});
+	ctx.effect(() => {
+		const stopWatching = [catalog.watch(routeChanged), preferences.watch(routeChanged)];
+		preferences.restore();
+		costs.restore();
+		catalog.restore().then(() => catalog.sync()).then(() => {
+			if (catalog.lastError !== void 0) ctx.logger.warn(`[routerai] ${catalog.lastError}`);
+		});
+		const timer = setInterval(() => {
+			catalog.sync();
+		}, hours(config.catalogRefreshHours));
+		return () => {
+			clearInterval(timer);
+			for (const stop of stopWatching) stop();
+			costs.flush();
+		};
+	}, "routerai: state");
+	ctx.inject(["connection"], (scope) => {
+		for (const endpoint of bridge.endpoints()) scope.effect(() => scope.connection.fetch.register({
+			...endpoint,
+			requestBody: "buffered"
+		}), `routerai: ${endpoint.path}`);
+	});
+	ctx.inject(["commands"], (scope) => {
+		registerSlashCommand(scope, {
+			apiBase,
+			credentialName: config.apiKeyEnv,
+			readKey,
+			storeKey,
+			forgetKey,
+			catalog,
+			pickerModels: () => preferences.pickerModels()
+		});
+	});
+}
+export { Config, apply, inject, name };