@eum-agent/llm-capability-image 0.0.0-stage → 1.1.0

package/dist/index.js

@@ -0,0 +1,1323 @@
+import { constants, existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { randomUUID } from "node:crypto";
+import { open, realpath, stat } from "node:fs/promises";
+//#region src/runtime/models/redact.ts
+function redactables(type, secrets) {
+	const out = { ...secrets };
+	for (const field of type.fields) {
+		if (field.kind !== "login") continue;
+		const value = secrets[field.key];
+		if (value === void 0) continue;
+		try {
+			const parsed = JSON.parse(value);
+			if (typeof parsed !== "object" || parsed === null) continue;
+			for (const [member, token] of Object.entries(parsed)) if (typeof token === "string" && token !== "") out[`${field.key}.${member}`] = token;
+		} catch {}
+	}
+	return out;
+}
+/** Adds every opaque token string to the call's redaction set, including rotated tokens. */
+function trackLogin(handle, values) {
+	let count = 0;
+	function record(value) {
+		if (!value) return;
+		values[`login.${count++}`] = value;
+		try {
+			const parsed = JSON.parse(value);
+			if (parsed && typeof parsed === "object") {
+				for (const member of Object.values(parsed)) if (typeof member === "string") record(member);
+			}
+		} catch {}
+	}
+	return {
+		async get(signal) {
+			const result = await handle.get(signal);
+			record(result.credential);
+			return result;
+		},
+		expire: (credential) => handle.expire(credential)
+	};
+}
+//#endregion
+//#region src/runtime/models/binding-port.ts
+/** Keeps construction, generation and deferred asset errors inside the same redaction lifetime. */
+function createImageBindingPort(adapter, call) {
+	const values = { ...call.secrets };
+	for (const [key, value] of Object.entries(call.secrets)) try {
+		const parsed = JSON.parse(value);
+		if (parsed && typeof parsed === "object") {
+			for (const [member, token] of Object.entries(parsed)) if (typeof token === "string" && token) values[`${key}.${member}`] = token;
+		}
+	} catch {}
+	function redact(value) {
+		for (const secret of Object.values(values).toSorted((a, b) => b.length - a.length)) if (secret) value = value.split(secret).join("****");
+		return value;
+	}
+	function failure(error) {
+		const source = error !== null && typeof error === "object" ? error : {};
+		const safe = new Error(typeof source.message === "string" ? redact(source.message) : "Image adapter failed");
+		if (typeof source.name === "string") safe.name = redact(source.name);
+		for (const key of [
+			"code",
+			"resultState",
+			"providerText",
+			"problem"
+		]) if (typeof source[key] === "string") Object.assign(safe, { [key]: redact(source[key]) });
+		for (const key of ["status", "retryAt"]) if (typeof source[key] === "number") Object.assign(safe, { [key]: source[key] });
+		if (typeof source.authored === "boolean") Object.assign(safe, { authored: source.authored });
+		return safe;
+	}
+	let port;
+	try {
+		port = adapter.createPort({
+			...call,
+			...call.login ? { login: trackLogin(call.login, values) } : {}
+		});
+	} catch (error) {
+		throw failure(error);
+	}
+	return { async generate(request, signal) {
+		try {
+			const result = await port.generate(request, signal);
+			if (!result || !Array.isArray(result.assets)) return result;
+			return {
+				...result,
+				assets: result.assets.map((asset) => ({
+					...asset,
+					body: { async *[Symbol.asyncIterator]() {
+						try {
+							yield* asset.body;
+						} catch (error) {
+							throw failure(error);
+						}
+					} }
+				}))
+			};
+		} catch (error) {
+			throw failure(error);
+		}
+	} };
+}
+//#endregion
+//#region src/capability.ts
+/** Validates the Image adapter shape without touching credentials or network. */
+function assertImageAdapter(adapter) {
+	const value = adapter;
+	if (!value || typeof value.models !== "function" || typeof value.createPort !== "function") throw new Error("unsupported-binding: invalid Image adapter");
+}
+function containsCustomCheck(value, seen = /* @__PURE__ */ new Set()) {
+	if (value === null || typeof value !== "object" || seen.has(value)) return false;
+	seen.add(value);
+	const internal = value._zod;
+	if (internal) return containsCustomCheck(internal.def, seen);
+	const record = value;
+	return record.check === "custom" || Object.values(record).some((child) => containsCustomCheck(child, seen));
+}
+const unique = (values) => new Set(values).size === values.length;
+const descriptors = z.array(z.strictObject({
+	id: z.string().trim().min(1),
+	label: z.string().trim().min(1),
+	outputKinds: z.array(z.enum([
+		"image",
+		"audio",
+		"video"
+	])).nonempty().refine(unique),
+	artifactOrigins: z.array(z.string().url().refine((value) => {
+		const url = new URL(value);
+		return url.protocol === "https:" && !url.username && !url.password && url.origin === value;
+	})).refine(unique).optional(),
+	operations: z.array(z.strictObject({
+		id: z.string().trim().min(1),
+		inputKinds: z.array(z.string().min(1)).refine(unique),
+		minInputs: z.number().int().nonnegative(),
+		maxInputs: z.number().int().nonnegative(),
+		paramsSchema: z.custom((value) => value instanceof z.ZodType)
+	}).refine((value) => value.minInputs <= value.maxInputs)).nonempty().refine((values) => unique(values.map((value) => value.id)))
+})).refine((values) => unique(values.map((value) => value.id)));
+/** Validates descriptors at their capability boundary, including strict lossless operation schemas. */
+function generationModelsOf(protocol, context) {
+	const adapter = protocol.adapters.image;
+	if (!adapter) return [];
+	assertImageAdapter(adapter);
+	const models = adapter.models(context);
+	if (!descriptors.safeParse(models).success) throw new Error("invalid Image model descriptors");
+	for (const model of models) {
+		if (!model.id || !model.label || !Array.isArray(model.outputKinds) || !Array.isArray(model.operations)) throw new Error("invalid Image model descriptor");
+		for (const operation of model.operations) {
+			if (!(operation.paramsSchema instanceof z.ZodObject) || !(operation.paramsSchema._zod.def.catchall instanceof z.ZodNever) || containsCustomCheck(operation.paramsSchema)) throw new Error("Image operation parameters must be a strict, lossless object schema");
+			operation.paramsSchema.toJSONSchema();
+		}
+	}
+	return models;
+}
+const ImageDiscoveryFacts = z.object({ output: z.array(z.string()).optional() });
+const ImageModelFacts = z.object({
+	modalities: z.object({ output: z.array(z.string()).optional() }).optional(),
+	generation: z.object({
+		outputKinds: z.array(z.string()).optional(),
+		operations: z.array(z.object({ id: z.string() })).optional()
+	}).optional()
+});
+function imageModelFor(input) {
+	assertImageAdapter(input.adapter);
+	const discovery = ImageDiscoveryFacts.safeParse(input.descriptor?.discoveryFacts).data;
+	const facts = ImageModelFacts.safeParse(input.descriptor?.modelFacts ?? input.facts).data;
+	const output = discovery?.output ?? facts?.modalities?.output ?? facts?.generation?.outputKinds;
+	if (output !== void 0 && !output.includes("image")) return void 0;
+	const declaredOperations = facts?.generation?.operations;
+	const context = {
+		providerId: input.ref.providerId,
+		config: input.config,
+		configuredModels: [{
+			id: input.ref.model,
+			...input.execution ? { execution: input.execution } : {}
+		}]
+	};
+	const model = input.adapter.models(context).find((item) => item.id === input.ref.model && item.outputKinds.includes("image"));
+	if (!model) return void 0;
+	const operations = model.operations.filter((operation) => (operation.id === "create" || operation.id === "edit") && (declaredOperations === void 0 || declaredOperations.some((one) => one.id === operation.id)));
+	return operations.length ? {
+		...model,
+		operations
+	} : void 0;
+}
+/** Registered Image ability; ordinary parameter edits affect only the next submission. */
+const imageCapability = {
+	id: "image",
+	tools: ["model_image_generate"],
+	label: "Image",
+	order: 20,
+	uiContributionKey: "image-models",
+	configurationPolicy: {
+		params: "retain",
+		connection: "cancel"
+	},
+	bindingSchema: z.record(z.string(), z.unknown()),
+	descriptorSchema: z.record(z.string(), z.unknown()),
+	paramsSchema(input) {
+		const operations = input.descriptor?.operations;
+		const fields = {};
+		if (Array.isArray(operations)) for (const operation of operations) {
+			if (!operation || typeof operation !== "object") continue;
+			const value = operation;
+			if (typeof value.id === "string" && value.parameterSchema && typeof value.parameterSchema === "object") fields[value.id] = z.fromJSONSchema(value.parameterSchema).optional();
+		}
+		return Object.keys(fields).length ? z.strictObject(fields) : z.strictObject({
+			create: z.record(z.string(), z.unknown()).optional(),
+			edit: z.record(z.string(), z.unknown()).optional()
+		});
+	},
+	validateAdapter: assertImageAdapter,
+	describeBinding(input) {
+		const model = imageModelFor(input);
+		return {
+			availability: {
+				available: !!model,
+				...!model ? { reason: "execution-unverified" } : {}
+			},
+			descriptor: { operations: model?.operations.map((operation) => ({
+				id: operation.id,
+				inputKinds: [...operation.inputKinds],
+				parameterSchema: operation.paramsSchema.toJSONSchema({ io: "input" })
+			})) ?? [] }
+		};
+	},
+	createBinding(input) {
+		const model = imageModelFor(input);
+		return {
+			...imageCapability.describeBinding(input),
+			model,
+			async createPort() {
+				return createImageBindingPort(input.adapter, input.getCall());
+			},
+			async dispose() {}
+		};
+	}
+};
+//#endregion
+//#region src/guidance.ts
+/** Image generation guidance withdraws with the owning tool. */
+const GUIDANCE = {
+	title: "Images",
+	entries: [{
+		tools: ["model_image_generate"],
+		text: "Use model_image_generate for image creation or editing. model_list with capabilityId image reports configured targets and operation parameter schemas. Explicit target overrides the retained image default. A failed default is never silently replaced. File references are returned after publication. If the conversation model cannot view images, do not claim to have inspected the generated result. Never automatically retry an unknown or failed submission.\nAfter successful generation or editing, deliver the image in your final reply using its canonical private attachment URI from the tool result's File reference. Choose presentation from the person's explicit request, task context and effective prompts. By default, show ordinary generation or editing inline as ![description](uri). When the person explicitly requests only a link, use [label](uri) with no inline image. To change only the presentation of an already delivered image, reuse its same URI without calling `model_image_generate` again.\nCopy the URI exactly as returned for that file; never guess or construct it, or substitute a local path, temporary download address, Base64, data URI, browser Blob URL or credential-bearing URL. If the image was saved and delivered as an attachment but no usable URI was returned, say it was generated but a body reference is currently unavailable; retain the attachment viewing entry, do not describe generation as failed, invent a link or generate again just to display it.\nFor failed, cancelled or unknown results, do not invent success, an image or a link, and do not automatically retry generation. Explain the actual result only while the turn can continue. If the whole turn was cancelled, preserve its cancellation state: do not append a reply, resume or restart the turn."
+	}]
+};
+//#endregion
+//#region src/output-schema.ts
+/** Validates complete owner business results and bounded recoverable delivery failures. */
+/** Adds the standard failure envelope and bounded text refusals to an owner's result schema. */
+function toolOutputSchema(body, input, name) {
+	return z.union([
+		body,
+		z.strictObject({
+			ok: z.literal(false),
+			error: z.strictObject({
+				code: z.string().min(1).max(128),
+				message: z.string().refine((value) => [...value].length <= 256).meta({ maxLength: 256 }),
+				retryable: z.boolean(),
+				field: z.string().max(256).optional(),
+				maximum: z.number().finite().optional()
+			}),
+			next: z.strictObject({
+				tool: z.literal(name),
+				arguments: input
+			}).nullable(),
+			execution: z.strictObject({ state: z.enum([
+				"not-started",
+				"committed",
+				"unknown"
+			]) }).optional()
+		}),
+		z.string().max(1024)
+	]);
+}
+//#endregion
+//#region src/image-generation.ts
+const target = z.strictObject({
+	providerId: z.string().min(1).max(512).describe("Exact configured provider connection ID from model_list."),
+	model: z.string().min(1).max(256).describe("Exact configured image model ID from model_list.")
+});
+const common = {
+	target: target.optional().describe("Exact configured target; otherwise use the global image default."),
+	prompt: z.string().refine((value) => value.trim().length > 0 && [...value.trim()].length <= 32e3, { message: "The prompt must contain 1–32000 Unicode characters after trimming." }).meta({
+		minLength: 1,
+		maxLength: 32e3
+	}).describe("Image instructions; 1–32000 Unicode characters after trimming."),
+	params: z.record(z.string(), z.unknown()).default({}).describe("Parameters must match the selected model operation schema; omit to use that model default.")
+};
+const reference = z.union([z.strictObject({ fileId: z.string().regex(/^[0-9a-f]{64}$/).describe("Stored image file ID from this session.") }), z.strictObject({ path: z.string().min(1).max(4096).describe("Local image path to authorize before submission.") })]);
+const create = {
+	...common,
+	operation: z.literal("create").default("create").describe("Create a new image without references.")
+};
+const edit = {
+	...common,
+	operation: z.literal("edit").describe("Edit existing images selected by one reference mechanism.")
+};
+const explicit = { reference_images: z.array(reference).min(1).max(14).describe("1–14 ordered references, subject to the selected model limit; mutually exclusive with recent count.") };
+const recent = { num_last_images_to_include: z.number().int().min(1).max(14).describe("1–14 most recent distinct session images; mutually exclusive with explicit references.") };
+/** Strict create/edit shapes, with paired explicit targets and mutually exclusive reference selectors. */
+const IMAGE_INPUT_SCHEMA = z.union([
+	z.strictObject(create),
+	z.strictObject({
+		...edit,
+		...explicit
+	}),
+	z.strictObject({
+		...edit,
+		...recent
+	})
+]);
+function refusal(content) {
+	return {
+		isError: true,
+		content: content.slice(0, 1024)
+	};
+}
+const FAILURE_TEXT = {
+	unsupported: "This connection does not support the requested image operation.",
+	"invalid-params": "The image request parameters are invalid.",
+	"invalid-input": "The selected reference images are missing, stale or unsupported.",
+	unavailable: "The current image generation connection is unavailable.",
+	busy: "Too many image calls are active; wait for one to finish.",
+	cancelled: "Image generation was cancelled.",
+	"credential-unavailable": "The connection credential is unavailable; check model settings.",
+	"not-signed-in": "Sign in to the selected connection in model settings.",
+	expired: "The provider sign-in expired; sign in again in model settings.",
+	forbidden: "This account or request is not permitted to generate an image.",
+	quota: "The image service rate or quota limit has been reached.",
+	timeout: "Image generation timed out.",
+	network: "The connection to the image service failed.",
+	provider: "The image service request failed.",
+	"invalid-output": "The returned image could not be read or did not meet output requirements.",
+	"too-large": "The image inputs or output exceeded the size limit.",
+	storage: "The generated image could not be saved."
+};
+const STATE_TEXT = {
+	"not-submitted": "No image request was submitted.",
+	unknown: "The server result is unknown; another attempt creates a new request.",
+	"not-delivered": "No image was delivered."
+};
+/** Displays only host-normalized detail; unexpected exceptions never expose their messages. */
+function failureOf(error, cancelled) {
+	const failure = error;
+	if (failure?.name !== "GenerationFailure" || typeof failure.code !== "string" || !Object.hasOwn(FAILURE_TEXT, failure.code)) return {
+		isError: true,
+		content: cancelled ? "Image generation was cancelled. No image was delivered." : "Image generation failed. No image was delivered."
+	};
+	const state = failure.resultState ?? "not-delivered";
+	const prefix = `${FAILURE_TEXT[failure.code]} ${STATE_TEXT[state] ?? STATE_TEXT["not-delivered"]}`;
+	const retryAt = failure.retryAt;
+	const retry = typeof retryAt === "number" && Number.isFinite(retryAt) && retryAt > 0 && retryAt <= 864e13 ? ` Retry after ${new Date(retryAt).toISOString()} UTC.` : "";
+	return {
+		isError: true,
+		content: (prefix + (typeof failure.message === "string" ? ` ${failure.message}` : "")).slice(0, 511 - retry.length) + retry + " Do not automatically retry."
+	};
+}
+/** Creates the shared image tool with explicit, default, then unique-candidate routing. */
+function imageGenerationTool(deps) {
+	const candidates = (operation) => deps.generation.connections().flatMap((connection) => connection.models.filter((model) => model.outputKinds.includes("image")).flatMap((model) => model.operations.filter((one) => one.id === operation).map((descriptor) => ({
+		ref: {
+			providerId: connection.providerId,
+			model: model.id
+		},
+		descriptor
+	}))));
+	return {
+		name: "model_image_generate",
+		preload: false,
+		deliveryKind: "preview",
+		description: "Generate or edit an image using a configured image model. Inspect model_list for operation parameter schemas. Supply target to override the global image default. Never automatically retry a failed submission.",
+		inputSchema: IMAGE_INPUT_SCHEMA,
+		outputSchema: toolOutputSchema(z.strictObject({
+			ok: z.literal(true),
+			committed: z.literal(true),
+			text: z.string(),
+			target,
+			fileIds: z.array(z.string().regex(/^[0-9a-f]{64}$/)).min(1).max(8)
+		}), IMAGE_INPUT_SCHEMA, "model_image_generate"),
+		available(view) {
+			return view.model !== null && deps.generation.connections().some((connection) => connection.models.some((model) => model.outputKinds.includes("image") && model.operations.some((operation) => operation.id === "create" || operation.id === "edit")));
+		},
+		async execute(input, ctx) {
+			try {
+				const current = deps.generation.current(ctx);
+				const requested = input.target ?? deps.defaultModel();
+				const all = candidates(input.operation);
+				const eligible = requested ? all.filter((one) => one.ref.providerId === requested.providerId && one.ref.model === requested.model) : all;
+				if (!eligible.length) return refusal("The selected or default image model is unavailable for this operation. Choose an image model in settings or pass an explicit target. No request was submitted.");
+				if (eligible.length !== 1) return refusal("Multiple image models are available. Set a default image model or pass an explicit target from model_list.");
+				const selected = eligible[0];
+				const identity = deps.identity(selected.ref);
+				if (!identity) return refusal("The image connection is unavailable. No request was submitted.");
+				const merged = structuredClone({
+					...deps.params(selected.ref, input.operation),
+					...input.params
+				});
+				const params = selected.descriptor.paramsSchema.safeParse(merged);
+				if (!params.success) return refusal("The selected image model does not support these parameters. Inspect model_list for its operation schema.");
+				let prepared;
+				if (input.operation === "edit") {
+					const count = "reference_images" in input ? input.reference_images.length : input.num_last_images_to_include;
+					if (count < selected.descriptor.minInputs || count > selected.descriptor.maxInputs) return refusal("The selected image model does not support this number of reference images.");
+					const selection = "reference_images" in input ? input.reference_images : { recent: input.num_last_images_to_include };
+					const result = await deps.inputs.prepare(ctx, selection);
+					if (result.kind === "ask") return result.result;
+					if (result.kind === "refused") return refusal(result.message);
+					prepared = result.inputs;
+				}
+				const authorization = await deps.generation.authorizeArtifacts(ctx, selected.ref);
+				if (authorization.kind === "ask") return authorization.result;
+				if (authorization.kind === "refused") return refusal(authorization.message);
+				const next = deps.generation.current(ctx);
+				if (JSON.stringify(next?.ref) !== JSON.stringify(current?.ref) || next?.connectionRevision !== current?.connectionRevision || next?.registrationEpoch !== current?.registrationEpoch || deps.identity(selected.ref) !== identity) return refusal("The current conversation connection changed. No image request was submitted.");
+				if (!candidates(input.operation).some((one) => one.ref.providerId === selected.ref.providerId && one.ref.model === selected.ref.model)) return refusal("The selected image model became unavailable. No image request was submitted.");
+				ctx.signal.throwIfAborted();
+				const result = await deps.generation.generate(ctx, {
+					ref: selected.ref,
+					operation: input.operation,
+					outputKind: "image",
+					prompt: input.prompt.trim(),
+					params: params.data,
+					...prepared === void 0 ? {} : { inputs: prepared }
+				});
+				return {
+					content: JSON.stringify({
+						ok: true,
+						committed: true,
+						target: selected.ref,
+						text: result.text?.trim() || "Image generated.",
+						fileIds: result.files.map((file) => file.id)
+					}),
+					files: result.files.map((file) => ({
+						fileId: file.id,
+						name: file.name
+					}))
+				};
+			} catch (error) {
+				return failureOf(error, ctx.signal.aborted);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/adapters.ts
+/** Returns the capability-owned image adapter. */
+function imageAdapter(protocol) {
+	return protocol?.adapters.image;
+}
+//#endregion
+//#region src/runtime/models/generation.ts
+/** Host admission, validation, cancellation and atomic delivery for generation tools. */
+/** A stable failure whose text never contains raw provider headers or bodies. */
+var GenerationFailure = class extends Error {
+	name = "GenerationFailure";
+	code;
+	resultState;
+	status;
+	retryAt;
+	constructor(code, message, resultState = "not-submitted", status, retryAt) {
+		super(message.slice(0, 512));
+		this.code = code;
+		this.resultState = resultState;
+		this.status = status;
+		this.retryAt = retryAt;
+	}
+};
+const FAILURE_CODES = /* @__PURE__ */ new Set([
+	"unsupported",
+	"invalid-params",
+	"invalid-input",
+	"unavailable",
+	"busy",
+	"cancelled",
+	"credential-unavailable",
+	"not-signed-in",
+	"expired",
+	"forbidden",
+	"quota",
+	"timeout",
+	"network",
+	"provider",
+	"invalid-output",
+	"too-large",
+	"storage"
+]);
+function fail(code, message) {
+	throw new GenerationFailure(code, message);
+}
+/** Races uncooperative promises while still observing their eventual rejection. */
+function untilAbort(promise, signal) {
+	if (signal.aborted) {
+		promise.catch(() => {});
+		signal.throwIfAborted();
+	}
+	return new Promise((resolve, reject) => {
+		const abort = () => reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+		signal.addEventListener("abort", abort, { once: true });
+		promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+	});
+}
+/** Builds independently bound services sharing the installation's admission budget. */
+function createGenerationHost(deps) {
+	const prepared = /* @__PURE__ */ new WeakMap();
+	const active = /* @__PURE__ */ new Set();
+	const authorized = /* @__PURE__ */ new WeakMap();
+	const ports = /* @__PURE__ */ new Map();
+	let stopped = false;
+	function descriptor(owner, ref, crossOwner = false) {
+		const target = deps.target(ref);
+		if (!target?.enabled || target.lifetime.aborted || !crossOwner && target.owner !== owner || !imageAdapter(target.protocol)) fail("unavailable", "the generation provider is unavailable");
+		const model = deps.descriptors(target.protocol, {
+			providerId: ref.providerId,
+			config: target.config,
+			configuredModels: target.configuredModels
+		}).find((one) => one.id === ref.model);
+		if (!model) fail("unsupported", "the generation model is unsupported");
+		return {
+			target,
+			model
+		};
+	}
+	function bind(owner, crossOwner = false) {
+		return {
+			connections: () => deps.connections(crossOwner ? void 0 : owner),
+			current(ctx) {
+				deps.authenticate(owner, ctx);
+				return deps.current(ctx);
+			},
+			async authorizeArtifacts(ctx, ref) {
+				deps.authenticate(owner, ctx);
+				const { model, target } = descriptor(owner, ref, crossOwner);
+				const result = await deps.authorize(ctx, model.artifactOrigins ?? []);
+				if (result.kind === "ready") {
+					if (deps.target(ref)?.registrationEpoch !== target.registrationEpoch || deps.target(ref)?.protocolEpoch !== target.protocolEpoch || deps.target(ref)?.connectionRevision !== target.connectionRevision || !deps.target(ref)?.enabled || target.lifetime.aborted || ctx.signal.aborted) fail("cancelled", "the provider changed during authorization");
+					authorized.set(ctx, new Set(model.artifactOrigins ?? []));
+				}
+				return result;
+			},
+			async generate(ctx, input) {
+				deps.authenticate(owner, ctx);
+				if (stopped) fail("unavailable", "generation is stopped");
+				ctx.signal.throwIfAborted();
+				const { target, model } = descriptor(owner, input.ref, crossOwner);
+				const operation = model.operations.find((one) => one.id === input.operation);
+				if (!operation || !model.outputKinds.includes(input.outputKind)) fail("unsupported", "the generation operation is unsupported");
+				const prompt = input.prompt.trim();
+				if (!prompt || [...prompt].length > 32e3) fail("invalid-params", "the generation prompt must contain 1–32000 characters");
+				const params = operation.paramsSchema.safeParse(input.params);
+				if (!params.success) fail("invalid-params", `the generation parameters are invalid (${params.error.issues.slice(0, 4).map((issue) => `${issue.path.map(String).join(".") || "params"}: ${issue.code}`).join("; ")})`);
+				const selection = input.inputs === void 0 ? void 0 : prepared.get(input.inputs);
+				const historyRevision = deps.sessionRevision(ctx.sessionId);
+				if (input.inputs !== void 0 && (!selection || selection.owner !== owner || selection.ctx !== ctx || selection.sessionId !== ctx.sessionId || selection.callId !== ctx.toolCallId || selection.revision !== historyRevision)) fail("invalid-input", "the input selection is invalid or stale");
+				const inputs = selection?.files ?? [];
+				if (inputs.length < operation.minInputs || inputs.length > operation.maxInputs || inputs.some((file) => !operation.inputKinds.includes(file.mediaType.split("/")[0]))) fail("invalid-input", "the generation input count or media kind is unsupported");
+				const origins = model.artifactOrigins ?? [];
+				if (origins.some((origin) => !authorized.get(ctx)?.has(origin))) fail("forbidden", "authorize artifact origins before generation");
+				if (active.size >= 4 || [...active].filter((one) => one.ctx.sessionId === ctx.sessionId).length >= 2) fail("busy", "too many active generation calls");
+				const initial = deps.current(ctx);
+				const controller = new AbortController();
+				const deadline = AbortSignal.timeout(9e5);
+				const signal = AbortSignal.any([
+					ctx.signal,
+					target.lifetime,
+					controller.signal,
+					deadline
+				]);
+				const staged = [];
+				let submitted = false;
+				let responded = false;
+				let phase = "provider";
+				const admission = {
+					ctx,
+					controller,
+					assertCurrent() {
+						signal.throwIfAborted();
+						const now = deps.target(input.ref);
+						const current = deps.current(ctx);
+						if (!now?.enabled || now.owner !== target.owner || now.registrationEpoch !== target.registrationEpoch || now.protocolEpoch !== target.protocolEpoch || now.connectionRevision !== target.connectionRevision || historyRevision !== deps.sessionRevision(ctx.sessionId) || JSON.stringify(current?.ref) !== JSON.stringify(initial?.ref)) fail("cancelled", "the generation context changed");
+					}
+				};
+				active.add(admission);
+				let secrets = {};
+				try {
+					admission.assertCurrent();
+					const key = JSON.stringify([
+						owner,
+						input.ref.providerId,
+						input.ref.model,
+						"generation"
+					]);
+					let kept = ports.get(key);
+					if (!kept || kept.epoch !== target.registrationEpoch || kept.protocolEpoch !== target.protocolEpoch || kept.revision !== target.connectionRevision) {
+						const credential = deps.credential(input.ref, target.type);
+						const redactions = redactables(target.type, credential.secrets);
+						const login = credential.login === void 0 ? void 0 : trackLogin(credential.login, redactions);
+						secrets = redactions;
+						const port = imageAdapter(target.protocol).createPort({
+							endpointId: String(target.config.endpointId),
+							protocolId: target.protocol.type,
+							options: target.options,
+							providerId: input.ref.providerId,
+							model: input.ref.model,
+							config: target.config,
+							configuredModels: target.configuredModels,
+							secrets: credential.secrets,
+							...login ? { login } : {}
+						});
+						kept = {
+							ref: input.ref,
+							owner: target.owner,
+							epoch: target.registrationEpoch,
+							protocolEpoch: target.protocolEpoch,
+							revision: target.connectionRevision,
+							port,
+							secrets: redactions
+						};
+						ports.set(key, kept);
+					}
+					secrets = kept.secrets;
+					const port = kept.port;
+					submitted = true;
+					const firstDeadline = new AbortController();
+					const firstTimer = setTimeout(() => {
+						firstDeadline.abort(new DOMException("The first response timed out", "TimeoutError"));
+					}, 3e5);
+					firstTimer.unref();
+					const first = AbortSignal.any([signal, firstDeadline.signal]);
+					const result = await untilAbort((async () => port.generate({
+						identity: { callId: randomUUID() },
+						artifacts: deps.artifacts(ctx, origins),
+						operation: input.operation,
+						outputKind: input.outputKind,
+						prompt,
+						params: params.data,
+						inputs
+					}, first))(), first).finally(() => clearTimeout(firstTimer));
+					responded = true;
+					if (result === null || typeof result !== "object" || !Array.isArray(result.assets) || result.assets.length < 1 || result.assets.length > 8 || result.text !== void 0 && (typeof result.text !== "string" || [...result.text].length > 16e3)) fail("invalid-output", "the provider returned an invalid generation result");
+					phase = "stage";
+					let total = 0;
+					for (const asset of result.assets) {
+						admission.assertCurrent();
+						const body = (async function* () {
+							const iterator = asset.body[Symbol.asyncIterator]();
+							try {
+								for (;;) {
+									const next = await untilAbort(iterator.next(), AbortSignal.any([signal, AbortSignal.timeout(6e4)]));
+									if (next.done) break;
+									if (!(next.value instanceof Uint8Array)) fail("invalid-output", "the provider returned invalid asset bytes");
+									total += next.value.byteLength;
+									if (total > 268435456) fail("too-large", "the generation result exceeds 256 MiB");
+									yield next.value;
+								}
+							} finally {
+								iterator.return?.().catch(() => {});
+							}
+						})();
+						staged.push(await deps.files.stageStream(ctx.address.workspaceId, {
+							mediaType: asset.mediaType,
+							name: asset.name,
+							body
+						}, {
+							outputKind: input.outputKind,
+							signal
+						}));
+					}
+					phase = "commit";
+					const files = await deps.files.commitBatch(ctx.address.workspaceId, ctx.sessionId, staged, {
+						signal,
+						assertCurrent: admission.assertCurrent
+					});
+					return {
+						...result.text === void 0 ? {} : { text: result.text },
+						files
+					};
+				} catch (error) {
+					if (error instanceof GenerationFailure) {
+						if (submitted && error.resultState === "not-submitted") throw new GenerationFailure(error.code, error.message, responded ? "not-delivered" : "unknown", error.status, error.retryAt);
+						throw error;
+					}
+					const record = error;
+					const cancelled = ctx.signal.aborted || target.lifetime.aborted || controller.signal.aborted || record.name === "AbortError";
+					const timeout = record.name === "TimeoutError" || deadline.aborted;
+					const reported = typeof record.code === "string" && FAILURE_CODES.has(record.code) && (record.authored || record.name === "GenerationFailure") ? record.code : void 0;
+					const code = cancelled ? "cancelled" : timeout ? "timeout" : phase === "commit" ? "storage" : phase === "stage" ? record.problem === "too-large" ? "too-large" : "invalid-output" : reported ?? (record.name === "CredentialUnavailableError" ? "credential-unavailable" : record.status === 401 ? "expired" : record.status === 403 ? "forbidden" : record.status === 429 ? "quota" : "provider");
+					let message = (record.authored || reported) && typeof record.message === "string" ? record.message : code === "cancelled" ? "generation was cancelled" : code === "timeout" ? "generation timed out" : code === "storage" ? "the generated files could not be saved" : code === "invalid-output" ? "the generated media is invalid" : code === "expired" ? "your sign-in expired; sign in again" : "the generation provider call failed";
+					if (typeof record.providerText === "string") message += `: ${record.providerText.slice(0, 65536)}`;
+					for (const secret of Object.values(secrets)) if (secret) message = message.split(secret).join("****");
+					const retryAt = typeof record.retryAt === "number" && Number.isFinite(record.retryAt) && record.retryAt > 0 && record.retryAt <= 864e13 ? record.retryAt : void 0;
+					if (retryAt !== void 0) message += ` Retry after ${new Date(retryAt).toISOString()}.`;
+					const declaredState = record.name === "GenerationFailure" && reported !== void 0 && (record.resultState === "not-submitted" || record.resultState === "unknown" || record.resultState === "not-delivered") ? record.resultState : void 0;
+					throw new GenerationFailure(code, message, responded ? "not-delivered" : declaredState ?? (submitted ? "unknown" : "not-submitted"), typeof record.status === "number" ? record.status : void 0, retryAt);
+				} finally {
+					active.delete(admission);
+					deps.files.discard(staged);
+				}
+			}
+		};
+	}
+	return {
+		bindInputs(owner) {
+			return { async prepare(ctx, selectors) {
+				deps.authenticate(owner, ctx);
+				ctx.signal.throwIfAborted();
+				const revision = deps.sessionRevision(ctx.sessionId);
+				const result = await deps.prepare(ctx, selectors);
+				ctx.signal.throwIfAborted();
+				if (!Array.isArray(result)) return result;
+				if (revision !== deps.sessionRevision(ctx.sessionId)) fail("cancelled", "the session history changed");
+				const token = Object.freeze({});
+				prepared.set(token, {
+					owner,
+					ctx,
+					callId: ctx.toolCallId,
+					sessionId: ctx.sessionId,
+					revision,
+					files: result
+				});
+				return {
+					kind: "ready",
+					inputs: token
+				};
+			} };
+		},
+		bind,
+		bindCoordinator: (owner) => bind(owner, true),
+		invalidate() {
+			for (const [key, kept] of ports) {
+				const target = deps.target(kept.ref);
+				if (!target?.enabled || target.owner !== kept.owner || target.registrationEpoch !== kept.epoch || target.protocolEpoch !== kept.protocolEpoch || target.connectionRevision !== kept.revision) ports.delete(key);
+			}
+			for (const call of active) try {
+				call.assertCurrent();
+			} catch {
+				call.controller.abort();
+			}
+		},
+		stop() {
+			stopped = true;
+			ports.clear();
+			for (const call of active) call.controller.abort();
+		}
+	};
+}
+//#endregion
+//#region src/runtime/models/generation-inputs.ts
+/** Ordered, host-authorized image references for generation tool submissions. */
+const FILE_ORIGINAL_LIMIT = 20971520;
+const IMAGE_MEDIA_TYPES = [
+	"image/png",
+	"image/jpeg",
+	"image/gif",
+	"image/webp"
+];
+const selectorsSchema = z.union([z.object({ recent: z.number().int().min(1).max(16) }).strict(), z.array(z.union([z.object({ fileId: z.string().regex(/^[0-9a-f]{64}$/) }).strict(), z.object({ path: z.string().min(1) }).strict()])).max(16)]);
+/** Prepares authorized bytes only after every selected path has passed the fence. */
+function createGenerationInputReader(deps) {
+	return async (ctx, selectors) => {
+		ctx.signal.throwIfAborted();
+		const parsed = selectorsSchema.safeParse(selectors);
+		if (!parsed.success) return {
+			kind: "refused",
+			message: "invalid generation input selectors"
+		};
+		selectors = parsed.data;
+		const history = deps.history(ctx);
+		const ordered = [];
+		for (const message of history) for (const part of message.content) {
+			if (part.type === "file") ordered.push(part.file);
+			if (part.type === "tool-result") ordered.push(...part.files ?? []);
+		}
+		const latest = new Map(ordered.map((file, index) => [file.id, {
+			file,
+			index
+		}]));
+		let selection;
+		if ("recent" in selectors) {
+			const recent = [...latest.values()].filter((one) => IMAGE_MEDIA_TYPES.includes(one.file.mediaType)).sort((a, b) => a.index - b.index).slice(-selectors.recent);
+			if (recent.length !== selectors.recent) return {
+				kind: "refused",
+				message: "the session does not contain enough recent images"
+			};
+			selection = recent.map((one) => ({ fileId: one.file.id }));
+		} else selection = selectors;
+		const paths = /* @__PURE__ */ new Map();
+		for (const item of selection) if ("fileId" in item) {
+			const selected = latest.get(item.fileId);
+			if (!selected) return {
+				kind: "refused",
+				message: "the selected file is not in this session history"
+			};
+			if (!IMAGE_MEDIA_TYPES.includes(selected.file.mediaType)) return {
+				kind: "refused",
+				message: "the selected file is not an image"
+			};
+		}
+		const requested = selection.flatMap((item, index) => "path" in item ? [{
+			index,
+			path: item.path
+		}] : []);
+		if (requested.length > 0) {
+			const verdict = deps.scope.allowsBatch(ctx, requested.map((item) => item.path), "read");
+			if (!verdict.allowed) {
+				if (verdict.reason === "ask" && "awaitHuman" in verdict.ask) return {
+					kind: "ask",
+					result: verdict.ask
+				};
+				return {
+					kind: "refused",
+					message: "message" in verdict ? verdict.message : "content" in verdict.ask ? verdict.ask.content : "reading the selected image paths was refused"
+				};
+			}
+			for (const [offset, item] of requested.entries()) {
+				const path = verdict.paths[offset];
+				if (path === void 0) return {
+					kind: "refused",
+					message: "the image path was not authorized"
+				};
+				paths.set(item.index, path);
+			}
+		}
+		function pathsCurrent() {
+			const verdict = deps.scope.allowsBatch(ctx, requested.map((item) => item.path), "read");
+			return verdict.allowed && requested.every((item, offset) => verdict.paths[offset] === paths.get(item.index));
+		}
+		const files = [];
+		try {
+			for (const [index, item] of selection.entries()) {
+				ctx.signal.throwIfAborted();
+				let bytes;
+				if ("path" in item) {
+					const path = paths.get(index);
+					if (path === void 0) return {
+						kind: "refused",
+						message: "the image path was not authorized"
+					};
+					const descriptor = await (deps.open ?? open)(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+					try {
+						ctx.signal.throwIfAborted();
+						const before = await descriptor.stat();
+						if (!before.isFile() || before.size > FILE_ORIGINAL_LIMIT) return {
+							kind: "refused",
+							message: "the image exceeds the input size limit"
+						};
+						if (!pathsCurrent() || await realpath(path) !== path || !sameFile(before, await stat(path))) return {
+							kind: "refused",
+							message: "the image path changed before it was read"
+						};
+						const parts = [];
+						let size = 0;
+						for (;;) {
+							ctx.signal.throwIfAborted();
+							const chunk = Buffer.alloc(Math.min(65536, FILE_ORIGINAL_LIMIT - size + 1));
+							const result = await descriptor.read(chunk, 0, chunk.length, size);
+							ctx.signal.throwIfAborted();
+							if (result.bytesRead === 0) break;
+							size += result.bytesRead;
+							if (size > FILE_ORIGINAL_LIMIT) return {
+								kind: "refused",
+								message: "the image exceeds the input size limit"
+							};
+							parts.push(chunk.subarray(0, result.bytesRead));
+						}
+						const after = await descriptor.stat();
+						if (!sameFile(before, after) || size !== after.size) return {
+							kind: "refused",
+							message: "the image changed while it was read"
+						};
+						if (!pathsCurrent() || await realpath(path) !== path || !sameFile(after, await stat(path))) return {
+							kind: "refused",
+							message: "the image path changed while it was read"
+						};
+						bytes = Buffer.concat(parts, size);
+					} finally {
+						await descriptor.close();
+					}
+				} else bytes = await deps.files.read(ctx.address.workspaceId, item.fileId);
+				if (!bytes || bytes.length > FILE_ORIGINAL_LIMIT) return {
+					kind: "refused",
+					message: "the selected image is missing or exceeds the input size limit"
+				};
+				const info = await deps.probeImage(bytes);
+				ctx.signal.throwIfAborted();
+				const held = bytes;
+				files.push({
+					mediaType: info.mediaType,
+					size: held.length,
+					async *read(signal) {
+						signal.throwIfAborted();
+						yield held;
+						signal.throwIfAborted();
+					}
+				});
+			}
+			return files;
+		} catch {
+			ctx.signal.throwIfAborted();
+			return {
+				kind: "refused",
+				message: "the selected image could not be read"
+			};
+		}
+	};
+}
+function sameFile(before, after) {
+	return before.ino === after.ino && before.dev === after.dev && before.size === after.size && before.mtimeMs === after.mtimeMs && before.ctimeMs === after.ctimeMs;
+}
+//#endregion
+//#region src/runtime/models/generation-services.ts
+/** Composes resource authorization with capability-owned image execution and atomic publication. */
+function createGenerationServices(input) {
+	const { ctx, manager, host } = input;
+	const deps = {
+		files: host.files,
+		security: host.security,
+		contexts: host.contexts,
+		approval: input.approval,
+		transport: host.transport,
+		probeImage: host.media.probeImage
+	};
+	function session(id) {
+		return host.contexts.session(id);
+	}
+	const identities = /* @__PURE__ */ new Map();
+	function target(ref) {
+		const row = manager.store.findConnection(ref.providerId);
+		if (!row) return void 0;
+		const provider = manager.registries.models.entry(row.type);
+		const selected = manager.store.findChannel(ref.providerId, "image");
+		const capability = manager.registries.capabilities.entry("image");
+		const protocol = selected && manager.registries.protocols.entry(selected.protocolId);
+		if (!provider || !selected || !protocol || !capability || !protocol.type.adapters.image) return void 0;
+		const configuredModels = manager.store.listBindings(ref.providerId, "image").filter((binding) => !binding.invalid).map((binding) => ({
+			id: binding.ref.model,
+			...binding.execution ? { execution: binding.execution } : {}
+		}));
+		const fingerprint = JSON.stringify([
+			row.revision,
+			selected.revision,
+			configuredModels,
+			provider.registrationEpoch,
+			protocol.registrationEpoch,
+			capability.registrationEpoch
+		]);
+		const prior = identities.get(ref.providerId);
+		const revision = prior?.fingerprint === fingerprint ? prior.revision : (prior?.revision ?? 0) + 1;
+		identities.set(ref.providerId, {
+			fingerprint,
+			revision
+		});
+		const original = protocol.type.adapters.image;
+		const wrapped = {
+			...protocol.type,
+			adapters: {
+				...protocol.type.adapters,
+				image: {
+					...original,
+					createPort: () => ({ async generate(request, signal) {
+						const lease = await manager.acquire({
+							...ref,
+							capabilityId: "image"
+						}, signal);
+						try {
+							return await (await lease.runtime.createPort()).generate(request, lease.signal);
+						} finally {
+							await lease.release();
+						}
+					} })
+				}
+			}
+		};
+		return {
+			type: provider.type,
+			protocol: wrapped,
+			protocolEpoch: protocol.registrationEpoch,
+			options: selected.options,
+			owner: provider.owner,
+			registrationEpoch: provider.registrationEpoch,
+			lifetime: AbortSignal.any([
+				provider.lifetime,
+				protocol.lifetime,
+				capability.lifetime
+			]),
+			enabled: row.enabled,
+			config: {
+				...row.config,
+				endpointId: row.endpointId,
+				protocolId: protocol.type.type
+			},
+			configuredModels,
+			connectionRevision: revision
+		};
+	}
+	function descriptors(providerId, found = target({
+		providerId,
+		model: ""
+	})) {
+		return found?.enabled ? generationModelsOf(found.protocol, {
+			providerId,
+			config: found.config,
+			configuredModels: found.configuredModels
+		}) : [];
+	}
+	function current(call) {
+		const ref = session(call.sessionId)?.model;
+		if (!ref) return null;
+		const row = manager.store.findConnection(ref.providerId);
+		const entry = row && manager.registries.models.entry(row.type);
+		if (!row || !entry) return null;
+		return {
+			ref,
+			type: row.type,
+			owner: entry.owner,
+			registrationEpoch: entry.registrationEpoch,
+			connectionRevision: row.revision,
+			loginState: null,
+			chatInputKinds: []
+		};
+	}
+	const approved = /* @__PURE__ */ new WeakMap();
+	const generation = createGenerationHost({
+		files: host.files,
+		descriptors: generationModelsOf,
+		authenticate: (owner, call) => host.contexts.authenticate(owner, call),
+		current,
+		target,
+		connections(owner) {
+			return manager.store.listConnections().flatMap((row) => {
+				const entry = manager.registries.models.entry(row.type);
+				if (!row.enabled || !entry || owner !== void 0 && entry.owner !== owner) return [];
+				const found = target({
+					providerId: row.providerId,
+					model: ""
+				});
+				if (!found) return [];
+				return [{
+					providerId: row.providerId,
+					type: row.type,
+					owner: entry.owner,
+					label: row.name,
+					loginState: null,
+					models: descriptors(row.providerId, found)
+				}];
+			});
+		},
+		credential(ref, type) {
+			if (type.login && manager.connections().find((row) => row.providerId === ref.providerId)?.login?.state !== "signed-in") throw new GenerationFailure("not-signed-in", "Sign in to the selected connection in model settings.");
+			const availability = manager.availability({
+				...ref,
+				capabilityId: "image"
+			});
+			if (!availability.available && availability.reason === "credential-unavailable") throw new GenerationFailure("credential-unavailable", "The connection credential is unavailable; check model settings.");
+			return { secrets: {} };
+		},
+		sessionRevision: (id) => session(id)?.historyGeneration ?? -1,
+		prepare: createGenerationInputReader({
+			files: host.files,
+			scope: host.security,
+			probeImage: host.media.probeImage,
+			history: (call) => host.contexts.history(call)
+		}),
+		async authorize(ctx, origins) {
+			ctx.signal.throwIfAborted();
+			const needs = [];
+			for (const origin of origins) {
+				const url = new URL(origin);
+				if (url.protocol !== "https:" || url.origin !== origin || url.username || url.password) return {
+					kind: "refused",
+					message: "artifact origins must be exact HTTPS origins"
+				};
+				const verdict = await deps.security.judgeAddress(origin);
+				ctx.signal.throwIfAborted();
+				if (verdict.kind !== "allowed") return {
+					kind: "refused",
+					message: "the artifact origin address was refused or unresolved"
+				};
+				const port = Number(url.port || 443);
+				if (!deps.security.holdsHost(verdict.host, port, "connect")) needs.push({
+					host: verdict.host,
+					port
+				});
+			}
+			ctx.signal.throwIfAborted();
+			if (needs.length) {
+				const decision = deps.approval.decide(ctx, {
+					id: "generationArtifactOrigins",
+					subject: "Download generated media",
+					reason: "The provider will return generated media from these hosts.",
+					targets: needs.map((one) => ({
+						access: "connect",
+						target: `${one.host}:${one.port}`
+					})),
+					accepts: [
+						"allowed-once",
+						"allowed-always",
+						"rejected"
+					],
+					globalResource: true
+				});
+				if (decision.kind === "ask") {
+					if ("awaitHuman" in decision.result) return {
+						kind: "ask",
+						result: decision.result
+					};
+					return {
+						kind: "refused",
+						message: "artifact authorization is unavailable"
+					};
+				}
+				if (decision.result.kind !== "allowed-once" && decision.result.kind !== "allowed-always") return {
+					kind: "refused",
+					message: "artifact authorization was refused"
+				};
+				ctx.signal.throwIfAborted();
+				if (decision.result.kind === "allowed-always") deps.security.recordHosts(needs.map((one) => ({
+					host: one.host,
+					port: one.port,
+					operations: ["connect"]
+				})));
+			}
+			approved.set(ctx, new Set(origins));
+			return { kind: "ready" };
+		},
+		artifacts(ctx, origins) {
+			return { async fetch(url, signal) {
+				let currentUrl = url;
+				for (let hop = 0; hop <= 5; hop++) {
+					signal.throwIfAborted();
+					const parsed = new URL(currentUrl);
+					if (!origins.includes(parsed.origin) || !approved.get(ctx)?.has(parsed.origin) || parsed.username || parsed.password) throw new GenerationFailure("forbidden", "the artifact URL has an unauthorized origin", "not-delivered");
+					const address = await deps.security.judgeAddress(currentUrl);
+					if (address.kind !== "allowed") throw new GenerationFailure("forbidden", "the artifact address was refused or unresolved", "not-delivered");
+					signal.throwIfAborted();
+					const response = await deps.transport({
+						url: currentUrl,
+						addresses: address.addresses,
+						headers: {
+							"user-agent": "yaoguang",
+							accept: "*/*"
+						},
+						signal
+					});
+					if ([
+						301,
+						302,
+						303,
+						307,
+						308
+					].includes(response.status)) {
+						response.cancel();
+						if (hop === 5 || !response.headers.location) throw new GenerationFailure("network", "the artifact redirect limit was exceeded", "not-delivered");
+						currentUrl = new URL(response.headers.location, currentUrl).href;
+						continue;
+					}
+					if (signal.aborted) {
+						response.cancel();
+						signal.throwIfAborted();
+					}
+					return artifactResponse(response, signal);
+				}
+				throw new GenerationFailure("network", "the artifact download failed", "not-delivered");
+			} };
+		}
+	});
+	const dispose = manager.onChanged(() => generation.invalidate());
+	ctx.onDispose(() => {
+		dispose();
+	});
+	ctx.signal.addEventListener("abort", () => generation.stop(), { once: true });
+	return {
+		...generation,
+		identity(ref) {
+			const found = target(ref);
+			return found?.enabled && !found.lifetime.aborted ? JSON.stringify([
+				found.owner,
+				found.registrationEpoch,
+				found.protocolEpoch,
+				found.connectionRevision
+			]) : void 0;
+		},
+		availability(address, id) {
+			const ref = id ? session(id)?.model ?? null : null;
+			const row = ref ? manager.store.findConnection(ref.providerId) : void 0;
+			const entry = row ? manager.registries.models.entry(row.type) : void 0;
+			let toolsAllowed;
+			let chatInputKinds = [];
+			try {
+				const policy = ctx.services.get("model-tool-policy").availability(address, id);
+				toolsAllowed = policy.toolsAllowed;
+				chatInputKinds = policy.chatInputKinds;
+			} catch {}
+			return {
+				toolsAllowed,
+				sessionId: id ?? "",
+				address,
+				model: ref,
+				type: row?.type ?? null,
+				owner: entry?.owner ?? null,
+				chatInputKinds: [...chatInputKinds],
+				generation: ref ? descriptors(ref.providerId).map(({ id, label, outputKinds }) => ({
+					id,
+					label,
+					outputKinds
+				})) : [],
+				loginState: null
+			};
+		}
+	};
+}
+/** Keeps a downloaded body in the same cancellation lifetime as its generation call. */
+function artifactResponse(response, signal) {
+	const iterator = response.body?.[Symbol.asyncIterator]();
+	let finished = false;
+	let streamController;
+	const release = () => {
+		if (finished) return;
+		finished = true;
+		signal.removeEventListener("abort", abort);
+		response.cancel();
+		if (iterator?.return) Promise.resolve().then(() => iterator.return?.()).catch(() => void 0);
+	};
+	const abort = () => {
+		release();
+		streamController?.error(signal.reason);
+	};
+	const body = iterator ? new ReadableStream({
+		start(controller) {
+			streamController = controller;
+			signal.addEventListener("abort", abort, { once: true });
+			if (signal.aborted) abort();
+		},
+		async pull(controller) {
+			try {
+				signal.throwIfAborted();
+				const next = await iterator.next();
+				signal.throwIfAborted();
+				if (finished) return;
+				if (next.done) {
+					controller.close();
+					release();
+				} else controller.enqueue(next.value);
+			} catch (error) {
+				if (!finished) controller.error(error);
+				release();
+			}
+		},
+		cancel() {
+			release();
+		}
+	}) : null;
+	if (body === null) release();
+	try {
+		return new Response(body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: Object.fromEntries(Object.entries(response.headers).filter((entry) => entry[1] !== void 0))
+		});
+	} catch (error) {
+		release();
+		throw error;
+	}
+}
+//#endregion
+//#region src/index.ts
+/** Image generation and editing capability, independent from the selected Chat provider. */
+/** Tools owned by the Image capability. */
+const TOOL_NAMES = ["model_image_generate"];
+/** Image tool settings withdraw the tool and its guidance together. */
+const ImageToolConfig = z.strictObject({ disabled: z.array(z.enum(TOOL_NAMES)).default([]) }).default({ disabled: [] });
+const plugin = {
+	name: "@eum-agent/llm-capability-image",
+	requires: [
+		"model-management",
+		"agent-capability-host",
+		"approval"
+	],
+	provides: ["generation-runtime"],
+	configSchema: ImageToolConfig,
+	apply(ctx, config) {
+		ctx.modelCapabilities.register({
+			...imageCapability,
+			tools: config.disabled.includes("model_image_generate") ? [] : TOOL_NAMES
+		});
+		const manager = ctx.services.get("model-management");
+		const generation = createGenerationServices({
+			ctx,
+			manager,
+			host: ctx.services.get("agent-capability-host"),
+			approval: ctx.services.get("approval")
+		});
+		ctx.services.provide("generation-runtime", {
+			bind: generation.bind,
+			bindInputs: generation.bindInputs,
+			availability: generation.availability,
+			invalidate: generation.invalidate
+		});
+		if (!config.disabled.includes("model_image_generate")) ctx.tools.register(imageGenerationTool({
+			generation: generation.bindCoordinator(ctx.pluginName),
+			inputs: generation.bindInputs(ctx.pluginName),
+			defaultModel: () => {
+				const ref = manager.store.getDefault("image")?.ref;
+				return ref ? {
+					providerId: ref.providerId,
+					model: ref.model
+				} : null;
+			},
+			params: (ref, operation) => manager.store.findBinding({
+				...ref,
+				capabilityId: "image"
+			})?.params[operation] ?? {},
+			identity: generation.identity
+		}));
+		ctx.tools.guide(GUIDANCE);
+		const ui = fileURLToPath(new URL("../ui/ui.js", import.meta.url));
+		if (existsSync(ui)) ctx.client.registerUi({ module: ui });
+	}
+};
+//#endregion
+export { ImageToolConfig, TOOL_NAMES, plugin as default };