@wxip/dsh-sub2api 0.2.2

package/lib/index.js

@@ -0,0 +1,1220 @@
+import z from "@deepseek-ai/schemastery";
+import { LlmError, LlmError as LlmError$1, assertUsableApiKey, attributionHeaders } from "@deepseek-ai/dsh-llm";
+import { credentialRef, credentialRef as credentialRef$1 } from "@deepseek-ai/dsh-credentials";
+import { mkdir, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join } from "node:path";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+
+//#region src/routes.ts
+const ROUTES = {
+	get: "/plugins/dsh-sub2api/config",
+	set: "/plugins/dsh-sub2api/config",
+	discover: "/plugins/dsh-sub2api/discover",
+	usage: "/plugins/dsh-sub2api/usage",
+	status: "/plugins/dsh-sub2api/status",
+	attachment: "/plugins/dsh-sub2api/attachment"
+};
+function trustedRequest(req) {
+	const remote = req.socket.remoteAddress;
+	if (remote !== "127.0.0.1" && remote !== "::1" && remote !== "::ffff:127.0.0.1") return false;
+	if (req.headers["sec-fetch-site"] === "cross-site") return false;
+	const host = req.headers.host;
+	if (host === undefined) return false;
+	const origin = req.headers.origin;
+	if (origin === undefined) return true;
+	try {
+		return new URL(origin).host === new URL(`http://${host}`).host;
+	} catch {
+		return false;
+	}
+}
+async function readJson(req) {
+	const chunks = [];
+	for await (const chunk of req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	const text = Buffer.concat(chunks).toString("utf8").trim();
+	if (text.length === 0) return {};
+	const value = JSON.parse(text);
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function json(res, status, value) {
+	res.writeHead(status, {
+		"content-type": "application/json; charset=utf-8",
+		"cache-control": "no-store",
+		"x-content-type-options": "nosniff"
+	});
+	res.end(JSON.stringify(value));
+}
+function safeMessage(error) {
+	if (error instanceof Error) return error.message;
+	try {
+		const text = String(error);
+		return text.length > 0 ? text : "unknown error";
+	} catch {
+		return "unknown error";
+	}
+}
+function readProviderConfig(config) {
+	const providers = {};
+	for (const def of PROVIDERS) {
+		const profile = config.providers[def.key];
+		providers[def.key] = {
+			keyConfigured: profile.apiKeyEnv !== undefined,
+			models: profile.models?.map((model) => ({ ...model })) ?? []
+		};
+	}
+	return {
+		baseURL: config.baseURL,
+		catalogFormat: "structured-v1",
+		providers,
+		tools: { ...config.tools?.generate !== undefined ? { generate: { ...config.tools.generate } } : {} }
+	};
+}
+function legacyCatalogModel(value) {
+	const [rawId = "", rawName = "", rawContextWindow = ""] = value.split("|");
+	const id = rawId.trim();
+	if (id.length === 0) return undefined;
+	const name$1 = rawName.trim();
+	const parsedContextWindow = Number(rawContextWindow.trim());
+	const contextWindow = Number.isSafeInteger(parsedContextWindow) && parsedContextWindow > 0 ? parsedContextWindow : undefined;
+	return {
+		id,
+		...name$1.length > 0 ? { name: name$1 } : {},
+		...contextWindow !== undefined ? { contextWindow } : {}
+	};
+}
+function structuredCatalogModel(value) {
+	if (typeof value === "string") return legacyCatalogModel(value);
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+	const raw = value;
+	const id = typeof raw.id === "string" ? raw.id.trim() : "";
+	if (id.length === 0) return undefined;
+	const name$1 = typeof raw.name === "string" ? raw.name.trim() : "";
+	const contextWindow = typeof raw.contextWindow === "number" && Number.isSafeInteger(raw.contextWindow) && raw.contextWindow > 0 ? raw.contextWindow : undefined;
+	const maxTokens = typeof raw.maxTokens === "number" && Number.isSafeInteger(raw.maxTokens) && raw.maxTokens > 0 ? raw.maxTokens : undefined;
+	const reasoningEfforts = Array.isArray(raw.reasoningEfforts) ? raw.reasoningEfforts.filter((effort) => typeof effort === "string" && effort.length > 0) : undefined;
+	const input = Array.isArray(raw.input) ? raw.input.filter((modality) => modality === "text" || modality === "image") : undefined;
+	return {
+		id,
+		...name$1.length > 0 ? { name: name$1 } : {},
+		...contextWindow !== undefined ? { contextWindow } : {},
+		...maxTokens !== undefined ? { maxTokens } : {},
+		...reasoningEfforts !== undefined ? { reasoningEfforts } : {},
+		...input !== undefined && input.length > 0 ? { input } : {}
+	};
+}
+function readCatalogModels(value, fallback) {
+	if (Array.isArray(value)) return value.map(structuredCatalogModel).filter((model) => model !== undefined);
+	if (typeof value === "string") return value.split(/[\n,]/).map(legacyCatalogModel).filter((model) => model !== undefined);
+	return fallback;
+}
+function providerCredentialRef(platform) {
+	return credentialRef$1(`SUB2API_${platform.toUpperCase()}_API_KEY`);
+}
+function isProviderKey$1(value) {
+	return PROVIDERS.some((def) => def.key === value);
+}
+function readToolModelRef(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+	const raw = value;
+	const provider = typeof raw.provider === "string" ? raw.provider.trim() : "";
+	const model = typeof raw.model === "string" ? raw.model.trim() : "";
+	if (!isProviderKey$1(provider) || model.length === 0) return undefined;
+	return {
+		provider,
+		model
+	};
+}
+function readImageTools(value, fallback) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return fallback;
+	const raw = value;
+	const generate = readToolModelRef(raw.generate);
+	if (generate === undefined) return undefined;
+	return { ...generate !== undefined ? { generate } : {} };
+}
+/**
+
+* One-shot probe key for discovery/usage: a freshly typed key wins (it is the
+
+* one under test); otherwise fall back to the credential already stored for
+
+* that provider, so the settings page does not force the user to re-type the
+
+* key every time.
+
+*/
+async function resolveProbeKey(ctx, routes, provider, typedKey) {
+	if (typedKey.length > 0) return typedKey;
+	if (!isProviderKey$1(provider)) throw new Error("provider 无效，应为 openai / claude / grok");
+	const def = PROVIDERS.find((entry) => entry.key === provider);
+	const profile = routes.config().providers[provider];
+	if (profile?.apiKeyEnv === undefined) throw new Error(`${def?.label ?? provider} 未配置 API key：请先填写 key 并保存配置，再获取模型/查看用量`);
+	try {
+		return await routes.resolveApiKey(`sub2api-${provider}`, profile);
+	} catch (error) {
+		throw new Error(`无法使用已保存的 ${def?.label ?? provider} key：${safeMessage(error)}`);
+	}
+}
+function registerRoutes(ctx, routes) {
+	ctx.inject(["webServer"], (webCtx) => {
+		const register = (path, handler) => {
+			webCtx.effect(() => webCtx.webServer.register({
+				kind: "exact",
+				path,
+				handler
+			}));
+		};
+		register(ROUTES.get, async (req, res) => {
+			if (req.method !== "GET" && req.method !== "POST") return json(res, 405, { error: "method not allowed" });
+			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
+			if (req.method === "GET") {
+				json(res, 200, readProviderConfig(routes.config()));
+				return;
+			}
+			try {
+				const body = await readJson(req);
+				const baseURL = typeof body.baseURL === "string" ? body.baseURL.trim().replace(/\/+$/, "") : "";
+				if (baseURL.length === 0) return json(res, 400, { error: "baseURL is required" });
+				if (!/^https?:\/\//.test(baseURL)) return json(res, 400, { error: "baseURL must start with http(s)://" });
+				const current = routes.config();
+				const next = {
+					baseURL,
+					providers: {
+						openai: { ...current.providers.openai },
+						claude: { ...current.providers.claude },
+						grok: { ...current.providers.grok }
+					},
+					...current.tools !== undefined ? { tools: { ...current.tools } } : {}
+				};
+				const rawProviders = typeof body.providers === "object" && body.providers !== null ? body.providers : {};
+				const credentials = ctx.get("credentials");
+				for (const def of PROVIDERS) {
+					const raw = rawProviders[def.key];
+					const profile = next.providers[def.key];
+					const apiKey = typeof raw?.apiKey === "string" ? raw.apiKey.trim() : "";
+					if (apiKey.length > 0 && credentials !== undefined) {
+						await credentials.set(providerCredentialRef(def.key), apiKey);
+						profile.apiKeyEnv = providerCredentialRef(def.key);
+					} else if (apiKey.length > 0 && credentials === undefined) profile.apiKeyEnv = providerCredentialRef(def.key);
+					const api = typeof raw?.api === "string" ? raw.api.trim() : undefined;
+					if (api !== undefined) if (api.length === 0) delete profile.api;
+else if (API_PROTOCOLS.includes(api)) profile.api = api;
+else return json(res, 400, { error: `${def.label} 的网关协议 "${api}" 无效，应为 ${API_PROTOCOLS.join(" / ")}` });
+					profile.models = readCatalogModels(raw?.models, profile.models ?? []);
+				}
+				const tools = readImageTools(body.tools, current.tools);
+				if (tools !== undefined) next.tools = tools;
+else delete next.tools;
+				await routes.setConfig(next);
+				json(res, 200, {
+					ok: true,
+					...readProviderConfig(next),
+					routes: routes.listRegisteredRoutes()
+				});
+			} catch (error) {
+				json(res, 500, { error: safeMessage(error) });
+			}
+		});
+		register(ROUTES.discover, async (req, res) => {
+			if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
+			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
+			try {
+				const body = await readJson(req);
+				const baseURL = typeof body.baseURL === "string" ? body.baseURL.trim().replace(/\/+$/, "") : "";
+				const provider = typeof body.provider === "string" ? body.provider.trim() : "";
+				if (baseURL.length === 0) return json(res, 400, { error: "baseURL is required" });
+				let apiKey;
+				try {
+					apiKey = await resolveProbeKey(ctx, routes, provider, typeof body.apiKey === "string" ? body.apiKey.trim() : "");
+				} catch (error) {
+					return json(res, 400, { error: safeMessage(error) });
+				}
+				const response = await fetch(`${gatewayApiRoot(baseURL)}/models`, {
+					method: "GET",
+					headers: { authorization: `Bearer ${apiKey}` },
+					signal: AbortSignal.timeout(3e4)
+				});
+				if (!response.ok) {
+					const text = await response.text().catch(() => "");
+					return json(res, response.status, { error: `HTTP ${response.status}: ${text.slice(0, 300)}` });
+				}
+				const payload = await response.json();
+				const models = Array.isArray(payload.data) ? payload.data.map((m) => ({
+					id: typeof m.id === "string" ? m.id : "",
+					name: typeof m.display_name === "string" ? m.display_name : typeof m.name === "string" ? m.name : undefined
+				})).filter((m) => m.id.length > 0) : [];
+				json(res, 200, {
+					ok: true,
+					models
+				});
+			} catch (error) {
+				json(res, 500, { error: safeMessage(error) });
+			}
+		});
+		register(ROUTES.usage, async (req, res) => {
+			if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
+			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
+			try {
+				const body = await readJson(req);
+				const baseURL = typeof body.baseURL === "string" ? body.baseURL.trim().replace(/\/+$/, "") : "";
+				const provider = typeof body.provider === "string" ? body.provider.trim() : "";
+				if (baseURL.length === 0) return json(res, 400, { error: "baseURL is required" });
+				let apiKey;
+				try {
+					apiKey = await resolveProbeKey(ctx, routes, provider, typeof body.apiKey === "string" ? body.apiKey.trim() : "");
+				} catch (error) {
+					return json(res, 400, { error: safeMessage(error) });
+				}
+				const response = await fetch(`${gatewayApiRoot(baseURL)}/usage`, {
+					method: "GET",
+					headers: { authorization: `Bearer ${apiKey}` },
+					signal: AbortSignal.timeout(3e4)
+				});
+				if (!response.ok) {
+					const text = await response.text().catch(() => "");
+					return json(res, response.status, { error: `HTTP ${response.status}: ${text.slice(0, 300)}` });
+				}
+				const payload = await response.json();
+				const parts = [];
+				const quota = payload.quota;
+				if (quota !== undefined && typeof quota.limit === "number") parts.push(`配额 ${String(quota.used ?? 0)}/${quota.limit}${typeof quota.unit === "string" ? ` ${quota.unit}` : ""}（剩余 ${String(quota.remaining ?? 0)}）`);
+else if (typeof payload.balance === "number") parts.push(`余额 $${payload.balance}`);
+else if (typeof payload.remaining === "number") parts.push(`剩余 ${payload.remaining}${typeof payload.unit === "string" ? ` ${payload.unit}` : " USD"}`);
+				if (typeof payload.planName === "string") parts.push(`分组: ${payload.planName}`);
+				if (typeof payload.mode === "string") parts.push(`模式: ${payload.mode}`);
+				if (typeof payload.status === "string") parts.push(`状态: ${payload.status}`);
+				if (Array.isArray(payload.rate_limits)) parts.push(`限流: ${payload.rate_limits.map((r) => `${String(r.window ?? "")} ${String(r.used ?? 0)}/${String(r.limit ?? 0)}`).join(", ")}`);
+				const sub = payload.subscription;
+				if (sub !== undefined) parts.push(`订阅日/周/月: ${[
+					sub.daily_usage_usd,
+					sub.weekly_usage_usd,
+					sub.monthly_usage_usd
+				].map((v) => typeof v === "number" ? `$${v}` : "-").join(" / ")}`);
+				json(res, 200, {
+					ok: true,
+					summary: parts.length > 0 ? parts.join("；") : "该 key 无配额/余额信息（unrestricted 模式）"
+				});
+			} catch (error) {
+				json(res, 500, { error: safeMessage(error) });
+			}
+		});
+		register(ROUTES.status, async (req, res) => {
+			if (req.method !== "GET") return json(res, 405, { error: "method not allowed" });
+			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
+			const config = routes.config();
+			const models = {};
+			for (const def of PROVIDERS) if (config.providers[def.key].apiKeyEnv !== undefined) models[def.route] = config.providers[def.key].models?.map((m) => m.id) ?? [];
+			json(res, 200, {
+				routes: routes.listRegisteredRoutes(),
+				models
+			});
+		});
+		webCtx.effect(() => webCtx.webServer.register({
+			kind: "prefix",
+			path: ROUTES.attachment,
+			handler: async (req, res) => {
+				if (req.method !== "GET") return json(res, 405, { error: "method not allowed" });
+				if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
+				let ref;
+				try {
+					const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+					const raw = url.searchParams.get("ref") ?? "";
+					if (raw.length === 0) return json(res, 400, { error: "ref is required" });
+					const parsed = JSON.parse(Buffer.from(raw, "base64url").toString("utf8"));
+					if (typeof parsed !== "object" || parsed === null) throw new Error("ref must be an object");
+					const candidate = parsed;
+					if (typeof candidate.attachmentId !== "string" || typeof candidate.mediaType !== "string") throw new Error("ref is incomplete");
+					ref = candidate;
+				} catch {
+					return json(res, 400, { error: "invalid ref" });
+				}
+				const attachments = ctx.get("attachments");
+				if (attachments === undefined) return json(res, 503, { error: "attachment service unavailable" });
+				try {
+					const stored = await attachments.readImage(ref);
+					res.writeHead(200, {
+						"content-type": stored.ref.mediaType,
+						"cache-control": "private, max-age=86400",
+						"x-content-type-options": "nosniff"
+					});
+					res.end(Buffer.from(stored.data));
+				} catch {
+					json(res, 404, { error: "attachment not found" });
+				}
+			}
+		}));
+	});
+}
+
+//#endregion
+//#region src/image-tools.ts
+function getFs(ctx) {
+	return ctx.get("fs");
+}
+const GENERATE_IMAGE_NAME = "generate_image";
+const DEFAULT_IMAGE_TOOL_TIMEOUT_MS = 18e4;
+const DEFAULT_MAX_IMAGE_BYTES = 20971520;
+const GENERATE_SIZES = [
+	"auto",
+	"256x256",
+	"512x512",
+	"1024x1024",
+	"1024x1536",
+	"1536x1024",
+	"1024x1792",
+	"1792x1024"
+];
+const GENERATE_QUALITIES = [
+	"auto",
+	"low",
+	"medium",
+	"high",
+	"standard",
+	"hd"
+];
+const PROVIDER_LABELS = {
+	openai: "OpenAI",
+	claude: "Claude",
+	grok: "Grok"
+};
+function isProviderKey(value) {
+	return value === "openai" || value === "claude" || value === "grok";
+}
+function mediaTypeFromBytes(data) {
+	if (data.length >= 8 && data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71) return "image/png";
+	if (data.length >= 3 && data[0] === 255 && data[1] === 216 && data[2] === 255) return "image/jpeg";
+	if (data.length >= 6 && data[0] === 71 && data[1] === 73 && data[2] === 70) return "image/gif";
+	if (data.length >= 12 && data[0] === 82 && data[1] === 73 && data[2] === 70 && data[3] === 70 && data[8] === 87 && data[9] === 69 && data[10] === 66 && data[11] === 80) return "image/webp";
+	return "image/png";
+}
+function extensionForMediaType(mediaType) {
+	switch (mediaType) {
+		case "image/jpeg": return ".jpg";
+		case "image/webp": return ".webp";
+		case "image/gif": return ".gif";
+		default: return ".png";
+	}
+}
+function decodeDataUrl(value) {
+	const match = /^data:(image\/(?:png|jpeg|jpg|webp|gif));base64,([A-Za-z0-9+/=\s]+)$/i.exec(value.trim());
+	if (match === null) return undefined;
+	const declared = match[1].toLowerCase() === "image/jpg" ? "image/jpeg" : match[1].toLowerCase();
+	const mediaType = declared;
+	return {
+		mediaType,
+		data: Buffer.from(match[2], "base64")
+	};
+}
+function sessionCwd(exec) {
+	return exec.agent?.session.header.cwd;
+}
+function resolveToolModel(config, kind) {
+	const ref = config.tools?.[kind];
+	const label = "生图";
+	const provider = typeof ref?.provider === "string" ? ref.provider.trim() : "";
+	const model = typeof ref?.model === "string" ? ref.model.trim() : "";
+	if (provider.length === 0 || model.length === 0) throw new Error(`sub2api: 未配置${label}模型。打开设置 → Sub2API 模型，为「全局图像工具」指定一个模型后再试`);
+	if (!isProviderKey(provider)) throw new Error(`sub2api: ${label}模型的平台 "${provider}" 无效，应为 openai / claude / grok`);
+	const baseURL = config.baseURL.trim().replace(/\/+$/, "");
+	if (baseURL.length === 0) throw new Error("sub2api: baseURL is not configured");
+	const profile = config.providers[provider];
+	if (profile.apiKeyEnv === undefined) throw new Error(`sub2api: ${PROVIDER_LABELS[provider]} 未配置 API key，无法调用${label}模型`);
+	const catalogModel$1 = profile.models?.find((entry) => entry.id === model);
+	const api = apiProtocolForKey(provider, profile);
+	const endpointRoot = api === "anthropic-messages" ? gatewayAnthropicRoot(baseURL) : gatewayApiRoot(baseURL);
+	return {
+		route: `sub2api-${provider}`,
+		label: PROVIDER_LABELS[provider],
+		profile,
+		model,
+		baseURL: endpointRoot,
+		api,
+		maxTokens: catalogModel$1?.maxTokens ?? DEFAULT_MAX_TOKENS
+	};
+}
+async function readErrorDetail(response) {
+	try {
+		const parsed = await response.json();
+		const message = parsed.error?.message;
+		if (typeof message === "string" && message.length > 0) return message;
+	} catch {}
+	return `HTTP ${response.status}`;
+}
+async function gatewayFetch(host, resolved, path, body, signal, accept) {
+	const apiKey = await host.resolveApiKey(resolved.route, resolved.profile);
+	let response;
+	try {
+		response = await fetch(`${resolved.baseURL}${path}`, {
+			method: "POST",
+			headers: {
+				authorization: `Bearer ${apiKey}`,
+				"content-type": "application/json",
+				accept,
+				...attributionHeaders()
+			},
+			body: JSON.stringify(body),
+			signal
+		});
+	} catch (error) {
+		if (signal?.aborted) throw new LlmError$1("sub2api: request aborted", "ABORTED", { cause: error });
+		throw new LlmError$1(`sub2api: API request to ${resolved.baseURL}${path} failed`, "TRANSPORT", { cause: error });
+	}
+	if (!response.ok) throw new Error(`sub2api ${path}: ${await readErrorDetail(response)}`);
+	return response;
+}
+async function collectSseText(response) {
+	if (response.body === null) throw new Error("sub2api: API returned no response body");
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let text = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			while (true) {
+				const idx = buffer.indexOf("\n\n");
+				if (idx === -1) break;
+				const raw = buffer.slice(0, idx);
+				buffer = buffer.slice(idx + 2);
+				const dataLines = raw.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart());
+				if (dataLines.length === 0) continue;
+				const joined = dataLines.join("\n");
+				if (joined === "[DONE]") return text;
+				for (const line of dataLines) {
+					if (line === "[DONE]") return text;
+					let chunk;
+					try {
+						chunk = JSON.parse(line);
+					} catch {
+						continue;
+					}
+					for (const choice of chunk.choices ?? []) {
+						const delta = choice.delta?.content ?? choice.message?.content;
+						if (typeof delta === "string") text += delta;
+					}
+				}
+			}
+		}
+	} finally {
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
+	return text;
+}
+function flattenMessageContent(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.map((part) => {
+		if (typeof part === "string") return part;
+		if (typeof part !== "object" || part === null) return "";
+		const record = part;
+		if (typeof record.text === "string") return record.text;
+		return "";
+	}).join("");
+}
+async function collectChatText(response) {
+	const contentType = response.headers.get("content-type") ?? "";
+	if (contentType.includes("text/event-stream")) {
+		const text$1 = (await collectSseText(response)).trim();
+		if (text$1.length === 0) throw new Error("sub2api: image model returned no text");
+		return text$1;
+	}
+	const payload = await response.json();
+	const text = flattenMessageContent(payload.choices?.[0]?.message?.content).trim();
+	if (text.length === 0) throw new Error("sub2api: image model returned no text");
+	return text;
+}
+async function loadRemoteImage(url, signal, maxBytes) {
+	const encoded = decodeDataUrl(url);
+	if (encoded !== undefined) return encoded;
+	let response;
+	try {
+		response = await fetch(url, {
+			method: "GET",
+			signal,
+			redirect: "follow"
+		});
+	} catch (error) {
+		if (signal?.aborted) throw new LlmError$1("sub2api: request aborted", "ABORTED", { cause: error });
+		throw new Error(`sub2api: failed to download image URL: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (!response.ok) throw new Error(`sub2api: image URL returned HTTP ${response.status}`);
+	const buffer = new Uint8Array(await response.arrayBuffer());
+	if (buffer.byteLength > maxBytes) throw new Error(`sub2api: image URL exceeds ${maxBytes} bytes`);
+	const headerType = (response.headers.get("content-type") ?? "").split(";")[0]?.trim().toLowerCase();
+	const mediaType = headerType === "image/png" || headerType === "image/jpeg" || headerType === "image/webp" || headerType === "image/gif" ? headerType : mediaTypeFromBytes(buffer);
+	return {
+		mediaType,
+		data: buffer
+	};
+}
+function extractGeneratedImage(payload) {
+	if (typeof payload !== "object" || payload === null) return undefined;
+	const record = payload;
+	const items = Array.isArray(record.data) ? record.data : [];
+	for (const item of items) {
+		if (typeof item !== "object" || item === null) continue;
+		const row = item;
+		const revised = typeof row.revised_prompt === "string" ? row.revised_prompt : undefined;
+		if (typeof row.b64_json === "string" && row.b64_json.length > 0) {
+			const data = Buffer.from(row.b64_json, "base64");
+			return {
+				data,
+				mediaType: mediaTypeFromBytes(data),
+				...revised !== undefined ? { revisedPrompt: revised } : {}
+			};
+		}
+		if (typeof row.url === "string" && row.url.length > 0) {
+			if (row.url.startsWith("data:")) {
+				const decoded = decodeDataUrl(row.url);
+				if (decoded !== undefined) return {
+					...decoded,
+					...revised !== undefined ? { revisedPrompt: revised } : {}
+				};
+			}
+			return {
+				url: row.url,
+				...revised !== undefined ? { revisedPrompt: revised } : {}
+			};
+		}
+	}
+	return undefined;
+}
+function extractImageFromText(text) {
+	const dataMatch = /data:image\/(?:png|jpeg|jpg|webp|gif);base64,[A-Za-z0-9+/=\s]+/i.exec(text);
+	if (dataMatch !== null) {
+		const decoded = decodeDataUrl(dataMatch[0]);
+		if (decoded !== undefined) return {
+			kind: "data",
+			...decoded
+		};
+	}
+	const urlMatch = /https?:\/\/\S+\.(?:png|jpe?g|webp|gif)(?:\?\S*)?/i.exec(text);
+	if (urlMatch !== null) return {
+		kind: "url",
+		url: urlMatch[0].replace(/[),.;]+$/, "")
+	};
+	const markdown = /!\[[^\]]*]\((https?:\/\/[^)\s]+)\)/i.exec(text);
+	if (markdown !== null) return {
+		kind: "url",
+		url: markdown[1]
+	};
+	return undefined;
+}
+function defaultOutputName(mediaType) {
+	const stamp = new Date().toISOString().replace(/[:.]/g, "-").replace("T", "-").slice(0, 19);
+	return `generated-${stamp}${extensionForMediaType(mediaType)}`;
+}
+async function writeGeneratedFile(ctx, exec, requestedPath, data, mediaType) {
+	const fs = getFs(ctx);
+	if (fs === undefined) throw new Error("cannot write generated image: filesystem service is not mounted");
+	const cwd = sessionCwd(exec);
+	const rawPath = requestedPath !== undefined && requestedPath.trim().length > 0 ? requestedPath.trim() : defaultOutputName(mediaType);
+	const withExt = extname(rawPath).length === 0 ? `${rawPath}${extensionForMediaType(mediaType)}` : rawPath;
+	const target = await fs.resolve(withExt, {
+		...cwd !== undefined ? { cwd } : {},
+		signal: exec.signal
+	});
+	if (cwd !== undefined) {
+		const root = await fs.resolve(".", {
+			cwd,
+			signal: exec.signal
+		});
+		if (!fs.contains(root, target)) throw new Error(`generate_image can only write inside the session workspace; refused "${target.displayPath}"`);
+	}
+	const abs = fs.processPath(target);
+	await mkdir(dirname(abs), { recursive: true });
+	await writeFile(abs, data);
+	return target.displayPath;
+}
+async function generateViaImagesApi(host, resolved, args, signal, maxBytes) {
+	const response = await gatewayFetch(host, resolved, "/images/generations", {
+		model: resolved.model,
+		prompt: args.prompt,
+		n: 1,
+		response_format: "b64_json",
+		...args.size !== undefined && args.size !== "auto" ? { size: args.size } : {},
+		...args.quality !== undefined && args.quality !== "auto" ? { quality: args.quality } : {}
+	}, signal, "application/json");
+	const payload = await response.json();
+	const image = extractGeneratedImage(payload);
+	if (image === undefined) throw new Error("sub2api: image API returned no image data");
+	if (image.data !== undefined && image.mediaType !== undefined) return {
+		data: image.data,
+		mediaType: image.mediaType,
+		...image.revisedPrompt !== undefined ? { revisedPrompt: image.revisedPrompt } : {}
+	};
+	if (image.url !== undefined) {
+		const downloaded = await loadRemoteImage(image.url, signal, maxBytes);
+		return {
+			...downloaded,
+			...image.revisedPrompt !== undefined ? { revisedPrompt: image.revisedPrompt } : {}
+		};
+	}
+	throw new Error("sub2api: image API returned no image data");
+}
+async function generateViaChat(host, resolved, prompt, signal, maxBytes) {
+	const response = await gatewayFetch(host, resolved, "/chat/completions", {
+		model: resolved.model,
+		messages: [{
+			role: "user",
+			content: `Generate an image for this prompt and return the image itself (as a data URL or a direct image URL), not a description:\n\n${prompt}`
+		}],
+		stream: true,
+		stream_options: { include_usage: true }
+	}, signal, "text/event-stream");
+	const text = await collectChatText(response);
+	const extracted = extractImageFromText(text);
+	if (extracted === undefined) throw new Error(`sub2api: chat image model did not return image data. Response preview: ${text.slice(0, 240)}`);
+	if (extracted.kind === "data") return {
+		data: extracted.data,
+		mediaType: extracted.mediaType
+	};
+	return await loadRemoteImage(extracted.url, signal, maxBytes);
+}
+function registerImageTools(ctx, host) {
+	ctx.inject(["tools", "systemPrompt"], (toolCtx) => {
+		toolCtx.systemPrompt.section({
+			name: "tool:generate_image",
+			order: 119,
+			text: "Use the generate_image tool to create an image with the configured image model and write it to the workspace. Call it when the current chat model cannot generate images. The tool returns the saved file path, not the image bytes."
+		});
+		toolCtx.tools.register(defineTool({
+			name: GENERATE_IMAGE_NAME,
+			description: "Generate an image with the configured image model and write it to the workspace. Use this when the current chat model cannot generate images. Returns the saved file path.",
+			parameters: {
+				prompt: {
+					type: "string",
+					required: true,
+					description: "Image generation prompt."
+				},
+				file_path: {
+					type: "string",
+					description: "Workspace path to write. Defaults to generated-<timestamp>.png in the session cwd."
+				},
+				size: {
+					type: "string",
+					enum: [...GENERATE_SIZES],
+					description: "Requested size when the image API supports it."
+				},
+				quality: {
+					type: "string",
+					enum: [...GENERATE_QUALITIES],
+					description: "Requested quality when the image API supports it."
+				}
+			},
+			output: {
+				schema: {
+					type: "object",
+					additionalProperties: false,
+					properties: {
+						path: {
+							type: "string",
+							required: true
+						},
+						model: {
+							type: "string",
+							required: true
+						},
+						mediaType: {
+							type: "string",
+							required: true
+						},
+						bytes: {
+							type: "integer",
+							required: true
+						},
+						revisedPrompt: { type: "string" },
+						attachment: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								attachmentId: {
+									type: "string",
+									required: true
+								},
+								mediaType: {
+									type: "string",
+									required: true
+								},
+								bytes: {
+									type: "integer",
+									required: true
+								},
+								width: {
+									type: "integer",
+									required: true
+								},
+								height: {
+									type: "integer",
+									required: true
+								},
+								name: { type: "string" },
+								originalDimensions: {
+									type: "object",
+									additionalProperties: false,
+									properties: {
+										width: {
+											type: "integer",
+											required: true
+										},
+										height: {
+											type: "integer",
+											required: true
+										}
+									}
+								}
+							}
+						}
+					}
+				},
+				render: (_args, value) => {
+					const blocks = [];
+					const attachment = value.attachment;
+					if (attachment !== undefined && typeof attachment === "object" && attachment !== null) blocks.push({
+						type: "image",
+						attachment
+					});
+					blocks.push({
+						type: "text",
+						text: [
+							`<path>${value.path}</path>`,
+							"<type>image</type>",
+							"<content>",
+							`${value.mediaType}, ${value.bytes} bytes, model ${value.model}`,
+							value.revisedPrompt !== undefined ? `revised prompt: ${value.revisedPrompt}` : "",
+							"</content>"
+						].filter((line) => line.length > 0).join("\n")
+					});
+					return blocks;
+				}
+			},
+			timeoutMs: DEFAULT_IMAGE_TOOL_TIMEOUT_MS,
+			async execute(args, exec) {
+				const prompt = args.prompt.trim();
+				if (prompt.length === 0) throw new Error("prompt must be a non-empty string");
+				const resolved = resolveToolModel(host.config(), "generate");
+				const maxBytes = ctx.get("attachments")?.imageLimits.maxImageBytes ?? DEFAULT_MAX_IMAGE_BYTES;
+				let image;
+				try {
+					image = await generateViaImagesApi(host, resolved, {
+						prompt,
+						...args.size !== undefined ? { size: args.size } : {},
+						...args.quality !== undefined ? { quality: args.quality } : {}
+					}, exec.signal, maxBytes);
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					if (!/HTTP 404|HTTP 405|HTTP 501|not found|unknown endpoint|does not exist|not implemented/i.test(message)) throw error;
+					image = await generateViaChat(host, resolved, prompt, exec.signal, maxBytes);
+				}
+				const path = await writeGeneratedFile(ctx, exec, args.file_path, image.data, image.mediaType);
+				let attachment;
+				const attachmentStore = ctx.get("attachments");
+				if (attachmentStore !== undefined) try {
+					attachment = await attachmentStore.saveImage({
+						data: image.data,
+						mediaType: image.mediaType,
+						...path.length > 0 ? { name: basename(path) } : {}
+					});
+				} catch {
+					attachment = undefined;
+				}
+				return {
+					path,
+					model: `${resolved.route}/${resolved.model}`,
+					mediaType: image.mediaType,
+					bytes: image.data.byteLength,
+					...image.revisedPrompt !== undefined ? { revisedPrompt: image.revisedPrompt } : {},
+					...attachment !== undefined ? { attachment } : {}
+				};
+			},
+			presentCall(args) {
+				return {
+					card: "generic",
+					title: `Generate image${args.file_path !== undefined ? ` ${args.file_path}` : ""}`,
+					...args.file_path !== undefined ? { locations: [{ path: args.file_path }] } : {}
+				};
+			},
+			presentResult(_args, result) {
+				const imageBlock = result.content.find((b) => b.type === "image");
+				if (imageBlock !== undefined) return {
+					card: "generic",
+					content: [imageBlock]
+				};
+				const textBlock = result.content.find((b) => b.type === "text");
+				if (textBlock !== undefined && textBlock.type === "text") {
+					const pathLine = textBlock.text.match(/<path>(.*?)<\/path>/)?.[1];
+					if (pathLine !== undefined) return {
+						card: "generic",
+						content: [{
+							type: "text",
+							text: pathLine
+						}]
+					};
+				}
+				return undefined;
+			}
+		}));
+	});
+}
+
+//#endregion
+//#region src/pi-ai.ts
+const PI_AI_NS = "llm-pi-ai";
+const ROUTE_PREFIX = "sub2api-";
+/** pi-ai thinking levels a profile may declare (catalog `THINKING_LEVELS`). */
+const THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+/**
+* Request modalities a catalog model declares to the harness. An explicit
+* `input` wins; absent/empty falls back to a family guess — frontier
+* multimodal families accept images, everything else stays text-only (the
+* official harness posture: a hand-entered model is text-only until it says
+* otherwise).
+*/
+function catalogInputModalities(model) {
+	if (model.input !== undefined && model.input.length > 0) return [...model.input];
+	return /^(gpt|o[1-9]|claude|gemini|grok|glm|qwen|kimi|moonshot|minimax|mistral|llama|phi|command|jamba|codex|sora|veo|imagen|dall-e)/i.test(model.id) ? ["text", "image"] : ["text"];
+}
+/**
+* Map this plugin's reasoning-effort ids (OpenAI vocabulary — `none`,
+* `xhigh`, `max`, …) onto pi-ai's level keys. `none` is not a pi-ai level; it
+* becomes `off` with wire spelling `none`, which pi-ai dispatches as
+* `reasoning_effort: "none"` (chat/completions) or `reasoning:{effort:"none"}`
+* (responses) — exactly what this plugin used to send. An empty list declares
+* a non-reasoning model, as does a list containing only off/none; unmappable
+* ids are dropped.
+*/
+function translateReasoningEfforts(model) {
+	const ids = model.reasoningEfforts;
+	if (ids === undefined) {
+		if (/image/i.test(model.id)) return false;
+		return {
+			low: "low",
+			medium: "medium",
+			high: "high"
+		};
+	}
+	if (ids.length === 0) return false;
+	const efforts = {};
+	for (const id of ids) if (id === "none") efforts.off = "none";
+else if (THINKING_LEVELS.includes(id)) efforts[id] = id;
+	if (Object.keys(efforts).length === 0) return undefined;
+	return Object.keys(efforts).some((level) => level !== "off") ? efforts : false;
+}
+/** One configured catalog model, translated onto pi-ai's per-model fields. */
+function translateModel(model) {
+	const reasoningEfforts = translateReasoningEfforts(model);
+	return {
+		id: model.id,
+		...model.name !== undefined && model.name.length > 0 ? { name: model.name } : {},
+		...model.contextWindow !== undefined ? { contextWindow: model.contextWindow } : {},
+		...model.maxTokens !== undefined ? { maxTokens: model.maxTokens } : {},
+		input: catalogInputModalities(model),
+		...reasoningEfforts !== undefined ? { reasoningEfforts } : {}
+	};
+}
+/**
+* Translate one sub2api group into a hand-declared llm-pi-ai provider profile.
+* `apiKeyEnv` passes through verbatim (the harness resolves it per request
+* through `ctx.credentials`); routes without a key are skipped by the caller.
+*
+* The settings store the bare gateway host; the protocols join it differently.
+* OpenAI-compatible SDKs append their endpoint to the `/v1` API root, while
+* `@anthropic-ai/sdk` treats the given URL as the bare host and appends
+* `/v1/messages` itself — so OpenAI-style routes get the `/v1`-rooted URL and
+* the anthropic route gets the bare host.
+*/
+function translateProfile(key, profile, baseURL, label) {
+	const api = apiProtocolForKey(key, profile);
+	return {
+		...profile.apiKeyEnv !== undefined ? { apiKeyEnv: profile.apiKeyEnv } : {},
+		displayName: `Sub2API ${label}`,
+		api,
+		baseURL: api === "anthropic-messages" ? gatewayAnthropicRoot(baseURL) : gatewayApiRoot(baseURL),
+		models: (profile.models ?? []).map(translateModel),
+		defaultContextWindow: DEFAULT_CONTEXT_WINDOW,
+		defaultMaxTokens: DEFAULT_MAX_TOKENS,
+		defaultInput: ["text"],
+		retryPolicy: {
+			mode: "normal",
+			maxRetries: 5,
+			retryableCodes: [
+				"RATE_LIMIT",
+				"SERVER",
+				"TIMEOUT",
+				"TRANSPORT",
+				"EMPTY_RESPONSE"
+			],
+			backoff: {
+				initialDelayMs: 1e3,
+				maxDelayMs: 12e4,
+				jitterRatio: .2
+			}
+		}
+	};
+}
+function translateToPiAi(config) {
+	const baseURL = (config.baseURL ?? "").trim().replace(/\/+$/, "");
+	if (baseURL.length === 0) return {};
+	const profiles = {};
+	for (const def of PROVIDERS) {
+		const profile = config.providers[def.key];
+		if (profile.apiKeyEnv === undefined) continue;
+		const models = (profile.models ?? []).filter((model) => model.id.length > 0);
+		if (models.length === 0) continue;
+		profiles[def.route] = translateProfile(def.key, {
+			...profile,
+			models
+		}, baseURL, def.label);
+	}
+	return profiles;
+}
+async function syncPiAiProfiles(ctx, config) {
+	const settings = ctx.get("settings");
+	if (settings === undefined) return;
+	const current = settings.describe().find((section) => section.ns === PI_AI_NS)?.value;
+	const providers = { ...current?.providers ?? {} };
+	for (const route of Object.keys(providers)) if (route.startsWith(ROUTE_PREFIX)) delete providers[route];
+	Object.assign(providers, translateToPiAi(config));
+	const next = { providers };
+	const before = JSON.stringify(current?.providers ?? {});
+	if (JSON.stringify(providers) === before) return;
+	await settings.replace(PI_AI_NS, next);
+}
+
+//#endregion
+//#region src/pi-ai-patch.ts
+/** Guard marker; its presence means the patch is already applied. */
+const MARKER = "assistant.usage !== undefined";
+/** The exact upstream expression this patch guards. */
+const TARGET = "calculateContextTokens(assistant.usage) > 0";
+/** Candidate locations of the pi-ai estimate module inside a dsh install. */
+function candidateEstimatePaths() {
+	const roots = new Set();
+	const global = spawnSync("npm", ["root", "-g"], {
+		encoding: "utf8",
+		windowsHide: true
+	});
+	if (global.status === 0 && global.stdout.trim().length > 0) roots.add(global.stdout.trim());
+	if (process.env.npm_config_prefix !== undefined) roots.add(join(process.env.npm_config_prefix, "lib", "node_modules"));
+	roots.add(join(homedir(), ".npm-global", "lib", "node_modules"));
+	const dshHome = process.env.DSH_HOME !== undefined ? process.env.DSH_HOME : join(homedir(), ".dsh");
+	const paths = [];
+	for (const root of roots) {
+		paths.push(join(root, "@deepseek-ai", "dsh", "node_modules", "@earendil-works", "pi-ai", "dist", "utils", "estimate.js"));
+		paths.push(join(root, "@deepseek-ai", "dsh", "node_modules", "@deepseek-ai", "dsh-llm-pi-ai", "node_modules", "@earendil-works", "pi-ai", "dist", "utils", "estimate.js"));
+	}
+	paths.push(join(dshHome, "profiles", "web", "node_modules", "@deepseek-ai", "dsh-llm-pi-ai", "node_modules", "@earendil-works", "pi-ai", "dist", "utils", "estimate.js"));
+	return paths;
+}
+function applyPiAiMultiTurnPatch() {
+	const file = candidateEstimatePaths().find((candidate) => existsSync(candidate));
+	if (file === undefined) return {
+		kind: "skipped",
+		reason: "pi-ai estimate.js not found under the dsh install"
+	};
+	let source;
+	try {
+		source = readFileSync(file, "utf8");
+	} catch (error) {
+		return {
+			kind: "skipped",
+			reason: `cannot read ${file}: ${String(error)}`
+		};
+	}
+	if (source.includes(MARKER)) return {
+		kind: "already",
+		file
+	};
+	const index = source.indexOf(TARGET);
+	if (index === -1) return {
+		kind: "skipped",
+		reason: `target pattern not found in ${file} (pi-ai layout changed?)`
+	};
+	const lineStart = source.lastIndexOf("\n", index) + 1;
+	const indent = source.slice(lineStart, index).match(/^[ \t]*/)?.[0] ?? "";
+	const replacement = `${MARKER} &&\n${indent}${TARGET}`;
+	const next = source.slice(0, index) + replacement + source.slice(index + TARGET.length);
+	try {
+		writeFileSync(file, next);
+	} catch (error) {
+		return {
+			kind: "skipped",
+			reason: `cannot write ${file}: ${String(error)}`
+		};
+	}
+	return {
+		kind: "patched",
+		file
+	};
+}
+
+//#endregion
+//#region src/index.ts
+const name = "llm-sub2api";
+const inject = [
+	"llm",
+	"settings",
+	"credentials"
+];
+const NS = "llm-sub2api";
+const DEFAULT_CONTEXT_WINDOW = 128e3;
+const DEFAULT_MAX_TOKENS = 8192;
+const REASONING_EFFORTS = [
+	{
+		id: "low",
+		name: "Low"
+	},
+	{
+		id: "medium",
+		name: "Medium"
+	},
+	{
+		id: "high",
+		name: "High"
+	}
+];
+const PROVIDERS = [
+	{
+		key: "openai",
+		route: "sub2api-openai",
+		label: "OpenAI",
+		icon: "openai"
+	},
+	{
+		key: "claude",
+		route: "sub2api-claude",
+		label: "Claude",
+		icon: "claude"
+	},
+	{
+		key: "grok",
+		route: "sub2api-grok",
+		label: "Grok",
+		icon: "grok"
+	}
+];
+function readConfig(config) {
+	return {
+		baseURL: config.baseURL.get(),
+		providers: structuredClone(config.providers.get()),
+		tools: structuredClone(config.tools.get())
+	};
+}
+const catalogModel = z.object({
+	id: z.string().required(),
+	name: z.string(),
+	contextWindow: z.number().step(1).min(1),
+	maxTokens: z.number().step(1).min(1),
+	input: z.array(z.union([z.const("text"), z.const("image")])).default([]),
+	reasoningEfforts: z.array(z.string()).default(REASONING_EFFORTS.map((effort) => effort.id))
+});
+const apiProtocol = z.union([
+	z.const("openai-completions"),
+	z.const("openai-responses"),
+	z.const("anthropic-messages")
+]);
+const providerProfile = z.object({
+	apiKeyEnv: z.string().role("credential-ref"),
+	api: apiProtocol,
+	models: z.array(catalogModel)
+});
+const imageToolModelRef = z.object({
+	provider: z.string(),
+	model: z.string()
+});
+const Config = z.object({
+	baseURL: z.string().default("").volatile(),
+	providers: z.object({
+		openai: providerProfile,
+		claude: providerProfile,
+		grok: providerProfile
+	}).default({}).volatile(),
+	tools: z.object({ generate: imageToolModelRef }).default({}).volatile()
+});
+const API_PROTOCOLS = [
+	"openai-completions",
+	"openai-responses",
+	"anthropic-messages"
+];
+/**
+* The wire protocol each sub2api platform group speaks natively at the
+* gateway. Openai groups are served upstream through the Responses API and
+* Claude groups through the Messages API; grok groups are
+* chat-completions. Speaking the native protocol avoids the gateway's
+* chat/completions ↔ native conversion, which drops/misaligns tool-call
+* names and ids for parallel calls. A provider profile may override.
+*/
+const DEFAULT_PROTOCOL = {
+	openai: "openai-responses",
+	claude: "anthropic-messages",
+	grok: "openai-completions"
+};
+function apiProtocolForKey(key, profile) {
+	return profile.api ?? DEFAULT_PROTOCOL[key];
+}
+function gatewayApiRoot(baseURL) {
+	const cleaned = (baseURL ?? "").trim().replace(/\/+$/, "");
+	if (cleaned.length === 0) return "";
+	return /\/v1$/i.test(cleaned) ? cleaned : `${cleaned}/v1`;
+}
+function gatewayAnthropicRoot(baseURL) {
+	return gatewayApiRoot(baseURL).replace(/\/v1$/i, "");
+}
+function resolveAdapterOptions(config) {
+	const baseURL = (config.baseURL ?? "").trim().replace(/\/+$/, "");
+	if (baseURL.length > 0 && !/^https?:\/\//.test(baseURL)) throw new Error("llm-sub2api: baseURL must start with http(s)://");
+	return { baseURL };
+}
+function apply(ctx, config) {
+	const current = () => readConfig(config);
+	const namespace = ctx.fiber.entry?.options.id ?? NS;
+	resolveAdapterOptions(current());
+	ctx.effect(() => ctx.settings.configure({ auto: false }));
+	const resolveApiKey = async (route, profile) => {
+		if (profile.apiKeyEnv === undefined) throw new LlmError(`sub2api: no API key configured for route "${route}"`, "MISSING_CREDENTIAL");
+		const ref = credentialRef(profile.apiKeyEnv);
+		const credentials = ctx.get("credentials");
+		const hit = credentials !== undefined ? await credentials.resolve(ref) : undefined;
+		if (hit !== undefined && hit.value.length > 0) return assertUsableApiKey(hit.value, "llm-sub2api", ref);
+		throw new LlmError(`sub2api: no credential for provider route "${route}"; its profile resolves ${profile.apiKeyEnv}, which is not set — store it through the credentials service (the web Models page writes it) or export it`, "MISSING_CREDENTIAL");
+	};
+	const syncPiAi = () => {
+		syncPiAiProfiles(ctx, current()).catch((error) => {
+			ctx.logger.error("llm-sub2api: refused to update llm-pi-ai profiles; keeping the previously registered routes");
+			ctx.logger.error(error);
+		});
+	};
+	registerRoutes(ctx, {
+		config: () => current(),
+		setConfig: async (next) => {
+			resolveAdapterOptions(next);
+			await ctx.settings.replace(namespace, next);
+			await syncPiAiProfiles(ctx, current());
+		},
+		listRegisteredRoutes: () => ctx.llm.listProviders().map((info) => info.id).filter((route) => route.startsWith("sub2api-")),
+		resolveApiKey
+	});
+	registerImageTools(ctx, {
+		config: () => current(),
+		resolveApiKey
+	});
+	syncPiAi();
+	ctx.on("loader/volatile-update", syncPiAi);
+}
+
+//#endregion
+export { API_PROTOCOLS, Config, DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_TOKENS, PI_AI_NS, PROVIDERS, REASONING_EFFORTS, ROUTE_PREFIX, apiProtocolForKey, apply, applyPiAiMultiTurnPatch, gatewayAnthropicRoot, gatewayApiRoot, inject, name, readConfig, syncPiAiProfiles, translateToPiAi };