@xopcai/xopc 0.0.364 → 0.0.367

package/dist/packages/image-providers/src/execute.js

@@ -0,0 +1,372 @@
+import { getImageProviderSpec } from "./catalog.js";
+import { ImageProviderError, validateImageRequest } from "./validation.js";
+import { MAX_IMAGE_BYTES, assertImageResponseOk, authenticatedJobUrl, decodeBase64, encodeBase64, imageFromBytes, readBytesLimited, readImageJson, waitForImagePoll } from "./http.js";
+//#region packages/image-providers/src/execute.ts
+const object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+const array = (value) => Array.isArray(value) ? value : [];
+var ImageTransport = class {
+	constructor(execution) {
+		this.execution = execution;
+	}
+	endpoint(path) {
+		return `${this.execution.baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+	}
+	async json(url, body, headers = {}) {
+		return readImageJson(await this.execution.fetchImpl(url, {
+			method: body ? "POST" : "GET",
+			headers: {
+				...body ? { "content-type": "application/json" } : {},
+				...headers
+			},
+			...body ? { body: JSON.stringify(body) } : {},
+			signal: this.execution.signal,
+			redirect: "error"
+		}));
+	}
+	async form(url, form, headers) {
+		return readImageJson(await this.execution.fetchImpl(url, {
+			method: "POST",
+			headers,
+			body: form,
+			signal: this.execution.signal,
+			redirect: "error"
+		}));
+	}
+	async image(url) {
+		if (typeof url !== "string" || !/^https?:\/\//.test(url)) throw new ImageProviderError("Missing generated image URL", 502);
+		const response = await this.execution.fetchImpl(url, {
+			signal: this.execution.signal,
+			redirect: "error"
+		});
+		try {
+			await assertImageResponseOk(response);
+		} catch (error) {
+			if (error instanceof ImageProviderError) throw new ImageProviderError(error.message, error.status);
+			throw error;
+		}
+		return imageFromBytes(await readBytesLimited(response, MAX_IMAGE_BYTES));
+	}
+	bearer() {
+		return { authorization: `Bearer ${this.execution.apiKey}` };
+	}
+	async dataImages(data) {
+		const entries = array(data);
+		if (entries.length > (this.execution.request.count ?? 1)) throw new ImageProviderError("Provider returned too many images", 502);
+		const images = [];
+		let total = 0;
+		for (const value of entries) {
+			const entry = object(value);
+			const image = entry.b64_json ? imageFromBytes(decodeBase64(entry.b64_json)) : await this.image(entry.url);
+			total += image.bytes.byteLength;
+			if (total > 67108864) throw new ImageProviderError("Generated images exceed total byte limit", 502);
+			images.push(image);
+		}
+		return images;
+	}
+};
+async function jobJson(http, url, headers) {
+	try {
+		return await http.json(url, void 0, headers);
+	} catch (error) {
+		if (error instanceof ImageProviderError) throw new ImageProviderError(error.message, error.status);
+		throw error;
+	}
+}
+async function inputUris(execution) {
+	return Promise.all((execution.request.inputImages ?? []).map(async (image) => `data:${image.blob.type};base64,${encodeBase64(new Uint8Array(await image.blob.arrayBuffer()))}`));
+}
+async function openai(http) {
+	const { request: req } = http.execution;
+	const body = {
+		model: req.model,
+		prompt: req.prompt,
+		n: req.count ?? 1
+	};
+	if (req.size) body.size = req.size;
+	if (req.quality) body.quality = req.quality;
+	if (req.outputFormat) body.output_format = req.outputFormat;
+	if (req.background) body.background = req.background;
+	if (req.openai?.moderation) body.moderation = req.openai.moderation;
+	if (req.openai?.outputCompression !== void 0) body.output_compression = req.openai.outputCompression;
+	if (req.openai?.user) body.user = req.openai.user;
+	let data;
+	if (req.inputImages?.length) {
+		const form = new FormData();
+		for (const [key, value] of Object.entries(body)) form.append(key, String(value));
+		for (const image of req.inputImages) form.append("image[]", image.blob, image.fileName);
+		data = await http.form(http.endpoint("/images/edits"), form, http.bearer());
+	} else data = await http.json(http.endpoint("/images/generations"), body, http.bearer());
+	return {
+		images: await http.dataImages(data.data),
+		usage: data.usage
+	};
+}
+async function dashscope(http) {
+	const { request: req } = http.execution;
+	const content = [{ text: req.prompt }, ...(await inputUris(http.execution)).map((image) => ({ image }))];
+	const parameters = {
+		n: req.count ?? 1,
+		watermark: false
+	};
+	if (req.size) parameters.size = req.size.replace("x", "*");
+	const data = await http.json(http.endpoint("/api/v1/services/aigc/multimodal-generation/generation"), {
+		model: req.model,
+		input: { messages: [{
+			role: "user",
+			content
+		}] },
+		parameters
+	}, http.bearer());
+	if (data.code) throw new ImageProviderError("DashScope image request rejected", 400);
+	const urls = array(object(data.output).choices).flatMap((choice) => array(object(object(choice).message).content)).map((item) => object(item).image).filter((url) => typeof url === "string");
+	return {
+		images: await http.dataImages(urls.map((url) => ({ url }))),
+		usage: data.usage,
+		requestId: typeof data.request_id === "string" ? data.request_id : void 0
+	};
+}
+async function google(http) {
+	const { request: req, apiKey } = http.execution;
+	const input = [{
+		type: "text",
+		text: req.prompt
+	}];
+	for (const image of req.inputImages ?? []) input.push({
+		type: "image",
+		mime_type: image.blob.type,
+		data: encodeBase64(new Uint8Array(await image.blob.arrayBuffer()))
+	});
+	const responseFormat = { type: "image" };
+	if (req.aspectRatio) responseFormat.aspect_ratio = req.aspectRatio;
+	if (req.resolution) responseFormat.image_size = req.resolution;
+	if (req.outputFormat) responseFormat.mime_type = `image/${req.outputFormat}`;
+	const data = await http.json(http.endpoint("/v1beta/interactions"), {
+		model: req.model,
+		input,
+		store: false,
+		response_format: responseFormat
+	}, { "x-goog-api-key": apiKey });
+	if (data.status !== "completed") throw new ImageProviderError("Google image interaction did not complete", 502);
+	const parts = array(object(array(data.steps).filter((step) => object(step).type === "model_output").at(-1)).content).filter((part) => object(part).type === "image");
+	return {
+		images: await http.dataImages(parts.map((part) => ({
+			b64_json: object(part).data,
+			url: object(part).uri
+		}))),
+		usage: data.usage,
+		requestId: typeof data.id === "string" ? data.id : void 0
+	};
+}
+async function fal(http, model) {
+	const { request: req, apiKey, signal, baseUrl } = http.execution;
+	const editing = Boolean(req.inputImages?.length);
+	const path = editing ? model.editPath : req.model;
+	const body = { prompt: req.prompt };
+	if (req.model.startsWith("google/")) {
+		body.num_images = req.count ?? 1;
+		if (req.aspectRatio) body.aspect_ratio = req.aspectRatio;
+		if (req.resolution) body.resolution = req.resolution;
+	} else if (req.size) {
+		const [width, height] = req.size.split("x").map(Number);
+		body.image_size = {
+			width,
+			height
+		};
+	}
+	if (req.outputFormat) body.output_format = req.outputFormat;
+	if (editing) body.image_urls = await inputUris(http.execution);
+	const headers = { authorization: `Key ${apiKey}` };
+	const submit = await http.json(http.endpoint(path), body, headers);
+	const statusUrl = authenticatedJobUrl(submit.status_url, baseUrl);
+	const resultUrl = authenticatedJobUrl(submit.response_url, baseUrl);
+	for (;;) {
+		signal.throwIfAborted();
+		const status = await jobJson(http, statusUrl, headers);
+		if (status.status === "COMPLETED") break;
+		if (status.status !== "IN_QUEUE" && status.status !== "IN_PROGRESS") throw new ImageProviderError("fal image job failed", 502);
+		await waitForImagePoll(signal);
+	}
+	const result = await jobJson(http, resultUrl, headers);
+	return {
+		images: await http.dataImages(result.images),
+		requestId: typeof submit.request_id === "string" ? submit.request_id : void 0
+	};
+}
+async function seedream(http) {
+	const { request: req } = http.execution;
+	const images = await inputUris(http.execution);
+	const body = {
+		model: req.model,
+		prompt: req.prompt,
+		response_format: "b64_json",
+		watermark: false
+	};
+	if (images.length) body.image = images.length === 1 ? images[0] : images;
+	if (req.size) body.size = req.size;
+	if (req.outputFormat) body.output_format = req.outputFormat;
+	const data = await http.json(http.endpoint("/images/generations"), body, http.bearer());
+	if (data.error) throw new ImageProviderError("Seedream image request rejected", 400);
+	return {
+		images: await http.dataImages(data.data),
+		usage: data.usage
+	};
+}
+async function ideogram(http) {
+	const { request: req, apiKey } = http.execution;
+	const headers = { "Api-Key": apiKey };
+	let data;
+	if (req.inputImages?.length) {
+		const form = new FormData();
+		form.append("prompt", req.prompt);
+		form.append("num_images", String(req.count ?? 1));
+		if (req.quality) form.append("quality", req.quality);
+		req.inputImages.forEach((image, index) => form.append(index === 0 ? "image" : "reference_images", image.blob, image.fileName));
+		data = await http.form(http.endpoint(`/v2/image/precise-edit/${req.model}`), form, headers);
+	} else {
+		const body = {
+			prompt: req.prompt,
+			num_images: req.count ?? 1
+		};
+		if (req.size) body.resolution = req.size;
+		if (req.quality) body.quality = req.quality;
+		data = await http.json(http.endpoint(`/v2/image/generate/${req.model}`), body, headers);
+	}
+	return {
+		images: await http.dataImages(data.data),
+		requestId: typeof data.generation_id === "string" ? data.generation_id : void 0
+	};
+}
+async function bfl(http) {
+	const { request: req, apiKey, baseUrl, signal } = http.execution;
+	const body = { prompt: req.prompt };
+	if (req.size) {
+		const [width, height] = req.size.split("x").map(Number);
+		body.width = width;
+		body.height = height;
+	}
+	if (req.outputFormat) body.output_format = req.outputFormat;
+	(await inputUris(http.execution)).forEach((image, index) => {
+		body[index === 0 ? "input_image" : `input_image_${index + 1}`] = image;
+	});
+	const headers = { "x-key": apiKey };
+	const submit = await http.json(http.endpoint(req.model), body, headers);
+	const pollUrl = authenticatedJobUrl(submit.polling_url, baseUrl, true);
+	for (;;) {
+		signal.throwIfAborted();
+		const result = await jobJson(http, pollUrl, headers);
+		if (result.status === "Ready") return {
+			images: [await http.image(object(result.result).sample)],
+			requestId: typeof submit.id === "string" ? submit.id : void 0
+		};
+		if (!["Pending", "Processing"].includes(String(result.status))) throw new ImageProviderError("BFL image job failed", 502);
+		await waitForImagePoll(signal);
+	}
+}
+async function minimax(http) {
+	const { request: req } = http.execution;
+	const data = await http.json(http.endpoint("/v1/image_generation"), {
+		model: req.model,
+		prompt: req.prompt,
+		aspect_ratio: req.aspectRatio ?? "1:1",
+		response_format: "base64",
+		n: req.count ?? 1
+	}, http.bearer());
+	if (object(data.base_resp).status_code) throw new ImageProviderError("MiniMax image request rejected", 400);
+	return { images: await http.dataImages(array(object(data.data).image_base64).map((b64_json) => ({ b64_json }))) };
+}
+async function zhipu(http) {
+	const { request: req } = http.execution;
+	const data = await http.json(http.endpoint("/images/generations"), {
+		model: req.model,
+		prompt: req.prompt,
+		...req.size ? { size: req.size } : {}
+	}, http.bearer());
+	if (data.error) throw new ImageProviderError("Zhipu image request rejected", 400);
+	return { images: await http.dataImages(data.data) };
+}
+async function tokenhub(http) {
+	const { request: req } = http.execution;
+	const images = await inputUris(http.execution);
+	if (req.model === "hy-image-v3.5-preview") {
+		const data = await http.json(http.endpoint("/v1/wand/hunyuan-image/v35-generation"), {
+			model: req.model,
+			...req.size ? { size: req.size } : {},
+			messages: [{
+				role: "user",
+				content: [{
+					type: "text",
+					text: req.prompt
+				}, ...images.map((url) => ({
+					type: "image_url",
+					image_url: { url }
+				}))]
+			}]
+		}, http.bearer());
+		if (data.error) throw new ImageProviderError("TokenHub image request rejected", 400);
+		const urls = array(data.choices).map((choice) => object(object(object(choice).delta).image).url).filter((url) => typeof url === "string");
+		return {
+			images: await http.dataImages(urls.map((url) => ({ url }))),
+			usage: data.tokenhub_usage,
+			requestId: typeof data.request_id === "string" ? data.request_id : void 0
+		};
+	}
+	const data = await http.json(http.endpoint("/v1/wand/hunyuan-image/v3-generation"), {
+		model: req.model,
+		prompt: req.prompt,
+		...req.size ? { size: req.size } : {},
+		...images.length ? { images: images.map((image) => image.slice(image.indexOf(",") + 1)) } : {}
+	}, http.bearer());
+	if (data.error) throw new ImageProviderError("TokenHub image request rejected", 400);
+	return {
+		images: await http.dataImages(data.data),
+		usage: data.tokenhub_usage,
+		requestId: typeof data.request_id === "string" ? data.request_id : void 0
+	};
+}
+async function stability(http) {
+	const { request: req, signal, fetchImpl } = http.execution;
+	const form = new FormData();
+	form.append("prompt", req.prompt);
+	if (req.aspectRatio) form.append("aspect_ratio", req.aspectRatio);
+	if (req.outputFormat) form.append("output_format", req.outputFormat);
+	const response = await fetchImpl(http.endpoint(`/v2beta/stable-image/generate/${req.model === "stable-image-ultra" ? "ultra" : "core"}`), {
+		method: "POST",
+		headers: {
+			...http.bearer(),
+			accept: "image/*"
+		},
+		body: form,
+		signal,
+		redirect: "error"
+	});
+	await assertImageResponseOk(response);
+	return { images: [imageFromBytes(await readBytesLimited(response, MAX_IMAGE_BYTES))] };
+}
+const adapters = {
+	openai,
+	dashscope,
+	google,
+	seedream,
+	ideogram,
+	bfl,
+	minimax,
+	zhipu,
+	tokenhub,
+	stability,
+	fal
+};
+async function executeImageProvider(execution) {
+	const spec = getImageProviderSpec(execution.providerId);
+	const model = spec.models.find((item) => item.id === execution.request.model);
+	if (!model) throw new ImageProviderError(`Unsupported image model: ${execution.request.model}`, 400);
+	validateImageRequest(execution.request, model.capabilities);
+	const maxPrompt = spec.protocol === "zhipu" ? 1e3 : spec.protocol === "tokenhub" && model.id === "hy-image-v3" ? 8192 : spec.protocol === "dashscope" && model.id.startsWith("wan") ? 5e3 : Infinity;
+	if ([...execution.request.prompt].length > maxPrompt) throw new ImageProviderError("Image prompt exceeds model limit", 400);
+	if (execution.request.openai && spec.protocol !== "openai") throw new ImageProviderError("OpenAI options require an OpenAI image provider", 400);
+	execution.signal.throwIfAborted();
+	const result = await adapters[spec.protocol](new ImageTransport(execution), model);
+	if (!result.images.length || result.images.length > (execution.request.count ?? 1)) throw new ImageProviderError("Provider returned an invalid image count", 502);
+	return result;
+}
+//#endregion
+export { executeImageProvider };

package/dist/packages/image-providers/src/http.js

@@ -0,0 +1,94 @@
+import { ImageProviderError } from "./validation.js";
+//#region packages/image-providers/src/http.ts
+const MAX_IMAGE_BYTES = 32 * 1024 * 1024;
+const MAX_RESPONSE_BYTES = 64 * 1024 * 1024;
+async function readBytesLimited(response, limit = MAX_RESPONSE_BYTES) {
+	if (Number(response.headers.get("content-length")) > limit) {
+		await response.body?.cancel();
+		throw new ImageProviderError("Image response exceeds byte limit", 502);
+	}
+	const reader = response.body?.getReader();
+	if (!reader) throw new ImageProviderError("Empty image response", 502);
+	const chunks = [];
+	let length = 0;
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			length += value.byteLength;
+			if (length > limit) throw new ImageProviderError("Image response exceeds byte limit", 502);
+			chunks.push(value);
+		}
+	} catch (error) {
+		await reader.cancel().catch(() => {});
+		throw error;
+	} finally {
+		reader.releaseLock();
+	}
+	const result = new Uint8Array(length);
+	let offset = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return result;
+}
+async function assertImageResponseOk(response) {
+	if (response.ok) return;
+	await response.body?.cancel();
+	throw new ImageProviderError(`Image provider HTTP ${response.status}`, response.status, [
+		401,
+		403,
+		429
+	].includes(response.status));
+}
+async function readImageJson(response) {
+	await assertImageResponseOk(response);
+	try {
+		const data = JSON.parse(new TextDecoder().decode(await readBytesLimited(response)));
+		if (!data || typeof data !== "object" || Array.isArray(data)) throw new Error("Invalid object");
+		return data;
+	} catch (error) {
+		if (error instanceof ImageProviderError) throw error;
+		throw new ImageProviderError("Invalid image provider JSON", 502);
+	}
+}
+function encodeBase64(bytes) {
+	let binary = "";
+	for (let offset = 0; offset < bytes.length; offset += 8192) binary += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
+	return btoa(binary);
+}
+function decodeBase64(value) {
+	if (typeof value !== "string" || !value || value.length > Math.ceil(33554432 / 3) * 4 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)) throw new ImageProviderError("Invalid image base64", 502);
+	return Uint8Array.from(atob(value), (char) => char.charCodeAt(0));
+}
+function imageFromBytes(bytes) {
+	const mimeType = bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71 && bytes[4] === 13 && bytes[5] === 10 && bytes[6] === 26 && bytes[7] === 10 ? "image/png" : bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255 ? "image/jpeg" : new TextDecoder().decode(bytes.subarray(0, 4)) === "RIFF" && new TextDecoder().decode(bytes.subarray(8, 12)) === "WEBP" ? "image/webp" : null;
+	if (!mimeType || bytes.length > 33554432) throw new ImageProviderError("Invalid generated image bytes", 502);
+	return {
+		bytes,
+		mimeType
+	};
+}
+function authenticatedJobUrl(value, baseUrl, allowBflHost = false) {
+	if (typeof value !== "string") throw new ImageProviderError("Missing provider job URL", 502);
+	const url = new URL(value), base = new URL(baseUrl);
+	if (url.username || url.password || url.hash || url.protocol !== "https:" && url.origin !== base.origin || url.origin !== base.origin && !(allowBflHost && (base.hostname === "api.bfl.ai" || base.hostname.endsWith(".bfl.ai")) && url.protocol === "https:" && url.hostname.endsWith(".bfl.ai") && !url.port)) throw new ImageProviderError("Untrusted provider job URL", 502);
+	return url.toString();
+}
+async function waitForImagePoll(signal, delayMs = 1500) {
+	signal.throwIfAborted();
+	await new Promise((resolve, reject) => {
+		const aborted = () => {
+			clearTimeout(timer);
+			reject(signal.reason);
+		};
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", aborted);
+			resolve();
+		}, delayMs);
+		signal.addEventListener("abort", aborted, { once: true });
+	});
+}
+//#endregion
+export { MAX_IMAGE_BYTES, MAX_RESPONSE_BYTES, assertImageResponseOk, authenticatedJobUrl, decodeBase64, encodeBase64, imageFromBytes, readBytesLimited, readImageJson, waitForImagePoll };

package/dist/packages/image-providers/src/index.js

@@ -0,0 +1,5 @@
+import "./catalog.js";
+import "./validation.js";
+import "./http.js";
+import "./execute.js";
+export {};

package/dist/packages/image-providers/src/types.d.ts

@@ -0,0 +1,95 @@
+export type ImageQuality = 'low' | 'medium' | 'high' | 'xhigh' | 'max' | 'auto';
+export type ImageFormat = 'png' | 'jpeg' | 'webp';
+export type ImageResolution = '1K' | '2K' | '4K';
+export type ImageBackground = 'transparent' | 'opaque' | 'auto';
+export type ImageProtocol = 'openai' | 'minimax' | 'dashscope' | 'google' | 'fal' | 'seedream' | 'ideogram' | 'bfl' | 'zhipu' | 'tokenhub' | 'stability';
+export interface ImageGeometry {
+    sizes?: string[];
+    aspectRatios?: string[];
+    resolutions?: ImageResolution[];
+    pixels?: {
+        minPixels: number;
+        maxPixels: number;
+        maxEdge: number;
+        minEdge: number;
+        step: number;
+        maxRatio: number;
+    };
+}
+export interface ImageCapabilities {
+    generate?: {
+        maxCount?: number;
+        supportsSize?: boolean;
+        supportsAspectRatio?: boolean;
+        supportsResolution?: boolean;
+    };
+    edit?: {
+        enabled: boolean;
+        maxInputImages?: number;
+        inputFormats?: ImageFormat[];
+        maxInputBytes?: number;
+        supportsSize?: boolean;
+        supportsAspectRatio?: boolean;
+        supportsResolution?: boolean;
+        geometry?: ImageGeometry;
+    };
+    geometry?: ImageGeometry;
+    output?: {
+        qualities?: ImageQuality[];
+        formats?: ImageFormat[];
+        backgrounds?: ImageBackground[];
+    };
+}
+export interface ImageModel {
+    id: string;
+    name: string;
+    capabilities: ImageCapabilities;
+    editPath?: string;
+}
+export interface ImageProviderSpec {
+    id: string;
+    name: string;
+    protocol: ImageProtocol;
+    baseUrl: string;
+    regions?: Record<'cn' | 'intl', string>;
+    documentationUrl: string;
+    apiKeyUrl: string;
+    timeoutMs: number;
+    models: ImageModel[];
+}
+export interface ImageRequest {
+    model: string;
+    prompt: string;
+    count?: number;
+    size?: string;
+    aspectRatio?: string;
+    resolution?: ImageResolution;
+    quality?: ImageQuality;
+    outputFormat?: ImageFormat;
+    background?: ImageBackground;
+    openai?: {
+        moderation?: 'low' | 'auto';
+        outputCompression?: number;
+        user?: string;
+    };
+    inputImages?: Array<{
+        blob: Blob;
+        fileName: string;
+    }>;
+}
+export interface ImageResult {
+    images: Array<{
+        bytes: Uint8Array;
+        mimeType: string;
+    }>;
+    requestId?: string;
+    usage?: unknown;
+}
+export interface ImageExecution {
+    providerId: string;
+    baseUrl: string;
+    apiKey: string;
+    request: ImageRequest;
+    signal: AbortSignal;
+    fetchImpl: typeof fetch;
+}

package/dist/packages/image-providers/src/validation.js

@@ -0,0 +1,52 @@
+//#region packages/image-providers/src/validation.ts
+var ImageProviderError = class extends Error {
+	constructor(message, status, retryable = false) {
+		super(message);
+		this.status = status;
+		this.retryable = retryable;
+		this.name = "ImageProviderError";
+	}
+};
+function validateImageRequest(request, caps) {
+	const fail = (message) => {
+		throw new ImageProviderError(message, 400);
+	};
+	if (request.openai?.outputCompression !== void 0 && (!Number.isInteger(request.openai.outputCompression) || request.openai.outputCompression < 0 || request.openai.outputCompression > 100)) fail("Invalid output compression");
+	if (request.openai?.moderation && !["low", "auto"].includes(request.openai.moderation)) fail("Invalid moderation");
+	if (!request.prompt?.trim()) fail("Image prompt is required");
+	const count = request.count ?? 1;
+	if (!Number.isSafeInteger(count) || count < 1 || count > (caps.generate?.maxCount ?? 1)) fail(`Unsupported image count: ${count}`);
+	const inputs = request.inputImages ?? [];
+	const editing = inputs.length > 0;
+	if (editing && (!caps.edit?.enabled || inputs.length > (caps.edit.maxInputImages ?? 0))) fail("Unsupported image editing or reference image count");
+	let bytes = 0;
+	for (const image of inputs) {
+		bytes += image.blob.size;
+		if (!(caps.edit?.inputFormats ?? [
+			"png",
+			"jpeg",
+			"webp"
+		]).map((format) => `image/${format}`).includes(image.blob.type) || image.blob.size === 0 || image.blob.size > (caps.edit?.maxInputBytes ?? 25 * 1024 * 1024)) fail("Invalid input image format or size");
+	}
+	if (bytes > 64 * 1024 * 1024) fail("Input images exceed total byte limit");
+	const mode = editing ? caps.edit : caps.generate;
+	const geometry = editing && caps.edit?.geometry ? caps.edit.geometry : caps.geometry;
+	if (request.size && (!mode?.supportsSize || !isSupportedImageSize(request.size, geometry))) fail(`Unsupported image size: ${request.size}`);
+	if (request.aspectRatio && (!mode?.supportsAspectRatio || !geometry?.aspectRatios?.includes(request.aspectRatio))) fail(`Unsupported aspect ratio: ${request.aspectRatio}`);
+	if (request.resolution && (!mode?.supportsResolution || !geometry?.resolutions?.includes(request.resolution))) fail(`Unsupported resolution: ${request.resolution}`);
+	if (request.size && (request.aspectRatio || request.resolution)) fail("size cannot be combined with aspectRatio or resolution");
+	if (request.quality && !caps.output?.qualities?.includes(request.quality)) fail(`Unsupported image quality: ${request.quality}`);
+	if (request.outputFormat && !caps.output?.formats?.includes(request.outputFormat)) fail(`Unsupported image format: ${request.outputFormat}`);
+	if (request.background && !caps.output?.backgrounds?.includes(request.background)) fail(`Unsupported image background: ${request.background}`);
+	if (request.background === "transparent" && request.outputFormat === "jpeg") fail("Transparent images require PNG or WebP");
+}
+function isSupportedImageSize(size, geometry) {
+	if (geometry?.sizes?.includes(size)) return true;
+	const match = /^(\d+)x(\d+)$/.exec(size);
+	const bounds = geometry?.pixels;
+	if (!match || !bounds) return false;
+	const width = Number(match[1]), height = Number(match[2]), pixels = width * height;
+	return width >= bounds.minEdge && height >= bounds.minEdge && width <= bounds.maxEdge && height <= bounds.maxEdge && width % bounds.step === 0 && height % bounds.step === 0 && pixels >= bounds.minPixels && pixels <= bounds.maxPixels && Math.max(width / height, height / width) <= bounds.maxRatio;
+}
+//#endregion
+export { ImageProviderError, isSupportedImageSize, validateImageRequest };

package/dist/src/agent/agent-manager.d.ts

@@ -288,6 +288,7 @@ export declare class AgentManager implements AgentInstanceGateway {
     refreshCredentials(): Promise<void>;
     private resolveApiKeyWithCache;
     private composeDynamicProjectContext;
+    private readonly personalPromptContext;
     private buildExecutionScopeContext;
     private getInteractionStateVersion;
     private getUserContextAccessVersion;