dsh-image-gen 0.1.6 → 0.2.0

package/lib/index.js

@@ -2,6 +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 { 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. */
@@ -24,10 +27,12 @@ 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. */
+/** Default workspace subfolder that receives generated image files. */
+const DEFAULT_WORKSPACE_FOLDER = "dsh-image-gen";
 /** Google API credential reference. */
 const GOOGLE_API_KEY_ENV = "GEMINI_API_KEY";
 /** OpenAI Platform or compatible relay credential reference. */
@@ -46,7 +51,9 @@ const Config = z.object({
 	seedreamBaseURL: z.string().default(DEFAULT_SEEDREAM_BASE_URL),
 	seedreamModel: z.string().default(DEFAULT_SEEDREAM_MODEL),
 	dashscopeEndpoint: z.string().default(DEFAULT_DASHSCOPE_ENDPOINT),
-	dashscopeModel: z.string().default(DEFAULT_DASHSCOPE_MODEL)
+	dashscopeModel: z.string().default(DEFAULT_DASHSCOPE_MODEL),
+	saveToWorkspace: z.boolean().default(true),
+	workspaceFolder: z.string().default(DEFAULT_WORKSPACE_FOLDER)
 });
 /** Resolve exactly one provider profile for a tool call. */
 function resolveProvider(config) {
@@ -68,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"
 		};
@@ -84,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: [{ image: toDataUrl$1(options.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;
@@ -180,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
+		}, {
+			type: "image",
+			mime_type: input.sourceImage.mediaType,
+			data: Buffer.from(input.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",
@@ -194,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,
@@ -203,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);
@@ -238,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 = [];
@@ -268,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 {
@@ -283,6 +306,156 @@ 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 and read the image to edit from the current effective conversation.
+*
+* This is the only module allowed to know how DSH sessions expose effective
+* messages or how nested model-facing content stores durable image refs.
+*/
+async function resolveReferenceImage(input) {
+	if (input.sourceAttachmentId !== void 0 && input.sourcePath !== void 0) throw new Error("edit_image accepts either source_attachment_id or source_path, not both");
+	if (input.sourcePath !== void 0) return readWorkspaceReferenceImage({
+		sourcePath: input.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 ref = findReferenceImage(input.agent.session.deriveMessages(), input.sourceAttachmentId);
+	if (ref === void 0) {
+		if (input.sourceAttachmentId !== void 0) throw new Error(`edit_image could not find image attachment ${input.sourceAttachmentId} in the current conversation`);
+		throw new Error("edit_image requires an image in the current conversation; upload or generate an image first");
+	}
+	const stored = await input.attachments.readImage(ref, input.signal);
+	return {
+		data: stored.data,
+		mediaType: stored.ref.mediaType
+	};
+}
+/**
+* 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 || 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 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. */
@@ -317,20 +490,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;
@@ -355,10 +518,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,
@@ -372,20 +534,174 @@ 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 uploadBytes = new Uint8Array(input.sourceImage.data);
+	form.append("image", new Blob([uploadBytes], { type: input.sourceImage.mediaType }), `reference.${extensionOf(input.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: [toDataUrl(input.sourceImage)],
+			...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);
 }
@@ -393,37 +709,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) {
@@ -458,17 +785,130 @@ async function readBoundedBytes(response, maxBytes) {
 	return joined;
 }
 //#endregion
+//#region lib/types/workspace-save.js
+/** Persist one generated image as a file under the session workspace. */
+/** File extension for each supported image media type. */
+const EXTENSION = {
+	"image/png": "png",
+	"image/jpeg": "jpg",
+	"image/webp": "webp",
+	"image/gif": "gif"
+};
+/**
+* Build the deterministic file name for a generated image:
+* `image-<digest-prefix>.<ext>`. The digest prefix comes from the
+* content-addressed attachment id, so the same image bytes always map to the
+* same file name regardless of when they were generated, and re-saving simply
+* overwrites the previous copy in place.
+* @param attachmentId - durable attachment id (`sha256:<hex>`).
+* @param mediaType - verified image media type.
+* @returns the file name (no directory).
+*/
+function workspaceImageName(attachmentId, mediaType) {
+	return `image-${(attachmentId.startsWith("sha256:") ? attachmentId.slice(7) : attachmentId).slice(0, 8).padEnd(8, "0")}.${EXTENSION[mediaType]}`;
+}
+/**
+* Resolve the configured image folder inside the session workspace. The
+* folder may nest, but must stay inside the workspace: absolute paths and
+* parent-traversal segments are rejected for both separator styles.
+*
+* This lexical pass is necessary but not sufficient: `saveImageToWorkspace`
+* additionally verifies the on-disk resolution so symlinked folders cannot
+* escape the workspace.
+* @param workspaceRoot - the session workspace directory.
+* @param folder - configured subfolder; empty/blank means the workspace root.
+* @returns the absolute image directory.
+* @throws when the folder would escape the workspace root.
+*/
+function workspaceImageDir(workspaceRoot, folder) {
+	const trimmed = (folder ?? "").trim();
+	const root = resolve(workspaceRoot);
+	const dir = trimmed === "" ? root : resolve(root, trimmed);
+	if (!containsPath(root, dir)) throw new Error(`image workspace folder '${folder}' must stay inside the session workspace`);
+	return dir;
+}
+/** True when `child` equals `parent` or lives underneath it (lexically). */
+function containsPath(parent, child) {
+	const rel = relative(parent, child);
+	return rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+/**
+* Real path of the closest existing ancestor of `dir` (inclusive). Walking up
+* lets us validate symlinked folder segments before creating anything under
+* them.
+*/
+async function nearestExistingRealPath(dir) {
+	let probe = dir;
+	for (;;) try {
+		return await realpath(probe);
+	} catch (error) {
+		if (error?.code !== "ENOENT") throw error;
+		const parent = dirname(probe);
+		if (parent === probe) throw error;
+		probe = parent;
+	}
+}
+/** Reject a directory whose on-disk resolution lands outside the workspace. */
+function assertInsideWorkspace(realRoot, candidate, folder) {
+	if (containsPath(realRoot, candidate)) return;
+	throw new Error(`image workspace folder '${folder ?? ""}' must stay inside the session workspace (${candidate} resolves outside ${realRoot})`);
+}
+/**
+* Write one generated image durably under the session workspace.
+*
+* Containment is enforced twice: lexically by `workspaceImageDir`, then
+* against real paths, so a configured folder (or any intermediate segment)
+* that is a symlink pointing outside the workspace is rejected before and
+* after anything is created.
+*
+* The bytes are written to a same-directory staging file and renamed onto the
+* target, so a crash never leaves a half-written image under its final name.
+* Re-saving identical bytes rewrites the same file (the name is content-
+* addressed), which keeps repeated generations idempotent. A cancellation is
+* honoured up to and including the final rename: an aborted save never
+* resolves successfully and never leaves the image behind under its final
+* name.
+* @param options - workspace root, configured folder, attachment identity, and image bytes.
+* @returns the absolute path of the written file.
+*/
+async function saveImageToWorkspace(options) {
+	const dir = workspaceImageDir(options.workspaceRoot, options.folder);
+	options.signal?.throwIfAborted();
+	const realRoot = await realpath(resolve(options.workspaceRoot));
+	assertInsideWorkspace(realRoot, await nearestExistingRealPath(dir), options.folder);
+	const name = workspaceImageName(options.attachmentId, options.mediaType);
+	const target = join(dir, name);
+	const staging = join(dir, `.${name}.${process.pid}-${randomUUID()}.tmp`);
+	await mkdir(dir, { recursive: true });
+	assertInsideWorkspace(realRoot, await realpath(dir), options.folder);
+	try {
+		await writeFile(staging, options.data, {
+			flag: "wx",
+			signal: options.signal
+		});
+		options.signal?.throwIfAborted();
+		await rename(staging, target);
+	} catch (error) {
+		await unlink(staging).catch(() => {});
+		throw error;
+	}
+	try {
+		options.signal?.throwIfAborted();
+	} catch (error) {
+		await unlink(target).catch(() => {});
+		throw error;
+	}
+	return target;
+}
+//#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, {
@@ -484,7 +924,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 and has no local file path; do not call read, glob, or other tools to locate or verify it.",
+		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",
@@ -518,66 +958,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
-					}
-				}
-			},
-			render: (_args, value) => [{
-				type: "text",
-				text: `Generated one image with ${value.provider}/${value.model} (${value.output}). It is already attached to the conversation with no local file path; respond to the user without reading or searching for it.`
-			}],
-			presentationMeta: (args, value) => ({
-				kind: "dsh-image-gen",
-				attachment: value.attachment,
-				provider: value.provider,
-				model: value.model,
-				output: value.output,
-				prompt: args.prompt
-			})
-		},
+		output: imageOutput("Generated"),
 		async execute(args, exec) {
 			const active = resolveProvider(current());
 			const credential = await ctx.credentials.resolve(credentialRef(active.apiKeyEnv));
@@ -594,7 +975,7 @@ function apply(ctx, config = {}) {
 					imageSize,
 					maxBytes: ctx.attachments.imageLimits.maxImageBytes,
 					signal: exec.signal
-				}), active.provider, active.model, `${aspectRatio}, ${imageSize}`);
+				}), active.provider, active.model, `${aspectRatio}, ${imageSize}`, current(), exec);
 			}
 			if (active.provider === "dashscope") {
 				const size = args.size ?? active.imageSize;
@@ -606,7 +987,7 @@ function apply(ctx, config = {}) {
 					size,
 					maxBytes: ctx.attachments.imageLimits.maxImageBytes,
 					signal: exec.signal
-				}), active.provider, active.model, size);
+				}), active.provider, active.model, size, current(), exec);
 			}
 			const size = args.size ?? active.imageSize;
 			return saveGenerated(ctx, await generateOpenAICompatibleImage({
@@ -618,23 +999,249 @@ function apply(ctx, config = {}) {
 				size,
 				maxBytes: ctx.attachments.imageLimits.maxImageBytes,
 				signal: exec.signal
-			}), active.provider, active.model, size);
+			}), active.provider, active.model, size, current(), exec);
+		},
+		presentResult: (_args, result) => imagePresentation(result)
+	}));
+	ctx.tools.register(defineTool({
+		name: "edit_image",
+		description: "Edit or restyle an existing image with the configured provider. For a named workspace file, pass its exact path as source_path. For a specific image still attached to the current conversation, pass source_attachment_id. Never provide both. Omit both only when the user clearly means the newest conversation image. If the user identifies an older image but its exact path or attachment id is unknown, do not silently edit the newest image: first use an image-reading tool to put the intended file into the conversation, then call edit_image without a source.",
+		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_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."
+			},
+			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 sourceImage = await resolveReferenceImage({
+				...exec.agent === void 0 ? {} : { agent: exec.agent },
+				attachments: ctx.attachments,
+				...typeof args.source_attachment_id === "string" ? { sourceAttachmentId: args.source_attachment_id } : {},
+				...typeof args.source_path === "string" ? { sourcePath: args.source_path } : {},
+				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,
+					sourceImage,
+					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,
+				sourceImage,
+				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,
+				sourceImage,
+				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,
+				sourceImage,
+				size,
+				maxBytes: ctx.attachments.imageLimits.maxImageBytes,
+				signal: exec.signal
+			}), active.provider, active.model, size, current(), exec);
 		},
 		presentResult: (_args, result) => imagePresentation(result)
 	}));
 }
-async function saveGenerated(ctx, generated, provider, model, output) {
-	if (!ctx.attachments.imageLimits.mediaTypes.includes(generated.mediaType)) throw new Error(`This DSH deployment does not accept ${generated.mediaType} generated images`);
+function imageOutput(verb) {
 	return {
-		attachment: await ctx.attachments.saveImage({
-			data: generated.data,
-			mediaType: generated.mediaType,
-			name: "generated-image"
-		}),
+		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
+		} }
+	};
+}
+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({
+		data: generated.data,
+		mediaType: generated.mediaType,
+		name: "generated-image"
+	});
+	const value = {
+		attachment,
 		provider,
 		model,
 		output
 	};
+	if (config.saveToWorkspace === false) return value;
+	const workspaceRoot = exec.agent?.session.header.cwd;
+	if (workspaceRoot === void 0) return value;
+	try {
+		value.savedTo = await saveImageToWorkspace({
+			workspaceRoot,
+			folder: config.workspaceFolder,
+			attachmentId: attachment.attachmentId,
+			mediaType: generated.mediaType,
+			data: generated.data,
+			signal: exec.signal
+		});
+	} catch (error) {
+		exec.signal.throwIfAborted();
+		ctx.logger.warn(`dsh-image-gen: failed to save image to workspace: ${error instanceof Error ? error.message : String(error)}`);
+		value.saveError = error instanceof Error ? error.message : String(error);
+	}
+	return value;
 }
 function imagePresentation(result) {
 	const attachment = imageAttachmentFromMeta(result.meta);