dsh-image-gen 0.1.7 → 0.2.1

package/lib/index.js

@@ -2,9 +2,9 @@ import { credentialRef } from "@deepseek-ai/dsh-credentials";
 import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import z from "@deepseek-ai/schemastery";
-import { randomUUID } from "node:crypto";
-import { mkdir, realpath, rename, unlink, writeFile } from "node:fs/promises";
+import { mkdir, readFile, realpath, rename, stat, unlink, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { randomUUID } from "node:crypto";
 //#region lib/types/shared.js
 /** Values shared by the Host and browser Bundle faces. */
 /** Browser route used by the generated-image card. */
@@ -27,7 +27,7 @@ const DEFAULT_DASHSCOPE_ENDPOINT = "https://dashscope.aliyuncs.com/api/v1";
 const DEFAULT_GOOGLE_MODEL = "gemini-3.1-flash-image";
 const DEFAULT_OPENAI_MODEL = "gpt-image-2";
 const DEFAULT_SEEDREAM_MODEL = "doubao-seedream-5-0-260128";
-const DEFAULT_DASHSCOPE_MODEL = "wanx2.1-t2i-turbo";
+const DEFAULT_DASHSCOPE_MODEL = "qwen-image-3.0";
 //#endregion
 //#region lib/types/config.js
 /** User-facing configuration for supported image providers. */
@@ -75,7 +75,7 @@ function resolveProvider(config) {
 		case "dashscope": return {
 			provider: "dashscope",
 			apiKeyEnv: DASHSCOPE_API_KEY_ENV,
-			model: config.dashscopeModel ?? "wanx2.1-t2i-turbo",
+			model: config.dashscopeModel ?? "qwen-image-3.0",
 			endpoint: config.dashscopeEndpoint ?? "https://dashscope.aliyuncs.com/api/v1",
 			imageSize: "1024*1024"
 		};
@@ -91,83 +91,75 @@ function resolveProvider(config) {
 }
 //#endregion
 //#region lib/types/dashscope.js
-/** Call DashScope image synthesis/generation API and handle both synchronous output & async task polling. */
 async function generateDashScopeImage(options) {
+	assertQwenImageModel(options.model);
+	const formattedSize = formatSize(options.size);
+	return requestQwenImage({
+		...options,
+		requestBody: {
+			model: options.model,
+			input: { messages: [{
+				role: "user",
+				content: [{ text: options.prompt }]
+			}] },
+			parameters: { ...formattedSize === void 0 ? {} : { size: formattedSize } }
+		},
+		operation: "generation"
+	});
+}
+async function editDashScopeImage(options) {
+	assertQwenImageModel(options.model);
+	const formattedSize = formatSize(options.size);
+	return requestQwenImage({
+		...options,
+		requestBody: {
+			model: options.model,
+			input: { messages: [{
+				role: "user",
+				content: [...options.sourceImages.map((sourceImage) => ({ image: toDataUrl$1(sourceImage) })), { text: options.prompt }]
+			}] },
+			parameters: {
+				prompt_extend: true,
+				...formattedSize === void 0 ? {} : { size: formattedSize }
+			}
+		},
+		operation: "editing"
+	});
+}
+function assertQwenImageModel(model) {
+	if (!model.toLowerCase().startsWith("qwen-image")) throw new Error(`Unsupported DashScope image model ${model}. Configure a qwen-image model.`);
+}
+function formatSize(size) {
+	if (size === void 0 || size.length === 0) return void 0;
+	return size.replace("x", "*");
+}
+function toDataUrl$1(image) {
+	return `data:${image.mediaType};base64,${Buffer.from(image.data).toString("base64")}`;
+}
+async function requestQwenImage(options) {
 	const base = options.endpoint.replace(/\/+$/, "");
-	const formattedSize = (options.size ?? "1024*1024").replace("x", "*");
-	const isQwenImage = options.model.toLowerCase().startsWith("qwen-image");
-	const submitUrl = isQwenImage ? `${base}/services/aigc/multimodal-generation/generation` : `${base}/services/aigc/text2image/image-synthesis`;
-	const requestBody = isQwenImage ? {
-		model: options.model,
-		input: { messages: [{
-			role: "user",
-			content: [{ text: options.prompt }]
-		}] },
-		parameters: { size: formattedSize }
-	} : {
-		model: options.model,
-		input: { prompt: options.prompt },
-		parameters: {
-			size: formattedSize,
-			n: 1
-		}
-	};
-	const submitResponse = await fetch(submitUrl, {
+	const response = await fetch(`${base}/services/aigc/multimodal-generation/generation`, {
 		method: "POST",
 		...options.signal ? { signal: options.signal } : {},
 		headers: {
 			"content-type": "application/json",
-			authorization: `Bearer ${options.apiKey}`,
-			"X-DashScope-Async": "enable"
+			authorization: `Bearer ${options.apiKey}`
 		},
-		body: JSON.stringify(requestBody)
+		body: JSON.stringify(options.requestBody)
 	});
-	if (!submitResponse.ok) {
-		const errorText = await submitResponse.text();
-		throw new Error(`DashScope image generation failed (${String(submitResponse.status)}): ${errorText}`);
-	}
-	const submitResult = await submitResponse.json();
-	const directImageUrl = extractImageUrl(submitResult);
-	if (directImageUrl !== void 0) return downloadImageBlob(directImageUrl, options);
-	const taskId = submitResult.output?.task_id;
-	if (taskId === void 0 || taskId.length === 0) throw new Error(`DashScope did not return an image URL or task_id: ${submitResult.message ?? JSON.stringify(submitResult)}`);
-	const taskQueryUrl = `${base}/tasks/${taskId}`;
-	const startTime = Date.now();
-	const timeoutMs = 6e4;
-	while (Date.now() - startTime < timeoutMs) {
-		if (options.signal?.aborted) throw new Error("DashScope image task polling aborted");
-		await new Promise((resolve, reject) => {
-			const timer = setTimeout(resolve, 1500);
-			if (options.signal !== void 0) options.signal.addEventListener("abort", () => {
-				clearTimeout(timer);
-				reject(/* @__PURE__ */ new Error("DashScope image generation aborted"));
-			}, { once: true });
-		});
-		const taskResponse = await fetch(taskQueryUrl, {
-			method: "GET",
-			...options.signal ? { signal: options.signal } : {},
-			headers: { authorization: `Bearer ${options.apiKey}` }
-		});
-		if (!taskResponse.ok) {
-			const errorText = await taskResponse.text();
-			throw new Error(`DashScope task query failed (${String(taskResponse.status)}): ${errorText}`);
-		}
-		const taskResult = await taskResponse.json();
-		const status = taskResult.output?.task_status;
-		if (status === "SUCCEEDED") {
-			const imageUrl = extractImageUrl(taskResult);
-			if (imageUrl === void 0 || imageUrl.length === 0) throw new Error("DashScope task succeeded but returned no image URL");
-			return downloadImageBlob(imageUrl, options);
-		}
-		if (status === "FAILED") throw new Error(`DashScope image generation failed: ${taskResult.output?.message ?? taskResult.message ?? "Unknown error"}`);
+	if (!response.ok) {
+		const errorText = await response.text();
+		throw new Error(`DashScope image ${options.operation} failed (${String(response.status)}): ${errorText}`);
 	}
-	throw new Error(`DashScope image generation timed out after ${String(timeoutMs / 1e3)} seconds`);
+	const payload = await response.json();
+	const imageUrl = extractImageUrl(payload);
+	if (imageUrl === void 0) throw new Error(`DashScope image ${options.operation} returned no image URL: ${payload.message ?? JSON.stringify(payload)}`);
+	return downloadImageBlob(imageUrl, options);
 }
 function extractImageUrl(response) {
-	const resultUrl = response.output?.results?.[0]?.url;
-	if (resultUrl !== void 0 && resultUrl.length > 0) return resultUrl;
 	const contents = response.output?.choices?.[0]?.message?.content;
-	if (Array.isArray(contents)) for (const item of contents) {
+	if (!Array.isArray(contents)) return void 0;
+	for (const item of contents) {
 		if (item.image !== void 0 && item.image.length > 0) return item.image;
 		if (item.image_url !== void 0 && item.image_url.length > 0) return item.image_url;
 		if (item.url !== void 0 && item.url.length > 0) return item.url;
@@ -187,10 +179,34 @@ async function downloadImageBlob(imageUrl, options) {
 }
 //#endregion
 //#region lib/types/google.js
-const ERROR_LIMIT$1 = 4096;
+const ERROR_LIMIT$2 = 4096;
 const REQUESTED_MEDIA_TYPE = "image/jpeg";
-/** Send one native Google image request and validate its inline image response. */
-async function generateGoogleImage(input) {
+/** Send one native Google text-to-image request. */
+function generateGoogleImage(input) {
+	return requestGoogleImage({
+		...input,
+		operation: "generation",
+		interactionInput: input.prompt
+	});
+}
+/** Send one native Google image-editing request using already-resolved bytes. */
+function editGoogleImage(input) {
+	return requestGoogleImage({
+		...input,
+		operation: "editing",
+		interactionInput: [{
+			type: "text",
+			text: input.prompt
+		}, ...input.sourceImages.map((sourceImage) => ({
+			type: "image",
+			mime_type: sourceImage.mediaType,
+			data: Buffer.from(sourceImage.data).toString("base64")
+		}))]
+	});
+}
+/** Shared Google request, response parsing, decoding, and size enforcement. */
+async function requestGoogleImage(input) {
+	const label = `Google image ${input.operation}`;
 	const response = await fetch(input.endpoint, {
 		method: "POST",
 		redirect: "error",
@@ -201,7 +217,7 @@ async function generateGoogleImage(input) {
 		},
 		body: JSON.stringify({
 			model: input.model,
-			input: input.prompt,
+			input: input.interactionInput,
 			response_format: {
 				type: "image",
 				mime_type: REQUESTED_MEDIA_TYPE,
@@ -210,33 +226,33 @@ async function generateGoogleImage(input) {
 			}
 		})
 	});
-	const text = await readBoundedText$1(response, Math.ceil(input.maxBytes * 1.4) + ERROR_LIMIT$1);
-	if (!response.ok) throw new Error(`Google image generation failed (${response.status}): ${text.slice(0, ERROR_LIMIT$1)}`);
+	const text = await readBoundedText$2(response, Math.ceil(input.maxBytes * 1.4) + ERROR_LIMIT$2, label);
+	if (!response.ok) throw new Error(`${label} failed (${response.status}): ${text.slice(0, ERROR_LIMIT$2)}`);
 	let payload;
 	try {
 		payload = JSON.parse(text);
 	} catch {
-		throw new Error("Google image generation returned invalid JSON");
+		throw new Error(`${label} returned invalid JSON`);
 	}
 	const image = outputImage(payload);
-	if (image === void 0) throw new Error(`Google image generation returned no image: ${text.slice(0, ERROR_LIMIT$1)}`);
+	if (image === void 0) throw new Error(`${label} returned no image: ${text.slice(0, ERROR_LIMIT$2)}`);
 	const mediaType = mediaTypeOf(image.mime_type ?? REQUESTED_MEDIA_TYPE);
-	if (mediaType === void 0) throw new Error(`Google image generation returned unsupported media type ${JSON.stringify(image.mime_type)}`);
-	const data = decodeBase64$1(image.data);
-	if (data.byteLength > input.maxBytes) throw new Error(`Google image generation exceeded the ${String(input.maxBytes)} byte image limit`);
+	if (mediaType === void 0) throw new Error(`${label} returned unsupported media type ${JSON.stringify(image.mime_type)}`);
+	const data = decodeBase64$2(image.data, label);
+	if (data.byteLength > input.maxBytes) throw new Error(`${label} exceeded the ${String(input.maxBytes)} byte image limit`);
 	return {
 		data,
 		mediaType
 	};
 }
 function outputImage(value) {
-	const interaction = record$1(value);
+	const interaction = record$2(value);
 	if (interaction === void 0) return void 0;
 	const direct = imageContent(interaction.output_image, false);
 	if (direct !== void 0) return direct;
 	if (!Array.isArray(interaction.steps)) return void 0;
 	for (const step of interaction.steps) {
-		const modelOutput = record$1(step);
+		const modelOutput = record$2(step);
 		if (modelOutput?.type !== "model_output" || !Array.isArray(modelOutput.content)) continue;
 		for (const content of modelOutput.content) {
 			const image = imageContent(content, true);
@@ -245,27 +261,27 @@ function outputImage(value) {
 	}
 }
 function imageContent(value, requiresImageType) {
-	const image = record$1(value);
+	const image = record$2(value);
 	if (image === void 0 || requiresImageType && image.type !== "image" || typeof image.data !== "string") return void 0;
 	return {
 		data: image.data,
 		mime_type: image.mime_type
 	};
 }
-function record$1(value) {
+function record$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 function mediaTypeOf(value) {
 	return value === "image/png" || value === "image/jpeg" || value === "image/webp" || value === "image/gif" ? value : void 0;
 }
-function decodeBase64$1(data) {
+function decodeBase64$2(data, label) {
 	const clean = data.replace(/\s+/g, "");
-	if (clean.length === 0) throw new Error("Google image generation returned invalid base64 image data");
+	if (clean.length === 0) throw new Error(`${label} returned invalid base64 image data`);
 	const decoded = Buffer.from(clean, "base64");
-	if (decoded.length === 0) throw new Error("Google image generation returned invalid base64 image data");
+	if (decoded.length === 0) throw new Error(`${label} returned invalid base64 image data`);
 	return new Uint8Array(decoded);
 }
-async function readBoundedText$1(response, maxBytes) {
+async function readBoundedText$2(response, maxBytes, label) {
 	if (response.body === null) return "";
 	const reader = response.body.getReader();
 	const chunks = [];
@@ -275,7 +291,7 @@ async function readBoundedText$1(response, maxBytes) {
 			const next = await reader.read();
 			if (next.done) break;
 			bytes += next.value.byteLength;
-			if (bytes > maxBytes) throw new Error(`Google image generation response exceeded the ${String(maxBytes)} byte limit`);
+			if (bytes > maxBytes) throw new Error(`${label} response exceeded the ${String(maxBytes)} byte limit`);
 			chunks.push(next.value);
 		}
 	} finally {
@@ -290,6 +306,220 @@ async function readBoundedText$1(response, maxBytes) {
 	return new TextDecoder().decode(joined);
 }
 //#endregion
+//#region lib/types/reference-image.js
+/** Latest-DSH compatibility boundary for resolving conversation image references. */
+/**
+* Resolve one or more edit references while keeping every DSH-specific detail
+* behind this compatibility boundary. Explicit selectors preserve caller order;
+* without selectors, all images in the newest image-bearing message are used.
+*/
+async function resolveReferenceImages(input) {
+	const sourceAttachmentIds = mergeSelectors({
+		single: input.sourceAttachmentId,
+		multiple: input.sourceAttachmentIds,
+		singleName: "source_attachment_id",
+		multipleName: "source_attachment_ids",
+		equal: attachmentIdsEqual
+	});
+	const sourcePaths = mergeSelectors({
+		single: input.sourcePath,
+		multiple: input.sourcePaths,
+		singleName: "source_path",
+		multipleName: "source_paths",
+		equal: (left, right) => left.trim() === right.trim()
+	});
+	if (sourceAttachmentIds !== void 0 && sourcePaths !== void 0) throw new Error("edit_image accepts only one of source_attachment_id, source_attachment_ids, source_path, or source_paths");
+	if (sourcePaths !== void 0) return Promise.all(sourcePaths.map((sourcePath) => readWorkspaceReferenceImage({
+		sourcePath,
+		...input.agent?.session.header?.cwd === void 0 ? {} : { workspaceRoot: input.agent.session.header.cwd },
+		...input.maxBytes === void 0 ? {} : { maxBytes: input.maxBytes },
+		signal: input.signal
+	})));
+	if (input.agent === void 0) throw new Error("edit_image requires an active DSH agent session to resolve a reference image");
+	const refs = findReferenceImages(input.agent.session.deriveMessages(), sourceAttachmentIds);
+	if (refs.length === 0) {
+		if (sourceAttachmentIds !== void 0) throw new Error(`edit_image could not find image attachment ${sourceAttachmentIds[0]} in the current conversation`);
+		throw new Error("edit_image requires an image in the current conversation; upload or generate an image first");
+	}
+	if (sourceAttachmentIds !== void 0 && refs.length !== sourceAttachmentIds.length) {
+		const missing = sourceAttachmentIds.find((id) => !refs.some((ref) => attachmentIdsEqual(String(ref.attachmentId), id)));
+		throw new Error(`edit_image could not find image attachment ${missing ?? "unknown"} in the current conversation`);
+	}
+	return Promise.all(refs.map(async (ref) => {
+		const stored = await input.attachments.readImage(ref, input.signal);
+		if (input.maxBytes !== void 0 && stored.data.byteLength > input.maxBytes) throw new Error(`edit_image source image is too large (${stored.data.byteLength} bytes; maximum ${input.maxBytes})`);
+		return {
+			data: stored.data,
+			mediaType: stored.ref.mediaType
+		};
+	}));
+}
+/** Find images in caller order, or every image in the newest image-bearing message. */
+function findReferenceImages(messages, sourceAttachmentIds) {
+	if (sourceAttachmentIds !== void 0) return sourceAttachmentIds.flatMap((id) => {
+		const ref = findReferenceImage(messages, id);
+		return ref === void 0 ? [] : [ref];
+	});
+	const latestHumanMessage = [...messages].reverse().find((message) => message.source?.kind === "user");
+	if (latestHumanMessage !== void 0) {
+		const refs = collectInBlocks(latestHumanMessage.content);
+		if (refs.length > 0) return refs;
+	}
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const refs = collectInBlocks(messages[index]?.content ?? []);
+		if (refs.length > 0) return refs;
+	}
+	return [];
+}
+/**
+* Read an explicitly named workspace image without exposing filesystem or DSH
+* details to provider adapters. Both lexical and real-path containment are
+* enforced so absolute paths, parent traversal, and symlink escapes fail.
+*/
+async function readWorkspaceReferenceImage(input) {
+	const requested = input.sourcePath.trim();
+	if (requested.length === 0) throw new Error("edit_image source_path must not be empty");
+	if (input.workspaceRoot === void 0) throw new Error("edit_image source_path requires an active DSH session workspace");
+	const root = resolve(input.workspaceRoot);
+	const candidate = isAbsolute(requested) ? resolve(requested) : resolve(root, requested);
+	if (!containsPath$1(root, candidate)) throw new Error("edit_image source_path must stay inside the session workspace: " + requested);
+	let realRoot;
+	let realCandidate;
+	try {
+		[realRoot, realCandidate] = await Promise.all([realpath(root), realpath(candidate)]);
+	} catch (error) {
+		if (error.code === "ENOENT") throw new Error("edit_image could not find workspace image: " + requested);
+		throw error;
+	}
+	if (!containsPath$1(realRoot, realCandidate)) throw new Error("edit_image source_path resolves outside the session workspace: " + requested);
+	const file = await stat(realCandidate);
+	if (!file.isFile()) throw new Error("edit_image source_path is not a file: " + requested);
+	if (input.maxBytes !== void 0 && file.size > input.maxBytes) throw new Error("edit_image source image is too large (" + file.size + " bytes; maximum " + input.maxBytes + ")");
+	const data = await readFile(realCandidate, { signal: input.signal });
+	const mediaType = detectImageMediaType(data);
+	if (mediaType === void 0) throw new Error("edit_image source_path is not a supported PNG, JPEG, WebP, or GIF image: " + requested);
+	return {
+		data: new Uint8Array(data),
+		mediaType
+	};
+}
+/** Find the newest matching image in the effective, replacement-aware history. */
+function findReferenceImage(messages, sourceAttachmentId) {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const found = findInBlocks(messages[index]?.content ?? [], sourceAttachmentId);
+		if (found !== void 0) return found;
+	}
+}
+/** Validate an untrusted serialized image reference at an HTTP/UI boundary. */
+function parseImageAttachmentRef(value) {
+	const ref = record$1(value);
+	if (ref === void 0) return void 0;
+	if (typeof ref.attachmentId !== "string" || !imageMediaType$2(ref.mediaType)) return void 0;
+	if (!nonNegativeInteger(ref.bytes) || !positiveInteger(ref.width) || !positiveInteger(ref.height)) return void 0;
+	if (ref.name !== void 0 && typeof ref.name !== "string") return void 0;
+	const originalDimensions = ref.originalDimensions === void 0 ? void 0 : parseDimensions(ref.originalDimensions);
+	if (ref.originalDimensions !== void 0 && originalDimensions === void 0) return void 0;
+	return {
+		attachmentId: ref.attachmentId,
+		mediaType: ref.mediaType,
+		bytes: ref.bytes,
+		width: ref.width,
+		height: ref.height,
+		...typeof ref.name === "string" ? { name: ref.name } : {},
+		...originalDimensions === void 0 ? {} : { originalDimensions }
+	};
+}
+function findInBlocks(blocks, sourceAttachmentId) {
+	for (let index = blocks.length - 1; index >= 0; index -= 1) {
+		const block = blocks[index];
+		if (block === void 0) continue;
+		if (block.type === "image") {
+			if (sourceAttachmentId === void 0 || attachmentIdsEqual(String(block.attachment.attachmentId), sourceAttachmentId)) return block.attachment;
+			continue;
+		}
+		if (block.type === "tool-result") {
+			const nested = findInBlocks(block.content, sourceAttachmentId);
+			if (nested !== void 0) return nested;
+		}
+	}
+}
+function parseDimensions(value) {
+	const dimensions = record$1(value);
+	if (dimensions === void 0 || !positiveInteger(dimensions.width) || !positiveInteger(dimensions.height)) return void 0;
+	return {
+		width: dimensions.width,
+		height: dimensions.height
+	};
+}
+function imageMediaType$2(value) {
+	return value === "image/png" || value === "image/jpeg" || value === "image/webp" || value === "image/gif";
+}
+function collectInBlocks(blocks) {
+	const refs = [];
+	for (const block of blocks) {
+		if (block.type === "image") refs.push(block.attachment);
+		if (block.type === "tool-result") refs.push(...collectInBlocks(block.content));
+	}
+	return refs;
+}
+function attachmentIdsEqual(actual, requested) {
+	if (actual === requested) return true;
+	const actualDigest = sha256Digest(actual);
+	const requestedDigest = sha256Digest(requested);
+	return actualDigest !== void 0 && actualDigest === requestedDigest;
+}
+function sha256Digest(value) {
+	return /^(?:sha256:)?([0-9a-f]{64})$/i.exec(value.trim())?.[1]?.toLowerCase();
+}
+function mergeSelectors(input) {
+	if (input.multiple === void 0) return input.single === void 0 ? void 0 : [input.single];
+	if (input.multiple.length === 0) {
+		if (input.single !== void 0) return [input.single];
+		throw new Error(`edit_image ${input.multipleName} must not be empty`);
+	}
+	const single = input.single;
+	if (single !== void 0 && !input.multiple.some((value) => input.equal(single, value))) throw new Error(`edit_image ${input.singleName} must also appear in ${input.multipleName} when both are provided`);
+	return input.multiple;
+}
+function detectImageMediaType(data) {
+	if (startsWith(data, [
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10
+	])) return "image/png";
+	if (startsWith(data, [
+		255,
+		216,
+		255
+	])) return "image/jpeg";
+	if (ascii(data, 0, 6) === "GIF87a" || ascii(data, 0, 6) === "GIF89a") return "image/gif";
+	if (ascii(data, 0, 4) === "RIFF" && ascii(data, 8, 4) === "WEBP") return "image/webp";
+}
+function startsWith(data, signature) {
+	return signature.every((byte, index) => data[index] === byte);
+}
+function ascii(data, offset, length) {
+	return String.fromCharCode(...data.subarray(offset, offset + length));
+}
+function containsPath$1(parent, child) {
+	const rel = relative(parent, child);
+	return rel === "" || rel !== ".." && !rel.startsWith(".." + sep) && !isAbsolute(rel);
+}
+function positiveInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function nonNegativeInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function record$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+//#endregion
 //#region lib/types/image-route.js
 const MAX_BODY_BYTES = 4096;
 /** Serve one verified durable image reference to a same-origin browser request. */
@@ -324,20 +554,10 @@ async function serveImage(req, res, deps) {
 function imageAttachmentFromMeta(meta) {
 	const value = record(meta);
 	if (value?.kind !== "dsh-image-gen") return void 0;
-	return imageAttachment(value.attachment);
+	return parseImageAttachmentRef(value.attachment);
 }
 function attachmentFromRequest(value) {
-	return imageAttachment(record(value)?.attachment);
-}
-function imageAttachment(value) {
-	const ref = record(value);
-	if (ref === void 0) return void 0;
-	if (typeof ref.attachmentId !== "string" || !mediaType(ref.mediaType) || typeof ref.bytes !== "number" || typeof ref.width !== "number" || typeof ref.height !== "number") return void 0;
-	if (ref.name !== void 0 && typeof ref.name !== "string") return void 0;
-	return ref;
-}
-function mediaType(value) {
-	return value === "image/png" || value === "image/jpeg" || value === "image/webp" || value === "image/gif";
+	return parseImageAttachmentRef(record(value)?.attachment);
 }
 function record(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
@@ -362,10 +582,9 @@ function jsonError(res, status, code) {
 }
 //#endregion
 //#region lib/types/openai-compatible.js
-const ERROR_LIMIT = 4096;
-/** Generate an image from an OpenAI-compatible endpoint. */
+const ERROR_LIMIT$1 = 4096;
 async function generateOpenAICompatibleImage(input) {
-	const response = await fetch(imageEndpoint(input.baseURL), {
+	return parseImageResponse(await fetch(imageEndpoint$1(input.baseURL, "generations"), {
 		method: "POST",
 		redirect: "error",
 		signal: input.signal,
@@ -379,20 +598,177 @@ async function generateOpenAICompatibleImage(input) {
 			size: input.size,
 			...input.provider === "seedream" ? { response_format: "url" } : {}
 		})
+	}), input.provider, input);
+}
+async function editOpenAICompatibleImage(input) {
+	const form = new FormData();
+	const imageField = input.sourceImages.length === 1 ? "image" : "image[]";
+	input.sourceImages.forEach((sourceImage, index) => {
+		const uploadBytes = new Uint8Array(sourceImage.data);
+		form.append(imageField, new Blob([uploadBytes], { type: sourceImage.mediaType }), `reference-${index + 1}.${extensionOf(sourceImage.mediaType)}`);
+	});
+	form.append("prompt", input.prompt);
+	form.append("model", input.model);
+	if (input.size !== void 0 && input.size.length > 0) form.append("size", input.size);
+	return parseImageResponse(await fetch(imageEndpoint$1(input.baseURL, "edits"), {
+		method: "POST",
+		redirect: "error",
+		signal: input.signal,
+		headers: { authorization: `Bearer ${input.apiKey}` },
+		body: form
+	}), "openai", input);
+}
+async function parseImageResponse(response, provider, input) {
+	const text = await readBoundedText$1(response, Math.ceil(input.maxBytes * 1.4) + ERROR_LIMIT$1);
+	if (!response.ok) throw new Error(`${provider} image request failed (${response.status}): ${text.slice(0, ERROR_LIMIT$1)}`);
+	let payload;
+	try {
+		payload = JSON.parse(text);
+	} catch {
+		throw new Error(`${provider} image request returned invalid JSON`);
+	}
+	const image = firstImage$1(payload);
+	if (image === void 0) throw new Error(`${provider} image request returned no image: ${text.slice(0, ERROR_LIMIT$1)}`);
+	if (image.b64_json !== void 0) return {
+		data: decodeBase64$1(image.b64_json, provider),
+		mediaType: imageMediaType$1(image.mime_type) ?? "image/png"
+	};
+	return downloadImage$1(image.url, provider, input);
+}
+function imageEndpoint$1(baseURL, operation) {
+	try {
+		return new URL(`images/${operation}`, baseURL.endsWith("/") ? baseURL : `${baseURL}/`).toString();
+	} catch {
+		throw new Error("Image endpoint must be an absolute URL");
+	}
+}
+function firstImage$1(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const record = value;
+	const data = Array.isArray(record.data) ? record.data : Array.isArray(record.images) ? record.images : Array.isArray(record.output) ? record.output : void 0;
+	if (data === void 0 || data.length === 0) return void 0;
+	const candidate = data[0];
+	if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) return void 0;
+	const item = candidate;
+	const mime = typeof item.mime_type === "string" ? item.mime_type : typeof item.mime === "string" ? item.mime : void 0;
+	return typeof item.b64_json === "string" ? {
+		b64_json: item.b64_json,
+		...mime === void 0 ? {} : { mime_type: mime }
+	} : typeof item.url === "string" ? {
+		url: item.url,
+		...mime === void 0 ? {} : { mime_type: mime }
+	} : void 0;
+}
+async function downloadImage$1(url, provider, input) {
+	if (url === void 0) throw new Error(`${provider} image request returned no image data`);
+	if (url.startsWith("data:")) {
+		const parsed = parseDataUrl(url);
+		if (parsed === void 0) throw new Error(`${provider} image request returned invalid data URL`);
+		return {
+			data: decodeBase64$1(parsed.base64, provider),
+			mediaType: imageMediaType$1(parsed.mediaType) ?? "image/png"
+		};
+	}
+	const response = await fetch(url, {
+		redirect: "follow",
+		signal: input.signal,
+		...input.apiKey === void 0 ? {} : { headers: { authorization: `Bearer ${input.apiKey}` } }
+	});
+	if (!response.ok) throw new Error(`${provider} image download failed (${response.status})`);
+	const mediaType = imageMediaType$1(response.headers.get("content-type"));
+	if (mediaType === void 0) throw new Error(`${provider} image download returned unsupported content type`);
+	return {
+		data: await readBoundedBytes$1(response, input.maxBytes),
+		mediaType
+	};
+}
+function parseDataUrl(value) {
+	const match = /^data:([^;,]+);base64,(.*)$/s.exec(value.trim());
+	return match?.[1] !== void 0 && match[2] !== void 0 ? {
+		mediaType: match[1],
+		base64: match[2]
+	} : void 0;
+}
+function extensionOf(mediaType) {
+	switch (mediaType) {
+		case "image/jpeg": return "jpg";
+		case "image/webp": return "webp";
+		case "image/gif": return "gif";
+		case "image/png": return "png";
+	}
+}
+function decodeBase64$1(value, provider) {
+	const clean = (parseDataUrl(value)?.base64 ?? value).replace(/\s+/g, "");
+	if (clean.length === 0) throw new Error(`${provider} image request returned invalid base64 image data`);
+	const decoded = Buffer.from(clean, "base64");
+	if (decoded.length === 0) throw new Error(`${provider} image request returned invalid base64 image data`);
+	return new Uint8Array(decoded);
+}
+function imageMediaType$1(value) {
+	const mediaType = value?.split(";", 1)[0]?.trim().toLowerCase();
+	return mediaType === "image/png" || mediaType === "image/jpeg" || mediaType === "image/webp" || mediaType === "image/gif" ? mediaType : void 0;
+}
+async function readBoundedText$1(response, maxBytes) {
+	return new TextDecoder().decode(await readBoundedBytes$1(response, maxBytes));
+}
+async function readBoundedBytes$1(response, maxBytes) {
+	if (response.body === null) return /* @__PURE__ */ new Uint8Array();
+	const reader = response.body.getReader();
+	const chunks = [];
+	let bytes = 0;
+	try {
+		for (;;) {
+			const next = await reader.read();
+			if (next.done) break;
+			bytes += next.value.byteLength;
+			if (bytes > maxBytes) throw new Error(`Image response exceeded the ${String(maxBytes)} byte limit`);
+			chunks.push(next.value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const joined = new Uint8Array(bytes);
+	let offset = 0;
+	for (const chunk of chunks) {
+		joined.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return joined;
+}
+//#endregion
+//#region lib/types/seedream.js
+const ERROR_LIMIT = 4096;
+/** Edit one image through Ark ImageGenerations using a data-URL reference. */
+async function editSeedreamImage(input) {
+	const response = await fetch(imageEndpoint(input.baseURL), {
+		method: "POST",
+		redirect: "error",
+		signal: input.signal,
+		headers: {
+			authorization: `Bearer ${input.apiKey}`,
+			"content-type": "application/json"
+		},
+		body: JSON.stringify({
+			model: input.model,
+			prompt: input.prompt,
+			image: input.sourceImages.map(toDataUrl),
+			...input.size === void 0 || input.size.length === 0 ? {} : { size: input.size },
+			response_format: "b64_json"
+		})
 	});
 	const text = await readBoundedText(response, Math.ceil(input.maxBytes * 1.4) + ERROR_LIMIT);
-	if (!response.ok) throw new Error(`${input.provider} image generation failed (${response.status}): ${text.slice(0, ERROR_LIMIT)}`);
+	if (!response.ok) throw new Error(`seedream image editing failed (${response.status}): ${text.slice(0, ERROR_LIMIT)}`);
 	let payload;
 	try {
 		payload = JSON.parse(text);
 	} catch {
-		throw new Error(`${input.provider} image generation returned invalid JSON`);
+		throw new Error("seedream image editing returned invalid JSON");
 	}
 	const image = firstImage(payload);
-	if (image === void 0) throw new Error(`${input.provider} image generation returned no image: ${text.slice(0, ERROR_LIMIT)}`);
+	if (image === void 0) throw new Error(`seedream image editing returned no image: ${text.slice(0, ERROR_LIMIT)}`);
 	if (image.b64_json !== void 0) return {
-		data: decodeBase64(image.b64_json, input.provider),
-		mediaType: "image/png"
+		data: decodeBase64(image.b64_json),
+		mediaType: imageMediaType(image.mime_type) ?? "image/png"
 	};
 	return downloadImage(image.url, input);
 }
@@ -400,37 +776,48 @@ function imageEndpoint(baseURL) {
 	try {
 		return new URL("images/generations", baseURL.endsWith("/") ? baseURL : `${baseURL}/`).toString();
 	} catch {
-		throw new Error("Image generation endpoint must be an absolute URL");
+		throw new Error("Seedream image endpoint must be an absolute URL");
 	}
 }
+function toDataUrl(image) {
+	return `data:${image.mediaType};base64,${Buffer.from(image.data).toString("base64")}`;
+}
 function firstImage(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-	const data = value.data;
-	if (!Array.isArray(data) || data.length === 0) return void 0;
+	const record = value;
+	const data = Array.isArray(record.data) ? record.data : Array.isArray(record.images) ? record.images : Array.isArray(record.output) ? record.output : void 0;
+	if (data === void 0 || data.length === 0) return void 0;
 	const candidate = data[0];
 	if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) return void 0;
 	const item = candidate;
-	return typeof item.b64_json === "string" ? { b64_json: item.b64_json } : typeof item.url === "string" ? { url: item.url } : void 0;
+	const mime = typeof item.mime_type === "string" ? item.mime_type : typeof item.mime === "string" ? item.mime : void 0;
+	return typeof item.b64_json === "string" ? {
+		b64_json: item.b64_json,
+		...mime === void 0 ? {} : { mime_type: mime }
+	} : typeof item.url === "string" ? {
+		url: item.url,
+		...mime === void 0 ? {} : { mime_type: mime }
+	} : void 0;
 }
 async function downloadImage(url, input) {
-	if (url === void 0) throw new Error(`${input.provider} image generation returned no image data`);
+	if (url === void 0) throw new Error("seedream image editing returned no image data");
 	const response = await fetch(url, {
 		redirect: "follow",
 		signal: input.signal
 	});
-	if (!response.ok) throw new Error(`${input.provider} image download failed (${response.status})`);
+	if (!response.ok) throw new Error(`seedream image download failed (${response.status})`);
 	const mediaType = imageMediaType(response.headers.get("content-type"));
-	if (mediaType === void 0) throw new Error(`${input.provider} image download returned unsupported content type`);
+	if (mediaType === void 0) throw new Error("seedream image download returned unsupported content type");
 	return {
 		data: await readBoundedBytes(response, input.maxBytes),
 		mediaType
 	};
 }
-function decodeBase64(value, provider) {
+function decodeBase64(value) {
 	const clean = value.replace(/\s+/g, "");
-	if (clean.length === 0) throw new Error(`${provider} image generation returned invalid base64 image data`);
+	if (clean.length === 0) throw new Error("seedream image editing returned invalid base64 image data");
 	const decoded = Buffer.from(clean, "base64");
-	if (decoded.length === 0) throw new Error(`${provider} image generation returned invalid base64 image data`);
+	if (decoded.length === 0) throw new Error("seedream image editing returned invalid base64 image data");
 	return new Uint8Array(decoded);
 }
 function imageMediaType(value) {
@@ -582,16 +969,13 @@ async function saveImageToWorkspace(options) {
 }
 //#endregion
 //#region lib/types/index.js
-/** Cordis plugin name. */
 const name = "dsh-image-gen";
-/** Host services required by the Bundle. */
 const inject = [
 	"tools",
 	"attachments",
 	"credentials",
 	"webServer"
 ];
-/** Register settings, the image route, and the model-callable tool. */
 function apply(ctx, config = {}) {
 	let current = () => config;
 	installSettingsSection(ctx, settingsNamespace(IMAGE_GENERATION_NAMESPACE), Config, config, {
@@ -607,7 +991,7 @@ function apply(ctx, config = {}) {
 	}), "dsh-image-gen: image route");
 	ctx.tools.register(defineTool({
 		name: "generate_image",
-		description: "Generate one image with the configured image provider. Use when the user explicitly asks to create or draw an image. Give a complete visual prompt including subject, composition, style, lighting, and any exact text that should appear. A successful image is already attached directly to the conversation; with workspace saving enabled (the default) it is also written as a file under the session workspace, and the result's savedTo field carries that absolute file path. Do not call read, glob, or other tools to locate or verify the image.",
+		description: "Generate a new image with the configured provider. Use when the user asks to create or draw a new image; use edit_image instead when they want to change an existing image. Give a complete visual prompt including subject, composition, style, lighting, and any exact text that should appear. A successful image is attached directly to the conversation and may also be saved under the session workspace. Do not call read, glob, or other tools to locate or verify the image.",
 		parameters: {
 			prompt: {
 				type: "string",
@@ -641,72 +1025,7 @@ function apply(ctx, config = {}) {
 				description: "Optional dimensions or size tier for OpenAI, Seedream, or DashScope."
 			}
 		},
-		output: {
-			schema: {
-				type: "object",
-				additionalProperties: false,
-				properties: {
-					attachment: {
-						type: "object",
-						required: true,
-						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" }
-						}
-					},
-					provider: {
-						type: "string",
-						required: true
-					},
-					model: {
-						type: "string",
-						required: true
-					},
-					output: {
-						type: "string",
-						required: true
-					},
-					savedTo: { type: "string" },
-					saveError: { type: "string" }
-				}
-			},
-			render: (_args, value) => {
-				const saved = typeof value.savedTo === "string" ? ` It was also saved to the workspace as ${value.savedTo}.` : typeof value.saveError === "string" ? ` Saving it to the workspace failed: ${value.saveError}.` : " It has no local file path.";
-				return [{
-					type: "text",
-					text: `Generated one image with ${value.provider}/${value.model} (${value.output}). It is already attached to the conversation.${saved} Respond to the user without reading or searching for the image.`
-				}];
-			},
-			presentationMeta: (args, value) => ({
-				kind: "dsh-image-gen",
-				attachment: value.attachment,
-				provider: value.provider,
-				model: value.model,
-				output: value.output,
-				...typeof value.savedTo === "string" ? { savedTo: value.savedTo } : {},
-				prompt: args.prompt
-			})
-		},
+		output: imageOutput("Generated"),
 		async execute(args, exec) {
 			const active = resolveProvider(current());
 			const credential = await ctx.credentials.resolve(credentialRef(active.apiKeyEnv));
@@ -751,13 +1070,226 @@ function apply(ctx, config = {}) {
 		},
 		presentResult: (_args, result) => imagePresentation(result)
 	}));
+	ctx.tools.register(defineTool({
+		name: "edit_image",
+		description: "Edit, combine, or restyle existing images with the configured provider. Images attached inline to the latest human message are already readable DSH attachments even when no workspace file exists. In that case, call edit_image immediately with prompt only; NEVER call read_image, glob, or shell to locate them, and NEVER invent @ paths. All inline images will be used in upload order. For specific older conversation images use source_attachment_id or source_attachment_ids; both canonical sha256: IDs and full bare SHA-256 digests are accepted. For files the user explicitly names in the workspace use source_path or source_paths. Provide exactly one selector field. Without a selector, images from the latest human message take priority; only when that message has no images does editing fall back to the newest conversation image.",
+		parameters: {
+			prompt: {
+				type: "string",
+				required: true,
+				description: "Describe the changes to make while preserving everything else that should remain."
+			},
+			source_attachment_id: {
+				type: "string",
+				description: "Optional attachment id of a specific image already present in the current conversation."
+			},
+			source_attachment_ids: {
+				type: "array",
+				items: { type: "string" },
+				description: "Optional ordered attachment ids of multiple images already present in the current conversation. Prompt references such as image 1 and image 2 follow this order."
+			},
+			source_path: {
+				type: "string",
+				description: "Optional absolute or workspace-relative path of a specific image file inside the active session workspace. Prefer this when the user names a saved file."
+			},
+			source_paths: {
+				type: "array",
+				items: { type: "string" },
+				description: "Optional ordered absolute or workspace-relative paths of multiple image files inside the active session workspace."
+			},
+			aspect_ratio: {
+				type: "string",
+				enum: [
+					"1:1",
+					"3:2",
+					"2:3",
+					"4:3",
+					"3:4",
+					"16:9",
+					"9:16"
+				],
+				description: "Optional output aspect ratio for Google Gemini."
+			},
+			image_size: {
+				type: "string",
+				enum: [
+					"1K",
+					"2K",
+					"4K"
+				],
+				description: "Optional output resolution for Google Gemini."
+			},
+			size: {
+				type: "string",
+				description: "Optional output size for OpenAI, Seedream, or DashScope."
+			}
+		},
+		output: imageOutput("Edited"),
+		async execute(args, exec) {
+			const active = resolveProvider(current());
+			const credential = await ctx.credentials.resolve(credentialRef(active.apiKeyEnv));
+			if (credential === void 0 || credential.value.length === 0) throw new Error(`edit_image requires the ${active.apiKeyEnv} credential; configure it in Settings > Plugins > Image generation.`);
+			const sourceImages = await resolveReferenceImages({
+				...exec.agent === void 0 ? {} : { agent: exec.agent },
+				attachments: ctx.attachments,
+				...typeof args.source_attachment_id === "string" ? { sourceAttachmentId: args.source_attachment_id } : {},
+				...Array.isArray(args.source_attachment_ids) ? { sourceAttachmentIds: args.source_attachment_ids } : {},
+				...typeof args.source_path === "string" ? { sourcePath: args.source_path } : {},
+				...Array.isArray(args.source_paths) ? { sourcePaths: args.source_paths } : {},
+				maxBytes: ctx.attachments.imageLimits.maxImageBytes,
+				signal: exec.signal
+			});
+			if (active.provider === "google") {
+				const aspectRatio = args.aspect_ratio ?? active.aspectRatio;
+				const imageSize = args.image_size ?? active.imageSize;
+				return saveGenerated(ctx, await editGoogleImage({
+					apiKey: credential.value,
+					endpoint: active.endpoint,
+					model: active.model,
+					prompt: args.prompt,
+					sourceImages,
+					aspectRatio,
+					imageSize,
+					maxBytes: ctx.attachments.imageLimits.maxImageBytes,
+					signal: exec.signal
+				}), active.provider, active.model, `${aspectRatio}, ${imageSize}`, current(), exec);
+			}
+			const size = args.size ?? active.imageSize;
+			if (active.provider === "openai") return saveGenerated(ctx, await editOpenAICompatibleImage({
+				apiKey: credential.value,
+				baseURL: active.baseURL,
+				model: active.model,
+				prompt: args.prompt,
+				sourceImages,
+				size,
+				maxBytes: ctx.attachments.imageLimits.maxImageBytes,
+				signal: exec.signal
+			}), active.provider, active.model, size, current(), exec);
+			if (active.provider === "seedream") return saveGenerated(ctx, await editSeedreamImage({
+				apiKey: credential.value,
+				baseURL: active.baseURL,
+				model: active.model,
+				prompt: args.prompt,
+				sourceImages,
+				size,
+				maxBytes: ctx.attachments.imageLimits.maxImageBytes,
+				signal: exec.signal
+			}), active.provider, active.model, size, current(), exec);
+			return saveGenerated(ctx, await editDashScopeImage({
+				apiKey: credential.value,
+				endpoint: active.endpoint,
+				model: active.model,
+				prompt: args.prompt,
+				sourceImages,
+				size,
+				maxBytes: ctx.attachments.imageLimits.maxImageBytes,
+				signal: exec.signal
+			}), active.provider, active.model, size, current(), exec);
+		},
+		presentResult: (_args, result) => imagePresentation(result)
+	}));
+}
+function imageOutput(verb) {
+	return {
+		schema: {
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				attachment: {
+					type: "object",
+					required: true,
+					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
+								}
+							}
+						}
+					}
+				},
+				provider: {
+					type: "string",
+					required: true
+				},
+				model: {
+					type: "string",
+					required: true
+				},
+				output: {
+					type: "string",
+					required: true
+				},
+				savedTo: { type: "string" },
+				saveError: { type: "string" }
+			}
+		},
+		render: (_args, value) => {
+			const saved = typeof value.savedTo === "string" ? ` It was also saved to the workspace as ${value.savedTo}.` : typeof value.saveError === "string" ? ` Saving it to the workspace failed: ${value.saveError}.` : " It has no local file path.";
+			const action = verb === "Generated" ? "It is already attached to the conversation." : "The edited image is attached to the conversation.";
+			return [{
+				type: "text",
+				text: `${verb} one image with ${value.provider}/${value.model} (${value.output}). Attachment ID: ${String(value.attachment.attachmentId)}. ${action}${saved} Respond to the user without reading or searching for the image.`
+			}, {
+				type: "image",
+				attachment: value.attachment
+			}];
+		},
+		presentationMeta: (args, value) => ({
+			kind: "dsh-image-gen",
+			attachment: attachmentMeta(value.attachment),
+			provider: value.provider,
+			model: value.model,
+			output: value.output,
+			...verb === "Edited" ? { operation: "edit" } : {},
+			...typeof value.savedTo === "string" ? { savedTo: value.savedTo } : {},
+			prompt: args.prompt
+		})
+	};
+}
+function attachmentMeta(ref) {
+	return {
+		attachmentId: String(ref.attachmentId),
+		mediaType: ref.mediaType,
+		bytes: ref.bytes,
+		width: ref.width,
+		height: ref.height,
+		...ref.name === void 0 ? {} : { name: ref.name },
+		...ref.originalDimensions === void 0 ? {} : { originalDimensions: {
+			width: ref.originalDimensions.width,
+			height: ref.originalDimensions.height
+		} }
+	};
 }
-/**
-* Persist the generated image as a durable attachment, then — when workspace
-* saving is enabled — also write it as a file under the calling agent's
-* session workspace. A workspace write failure never discards the generated
-* attachment: it is reported through `saveError` instead.
-*/
 async function saveGenerated(ctx, generated, provider, model, output, config, exec) {
 	if (!ctx.attachments.imageLimits.mediaTypes.includes(generated.mediaType)) throw new Error(`This DSH deployment does not accept ${generated.mediaType} generated images`);
 	const attachment = await ctx.attachments.saveImage({