@dsh-plus/image-studio 0.1.0

package/lib/index.js

@@ -0,0 +1,1304 @@
+import z from "@deepseek-ai/schemastery";
+import { Service } from "@deepseek-ai/cordis";
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { request } from "node:http";
+import { request as request$1 } from "node:https";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { pluginDataPath } from "@dsh-plus/shared";
+//#endregion
+//#region src/config.ts
+/**
+* 配置单一事实源：cordis 行级 Config（组合默认）与 settings namespace
+* （用户层，$DSH_HOME/settings.yaml 热生效）共用同一 schemastery schema。
+* 三组纯用户配置：提示词预设 / 参数预设 / 提供商预设（API key 不在此，
+* 走 credentials，引用名由 preset id 派生）。
+* @module image-studio/config
+*/
+/** settings 命名空间（字面量即合法命名空间，编译期校验）。 */
+const SETTINGS_NS = "dsh-plus-image-studio";
+const PromptPreset = z.object({
+	id: z.string().required().description("预设 id（稳定标识，删除级联引用）"),
+	name: z.string().required().description("预设名称"),
+	text: z.string().required().description("提示词模板")
+});
+const ParamPreset = z.object({
+	id: z.string().required().description("预设 id"),
+	name: z.string().required().description("预设名称"),
+	endpoint: z.string().required().description("适用端点：generation | edit"),
+	/** 参数表结构由 params/spec 校验，settings 层存原始 JSON。 */
+	paramSpecs: z.any().required().description("参数开关表（ParamSpecMap JSON）")
+});
+const ProviderPreset = z.object({
+	id: z.string().required().description("预设 id"),
+	name: z.string().required().description("预设名称"),
+	protocol: z.string().required().description("协议 id（如 openai-images）"),
+	baseUrl: z.string().required().description("API 基础地址（含 /v1）"),
+	model: z.string().required().description("模型 id"),
+	credentialRef: z.string().required().description("凭据引用名（IMAGE_STUDIO_PRESET_*）"),
+	extraHeaders: z.dict(z.string()).description("附加请求头（部分中转需要）").default({})
+});
+const Config = z.object({
+	promptPresets: z.array(PromptPreset).description("提示词预设").default([]),
+	paramPresets: z.array(ParamPreset).description("参数预设").default([]),
+	providerPresets: z.array(ProviderPreset).description("提供商预设").default([]),
+	maxConcurrent: z.number().min(0).max(16).description("生图任务并发上限（0 = 不限）").default(3),
+	requestTimeoutMs: z.number().min(1e4).max(6e5).description("单请求超时（毫秒；生图长耗时，默认 5 分钟）").default(3e5),
+	proxy: z.string().description("上游请求代理（空 = 直连）").default(""),
+	galleryMaxItems: z.number().min(0).max(1e4).description("画廊保留上限（条，0 = 不清理；超限按最旧删除）").default(500)
+});
+//#endregion
+//#region src/errors.ts
+var ImageStudioError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message ?? code);
+		this.name = "ImageStudioError";
+		this.code = code;
+	}
+};
+/** 按错误码映射 HTTP 状态（端点边界统一使用）。 */
+function statusOfCode(code) {
+	switch (code) {
+		case "unknown-protocol":
+		case "unknown-endpoint":
+		case "invalid-request":
+		case "unknown-source":
+		case "unknown-task":
+		case "task-not-runnable": return 400;
+		case "credential-unavailable":
+		case "settings-unavailable": return 409;
+		default: return 500;
+	}
+}
+/** 只读目录（冻结防运行期篡改）。 */
+const PARAM_CATALOG = Object.freeze([
+	{
+		key: "model",
+		kind: "string",
+		applies: ["generation", "edit"],
+		generation: "all",
+		advanced: false,
+		description: "图像模型 id；请求基础来自提供商预设，此处仅作展示与 inline 覆盖"
+	},
+	{
+		key: "n",
+		kind: "integer",
+		min: 1,
+		max: 10,
+		applies: ["generation", "edit"],
+		generation: "current",
+		advanced: false,
+		description: "生成张数（1-10；部分中转仅支持 1）"
+	},
+	{
+		key: "size",
+		kind: "string",
+		applies: ["generation", "edit"],
+		generation: "current",
+		advanced: false,
+		description: "尺寸，如 1024x1024 / 1536x1024 / 1024x1536 / auto；宽高需为 16 的倍数、最大边 ≤3840、比例 ≤3:1（依模型限制）"
+	},
+	{
+		key: "quality",
+		kind: "enum",
+		values: [
+			"auto",
+			"low",
+			"medium",
+			"high"
+		],
+		applies: ["generation", "edit"],
+		generation: "current",
+		advanced: false,
+		description: "质量档位"
+	},
+	{
+		key: "background",
+		kind: "enum",
+		values: [
+			"auto",
+			"transparent",
+			"opaque"
+		],
+		applies: ["generation", "edit"],
+		generation: "current",
+		advanced: false,
+		description: "输出背景透明行为（对提示词里的场景背景无影响）"
+	},
+	{
+		key: "output_format",
+		kind: "enum",
+		values: [
+			"png",
+			"jpeg",
+			"webp"
+		],
+		applies: ["generation", "edit"],
+		generation: "current",
+		advanced: false,
+		description: "输出格式（部分中转不支持 webp）"
+	},
+	{
+		key: "output_compression",
+		kind: "integer",
+		min: 0,
+		max: 100,
+		applies: ["generation", "edit"],
+		generation: "current",
+		advanced: true,
+		description: "压缩率 0-100，仅 jpeg/webp 有效"
+	},
+	{
+		key: "moderation",
+		kind: "enum",
+		values: ["auto", "low"],
+		applies: ["generation", "edit"],
+		generation: "current",
+		advanced: true,
+		description: "内容审核严格度"
+	},
+	{
+		key: "response_format",
+		kind: "enum",
+		values: ["url", "b64_json"],
+		applies: ["generation", "edit"],
+		generation: "all",
+		advanced: false,
+		description: "返回形式；插件两种都会落盘本地化，画廊不受外链过期影响"
+	},
+	{
+		key: "stream",
+		kind: "boolean",
+		applies: ["generation", "edit"],
+		generation: "current",
+		advanced: true,
+		description: "流式返回（多数中转不支持，默认关闭）"
+	},
+	{
+		key: "partial_images",
+		kind: "integer",
+		min: 0,
+		max: 3,
+		applies: ["generation", "edit"],
+		generation: "current",
+		advanced: true,
+		description: "流式中间图数量（依赖 stream，默认关闭）"
+	},
+	{
+		key: "user",
+		kind: "string",
+		applies: ["generation", "edit"],
+		generation: "all",
+		advanced: true,
+		description: "终端用户标识（业务归因用）"
+	},
+	{
+		key: "input_fidelity",
+		kind: "enum",
+		values: ["low", "high"],
+		applies: ["edit"],
+		generation: "current",
+		advanced: false,
+		description: "图生图输入保真度（high 更保留原图细节，token 消耗增大）"
+	},
+	{
+		key: "style",
+		kind: "enum",
+		values: ["vivid", "natural"],
+		applies: ["generation"],
+		generation: "dall-e-3",
+		advanced: true,
+		description: "dall-e-3 代际风格参数（GPT Image 不需要）"
+	}
+].map((entry) => Object.freeze(entry)));
+/** 按字段名查目录条目。 */
+function paramEntryOf(key) {
+	return PARAM_CATALOG.find((entry) => entry.key === key) ?? null;
+}
+/** 某端点下可用的参数键集合（含 advanced）。 */
+function paramKeysFor(endpoint) {
+	return PARAM_CATALOG.filter((entry) => entry.applies.includes(endpoint)).map((entry) => entry.key);
+}
+//#endregion
+//#region src/params/spec.ts
+/** 归一化失败原因（边界校验用，端点转 invalid-request）。 */
+var ParamValidationError = class extends Error {
+	key;
+	constructor(key, message) {
+		super(`参数 ${key} ${message}`);
+		this.name = "ParamValidationError";
+		this.key = key;
+	}
+};
+/** 校验单个值符合目录条目约束；返回规范值。 */
+function validateParamValue(key, value) {
+	const entry = paramEntryOf(key);
+	if (entry === null) throw new ParamValidationError(key, "不在参数目录中");
+	switch (entry.kind) {
+		case "string":
+			if (typeof value !== "string" || value.length === 0) throw new ParamValidationError(key, "必须是非空字符串");
+			return value;
+		case "enum":
+			if (typeof value !== "string" || !entry.values?.includes(value)) throw new ParamValidationError(key, `必须是 ${entry.values?.join(" | ") ?? "枚举值"} 之一`);
+			return value;
+		case "integer":
+			if (typeof value !== "number" || !Number.isInteger(value)) throw new ParamValidationError(key, "必须是整数");
+			if (entry.min !== void 0 && value < entry.min) throw new ParamValidationError(key, `不能小于 ${entry.min}`);
+			if (entry.max !== void 0 && value > entry.max) throw new ParamValidationError(key, `不能大于 ${entry.max}`);
+			return value;
+		case "boolean":
+			if (typeof value !== "boolean") throw new ParamValidationError(key, "必须是布尔值");
+			return value;
+	}
+}
+/**
+* 校验并归一化一份参数表：仅保留启用且适用于该端点的参数；
+* model 是请求基础（提供商预设承载），不计入协议参数表。
+* 任何禁用/未知/越界项直接抛 ParamValidationError（边界 fail-loud）。
+*/
+function normalizeParamSpecs(specs, endpoint) {
+	const out = {};
+	for (const [key, spec] of Object.entries(specs)) {
+		if (!spec?.enabled) continue;
+		if (key === "model") continue;
+		const entry = paramEntryOf(key);
+		if (entry === null) throw new ParamValidationError(key, "不在参数目录中");
+		if (!entry.applies.includes(endpoint)) throw new ParamValidationError(key, `不适用于 ${endpoint} 端点`);
+		out[key] = validateParamValue(key, spec.value);
+	}
+	return out;
+}
+/** 校验预设里的参数表（结构合法但可跨端点；应用时再按端点归一化）。 */
+function validateParamSpecs(specs) {
+	if (specs === null || typeof specs !== "object" || Array.isArray(specs)) throw new ParamValidationError("(整体)", "必须是对象");
+	const out = {};
+	for (const [key, raw] of Object.entries(specs)) {
+		if (raw === null || typeof raw !== "object") throw new ParamValidationError(key, "条目必须是 { enabled, value? }");
+		const spec = raw;
+		if (typeof spec.enabled !== "boolean") throw new ParamValidationError(key, "enabled 必须是布尔值");
+		if (paramEntryOf(key) === null) throw new ParamValidationError(key, "不在参数目录中");
+		const item = { enabled: spec.enabled };
+		if (spec.value !== void 0) item.value = validateParamValue(key, spec.value);
+		out[key] = item;
+	}
+	return out;
+}
+//#endregion
+//#region src/provider/types.ts
+/** 适配器向上抛的结构化错误：HTTP 状态 + 上游响应摘要。 */
+var ProviderError = class extends Error {
+	status;
+	upstreamBody;
+	constructor(status, upstreamBody, message) {
+		super(message ?? `上游返回 HTTP ${status}`);
+		this.name = "ProviderError";
+		this.status = status;
+		this.upstreamBody = upstreamBody;
+	}
+};
+//#endregion
+//#region src/provider/openai-images.ts
+/**
+* OpenAI Images API 适配器（首批协议实现）。
+* - 请求构造是纯函数（单测覆盖 JSON/multipart 两种形态）；
+* - 执行走 node:http(s)，https 目标代理经 https-proxy-agent（与 llm-pi 同约定）；
+* - 响应统一取回字节（url → 下载 / b64_json → 解码），调用方零二次请求。
+* 开发测试指向本地 mock，严禁真实调用产生费用。
+* @module image-studio/provider/openai-images
+*/
+/** 顶层响应体上限（4K PNG 约 10-20MB，放宽到 64MB 防滥用）。 */
+const MAX_RESPONSE_BYTES = 67108864;
+const MIME_BY_FORMAT = {
+	png: "image/png",
+	jpeg: "image/jpeg",
+	webp: "image/webp"
+};
+/** output_format 参数值 → MIME（b64 结果无 content-type 时兜底）。 */
+function mimeOfFormat(format) {
+	return MIME_BY_FORMAT[format] ?? "image/png";
+}
+/** 官方端点路径。 */
+function endpointPath(endpoint) {
+	return endpoint === "generation" ? "/images/generations" : "/images/edits";
+}
+/** 公共请求头（鉴权 + 用户附加头）。 */
+function baseHeaders(apiKey, extra) {
+	return {
+		authorization: `Bearer ${apiKey}`,
+		...extra
+	};
+}
+/** multipart 文本字段分片。 */
+function formField(name, value) {
+	return `--BOUNDARY\r\ncontent-disposition: form-data; name="${name}"\r\n\r\n${value}\r\n`;
+}
+/** multipart 文件分片头。 */
+function formFileHead(name, index, file) {
+	return `--BOUNDARY\r\ncontent-disposition: form-data; name="${name}"; filename="${name}-${index}.${file.mime.split("/")[1] ?? "png"}"\r\ncontent-type: ${file.mime}\r\n\r\n`;
+}
+/** 构造 generations JSON 请求体（纯函数；params 已由 spec 层裁剪）。 */
+function buildGenerationBody(request) {
+	return JSON.stringify({
+		prompt: request.prompt,
+		n: request.n,
+		...request.params
+	});
+}
+/** 构造 edits multipart 请求体（纯函数；image 官方上限 ≤16 张由边界校验）。 */
+function buildEditBody(request) {
+	const chunks = [];
+	const pushText = (text) => chunks.push(Buffer.from(text, "utf8"));
+	pushText(formField("prompt", request.prompt));
+	pushText(formField("n", String(request.n)));
+	for (const [key, value] of Object.entries(request.params)) pushText(formField(key, String(value)));
+	request.images.forEach((file, index) => {
+		pushText(formFileHead("image", index, file));
+		chunks.push(Buffer.from(file.data), Buffer.from("\r\n", "utf8"));
+	});
+	if (request.mask !== null) {
+		pushText(formFileHead("mask", 0, request.mask));
+		chunks.push(Buffer.from(request.mask.data), Buffer.from("\r\n", "utf8"));
+	}
+	chunks.push(Buffer.from("--BOUNDARY--\r\n", "utf8"));
+	return {
+		headers: { "content-type": "multipart/form-data; boundary=BOUNDARY" },
+		body: Buffer.concat(chunks)
+	};
+}
+/** 收集响应体（带字节上限；流错误结算防悬挂）。 */
+function collect(req, response, done, fail) {
+	const chunks = [];
+	let size = 0;
+	response.on("data", (chunk) => {
+		size += chunk.length;
+		if (size <= MAX_RESPONSE_BYTES) {
+			chunks.push(chunk);
+			return;
+		}
+		response.destroy(/* @__PURE__ */ new Error("响应超过 64MB 上限"));
+	});
+	response.on("end", () => done({
+		status: response.statusCode ?? 0,
+		contentType: response.headers["content-type"]?.split(";")[0] ?? "",
+		body: Buffer.concat(chunks)
+	}));
+	response.on("error", fail);
+	req.on("error", fail);
+}
+/** HTTP(S) POST/GET 执行：代理 + 超时 + AbortSignal 贯穿。 */
+function execRequest(url, options) {
+	return new Promise((resolve, reject) => {
+		const target = new URL(url);
+		const doRequest = target.protocol === "https:" ? request$1 : request;
+		const agent = target.protocol === "https:" && options.proxy.length > 0 ? new HttpsProxyAgent(options.proxy) : void 0;
+		let settled = false;
+		const fail = (error) => {
+			if (settled) return;
+			settled = true;
+			reject(error);
+		};
+		const done = (reply) => {
+			if (settled) return;
+			settled = true;
+			resolve(reply);
+		};
+		const req = doRequest(url, {
+			method: options.method,
+			headers: options.headers,
+			timeout: options.timeoutMs,
+			agent,
+			signal: options.signal
+		}, (response) => collect(req, response, done, fail));
+		req.on("timeout", () => req.destroy(/* @__PURE__ */ new Error(`请求超时（${options.timeoutMs}ms）`)));
+		req.on("error", fail);
+		req.end(options.body ?? Buffer.alloc(0));
+	});
+}
+/** url 形式结果图下载（同代理/超时策略；MIME 取响应头）。 */
+async function fetchImageBytes(url, proxy, timeoutMs, signal) {
+	const reply = await execRequest(url, {
+		method: "GET",
+		headers: {},
+		proxy,
+		timeoutMs,
+		signal
+	});
+	if (reply.status !== 200) throw new ProviderError(reply.status, "", `结果图下载失败（HTTP ${reply.status}）`);
+	return {
+		data: new Uint8Array(reply.body),
+		mime: reply.contentType || "image/png"
+	};
+}
+/** 解析响应体为结果图列表（url 下载 / b64 解码统一为字节）。 */
+async function parseImagesReply(bodyText, fallbackMime, proxy, timeoutMs, signal) {
+	let doc;
+	try {
+		doc = JSON.parse(bodyText);
+	} catch {
+		throw new ProviderError(502, bodyText.slice(0, 500), "上游响应不是合法 JSON");
+	}
+	const images = [];
+	for (const item of doc.data ?? []) {
+		if (typeof item.b64_json === "string" && item.b64_json.length > 0) {
+			images.push({
+				data: new Uint8Array(Buffer.from(item.b64_json, "base64")),
+				mime: fallbackMime,
+				revisedPrompt: item.revised_prompt ?? null
+			});
+			continue;
+		}
+		if (typeof item.url === "string" && item.url.length > 0) {
+			const fetched = await fetchImageBytes(item.url, proxy, timeoutMs, signal);
+			images.push({
+				...fetched,
+				revisedPrompt: item.revised_prompt ?? null
+			});
+		}
+	}
+	if (images.length === 0) throw new ProviderError(502, bodyText.slice(0, 500), "上游未返回任何图片");
+	return {
+		images,
+		createdAt: typeof doc.created === "number" ? doc.created : null
+	};
+}
+/** 适配器主入口：构造请求 → 执行 → 解析。 */
+async function generateViaOpenAIImages(request, signal) {
+	const { target } = request;
+	const url = `${target.baseUrl.replace(/\/+$/, "")}${endpointPath(request.endpoint)}`;
+	const fallbackMime = mimeOfFormat(request.params.output_format);
+	const reply = request.endpoint === "generation" ? await execRequest(url, {
+		method: "POST",
+		headers: {
+			...baseHeaders(target.apiKey, target.extraHeaders),
+			"content-type": "application/json"
+		},
+		body: Buffer.from(buildGenerationBody(request), "utf8"),
+		proxy: target.proxy,
+		timeoutMs: target.timeoutMs,
+		signal
+	}) : await execRequest(url, {
+		method: "POST",
+		headers: baseHeaders(target.apiKey, {
+			...target.extraHeaders,
+			...buildEditBody(request).headers
+		}),
+		body: buildEditBody(request).body,
+		proxy: target.proxy,
+		timeoutMs: target.timeoutMs,
+		signal
+	});
+	if (reply.status !== 200) throw new ProviderError(reply.status, reply.body.toString("utf8").slice(0, 2e3));
+	return parseImagesReply(reply.body.toString("utf8"), fallbackMime, target.proxy, target.timeoutMs, signal);
+}
+//#endregion
+//#region src/provider/registry.ts
+/**
+* 协议注册表：协议 id → 适配器构造。封闭集合 + 统一注册入口，
+* 新增协议（如 gemini、stable-diffusion 等）只增注册不改核心。
+* @module image-studio/provider/registry
+*/
+const PROTOCOLS = Object.freeze([{
+	id: "openai-images",
+	label: "OpenAI Images API",
+	endpoints: ["generation", "edit"],
+	generate: generateViaOpenAIImages
+}]);
+/** 全部已注册协议（前端下拉依据）。 */
+function listProtocols() {
+	return PROTOCOLS.map(({ id, label, endpoints }) => ({
+		id,
+		label,
+		endpoints
+	}));
+}
+/** 按协议 id 查条目；未知协议抛结构化错误。 */
+function protocolOf(id) {
+	const found = PROTOCOLS.find((entry) => entry.id === id);
+	if (found === void 0) throw new ImageStudioError("unknown-protocol", `未知协议：${id}`);
+	return found;
+}
+/** 构造适配器（当前实现无状态，直接包一层满足 ImageProvider 契约）。 */
+function createProvider(id) {
+	const entry = protocolOf(id);
+	return {
+		id: entry.id,
+		endpoints: entry.endpoints,
+		generate: (request, signal) => entry.generate(request, signal)
+	};
+}
+//#endregion
+//#region src/api.ts
+const ROUTE_PREFIX = "/dsh-plus/image-studio";
+function sendJson(res, status, body) {
+	res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+	res.end(JSON.stringify(body));
+}
+function readBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (chunk) => chunks.push(chunk));
+		req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+		req.on("error", reject);
+	});
+}
+/** 统一错误结算：ImageStudioError/ParamValidationError 按码映射，其余 500。 */
+function sendError(res, error) {
+	if (error instanceof ImageStudioError) {
+		sendJson(res, statusOfCode(error.code), {
+			error: error.code,
+			message: error.message
+		});
+		return;
+	}
+	if (error instanceof ParamValidationError) {
+		sendJson(res, 400, {
+			error: "invalid-request",
+			message: error.message
+		});
+		return;
+	}
+	sendJson(res, 500, {
+		error: "internal",
+		message: error instanceof Error ? error.message : String(error)
+	});
+}
+function buildHandlers(service) {
+	return {
+		async generate(_req, res, rest) {
+			if (rest !== "") throw new ImageStudioError("invalid-request", "未知路径");
+			if (method(_req) !== "POST") {
+				sendJson(res, 405, { error: "POST only" });
+				return;
+			}
+			const body = JSON.parse(await readBody(_req));
+			sendJson(res, 202, { taskId: await service.submitGenerate(body) });
+		},
+		async tasks(_req, res, rest) {
+			if (rest === "") {
+				sendJson(res, 200, { tasks: service.taskWires() });
+				return;
+			}
+			const [taskId, action] = rest.split("/");
+			if (taskId === void 0 || taskId.length === 0) throw new ImageStudioError("invalid-request", "缺少任务 id");
+			if (action === "cancel") {
+				if (method(_req) !== "POST") {
+					sendJson(res, 405, { error: "POST only" });
+					return;
+				}
+				const ok = service.cancelTask(taskId);
+				sendJson(res, ok ? 200 : 409, ok ? { ok: true } : { error: "task-not-runnable" });
+				return;
+			}
+			if (action !== void 0) throw new ImageStudioError("invalid-request", `未知操作：${action}`);
+			const wire = service.taskWire(taskId);
+			if (wire === null) throw new ImageStudioError("unknown-task", `任务不存在：${taskId}`);
+			sendJson(res, 200, wire);
+		},
+		async gallery(_req, res, rest) {
+			const [itemId] = rest.split("/");
+			if (itemId === void 0 || itemId === "") {
+				if (method(_req) !== "GET") {
+					sendJson(res, 405, { error: "GET only" });
+					return;
+				}
+				const items = await service.gallery();
+				sendJson(res, 200, {
+					items,
+					total: items.length
+				});
+				return;
+			}
+			if (itemId === "credentials" || itemId === "providers") return;
+			if (method(_req) === "DELETE") {
+				const removed = await service.deleteGalleryItem(itemId);
+				sendJson(res, removed ? 200 : 404, removed ? { ok: true } : { error: "not-found" });
+				return;
+			}
+			if (method(_req) !== "GET") {
+				sendJson(res, 405, { error: "GET or DELETE only" });
+				return;
+			}
+			const item = (await service.gallery()).find((entry) => entry.id === itemId);
+			if (item === void 0) {
+				sendJson(res, 404, { error: "not-found" });
+				return;
+			}
+			sendJson(res, 200, item);
+		},
+		async images(_req, res, rest) {
+			const imageId = rest.replace(/\/$/, "");
+			if (imageId.length === 0 || imageId.includes("/")) {
+				sendJson(res, 404, { error: "not-found" });
+				return;
+			}
+			const bytes = await service.imageBytes(imageId);
+			if (bytes === null) {
+				sendJson(res, 404, { error: "not-found" });
+				return;
+			}
+			const mime = bytes.ext === "jpg" ? "image/jpeg" : `image/${bytes.ext}`;
+			res.writeHead(200, {
+				"content-type": mime,
+				"cache-control": "private, max-age=3600"
+			});
+			res.end(Buffer.from(bytes.data));
+		},
+		async credentials(_req, res, rest) {
+			const refName = rest.replace(/\/$/, "");
+			if (refName.length === 0) {
+				sendJson(res, 400, {
+					error: "invalid-request",
+					message: "缺少凭据引用名"
+				});
+				return;
+			}
+			if (method(_req) === "GET") {
+				sendJson(res, 200, await service.credentialStatus(refName));
+				return;
+			}
+			if (method(_req) === "POST") {
+				const body = JSON.parse(await readBody(_req));
+				if (typeof body.value !== "string" || body.value.length === 0) {
+					sendJson(res, 400, {
+						error: "invalid-request",
+						message: "value 必须是非空字符串"
+					});
+					return;
+				}
+				await service.setCredential(refName, body.value);
+				sendJson(res, 200, { ok: true });
+				return;
+			}
+			if (method(_req) === "DELETE") {
+				await service.unsetCredential(refName);
+				sendJson(res, 200, { ok: true });
+				return;
+			}
+			sendJson(res, 405, { error: "GET/POST/DELETE only" });
+		},
+		async providers(_req, res, rest) {
+			if (rest !== "" || method(_req) !== "GET") {
+				sendJson(res, rest !== "" ? 404 : 405, { error: "GET /providers only" });
+				return;
+			}
+			sendJson(res, 200, {
+				protocols: listProtocols(),
+				params: PARAM_CATALOG
+			});
+		},
+		async presets(_req, res, rest) {
+			if (rest !== "" || method(_req) !== "GET") {
+				sendJson(res, 405, { error: "GET /presets only" });
+				return;
+			}
+			sendJson(res, 200, service.presets());
+		}
+	};
+}
+/** 请求方法小写化。 */
+function method(req) {
+	return (req.method ?? "GET").toUpperCase();
+}
+/** 路由分发（prefix 单注册 + 内部分段）。 */
+function registerImageStudioApi(ctx, service) {
+	const handlers = buildHandlers(service);
+	ctx.webServer.register({
+		kind: "prefix",
+		path: ROUTE_PREFIX,
+		handler: (req, res) => {
+			const [head, ...tail] = new URL(req.url ?? "/", "http://localhost").pathname.slice(22).replace(/^\//, "").split("/");
+			const rest = tail.join("/");
+			(async () => {
+				if (head === void 0 || head === "") {
+					sendJson(res, 404, { error: "unknown endpoint" });
+					return;
+				}
+				const handler = handlers[head];
+				if (handler === void 0) {
+					sendJson(res, 404, { error: `unknown endpoint: ${head}` });
+					return;
+				}
+				await handler(req, res, rest);
+			})().catch((error) => sendError(res, error));
+		}
+	});
+}
+//#endregion
+//#region src/credentials.ts
+/**
+* 凭据引用名派生与校验：提供商预设 id → IMAGE_STUDIO_PRESET_<ID>。
+* 规则对齐《插件存储规范》：大写下划线、全大写、前缀属主。
+* 纯函数，零依赖。
+* @module image-studio/credentials
+*/
+/** 引用名前缀（属主段）。 */
+const REF_PREFIX = "IMAGE_STUDIO_PRESET_";
+/** 预设 id 是否合法（kebab-case，用于引用名派生）。 */
+function isValidPresetId(id) {
+	return /^[a-z][a-z0-9-]*$/.test(id) && id.length <= 64;
+}
+/** 预设 id → 凭据引用名（kebab → SNAKE 大写）。 */
+function credentialRefNameOf(presetId) {
+	if (!isValidPresetId(presetId)) throw new Error(`非法提供商预设 id：${JSON.stringify(presetId)}`);
+	return `${REF_PREFIX}${presetId.replaceAll("-", "_").toUpperCase()}`;
+}
+//#endregion
+//#region src/gallery/store.ts
+/**
+* 画廊存储：元数据 JSONL（追加）+ 图片落盘（原子写）。
+* 元数据记录完整请求参数与提示词（二次编辑回放依据）；
+* sourceIds 记录图生图衍生链。落点遵循《插件存储规范》：
+* $DSH_HOME/dsh-plus/image-studio/gallery/{index.jsonl, images/}
+* @module image-studio/gallery/store
+*/
+/**
+* 存储层根路径（惰性解析：DSH_HOME 可能在模块加载后才被测试/dev 环境设置）。
+*/
+function galleryRoot() {
+	return pluginDataPath("image-studio", "gallery");
+}
+function indexFile() {
+	return join(galleryRoot(), "index.jsonl");
+}
+function imagesDir() {
+	return join(galleryRoot(), "images");
+}
+/** 图片扩展名由 MIME 推导（仅白名单格式）。 */
+function extOfMime(mime) {
+	switch (mime) {
+		case "image/jpeg": return "jpg";
+		case "image/webp": return "webp";
+		default: return "png";
+	}
+}
+/** 确保目录存在。 */
+async function ensureDirs() {
+	await mkdir(imagesDir(), { recursive: true });
+}
+/** 解析 JSONL 全量元数据（坏行跳过并告警；空文件返回空表）。 */
+async function loadGallery(log) {
+	let text;
+	try {
+		text = await readFile(indexFile(), "utf8");
+	} catch {
+		return [];
+	}
+	const items = [];
+	for (const line of text.split("\n")) {
+		if (line.trim().length === 0) continue;
+		try {
+			items.push(JSON.parse(line));
+		} catch {
+			log(`画廊元数据坏行跳过：${line.slice(0, 80)}`);
+		}
+	}
+	return items;
+}
+/** 追加一条元数据（JSONL 原子性：单行小写入）。 */
+async function appendIndex(item) {
+	await ensureDirs();
+	await appendFile(indexFile(), `${JSON.stringify(item)}\n`, "utf8");
+}
+/** 图片文件绝对路径。 */
+function imagePathOf(imageId, ext) {
+	if (!/^[a-f0-9-]{36}$/.test(imageId) || !/^[a-z0-9]{2,4}$/.test(ext)) throw new Error(`非法画廊图片标识：${imageId}.${ext}`);
+	return join(imagesDir(), `${imageId}.${ext}`);
+}
+/** 读取图片字节（未知 id 抛错由调用方映射 404）。 */
+async function readImageBytes(imageId) {
+	const hit = (await readdir(imagesDir()).catch(() => [])).find((name) => name.startsWith(`${imageId}.`));
+	if (hit === void 0) throw new Error(`unknown-image: ${imageId}`);
+	const ext = hit.slice(imageId.length + 1);
+	const data = await readFile(imagePathOf(imageId, ext));
+	return {
+		data: new Uint8Array(data),
+		ext
+	};
+}
+/** 画廊新条目：落图片字节 + 追加元数据（一个事务语义，图片先落）。 */
+async function saveGalleryItem(input) {
+	await ensureDirs();
+	const imageIds = [];
+	for (const image of input.images) {
+		const imageId = randomUUID();
+		const target = imagePathOf(imageId, extOfMime(image.mime));
+		const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
+		await writeFile(tmp, image.data);
+		await rename(tmp, target);
+		imageIds.push(imageId);
+	}
+	const item = {
+		...input.item,
+		id: randomUUID(),
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		imageIds,
+		revisedPrompts: input.images.map((image) => image.revisedPrompt)
+	};
+	await appendIndex(item);
+	return item;
+}
+/** 删除单条：图片文件与 JSONL 行（重写式删除）。 */
+async function deleteGalleryItem(itemId) {
+	const items = await loadGallery(() => {});
+	const hit = items.find((item) => item.id === itemId);
+	if (hit === void 0) return false;
+	for (const imageId of hit.imageIds) {
+		const files = await readdir(imagesDir()).catch(() => []);
+		for (const name of files) if (name.startsWith(`${imageId}.`)) await rm(join(imagesDir(), name), { force: true });
+	}
+	const kept = items.filter((item) => item.id !== itemId);
+	const tmp = `${indexFile()}.tmp-${process.pid}-${Date.now()}`;
+	await writeFile(tmp, kept.map((item) => JSON.stringify(item)).join("\n") + (kept.length > 0 ? "\n" : ""), "utf8");
+	await rename(tmp, indexFile());
+	return true;
+}
+//#endregion
+//#region src/task/runner.ts
+/**
+* 并发任务执行器。
+* - submit 入队即返回记录引用（状态经 record 可变字段即时可见）；
+* - 每次完成自动拉起下一段（pump 链式，无定时器）；
+* - cancel 对 queued 置 cancelled、对 running 发 abort（任务体自行响应）。
+*/
+var TaskRunner = class {
+	entries = /* @__PURE__ */ new Map();
+	order = [];
+	maxConcurrent;
+	nextId;
+	/** 完结任务保留条数（防 Map 膨胀；由调用方配置）。 */
+	keepFinished;
+	constructor(options, keepFinished = 200) {
+		this.maxConcurrent = Math.max(0, Math.floor(options.maxConcurrent));
+		this.nextId = options.nextId ?? defaultIdCounter();
+		this.keepFinished = keepFinished;
+	}
+	/** 并发上限热更（配置热生效入口；进行中任务不受影响）。 */
+	reconfigure(maxConcurrent) {
+		this.maxConcurrent = Math.max(0, Math.floor(maxConcurrent));
+	}
+	/** 提交任务：返回记录（后续状态经同一引用轮询）。 */
+	submit(snapshot, run) {
+		const controller = new AbortController();
+		const record = {
+			id: this.nextId(),
+			state: "queued",
+			snapshot,
+			result: null,
+			error: null,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			startedAt: null,
+			finishedAt: null
+		};
+		this.entries.set(record.id, {
+			record,
+			run,
+			controller
+		});
+		this.order.push(record.id);
+		this.pump();
+		return record;
+	}
+	/** 单任务记录查询。 */
+	get(id) {
+		return this.entries.get(id)?.record ?? null;
+	}
+	/** 全部记录（完结在前端按需过滤）。 */
+	list() {
+		return this.order.map((id) => this.entries.get(id)?.record).filter((record) => record !== void 0);
+	}
+	/** 取消：queued 直接置 cancelled；running 发 abort（异步生效）。 */
+	cancel(id) {
+		const entry = this.entries.get(id);
+		if (entry === void 0) return false;
+		if (entry.record.state === "queued") {
+			entry.record.state = "cancelled";
+			entry.record.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+			this.prune();
+			return true;
+		}
+		if (entry.record.state === "running") {
+			entry.controller.abort();
+			return true;
+		}
+		return false;
+	}
+	/** 活跃数（queued + running）。 */
+	get activeCount() {
+		let count = 0;
+		for (const entry of this.entries.values()) if (entry.record.state === "queued" || entry.record.state === "running") count += 1;
+		return count;
+	}
+	/** 拉起可运行任务至并发上限。 */
+	async pump() {
+		for (;;) {
+			if ((this.maxConcurrent === 0 ? Number.POSITIVE_INFINITY : this.maxConcurrent - this.runningCount()) <= 0) return;
+			const next = this.order.map((id) => this.entries.get(id)).find((entry) => entry !== void 0 && entry.record.state === "queued");
+			if (next === void 0) return;
+			this.start(next);
+			if (this.maxConcurrent !== 0) return;
+		}
+	}
+	start(entry) {
+		entry.record.state = "running";
+		entry.record.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const signal = entry.controller.signal;
+		entry.run(signal).then((result) => {
+			if (signal.aborted) {
+				entry.record.state = "failed";
+				entry.record.error = "任务已取消";
+				entry.record.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+				return;
+			}
+			if (entry.record.state !== "running") return;
+			entry.record.state = "succeeded";
+			entry.record.result = result;
+			entry.record.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+		}).catch((error) => {
+			if (entry.record.state === "cancelled") return;
+			entry.record.state = "failed";
+			entry.record.error = error instanceof Error ? error.message : String(error);
+			entry.record.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+		}).finally(() => {
+			this.prune();
+			this.pump();
+		});
+	}
+	runningCount() {
+		let count = 0;
+		for (const entry of this.entries.values()) if (entry.record.state === "running") count += 1;
+		return count;
+	}
+	/** 清理最旧完结条目（保持 Map 上限）。 */
+	prune() {
+		const finished = this.order.filter((id) => {
+			const state = this.entries.get(id)?.record.state;
+			return state === "succeeded" || state === "failed" || state === "cancelled";
+		});
+		const overflow = finished.length - this.keepFinished;
+		if (overflow <= 0) return;
+		for (const id of finished.slice(0, overflow)) {
+			this.entries.delete(id);
+			const index = this.order.indexOf(id);
+			if (index >= 0) this.order.splice(index, 1);
+		}
+	}
+};
+/** 缺省 id 计数器。 */
+function defaultIdCounter() {
+	let counter = 0;
+	return () => {
+		counter += 1;
+		return `task-${counter}`;
+	};
+}
+//#endregion
+//#region src/service.ts
+/**
+* image-studio 服务主体：
+* - settings installSection（三组预设 + 并发/超时/代理/画廊上限）；
+* - TaskRunner 并发生图：提交即排队，成功自动入画廊（元数据 + 图片落盘）；
+* - 提供商预设按 id 即时 resolve credentials（不缓存）；
+* - 端点：generate/tasks/gallery/images/credentials/providers（api.ts 注册）。
+* 红线：开发测试仅指向本地 mock，严禁真实调用产生费用。
+* @module image-studio/service
+*/
+/** 静态 schema 引用（installSection 用；避免循环 import config → service）。 */
+var ImageStudioService = class extends Service {
+	current;
+	runner;
+	log;
+	constructor(ctx, config) {
+		super(ctx, "imageStudio");
+		this.current = () => config;
+		this.log = (message) => ctx.logger("image-studio").warn(message);
+		this.runner = new TaskRunner({ maxConcurrent: config.maxConcurrent });
+		ctx.inject(["settings"], (settingsCtx) => {
+			this.settingsRef = settingsCtx.settings;
+			settingsCtx.settings.installSection(ctx, SETTINGS_NS, Config, config, {
+				setSource: (source) => {
+					this.current = source;
+					this.applyConfig();
+				},
+				onChange: () => {}
+			});
+		});
+		ctx.inject(["webServer"], (webCtx) => {
+			registerImageStudioApi(webCtx, this);
+		});
+	}
+	/** 配置热更：并发上限即时生效（进行中任务不受影响）。 */
+	applyConfig() {
+		this.runner.reconfigure(this.current().maxConcurrent);
+	}
+	promptPresets() {
+		return this.current().promptPresets;
+	}
+	paramPresets() {
+		return this.current().paramPresets;
+	}
+	providerPresets() {
+		return this.current().providerPresets;
+	}
+	/** 预设快照（端点投影）。 */
+	presets() {
+		return {
+			promptPresets: this.promptPresets(),
+			paramPresets: this.paramPresets(),
+			providerPresets: this.providerPresets()
+		};
+	}
+	/** describe 单个提供商预设凭据（不回传值）。 */
+	async credentialStatus(presetId) {
+		const refName = credentialRefNameOf(presetId);
+		const credentials = await this.credentialsSeam();
+		if (credentials === null) return {
+			credentialRef: refName,
+			configured: false
+		};
+		return {
+			credentialRef: refName,
+			configured: (await credentials.describe(credentialRef(refName))).configured
+		};
+	}
+	/** set/unset 凭据（端点写通道）。 */
+	async setCredential(presetId, value) {
+		await (await this.requireCredentials()).set(credentialRef(credentialRefNameOf(presetId)), value);
+	}
+	async unsetCredential(presetId) {
+		await (await this.requireCredentials()).unset(credentialRef(credentialRefNameOf(presetId)));
+	}
+	/** credentials seam 可选探测（缺席返回 null）。 */
+	async credentialsSeam() {
+		const found = this.ctx.get?.("credentials");
+		return found === void 0 || found === null ? null : found;
+	}
+	async requireCredentials() {
+		const seam = await this.credentialsSeam();
+		if (seam === null) throw new ImageStudioError("credential-unavailable");
+		return seam;
+	}
+	/** 提交生图任务：校验 → 入队 → 返回 taskId。 */
+	async submitGenerate(request) {
+		const snapshot = await this.prepareTask(request);
+		const summary = {
+			endpoint: snapshot.endpoint,
+			model: snapshot.target.model,
+			prompt: snapshot.prompt
+		};
+		return this.runner.submit(summary, (signal) => this.executeTask(snapshot, signal)).id;
+	}
+	/** 单任务查询（wire 投影）。 */
+	taskWire(id) {
+		const record = this.runner.get(id);
+		return record === null ? null : this.toTaskWire(record);
+	}
+	/** 任务列表（最新在前）。 */
+	taskWires() {
+		return this.runner.list().reverse().map((record) => this.toTaskWire(record));
+	}
+	/** 取消任务。 */
+	cancelTask(id) {
+		return this.runner.cancel(id);
+	}
+	toTaskWire(record) {
+		const outcome = record.result;
+		return {
+			id: record.id,
+			state: record.state,
+			endpoint: record.snapshot.endpoint,
+			model: record.snapshot.model,
+			promptPreview: record.snapshot.prompt.slice(0, 120),
+			createdAt: record.createdAt,
+			startedAt: record.startedAt,
+			finishedAt: record.finishedAt,
+			error: record.error,
+			galleryItemId: record.state === "succeeded" && outcome !== null ? outcome.galleryItemId : null
+		};
+	}
+	/**
+	* 任务准备（边界校验集中地）：提供商预设/inline → target；
+	* 参数预设 + 覆盖 → 归一化参数表；sourceIds → 输入图字节。
+	*/
+	async prepareTask(request) {
+		const target = await this.resolveTarget(request);
+		const endpoint = request.endpoint;
+		if (endpoint !== "generation" && endpoint !== "edit") throw new ImageStudioError("invalid-request", `未知端点：${String(endpoint)}`);
+		if (typeof request.prompt !== "string" || request.prompt.trim().length === 0) throw new ImageStudioError("invalid-request", "prompt 不能为空");
+		const params = await this.resolveParams(request, endpoint);
+		const nValue = params.n;
+		const n = typeof nValue === "number" ? nValue : 1;
+		const sourceIds = request.sourceIds ?? [];
+		const images = await this.loadSourceImages(sourceIds, endpoint);
+		const mask = request.maskId !== void 0 ? await this.loadMask(request.maskId) : null;
+		return {
+			target,
+			endpoint,
+			prompt: request.prompt,
+			n,
+			images,
+			mask,
+			params: stripHostParams(params),
+			sourceIds
+		};
+	}
+	/** 提供商预设 / inline → ProviderTarget（凭据即时 resolve）。 */
+	async resolveTarget(request) {
+		const config = this.current();
+		const inline = request.inlineProvider;
+		let protocol;
+		let baseUrl;
+		let model;
+		let extraHeaders = {};
+		let refName;
+		if (inline !== void 0) {
+			protocol = inline.protocol;
+			baseUrl = inline.baseUrl;
+			model = inline.model;
+			if (request.providerPresetId === void 0) throw new ImageStudioError("invalid-request", "inline 提供商必须同时给出 providerPresetId 以定位凭据");
+			refName = credentialRefNameOf(request.providerPresetId);
+		} else if (request.providerPresetId !== void 0) {
+			const preset = this.providerPresets().find((item) => item.id === request.providerPresetId);
+			if (preset === void 0) throw new ImageStudioError("invalid-request", `未知提供商预设：${request.providerPresetId}`);
+			protocol = preset.protocol;
+			baseUrl = preset.baseUrl;
+			model = preset.model;
+			extraHeaders = preset.extraHeaders ?? {};
+			refName = isValidPresetId(preset.id) ? credentialRefNameOf(preset.id) : credentialRefNameOf(preset.credentialRef);
+		} else throw new ImageStudioError("invalid-request", "必须提供 providerPresetId 或 inlineProvider");
+		const apiKey = await this.resolveApiKey(refName);
+		const target = {
+			protocol,
+			baseUrl,
+			model,
+			apiKey,
+			extraHeaders,
+			proxy: config.proxy,
+			timeoutMs: config.requestTimeoutMs
+		};
+		target.presetId = inline !== void 0 ? request.providerPresetId ?? null : request.providerPresetId ?? null;
+		return target;
+	}
+	/** 凭据解析（每次操作即时 resolve，不缓存）。 */
+	async resolveApiKey(refName) {
+		const resolved = await (await this.requireCredentials()).resolve(credentialRef(refName));
+		if (resolved === void 0) throw new ImageStudioError("credential-unavailable", `凭据未配置：${refName}`);
+		return resolved.value;
+	}
+	/** 参数预设 + 覆盖合并 → 端点归一化（model 由 target 承载）。 */
+	async resolveParams(request, endpoint) {
+		let specs = {};
+		if (request.paramPresetId !== void 0) {
+			const preset = this.paramPresets().find((item) => item.id === request.paramPresetId);
+			if (preset === void 0) throw new ImageStudioError("invalid-request", `未知参数预设：${request.paramPresetId}`);
+			specs = validateParamSpecs(preset.paramSpecs);
+		}
+		if (request.paramSpecs !== void 0) specs = {
+			...specs,
+			...validateParamSpecs(request.paramSpecs)
+		};
+		const normalized = normalizeParamSpecs(specs, endpoint);
+		return {
+			model: this.modelOf(request),
+			...normalized
+		};
+	}
+	/** 模型优先级：inline > 提供商预设（参数表中的 model 仅为展示，不参与）。 */
+	modelOf(request) {
+		return request.inlineProvider?.model ?? this.providerModelOf(request.providerPresetId);
+	}
+	providerModelOf(presetId) {
+		if (presetId === void 0) return "";
+		return this.providerPresets().find((item) => item.id === presetId)?.model ?? "";
+	}
+	/** 源图字节加载（edit ≥1 张；单图上限 50MB 对齐官方）。 */
+	async loadSourceImages(sourceIds, endpoint) {
+		if (endpoint === "generation") return [];
+		if (sourceIds.length === 0) throw new ImageStudioError("invalid-request", "edit 端点必须提供至少一张源图（sourceIds）");
+		if (sourceIds.length > 16) throw new ImageStudioError("invalid-request", "源图最多 16 张（官方 GPT Image 限制）");
+		const images = [];
+		for (const imageId of sourceIds) images.push(await this.loadOneImage(imageId));
+		return images;
+	}
+	async loadMask(maskId) {
+		return this.loadOneImage(maskId);
+	}
+	async loadOneImage(imageId) {
+		try {
+			const { data, ext } = await readImageBytes(imageId);
+			return {
+				data,
+				mime: ext === "jpg" ? "image/jpeg" : `image/${ext}`
+			};
+		} catch {
+			throw new ImageStudioError("unknown-source", `源图不存在：${imageId}`);
+		}
+	}
+	/** 任务体：调协议适配器 → 成功入画廊。失败向上抛给 TaskRunner 记录。 */
+	async executeTask(snapshot, signal) {
+		const provider = createProvider(snapshot.target.protocol);
+		if (!provider.endpoints.includes(snapshot.endpoint)) throw new ImageStudioError("unknown-endpoint", `协议 ${provider.id} 不支持端点 ${snapshot.endpoint}`);
+		const result = await provider.generate({
+			target: snapshot.target,
+			endpoint: snapshot.endpoint,
+			prompt: snapshot.prompt,
+			n: snapshot.n,
+			images: snapshot.images,
+			mask: snapshot.mask,
+			params: snapshot.params
+		}, signal);
+		return { galleryItemId: (await saveGalleryItem({
+			item: {
+				providerPresetId: this.presetIdOf(snapshot),
+				protocol: snapshot.target.protocol,
+				endpoint: snapshot.endpoint,
+				model: snapshot.target.model,
+				prompt: snapshot.prompt,
+				params: snapshot.params,
+				sourceIds: snapshot.sourceIds
+			},
+			images: result.images.map((image) => ({
+				data: image.data,
+				mime: image.mime,
+				revisedPrompt: image.revisedPrompt
+			}))
+		})).id };
+	}
+	/** 提交时上下文里的预设 id（executeTask 无原请求，经 target 旁路携带）。 */
+	presetIdOf(snapshot) {
+		return snapshot.target.presetId ?? null;
+	}
+	/** 画廊列表（全量；分页/过滤由端点层做）。 */
+	async gallery() {
+		return loadGallery(this.log);
+	}
+	/** 删除画廊条目（图片 + 元数据）。 */
+	async deleteGalleryItem(itemId) {
+		return deleteGalleryItem(itemId);
+	}
+	/** 读取图片字节（端点直投流）。 */
+	async imageBytes(imageId) {
+		try {
+			return await readImageBytes(imageId);
+		} catch {
+			return null;
+		}
+	}
+	dispose() {}
+};
+/** 剔除 host 承载参数（model 不进协议参数表——openai-images 请求体单独拼）。 */
+function stripHostParams(params) {
+	const { model: _model, ...rest } = params;
+	return rest;
+}
+//#endregion
+//#region src/index.ts
+const name = "dsh-plus-image-studio";
+const inject = ["credentials"];
+function apply(ctx, config) {
+	ctx.plugin(ImageStudioService, config);
+}
+//#endregion
+export { Config, ImageStudioError, ImageStudioService, PARAM_CATALOG, ParamValidationError, apply, credentialRefNameOf, inject, isValidPresetId, name, normalizeParamSpecs, paramEntryOf, paramKeysFor, validateParamSpecs };