@hydraharness/harness-tool-media 0.1.1-rc.6

package/lib/index.js

@@ -0,0 +1,1063 @@
+import z from "@hydraharness/schemastery";
+import { admitEncodedImages, toolImageReferences, toolMediaLabels, toolVideoReferences } from "@hydraharness/harness-attachment";
+import { z as z$1 } from "zod";
+import { credentialRef } from "@hydraharness/harness-credentials";
+import { defineTool } from "@hydraharness/harness-tools";
+import { isGenerationRejection } from "@hydraharness/harness-llm";
+//#region lib/types/generated-images.js
+/** Durable attachment admission for decoded provider image results. */
+/** Describe stored images without loading image bytes into model history.
+* @param images - Durable image references available to later media calls.
+* @returns Attachment ids and image properties in a bounded JSON summary.
+*/
+function generatedImageSummary(images) {
+	return `Image attachments: ${JSON.stringify(images.map(({ attachmentId, mediaType, width, height }) => ({
+		attachmentId,
+		mediaType,
+		width,
+		height
+	})))}`;
+}
+/** Store each generated image using its position and media type as the filename.
+* @param store - session attachment owner.
+* @param images - encoded final provider images.
+* @param jobId - Optional provider job id for recovery after attachment admission fails.
+* @returns admitted references in provider order.
+*/
+function admitGeneratedImages(store, images, jobId) {
+	return admitEncodedImages(store, images.map((image, index) => ({
+		data: image.data,
+		mediaType: image.mimeType,
+		name: `generated-${index + 1}.${image.mimeType.slice(6)}`
+	}))).catch((error) => {
+		if (jobId !== void 0 && jobId !== null && /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(jobId)) throw new Error(`Image storage failed. jobId=${jobId}. Use gemini_web_retrieve without sending the prompt again.`);
+		throw error;
+	});
+}
+//#endregion
+//#region lib/types/media-job.js
+/** Non-secret provider job correlation carried by completed media responses. */
+/** Read a validated local recovery id without admitting provider URLs into metadata.
+* @param response - Completed media response.
+* @returns A local UUID, or undefined for providers without saved-task recovery.
+*/
+function mediaJobId(response) {
+	const id = response.headers.get("x-hydra-job-id");
+	return id !== null && /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(id) ? id : void 0;
+}
+//#endregion
+//#region lib/types/image-openai.js
+/** Loader defaults for the Images API. */
+const OpenAIImageConfig = z.object({
+	useProviderModels: z.boolean().default(true),
+	provider: z.string(),
+	fallbackModels: z.array(z.string()),
+	model: z.string().default("gpt-image-1.5"),
+	baseURL: z.string().default("https://api.openai.com/v1"),
+	apiKeyEnv: z.string().role("credential-ref").default("OPENAI_API_KEY"),
+	timeoutMs: z.number().default(18e4),
+	maxResponseBytes: z.number().default(32 * 1024 * 1024),
+	maxPromptChars: z.number().default(32e3),
+	maxImages: z.number().default(4)
+});
+const geminiResponse$1 = z$1.object({ candidates: z$1.array(z$1.object({
+	finishReason: z$1.literal("STOP"),
+	content: z$1.object({ parts: z$1.array(z$1.object({
+		thought: z$1.boolean().optional(),
+		inlineData: z$1.object({
+			mimeType: z$1.enum([
+				"image/png",
+				"image/jpeg",
+				"image/webp"
+			]),
+			data: z$1.string().min(1)
+		}).optional()
+	})) })
+})).length(1) });
+const chatResponse$1 = z$1.object({ choices: z$1.array(z$1.object({
+	finish_reason: z$1.literal("stop"),
+	message: z$1.object({ images: z$1.array(z$1.object({ image_url: z$1.object({ url: z$1.string().regex(/^data:image\/(?:png|jpeg|webp);base64,[A-Za-z0-9+/=]+$/) }) })).min(1) })
+})).length(1) }).transform((value) => ({ candidates: value.choices.map((choice) => ({
+	finishReason: "STOP",
+	content: { parts: choice.message.images.map((image) => {
+		const url = image.image_url.url;
+		const comma = url.indexOf(",");
+		return { inlineData: {
+			mimeType: z$1.enum([
+				"image/png",
+				"image/jpeg",
+				"image/webp"
+			]).parse(url.slice(5, comma - 7)),
+			data: url.slice(comma + 1)
+		} };
+	}) }
+})) }));
+const responseSchema$1 = z$1.union([
+	z$1.object({ data: z$1.array(z$1.object({ b64_json: z$1.string().min(1) })) }),
+	geminiResponse$1,
+	z$1.object({ response: geminiResponse$1 }).transform((value) => value.response),
+	chatResponse$1
+]);
+const imageSchema = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		attachmentId: {
+			type: "string",
+			required: true
+		},
+		mediaType: {
+			type: "string",
+			required: true,
+			enum: [
+				"image/png",
+				"image/jpeg",
+				"image/webp",
+				"image/gif"
+			]
+		},
+		bytes: {
+			type: "integer",
+			required: true,
+			minimum: 1
+		},
+		width: {
+			type: "integer",
+			required: true,
+			minimum: 1
+		},
+		height: {
+			type: "integer",
+			required: true,
+			minimum: 1
+		},
+		name: { type: "string" }
+	}
+};
+/**
+* Register image_generate over configured Images API routes. Explicit rejections
+* permit fallback; timeouts and ambiguous failures stop to avoid duplicate billing.
+* @param ctx - Tool, credential, and attachment services.
+* @param config - Loader-validated deployment configuration.
+*/
+function registerOpenAIImages(ctx, config) {
+	const resolved = config;
+	for (const field of [
+		"timeoutMs",
+		"maxResponseBytes",
+		"maxPromptChars",
+		"maxImages"
+	]) if (!Number.isSafeInteger(resolved[field]) || resolved[field] < 1) throw new TypeError(`tool-media: openai. ${field} must be a positive safe integer`);
+	if (resolved.maxImages > 10) throw new TypeError("tool-media: openai. maxImages must not exceed 10");
+	if (resolved.model.trim() === "") throw new TypeError("tool-media: openai. model must not be empty");
+	if (resolved.fallbackModels.some((model) => model.trim() === "")) throw new TypeError("tool-media: openai. fallbackModels must not contain empty ids");
+	const endpoint = new URL(`${resolved.baseURL.replace(/\/$/, "")}/images/generations`);
+	if (endpoint.username || endpoint.password || endpoint.search || endpoint.hash || endpoint.protocol !== "https:" && !(endpoint.protocol === "http:" && [
+		"localhost",
+		"127.0.0.1",
+		"[::1]"
+	].includes(endpoint.hostname))) throw new TypeError("tool-media: openai. baseURL must use HTTPS or loopback HTTP without credentials, query, or fragment");
+	const ref = credentialRef(resolved.apiKeyEnv);
+	const maxImages = Math.min(resolved.maxImages, ctx.attachments.imageLimits.maxImagesPerMessage);
+	ctx.tools.register(defineTool({
+		name: "image_generate",
+		description: "Generate images with the configured image model and display them in chat. Uses the connected provider's quota or API billing. Do not retry a timeout automatically.",
+		timeoutMs: resolved.timeoutMs,
+		parameters: {
+			prompt: {
+				type: "string",
+				required: true,
+				description: "Refine the user request into an image prompt using your current conversation context before calling this tool. Use precise terminology for composition, framing, lighting, materials, and style where the request supports it. Preserve the subject, intent, exact quoted text and its language, counts, and all constraints or exclusions. Do not invent requirements or add conflicting details. If the user requests an exact prompt or no rewriting, pass that prompt verbatim. Send the final generation prompt only, without commentary."
+			},
+			count: {
+				type: "integer",
+				minimum: 1,
+				maximum: maxImages,
+				description: "Number of images; defaults to 1."
+			},
+			size: {
+				type: "string",
+				enum: [
+					"auto",
+					"1024x1024",
+					"1536x1024",
+					"1024x1536"
+				]
+			},
+			quality: {
+				type: "string",
+				enum: [
+					"auto",
+					"low",
+					"medium",
+					"high"
+				]
+			},
+			format: {
+				type: "string",
+				enum: [
+					"png",
+					"jpeg",
+					"webp"
+				]
+			},
+			background: {
+				type: "string",
+				enum: [
+					"auto",
+					"opaque",
+					"transparent"
+				]
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					model: {
+						type: "string",
+						required: true
+					},
+					provider: { type: "string" },
+					jobId: { type: "string" },
+					images: {
+						type: "array",
+						required: true,
+						items: imageSchema
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Generated ${value.images.length} image(s) with ${value.provider ?? "OpenAI"} (${value.model}).\n${generatedImageSummary(value.images)}`
+			}],
+			presentationMeta: (_args, value) => ({
+				kind: "tool-images",
+				...value
+			})
+		},
+		presentCall: (args) => ({
+			card: "media",
+			kind: "image",
+			title: "Generate image",
+			prompt: args.prompt,
+			...args.size === void 0 || args.size === "auto" ? {} : { aspectRatio: {
+				"1024x1024": 1,
+				"1536x1024": 1.5,
+				"1024x1536": 2 / 3
+			}[args.size] }
+		}),
+		presentResult: (_args, result) => result.isError ? void 0 : {
+			card: "media",
+			kind: "image",
+			title: "Generated image",
+			content: toolImageReferences(result.meta).map((attachment) => ({
+				type: "image",
+				attachment
+			})),
+			...toolMediaLabels(result.meta)
+		},
+		async execute(args, execution) {
+			if (execution.parent !== void 0) throw new Error("image_generate requires Native tool mode for chat presentation.");
+			if (args.prompt.trim() === "" || args.prompt.length > resolved.maxPromptChars) throw new TypeError(`Image prompt must contain 1–${resolved.maxPromptChars} characters.`);
+			const request = {
+				model: resolved.model,
+				prompt: args.prompt,
+				n: args.count ?? 1,
+				size: args.size ?? "auto",
+				quality: args.quality ?? "auto",
+				output_format: args.format ?? "png",
+				background: args.background ?? "auto"
+			};
+			if (request.output_format === "jpeg" && request.background === "transparent") throw new TypeError("Transparent backgrounds require PNG or WebP.");
+			const signal = AbortSignal.any([execution.signal, AbortSignal.timeout(resolved.timeoutMs)]);
+			const generated = resolved.useProviderModels ? await ctx.get("llm")?.generateMedia({
+				endpoint: "images/generations",
+				body: request,
+				model: resolved.model,
+				signal,
+				maxResponseBytes: resolved.maxResponseBytes,
+				...config.provider === void 0 ? {} : { provider: config.provider }
+			}) : void 0;
+			if (config.provider !== void 0 && generated === void 0) throw new Error(`Provider ${config.provider} has no configured image generation models.`);
+			let response;
+			if (generated !== void 0) {
+				response = generated.response;
+				request.model = generated.model;
+			} else {
+				const credential = await ctx.credentials.resolve(ref);
+				if (credential === void 0) throw new Error(`Configure ${resolved.apiKeyEnv} or an image model with credentials on the Models page before generating images.`);
+				const post = (model) => {
+					signal.throwIfAborted();
+					request.model = model;
+					return fetch(endpoint, {
+						method: "POST",
+						redirect: "error",
+						signal,
+						headers: {
+							"Content-Type": "application/json",
+							Authorization: `Bearer ${credential.value}`
+						},
+						body: JSON.stringify(request)
+					});
+				};
+				response = await post(resolved.model);
+				for (const model of new Set(resolved.fallbackModels)) {
+					if (model === resolved.model) continue;
+					if (!isGenerationRejection(response.status)) break;
+					await response.body?.cancel();
+					response = await post(model);
+				}
+			}
+			if (!response.ok) {
+				await response.body?.cancel();
+				throw new Error(`OpenAI image request failed (HTTP ${response.status}). Check credentials, model access, and account limits before retrying.`);
+			}
+			let bytes = 0;
+			const body = response.body?.pipeThrough(new TransformStream({ transform(chunk, controller) {
+				bytes += chunk.byteLength;
+				if (bytes > resolved.maxResponseBytes) throw new Error("OpenAI image response exceeds maxResponseBytes.");
+				controller.enqueue(chunk);
+			} }));
+			const value = responseSchema$1.parse(await new Response(body).json());
+			signal.throwIfAborted();
+			const output = "data" in value ? value.data.map((image) => ({
+				data: image.b64_json,
+				mimeType: `image/${request.output_format}`
+			})) : value.candidates.flatMap((candidate) => candidate.content.parts.flatMap((part) => "thought" in part && part.thought || part.inlineData === void 0 ? [] : [part.inlineData]));
+			if (output.length !== request.n) throw new Error("Image provider returned an unexpected image count.");
+			const images = await admitGeneratedImages(ctx.attachments, output, response.headers.get("x-hydra-job-id"));
+			signal.throwIfAborted();
+			const jobId = mediaJobId(response);
+			return {
+				model: request.model,
+				images: [...images],
+				...generated === void 0 ? {} : { provider: generated.provider },
+				...jobId === void 0 ? {} : { jobId }
+			};
+		}
+	}));
+}
+//#endregion
+//#region lib/types/image-google.js
+/** Loader defaults for Gemini image generation. */
+const GoogleImageConfig = z.object({
+	useProviderModels: z.boolean().default(true),
+	provider: z.string(),
+	model: z.string().default("gemini-3.1-flash-image"),
+	baseURL: z.string().default("https://generativelanguage.googleapis.com/v1"),
+	apiKeyEnv: z.string().role("credential-ref").default("GEMINI_API_KEY"),
+	timeoutMs: z.number().default(18e4),
+	maxResponseBytes: z.number().default(32 * 1024 * 1024),
+	maxPromptChars: z.number().default(32e3),
+	maxImages: z.number().default(4)
+});
+const geminiResponse = z$1.object({ candidates: z$1.array(z$1.object({
+	finishReason: z$1.string(),
+	content: z$1.object({ parts: z$1.array(z$1.object({
+		thought: z$1.boolean().optional(),
+		inlineData: z$1.object({
+			mimeType: z$1.enum([
+				"image/png",
+				"image/jpeg",
+				"image/webp"
+			]),
+			data: z$1.string().min(1)
+		}).optional()
+	})) }).optional()
+})).max(1).optional() });
+const chatResponse = z$1.object({ choices: z$1.array(z$1.object({
+	finish_reason: z$1.literal("stop"),
+	message: z$1.object({ images: z$1.array(z$1.object({ image_url: z$1.object({ url: z$1.string().regex(/^data:image\/(?:png|jpeg|webp);base64,[A-Za-z0-9+/=]+$/) }) })).min(1) })
+})).length(1) }).transform((value) => ({ candidates: value.choices.map((choice) => ({
+	finishReason: "STOP",
+	content: { parts: choice.message.images.map((image) => {
+		const url = image.image_url.url;
+		const comma = url.indexOf(",");
+		return { inlineData: {
+			mimeType: z$1.enum([
+				"image/png",
+				"image/jpeg",
+				"image/webp"
+			]).parse(url.slice(5, comma - 7)),
+			data: url.slice(comma + 1)
+		} };
+	}) }
+})) }));
+const responseSchema = z$1.union([
+	z$1.object({ data: z$1.array(z$1.object({ b64_json: z$1.string().min(1) })) }),
+	z$1.object({ response: geminiResponse }).transform((value) => value.response),
+	chatResponse,
+	geminiResponse
+]);
+/**
+* Register image_generate_google with final images in presentation metadata.
+* Each call makes one stateless generateContent request without automatic retries.
+* @param ctx - Tool, credential, and attachment services.
+* @param config - Loader-validated deployment configuration.
+*/
+function registerGoogleImages(ctx, config) {
+	const resolved = config;
+	for (const field of [
+		"timeoutMs",
+		"maxResponseBytes",
+		"maxPromptChars",
+		"maxImages"
+	]) if (!Number.isSafeInteger(resolved[field]) || resolved[field] < 1) throw new TypeError(`tool-media: google. ${field} must be a positive safe integer`);
+	if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(resolved.model)) throw new TypeError("tool-media: google. model must be a bare Gemini model id");
+	const endpoint = new URL(`${resolved.baseURL.replace(/\/$/, "")}/models/${resolved.model}:generateContent`);
+	if (endpoint.username || endpoint.password || endpoint.search || endpoint.hash || endpoint.protocol !== "https:" && !(endpoint.protocol === "http:" && [
+		"localhost",
+		"127.0.0.1",
+		"[::1]"
+	].includes(endpoint.hostname))) throw new TypeError("tool-media: google. baseURL must use HTTPS or loopback HTTP without credentials, query, or fragment");
+	const ref = credentialRef(resolved.apiKeyEnv);
+	const maxImages = Math.min(resolved.maxImages, ctx.attachments.imageLimits.maxImagesPerMessage);
+	ctx.tools.register(defineTool({
+		name: "image_generate_google",
+		description: "Generate images with Google Gemini and display them in chat. Uses the connected provider's quota or API billing. Do not retry a timeout automatically.",
+		timeoutMs: resolved.timeoutMs,
+		parameters: { prompt: {
+			type: "string",
+			required: true,
+			description: "Refine the user request into an image prompt using your current conversation context before calling this tool. Use precise terminology for composition, framing, lighting, materials, and style where the request supports it. Preserve the subject, intent, exact quoted text and its language, counts, and all constraints or exclusions. Do not invent requirements or add conflicting details. If the user requests an exact prompt or no rewriting, pass that prompt verbatim. Send the final generation prompt only, without commentary."
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					model: {
+						type: "string",
+						required: true
+					},
+					provider: { type: "string" },
+					jobId: { type: "string" },
+					images: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								attachmentId: {
+									type: "string",
+									required: true
+								},
+								mediaType: {
+									type: "string",
+									required: true,
+									enum: [
+										"image/png",
+										"image/jpeg",
+										"image/webp",
+										"image/gif"
+									]
+								},
+								bytes: {
+									type: "integer",
+									required: true,
+									minimum: 1
+								},
+								width: {
+									type: "integer",
+									required: true,
+									minimum: 1
+								},
+								height: {
+									type: "integer",
+									required: true,
+									minimum: 1
+								},
+								name: { type: "string" }
+							}
+						}
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Generated ${value.images.length} image(s) with ${value.provider ?? "Google"} (${value.model}).\n${generatedImageSummary(value.images)}`
+			}],
+			presentationMeta: (_args, value) => ({
+				kind: "tool-images",
+				...value
+			})
+		},
+		presentCall: (args) => ({
+			card: "media",
+			kind: "image",
+			title: "Generate image with Google",
+			prompt: args.prompt
+		}),
+		presentResult: (_args, result) => result.isError ? void 0 : {
+			card: "media",
+			kind: "image",
+			title: "Generated image",
+			content: toolImageReferences(result.meta).map((attachment) => ({
+				type: "image",
+				attachment
+			})),
+			...toolMediaLabels(result.meta)
+		},
+		async execute(args, execution) {
+			if (execution.parent !== void 0) throw new Error("image_generate_google requires Native tool mode for chat presentation.");
+			if (args.prompt.trim() === "" || args.prompt.length > resolved.maxPromptChars) throw new TypeError(`Image prompt must contain 1–${resolved.maxPromptChars} characters.`);
+			const request = {
+				contents: [{
+					role: "user",
+					parts: [{ text: args.prompt }]
+				}],
+				generationConfig: { responseModalities: ["IMAGE"] }
+			};
+			const signal = AbortSignal.any([execution.signal, AbortSignal.timeout(resolved.timeoutMs)]);
+			const generated = resolved.useProviderModels ? await ctx.get("llm")?.generateMedia({
+				endpoint: "images/generations",
+				body: {
+					prompt: args.prompt,
+					n: 1,
+					output_format: "png"
+				},
+				model: resolved.model,
+				signal,
+				maxResponseBytes: resolved.maxResponseBytes,
+				...config.provider === void 0 ? {} : { provider: config.provider }
+			}) : void 0;
+			if (config.provider !== void 0 && generated === void 0) throw new Error(`Provider ${config.provider} has no configured image generation models.`);
+			let response;
+			if (generated !== void 0) response = generated.response;
+			else {
+				const credential = await ctx.credentials.resolve(ref);
+				if (credential === void 0) throw new Error(`Configure ${resolved.apiKeyEnv} or an image model on the Models page before generating images.`);
+				response = await fetch(endpoint, {
+					method: "POST",
+					redirect: "error",
+					signal,
+					headers: {
+						"Content-Type": "application/json",
+						"x-goog-api-key": credential.value
+					},
+					body: JSON.stringify(request)
+				});
+			}
+			if (!response.ok) {
+				await response.body?.cancel();
+				throw new Error(`Google image request failed (HTTP ${response.status}). Check credentials, model access, and account limits before retrying.`);
+			}
+			let bytes = 0;
+			const body = response.body?.pipeThrough(new TransformStream({ transform(chunk, controller) {
+				bytes += chunk.byteLength;
+				if (bytes > resolved.maxResponseBytes) throw new Error("Google image response exceeds maxResponseBytes.");
+				controller.enqueue(chunk);
+			} }));
+			const value = responseSchema.parse(await new Response(body).json());
+			signal.throwIfAborted();
+			const output = (() => {
+				if ("data" in value) return value.data.map((image) => ({
+					data: image.b64_json,
+					mimeType: "image/png"
+				}));
+				const candidate = value.candidates?.[0];
+				if (candidate?.finishReason !== "STOP" || candidate.content === void 0) throw new Error("Google did not return a complete image response. Check the prompt and model access before retrying.");
+				return candidate.content.parts.flatMap((part) => "thought" in part && part.thought || part.inlineData === void 0 ? [] : [part.inlineData]);
+			})();
+			if (output.length === 0 || output.length > maxImages) throw new Error(`Google must return 1–${maxImages} final images.`);
+			const images = await admitGeneratedImages(ctx.attachments, output, response.headers.get("x-hydra-job-id"));
+			signal.throwIfAborted();
+			const jobId = mediaJobId(response);
+			return {
+				model: generated?.model ?? resolved.model,
+				images: [...images],
+				...generated === void 0 ? {} : { provider: generated.provider },
+				...jobId === void 0 ? {} : { jobId }
+			};
+		}
+	}));
+}
+//#endregion
+//#region lib/types/generated-video.js
+/** Persist a completed video without retaining its stream in the transcript.
+* @param store - Durable attachment owner.
+* @param response - Completed MP4 or WebM response.
+* @param maxBytes - Deployment byte limit.
+* @param signal - Cancellation covering download and storage.
+* @returns A durable video reference after every byte has been stored.
+*/
+async function admitGeneratedVideo(store, response, maxBytes, signal) {
+	try {
+		const mediaType = response.headers.get("content-type")?.split(";")[0]?.trim();
+		if (mediaType !== "video/mp4" && mediaType !== "video/webm") {
+			await response.body?.cancel();
+			throw new Error("Video provider did not return a completed MP4 or WebM video.");
+		}
+		if (response.body === null) throw new Error("Video provider returned no video bytes.");
+		const stream = response.body;
+		async function* data() {
+			let bytes = 0;
+			const reader = stream.getReader();
+			try {
+				while (true) {
+					signal.throwIfAborted();
+					const chunk = await reader.read();
+					if (chunk.done) break;
+					bytes += chunk.value.byteLength;
+					if (bytes > maxBytes) throw new Error("Video response exceeds maxVideoBytes.");
+					yield chunk.value;
+				}
+				if (bytes === 0) throw new Error("Video provider returned an empty video.");
+			} finally {
+				try {
+					await reader.cancel();
+				} finally {
+					reader.releaseLock();
+				}
+			}
+		}
+		const video = await store.saveFileStream({
+			data: data(),
+			name: `generated-video.${mediaType === "video/mp4" ? "mp4" : "webm"}`,
+			signal
+		});
+		signal.throwIfAborted();
+		return {
+			...video,
+			mediaType
+		};
+	} catch (error) {
+		const id = mediaJobId(response);
+		if (id !== void 0) throw new Error(`Video storage failed. jobId=${id}. Use gemini_web_retrieve to recover this job without sending the prompt again.`);
+		throw error;
+	}
+}
+//#endregion
+//#region lib/types/video.js
+/** Loader defaults for video polling and storage. */
+const VideoConfig = z.object({
+	provider: z.string(),
+	model: z.string(),
+	timeoutMs: z.number().default(9e5),
+	pollIntervalMs: z.number().default(1e4),
+	maxResponseBytes: z.number().default(1024 * 1024),
+	maxVideoBytes: z.number().default(100 * 1024 * 1024),
+	maxPromptChars: z.number().default(32e3)
+});
+/** Register video_generate using the saved video provider and model.
+* @param ctx - Tool and attachment services, with optional configured LLM routes.
+* @param config - Loader-validated polling and storage limits.
+*/
+function registerVideos(ctx, config) {
+	const resolved = config;
+	for (const field of [
+		"timeoutMs",
+		"pollIntervalMs",
+		"maxResponseBytes",
+		"maxVideoBytes",
+		"maxPromptChars"
+	]) if (!Number.isSafeInteger(resolved[field]) || resolved[field] < 1) throw new TypeError(`tool-media: video.${field} must be a positive safe integer`);
+	if (resolved.timeoutMs > 2147483647 || resolved.pollIntervalMs > 2147483647) throw new TypeError("tool-media: video timer limits must not exceed 2147483647");
+	if (config.model?.trim() === "" || config.provider?.trim() === "") throw new TypeError("tool-media: video model and provider must not be empty");
+	ctx.tools.register(defineTool({
+		name: "video_generate",
+		description: "Generate a video with the configured video model and display it in chat. Uses the connected provider's quota or API billing. Do not retry a timeout automatically.",
+		timeoutMs: resolved.timeoutMs,
+		parameters: {
+			prompt: {
+				type: "string",
+				required: true,
+				description: "Refine the user request into a video prompt using your current conversation context before calling this tool. Use precise terminology for shot framing, camera movement, subject motion, timing, lighting, and style where the request supports it. Preserve the subject, intent, exact quoted text and its language, counts, duration, aspect ratio, and all constraints or exclusions. Keep the prompt consistent with seconds and size when supplied. Do not invent requirements or add conflicting details. If the user requests an exact prompt or no rewriting, pass that prompt verbatim. Send the final generation prompt only, without commentary."
+			},
+			seconds: {
+				type: "integer",
+				minimum: 1,
+				maximum: 15,
+				description: "Duration in seconds; omit unless the user requests it. Gemini Web uses its fixed default duration."
+			},
+			size: {
+				type: "string",
+				enum: ["1280x720", "720x1280"],
+				description: "Landscape or portrait video; omitted uses the provider default."
+			},
+			reference_image_ids: {
+				type: "array",
+				items: { type: "string" },
+				description: "Image attachmentIds from earlier user uploads or image-generation results in this conversation. Required when animating an existing image. Use \"latest\" for the last image when an older result did not include its id. Currently supported by Gemini Web."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					provider: {
+						type: "string",
+						required: true
+					},
+					model: {
+						type: "string",
+						required: true
+					},
+					jobId: { type: "string" },
+					videos: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								attachmentId: {
+									type: "string",
+									required: true
+								},
+								name: {
+									type: "string",
+									required: true
+								},
+								bytes: {
+									type: "integer",
+									required: true,
+									minimum: 1
+								},
+								mediaType: {
+									type: "string",
+									required: true,
+									enum: ["video/mp4", "video/webm"]
+								}
+							}
+						}
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Generated video with ${value.provider} (${value.model}).`
+			}],
+			presentationMeta: (_args, value) => ({
+				kind: "tool-videos",
+				...value
+			})
+		},
+		presentCall: (args) => ({
+			card: "media",
+			kind: "video",
+			title: "Generate video",
+			prompt: args.prompt,
+			...args.size === void 0 ? {} : { aspectRatio: args.size === "1280x720" ? 16 / 9 : 9 / 16 }
+		}),
+		presentResult: (_args, result) => result.isError ? void 0 : {
+			card: "media",
+			kind: "video",
+			title: "Generated video",
+			content: toolVideoReferences(result.meta).map((attachment) => ({
+				type: "video",
+				attachment
+			})),
+			...toolMediaLabels(result.meta)
+		},
+		async execute(args, execution) {
+			if (execution.parent !== void 0) throw new Error("video_generate requires Native tool mode for chat presentation.");
+			if (args.prompt.trim() === "" || args.prompt.length > resolved.maxPromptChars) throw new TypeError(`Video prompt must contain 1–${resolved.maxPromptChars} characters.`);
+			const signal = AbortSignal.any([execution.signal, AbortSignal.timeout(resolved.timeoutMs)]);
+			const referenceImages = [];
+			if (args.reference_image_ids !== void 0) {
+				if (args.reference_image_ids.length < 1 || args.reference_image_ids.length > 5 || new Set(args.reference_image_ids).size !== args.reference_image_ids.length) throw new TypeError("Supply one to five distinct reference image ids.");
+				const session = execution.agent?.session;
+				if (session === void 0) throw new Error("Reference images require the calling conversation.");
+				const refs = [];
+				for (const event of session.activeEvents) if (event.type === "user/message") {
+					for (const block of event.data.content) if (block.type === "image") refs.push(block.attachment);
+				} else if (event.type === "tool/result") {
+					refs.push(...toolImageReferences(event.data.meta));
+					for (const content of event.data.message.content[0].content) if (content.type === "image") refs.push(content.attachment);
+				}
+				for (const id of args.reference_image_ids) {
+					const ref = id === "latest" ? refs.at(-1) : refs.find((ref) => ref.attachmentId === id);
+					if (ref === void 0) throw new Error("Reference image is absent from this conversation. Upload it or use an image attachmentId from an earlier result.");
+					const stored = await ctx.attachments.readImage(ref, signal);
+					referenceImages.push({
+						data: stored.data,
+						mimeType: ref.mediaType
+					});
+				}
+			}
+			const generated = await ctx.get("llm")?.generateMedia({
+				endpoint: "videos",
+				body: {
+					prompt: args.prompt,
+					...args.seconds === void 0 ? {} : { seconds: args.seconds },
+					...args.size === void 0 ? {} : { size: args.size },
+					...args.reference_image_ids === void 0 ? {} : { referenceImages }
+				},
+				...config.provider === void 0 ? {} : { provider: config.provider },
+				...config.model === void 0 ? {} : { model: config.model },
+				signal,
+				maxResponseBytes: resolved.maxResponseBytes,
+				pollIntervalMs: resolved.pollIntervalMs
+			});
+			if (generated === void 0) throw new Error("Configure a video model and its credentials on the Models page before generating videos.");
+			const videos = [await admitGeneratedVideo(ctx.attachments, generated.response, resolved.maxVideoBytes, signal)];
+			const jobId = mediaJobId(generated.response);
+			return {
+				provider: generated.provider,
+				model: generated.model,
+				videos,
+				...jobId === void 0 ? {} : { jobId }
+			};
+		}
+	}));
+}
+//#endregion
+//#region lib/types/gemini-web-retrieve.js
+/** Register read-only task recovery with the existing media presentation protocol.
+* @param ctx - Tools and attachment services, with optional LLM routes.
+* @param image - Image response and prompt-independent attachment limits.
+* @param video - Video polling, response, and attachment limits.
+*/
+function registerGeminiWebRetrieve(ctx, image, video) {
+	const maxImageBytes = image.maxResponseBytes ?? 32 * 1024 * 1024;
+	const maxVideoBytes = video.maxVideoBytes ?? 100 * 1024 * 1024;
+	const timeoutMs = video.timeoutMs ?? 9e5;
+	ctx.tools.register(defineTool({
+		name: "gemini_web_retrieve",
+		description: "Retrieve an existing Gemini Web image or video using the jobId from an earlier error. Displays saved media in chat and never sends a new generation prompt. Reconnect Gemini Web first if the account session expired.",
+		timeoutMs,
+		parameters: {
+			jobId: {
+				type: "string",
+				required: true,
+				description: "Local jobId returned by the Gemini Web provider."
+			},
+			kind: {
+				type: "string",
+				required: true,
+				enum: ["image", "video"],
+				description: "Media kind of the original task."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					provider: {
+						type: "string",
+						required: true
+					},
+					model: {
+						type: "string",
+						required: true
+					},
+					jobId: {
+						type: "string",
+						required: true
+					},
+					kind: {
+						type: "string",
+						enum: ["image", "video"],
+						required: true
+					},
+					images: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								attachmentId: {
+									type: "string",
+									required: true
+								},
+								name: { type: "string" },
+								bytes: {
+									type: "integer",
+									required: true
+								},
+								mediaType: {
+									type: "string",
+									required: true,
+									enum: [
+										"image/png",
+										"image/jpeg",
+										"image/webp",
+										"image/gif"
+									]
+								},
+								width: {
+									type: "integer",
+									required: true
+								},
+								height: {
+									type: "integer",
+									required: true
+								}
+							}
+						}
+					},
+					videos: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								attachmentId: {
+									type: "string",
+									required: true
+								},
+								name: {
+									type: "string",
+									required: true
+								},
+								bytes: {
+									type: "integer",
+									required: true
+								},
+								mediaType: {
+									type: "string",
+									required: true,
+									enum: ["video/mp4", "video/webm"]
+								}
+							}
+						}
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Retrieved Gemini Web ${value.kind}. jobId=${value.jobId}.` + (value.kind === "image" ? `\n${generatedImageSummary(value.images)}` : "")
+			}],
+			presentationMeta: (_args, value) => value.kind === "image" ? {
+				kind: "tool-images",
+				images: value.images,
+				provider: value.provider,
+				model: value.model,
+				jobId: value.jobId
+			} : {
+				kind: "tool-videos",
+				videos: value.videos,
+				provider: value.provider,
+				model: value.model,
+				jobId: value.jobId
+			}
+		},
+		presentCall: (args) => ({
+			card: "media",
+			kind: args.kind,
+			title: "Retrieve Gemini Web media",
+			prompt: `Job ${args.jobId}`
+		}),
+		presentResult: (args, result) => result.isError ? void 0 : {
+			card: "media",
+			kind: args.kind,
+			title: "Retrieved Gemini Web media",
+			content: args.kind === "image" ? toolImageReferences(result.meta).map((attachment) => ({
+				type: "image",
+				attachment
+			})) : toolVideoReferences(result.meta).map((attachment) => ({
+				type: "video",
+				attachment
+			})),
+			...toolMediaLabels(result.meta)
+		},
+		async execute(args, execution) {
+			if (execution.parent !== void 0) throw new Error("gemini_web_retrieve requires Native tool mode for chat presentation.");
+			if (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(args.jobId)) throw new TypeError("Invalid Gemini Web jobId.");
+			const signal = AbortSignal.any([execution.signal, AbortSignal.timeout(timeoutMs)]);
+			const generated = await ctx.get("llm")?.generateMedia({
+				provider: "gemini-web",
+				model: `gemini-web-${args.kind}`,
+				endpoint: args.kind === "image" ? "images/generations" : "videos",
+				body: { jobId: args.jobId },
+				signal,
+				maxResponseBytes: args.kind === "image" ? maxImageBytes : video.maxResponseBytes ?? 1024 * 1024,
+				pollIntervalMs: video.pollIntervalMs ?? 1e4
+			});
+			if (generated === void 0) throw new Error("Apply Gemini Web in Account sign-in before retrieving media.");
+			const response = generated.response;
+			if (args.kind === "image") {
+				const reader = response.body?.getReader();
+				if (reader === void 0) throw new Error("Gemini Web returned no image bytes.");
+				const chunks = [];
+				let bytes = 0;
+				try {
+					while (true) {
+						signal.throwIfAborted();
+						const chunk = await reader.read();
+						if (chunk.done) break;
+						bytes += chunk.value.byteLength;
+						if (bytes > maxImageBytes) throw new Error("Gemini Web image exceeds the response limit.");
+						chunks.push(chunk.value);
+					}
+				} finally {
+					try {
+						await reader.cancel();
+					} finally {
+						reader.releaseLock();
+					}
+				}
+				const inline = z$1.object({ candidates: z$1.tuple([z$1.object({
+					finishReason: z$1.literal("STOP"),
+					content: z$1.object({ parts: z$1.tuple([z$1.object({ inlineData: z$1.object({
+						data: z$1.string().min(1),
+						mimeType: z$1.enum([
+							"image/png",
+							"image/jpeg",
+							"image/webp"
+						])
+					}) })]) })
+				})]) }).parse(JSON.parse(Buffer.concat(chunks).toString("utf8"))).candidates[0].content.parts[0].inlineData;
+				const images = [...await admitGeneratedImages(ctx.attachments, [{
+					data: inline.data,
+					mimeType: inline.mimeType
+				}], args.jobId)];
+				signal.throwIfAborted();
+				return {
+					provider: generated.provider,
+					model: generated.model,
+					kind: args.kind,
+					jobId: args.jobId,
+					images,
+					videos: []
+				};
+			}
+			const videos = [await admitGeneratedVideo(ctx.attachments, response, maxVideoBytes, signal)];
+			return {
+				provider: generated.provider,
+				model: generated.model,
+				kind: args.kind,
+				jobId: args.jobId,
+				images: [],
+				videos
+			};
+		}
+	}));
+}
+//#endregion
+//#region lib/types/index.js
+/** Cordis plugin name. */
+const name = "tool-media";
+/** Services consumed by image and video generation. */
+const inject = [
+	"tools",
+	"credentials",
+	"attachments"
+];
+/** Loader defaults for all media tools. */
+const Config = z.object({
+	openai: OpenAIImageConfig.default({}),
+	google: GoogleImageConfig.default({}),
+	video: VideoConfig.default({})
+});
+/** Register all media tools in the same fiber so one switch disposes them together.
+* @param ctx - Tool, credential, and attachment services.
+* @param config - Loader-validated settings for each generation API.
+*/
+function apply(ctx, config) {
+	const resolved = config;
+	registerOpenAIImages(ctx, resolved.openai);
+	registerGoogleImages(ctx, resolved.google);
+	registerVideos(ctx, resolved.video);
+	registerGeminiWebRetrieve(ctx, resolved.google, resolved.video);
+}
+//#endregion
+export { Config, apply, inject, name };