@xopcai/xopc 0.0.366 → 0.0.367

package/dist/src/agent/image/generation/native-provider.js

@@ -0,0 +1,118 @@
+import { privateNetworkPolicyToSsrfGuardOptions } from "../../../media-shared/http/private-network.js";
+import { resolveProviderHttpRequestConfig } from "../../../media-shared/http/resolve-provider-http-request-config.js";
+import { fetchWithTimeoutGuarded } from "../../../media-shared/http/provider-http.js";
+import "../../../media-shared/http/index.js";
+import { getImageProviderSpec } from "../../../../packages/image-providers/src/catalog.js";
+import { executeImageProvider } from "../../../../packages/image-providers/src/execute.js";
+import "../../../../packages/image-providers/src/index.js";
+import { resolveApiKeyForProvider } from "../../../providers/auth-runtime/resolve-api-key.js";
+import { isProviderApiKeyConfigured } from "../../../providers/auth-runtime/is-configured.js";
+import "../../../providers/auth-runtime/index.js";
+//#region src/agent/image/generation/native-provider.ts
+function buildNativeImageProvider(providerId) {
+	const spec = getImageProviderSpec(providerId);
+	const modelCapabilities = Object.fromEntries(spec.models.map((model) => [model.id, model.capabilities]));
+	return {
+		id: spec.id,
+		label: spec.name,
+		documentationUrl: spec.documentationUrl,
+		apiKeyUrl: spec.apiKeyUrl,
+		defaultModel: spec.models[0].id,
+		models: spec.models.map((model) => model.id),
+		capabilities: spec.models[0].capabilities,
+		modelCapabilities,
+		configFields: [...spec.regions ? [{
+			key: "region",
+			label: "Region",
+			type: "select",
+			required: true,
+			options: [{
+				value: "cn",
+				label: "China"
+			}, {
+				value: "intl",
+				label: "International"
+			}]
+		}] : [], {
+			key: "baseUrl",
+			label: "Base URL",
+			type: "url",
+			placeholder: spec.baseUrl
+		}],
+		isConfigured: (ctx) => isProviderApiKeyConfigured({
+			providerId,
+			cfg: ctx.cfg,
+			agentId: ctx.agentId
+		}) && (!spec.regions || Boolean(ctx.cfg?.providers?.[providerId]?.region)),
+		async generateImage(req) {
+			const apiKey = resolveApiKeyForProvider({
+				providerId,
+				cfg: req.cfg,
+				agentId: req.agentId,
+				store: req.authStore
+			});
+			if (!apiKey) throw new Error(`${spec.name} API key missing`);
+			const settings = req.cfg?.providers?.[providerId];
+			if (settings?.azure) throw new Error("Configure Azure images as an explicit custom image provider");
+			const baseUrl = settings?.baseUrl ?? (spec.regions ? spec.regions[settings?.region] : spec.baseUrl);
+			if (!baseUrl) throw new Error(`${spec.name} requires region or baseUrl`);
+			const http = resolveProviderHttpRequestConfig({
+				providerId,
+				cfg: req.cfg,
+				fallbackTimeoutMs: spec.timeoutMs
+			});
+			const timeoutMs = req.timeoutMs ?? http.timeoutMs ?? spec.timeoutMs;
+			const signal = AbortSignal.any([AbortSignal.timeout(timeoutMs), ...req.signal ? [req.signal] : []]);
+			const result = await executeImageProvider({
+				providerId,
+				baseUrl,
+				apiKey,
+				signal,
+				fetchImpl: ((url, init) => {
+					const headers = new Headers(new URL(String(url)).origin === new URL(baseUrl).origin ? http.headers : void 0);
+					new Headers(init?.headers).forEach((value, key) => headers.set(key, value));
+					return fetchWithTimeoutGuarded(String(url), {
+						label: spec.name,
+						timeoutMs,
+						signal,
+						init: {
+							...init,
+							headers,
+							redirect: "error"
+						},
+						...privateNetworkPolicyToSsrfGuardOptions()
+					});
+				}),
+				request: {
+					model: req.model,
+					prompt: req.prompt,
+					count: req.count,
+					size: req.size,
+					aspectRatio: req.aspectRatio,
+					resolution: req.resolution,
+					quality: req.quality,
+					outputFormat: req.outputFormat,
+					background: req.background ?? req.providerOptions?.openai?.background,
+					openai: req.providerOptions?.openai,
+					inputImages: req.inputImages?.map((image, index) => ({
+						blob: new Blob([new Uint8Array(image.buffer)], { type: image.mimeType }),
+						fileName: image.fileName ?? `input-${index}.png`
+					}))
+				}
+			});
+			return {
+				model: req.model,
+				images: result.images.map((image) => ({
+					buffer: Buffer.from(image.bytes),
+					mimeType: image.mimeType
+				})),
+				metadata: {
+					requestId: result.requestId,
+					usage: result.usage
+				}
+			};
+		}
+	};
+}
+//#endregion
+export { buildNativeImageProvider };

package/dist/src/agent/image/generation/openai-images-provider.d.ts

@@ -48,7 +48,7 @@ export interface OpenAiImagesProviderOptions {
     resolveEndpoint: (req: ImageGenerationRequest) => OpenAiImagesEndpointResolution;
     /** Default per-call timeout. Combined with provider-level config in provider-http. */
     defaultTimeoutMs?: number;
-    /** Default count clamp. Provider may also enforce via `capabilities.generate.maxCount`. */
+    /** Default image count. Provider may also enforce via `capabilities.generate.maxCount`. */
     defaultCount?: number;
     defaultSize?: string;
 }

package/dist/src/agent/image/generation/openai-images-provider.js

@@ -1,23 +1,24 @@
 import { createLogger } from "../../../utils/logger/index.js";
 import { init_logger } from "../../../utils/logger.js";
-import { imageAssetFromBase64, imageFileExtensionForMimeType } from "./image-assets.js";
+import { imageFileExtensionForMimeType } from "./image-assets.js";
 import { pickTimeoutMsOrFallback } from "../../../media-shared/http/deadline.js";
 import { privateNetworkPolicyToSsrfGuardOptions } from "../../../media-shared/http/private-network.js";
 import { resolveProviderHttpRequestConfig } from "../../../media-shared/http/resolve-provider-http-request-config.js";
 import { postJsonRequest, postMultipartRequest, readJsonResponseLimited } from "../../../media-shared/http/provider-http.js";
 import "../../../media-shared/http/index.js";
+import { ImageProviderError, validateImageRequest } from "../../../../packages/image-providers/src/validation.js";
+import { decodeBase64, imageFromBytes } from "../../../../packages/image-providers/src/http.js";
+import "../../../../packages/image-providers/src/index.js";
 //#region src/agent/image/generation/openai-images-provider.ts
+/** Strict implementation of the OpenAI Images REST protocol. */
 init_logger();
 const log = createLogger("ImageGen:OpenAIImages");
-const DEFAULT_OUTPUT_MIME = "image/png";
 const DEFAULT_TIMEOUT_MS = 12e4;
 const MAX_RESPONSE_BYTES = 64 * 1024 * 1024;
-const MAX_IMAGE_BYTES = 32 * 1024 * 1024;
 const MAX_TOTAL_IMAGE_BYTES = 64 * 1024 * 1024;
 function createOpenAiImagesProvider(options) {
-	const defaultMaxCount = options.capabilities.generate?.maxCount ?? 4;
 	const defaultCount = options.defaultCount ?? 1;
-	const defaultSize = options.defaultSize ?? "1024x1024";
+	const defaultSize = options.defaultSize ?? options.capabilities.geometry?.sizes?.[0];
 	return {
 		id: options.id,
 		label: options.label,
@@ -44,8 +45,20 @@ function createOpenAiImagesProvider(options) {
 			});
 			const ssrfGuardOptions = privateNetworkPolicyToSsrfGuardOptions(endpoint.privateNetworkPolicy);
 			const isEdit = (req.inputImages?.length ?? 0) > 0;
-			const count = clampCount(req.count, defaultCount, defaultMaxCount);
-			const size = req.size?.trim() || defaultSize;
+			const count = req.count ?? defaultCount;
+			const size = req.size?.trim() || (req.aspectRatio || req.resolution || !options.capabilities.generate?.supportsSize ? void 0 : defaultSize);
+			if (!options.models.includes(req.model)) throw new ImageProviderError(`Unsupported image model: ${req.model}`, 400);
+			validateImageRequest({
+				...req,
+				count,
+				size,
+				background: req.background ?? req.providerOptions?.openai?.background,
+				openai: req.providerOptions?.openai,
+				inputImages: req.inputImages?.map((image, index) => ({
+					blob: new Blob([new Uint8Array(image.buffer)], { type: image.mimeType }),
+					fileName: image.fileName ?? `input-${index}`
+				}))
+			}, options.capabilities);
 			const url = isEdit ? joinPath(endpoint.baseUrl, endpoint.editsPath ?? "/images/edits") : joinPath(endpoint.baseUrl, endpoint.generationsPath ?? "/images/generations");
 			log.debug({
 				providerId: options.id,
@@ -72,7 +85,11 @@ function createOpenAiImagesProvider(options) {
 				size,
 				httpDefaults,
 				ssrfGuardOptions
-			}), req);
+			}), {
+				...req,
+				count
+			});
+			if (mapped.length > count) throw new ImageProviderError("Provider returned too many images", 502);
 			if (mapped.length === 0) throw new Error(`${options.id} returned no images.`);
 			return {
 				images: mapped,
@@ -86,10 +103,13 @@ async function postGenerateRequest(params) {
 		model: params.req.model,
 		prompt: params.req.prompt,
 		n: params.count,
-		size: params.size,
-		response_format: "b64_json"
+		...params.size ? { size: params.size } : {}
 	};
 	applyOpenAiOptions(body, params.req);
+	if (params.req.aspectRatio || params.req.resolution) body.xopc = { image: {
+		aspectRatio: params.req.aspectRatio,
+		resolution: params.req.resolution
+	} };
 	const timeoutMs = pickTimeoutMsOrFallback(params.req.timeoutMs, params.httpDefaults.timeoutMs, DEFAULT_TIMEOUT_MS);
 	return await readJsonResponseLimited(await postJsonRequest(params.url, {
 		label: params.providerId,
@@ -106,9 +126,15 @@ async function postEditRequest(params) {
 		model: params.req.model,
 		prompt: params.req.prompt,
 		n: String(params.count),
-		size: params.size,
-		response_format: "b64_json"
+		...params.size ? { size: params.size } : {}
 	};
+	const options = {};
+	applyOpenAiOptions(options, params.req);
+	for (const [key, value] of Object.entries(options)) fields[key] = String(value);
+	if (params.req.aspectRatio || params.req.resolution) fields.xopc = JSON.stringify({ image: {
+		aspectRatio: params.req.aspectRatio,
+		resolution: params.req.resolution
+	} });
 	const form = new FormData();
 	for (const [k, v] of Object.entries(fields)) if (typeof v === "string") form.append(k, v);
 	for (let idx = 0; idx < inputImages.length; idx++) {
@@ -117,7 +143,7 @@ async function postEditRequest(params) {
 		const u8 = img.buffer instanceof Uint8Array ? img.buffer : new Uint8Array(img.buffer);
 		const copy = new Uint8Array(u8.byteLength);
 		copy.set(u8);
-		form.append(field, new Blob([copy], { type: img.mimeType || DEFAULT_OUTPUT_MIME }), pickEditFileName(img, idx));
+		form.append(field, new Blob([copy], { type: img.mimeType }), pickEditFileName(img, idx));
 	}
 	const headers = new Headers(params.headers);
 	headers.delete("content-type");
@@ -135,26 +161,20 @@ function mapOpenAiImagesResponse(raw, req) {
 	if (!raw || typeof raw !== "object") return [];
 	const data = raw.data;
 	if (!Array.isArray(data)) return [];
-	const ext = imageFileExtensionForMimeType(req.outputFormat ? `image/${req.outputFormat}` : DEFAULT_OUTPUT_MIME);
+	if (data.length > (req.count ?? 1)) throw new ImageProviderError("Provider returned too many images", 502);
 	const out = [];
 	let totalBytes = 0;
-	data.forEach((entry, index) => {
-		const b64 = entry?.b64_json;
-		if (typeof b64 !== "string" || b64.length === 0) return;
-		const estimatedBytes = Math.ceil(b64.replace(/\s+/g, "").length * 3 / 4);
-		if (estimatedBytes > MAX_IMAGE_BYTES) throw new Error(`OpenAI Images response image exceeds ${MAX_IMAGE_BYTES} bytes.`);
-		totalBytes += estimatedBytes;
-		if (totalBytes > MAX_TOTAL_IMAGE_BYTES) throw new Error(`OpenAI Images response images exceed ${MAX_TOTAL_IMAGE_BYTES} bytes total.`);
-		const asset = imageAssetFromBase64({
-			base64: b64,
-			mimeType: req.outputFormat ? `image/${req.outputFormat}` : void 0,
-			fileName: `image-${index + 1}.${ext}`
-		});
+	for (const [index, entry] of data.entries()) {
+		const image = imageFromBytes(decodeBase64(entry?.b64_json));
+		totalBytes += image.bytes.byteLength;
+		if (totalBytes > MAX_TOTAL_IMAGE_BYTES) throw new ImageProviderError("Generated images exceed total byte limit", 502);
 		out.push({
-			...asset,
+			buffer: Buffer.from(image.bytes),
+			mimeType: image.mimeType,
+			fileName: `image-${index + 1}.${imageFileExtensionForMimeType(image.mimeType)}`,
 			...typeof entry.revised_prompt === "string" ? { revisedPrompt: entry.revised_prompt } : {}
 		});
-	});
+	}
 	return out;
 }
 function applyAuthorizationHeader(params) {
@@ -191,10 +211,6 @@ function pickEditFileName(img, idx) {
 	const ext = imageFileExtensionForMimeType(img.mimeType);
 	return `image-${idx + 1}.${ext}`;
 }
-function clampCount(requested, fallback, max) {
-	if (typeof requested !== "number" || !Number.isFinite(requested) || requested <= 0) return fallback;
-	return Math.min(max, Math.max(1, Math.floor(requested)));
-}
 function joinPath(baseUrl, subPath) {
 	return `${baseUrl.replace(/\/+$/, "")}${subPath.startsWith("/") ? subPath : `/${subPath}`}`;
 }

package/dist/src/agent/image/generation/provider-registry.js

@@ -1,12 +1,10 @@
 import { createLogger } from "../../../utils/logger/index.js";
 import { init_logger } from "../../../utils/logger.js";
 import { init_models_json, loadModelsJson } from "../../../config/models-json.js";
+import { listImageProviderSpecs } from "../../../../packages/image-providers/src/catalog.js";
+import "../../../../packages/image-providers/src/index.js";
 import { buildCustomOpenAiImagesProvider } from "./custom-openai-images-provider.js";
-import { buildDashScopeImageGenerationProvider } from "./providers/dashscope.js";
-import { buildFalImageGenerationProvider } from "./providers/fal.js";
-import { buildGoogleImageGenerationProvider } from "./providers/google.js";
-import { buildMinimaxImageGenerationProvider } from "./providers/minimax.js";
-import { buildOpenAIImageGenerationProvider } from "./providers/openai.js";
+import { buildNativeImageProvider } from "./native-provider.js";
 import { buildXopcCloudImageGenerationProvider } from "./providers/xopc-cloud.js";
 //#region src/agent/image/generation/provider-registry.ts
 init_models_json();
@@ -14,14 +12,7 @@ init_logger();
 const log = createLogger("ImageGenerationRegistry");
 function buildBuiltInProviders() {
 	const cloud = buildXopcCloudImageGenerationProvider();
-	return [
-		...cloud ? [cloud] : [],
-		buildOpenAIImageGenerationProvider(),
-		buildDashScopeImageGenerationProvider(),
-		buildMinimaxImageGenerationProvider(),
-		buildGoogleImageGenerationProvider(),
-		buildFalImageGenerationProvider()
-	];
+	return [...cloud ? [cloud] : [], ...listImageProviderSpecs().map((spec) => buildNativeImageProvider(spec.id))];
 }
 let providers = buildBuiltInProviders();
 let providersById = new Map(providers.map((provider) => [provider.id, provider]));

package/dist/src/agent/image/generation/providers/xopc-cloud.js

@@ -9,9 +9,9 @@ init_provider_auth_service();
 init_xopc_cloud_config();
 function buildXopcCloudImageGenerationProvider() {
 	const source = getModelCatalogStore().getSource("xopc-cloud");
-	const models = source?.models.filter((model) => model.availability === "available" && model.kind === "image" && model.operations.includes("images.generate")).sort((left, right) => compareCatalogModels(left, right, source.recommended?.["image-generation"])) ?? [];
+	const models = source?.models.filter((model) => model.availability === "available" && model.kind === "image" && model.operations.includes("images.generate") && Boolean(model.imageGeneration)).sort((left, right) => compareCatalogModels(left, right, source.recommended?.["image-generation"])) ?? [];
 	if (models.length === 0) return void 0;
-	const modelCapabilities = Object.fromEntries(models.map((model) => [model.id, toProviderCapabilities(model)]));
+	const modelCapabilities = Object.fromEntries(models.map((model) => [model.id, model.imageGeneration]));
 	const defaultModel = models[0].id;
 	const baseUrl = source?.baseUrl ?? resolveXopcModelRouterUrl();
 	const executors = new Map(models.map((model) => [model.id, createOpenAiImagesProvider({
@@ -19,11 +19,12 @@ function buildXopcCloudImageGenerationProvider() {
 		label: "XOPC Model Service",
 		defaultModel: model.id,
 		models: [model.id],
+		defaultTimeoutMs: 6e5,
 		capabilities: modelCapabilities[model.id],
 		isConfigured: () => true,
 		resolveApiKey: (request) => getProviderAuthService().resolveApiKey("xopc-cloud", request.signal),
 		resolveEndpoint: () => ({ baseUrl }),
-		...model.imageGeneration?.sizes[0] ? { defaultSize: model.imageGeneration.sizes[0] } : {}
+		...model.imageGeneration?.geometry?.sizes?.[0] ? { defaultSize: model.imageGeneration.geometry.sizes[0] } : {}
 	})]));
 	return {
 		id: "xopc-cloud",
@@ -37,37 +38,7 @@ function buildXopcCloudImageGenerationProvider() {
 		async generateImage(request) {
 			const executor = executors.get(request.model);
 			if (!executor) throw new Error(`Image model is not available from XOPC Model Service: ${request.model}`);
-			const geometry = modelCapabilities[request.model]?.geometry;
-			const size = request.size ?? (request.aspectRatio && geometry?.aspectRatios?.includes(request.aspectRatio) ? request.aspectRatio : void 0) ?? (request.resolution && geometry?.resolutions?.includes(request.resolution) ? request.resolution : void 0);
-			return executor.generateImage({
-				...request,
-				...size ? { size } : {}
-			});
-		}
-	};
-}
-function toProviderCapabilities(model) {
-	const image = model.imageGeneration;
-	return {
-		generate: {
-			maxCount: image?.maxCount ?? 1,
-			supportsSize: Boolean(image?.sizes.length),
-			supportsAspectRatio: Boolean(image?.aspectRatios?.length)
-		},
-		edit: {
-			enabled: model.operations.includes("images.edit"),
-			maxInputImages: image?.maxInputImages ?? 0,
-			supportsSize: Boolean(image?.sizes.length),
-			supportsAspectRatio: Boolean(image?.aspectRatios?.length)
-		},
-		geometry: {
-			sizes: image?.sizes ?? [],
-			aspectRatios: image?.aspectRatios ?? []
-		},
-		output: {
-			qualities: image?.qualities ?? [],
-			formats: image?.formats ?? [],
-			backgrounds: image?.backgrounds ?? []
+			return executor.generateImage(request);
 		}
 	};
 }

package/dist/src/agent/image/generation/runtime-types.d.ts

@@ -10,9 +10,9 @@ import type { Config } from '../../../config/schema.js';
 import type { ToolModelConfig } from '../tool-model-config.js';
 import type { AuthProfileStore } from '../../../providers/auth-runtime/index.js';
 import type { FallbackAttempt } from '../../failover-error.js';
-import type { GeneratedImageAsset, ImageGenerationBackground, ImageGenerationIgnoredOverride, ImageGenerationNormalization, ImageGenerationOutputFormat, ImageGenerationProvider, ImageGenerationProviderOptions, ImageGenerationQuality, ImageGenerationResolution, ImageGenerationSourceImage } from './types.js';
+import type { GeneratedImageAsset, ImageGenerationBackground, ImageGenerationOutputFormat, ImageGenerationProvider, ImageGenerationProviderOptions, ImageGenerationQuality, ImageGenerationResolution, ImageGenerationSourceImage } from './types.js';
 export interface GenerateImageParams {
-    /** Active xopc config. Optional in Step 2 to keep tool-level callers compatible. */
+    /** Active xopc config. */
     cfg?: Config;
     prompt: string;
     agentId?: string;
@@ -41,8 +41,6 @@ export interface GenerateImageRuntimeResult {
     provider: string;
     model: string;
     attempts: FallbackAttempt[];
-    normalization?: ImageGenerationNormalization;
-    ignoredOverrides: ImageGenerationIgnoredOverride[];
     metadata?: Record<string, unknown>;
 }
 /**

package/dist/src/agent/image/generation/runtime.js

@@ -1,11 +1,13 @@
 import { createLogger } from "../../../utils/logger/index.js";
 import { init_logger } from "../../../utils/logger.js";
 import { PROVIDER_ENV_MAP, init_env_keys } from "../../../providers/env-keys.js";
+import { ImageProviderError } from "../../../../packages/image-providers/src/validation.js";
+import "../../../../packages/image-providers/src/index.js";
 import { describeFailoverError, isFailoverError } from "../../failover-error.js";
-import { buildMediaGenerationNormalizationMetadata, buildNoCapabilityModelConfiguredMessage, recordCapabilityCandidateFailure, resolveCapabilityModelCandidates, throwCapabilityGenerationFailure } from "../../media-generation/runtime-shared.js";
+import { buildNoCapabilityModelConfiguredMessage, recordCapabilityCandidateFailure, resolveCapabilityModelCandidates, throwCapabilityGenerationFailure } from "../../media-generation/runtime-shared.js";
 import "../../media-generation/index.js";
 import { parseImageGenerationModelRef } from "./model-ref.js";
-import { resolveImageGenerationOverrides } from "./normalization.js";
+import { validateImageGenerationRequest } from "./validation.js";
 import { getImageGenerationProvider, listImageGenerationProviders, listImageGenerationProvidersSummary as listImageGenerationProvidersSummary$1 } from "./provider-registry.js";
 //#region src/agent/image/generation/runtime.ts
 init_env_keys();
@@ -29,9 +31,13 @@ async function generateImage(params, deps = {}) {
 		autoProviderFallback: params.autoProviderFallback
 	});
 	if (candidates.length === 0) throw new Error(buildNoImageGenerationModelConfiguredMessage(params.cfg, deps));
+	params = {
+		...params,
+		signal: AbortSignal.any([AbortSignal.timeout(params.timeoutMs ?? 6e5), ...params.signal ? [params.signal] : []])
+	};
 	const attempts = [];
 	let lastError;
-	for (const candidate of candidates) {
+	for (const candidate of candidates.slice(0, 3)) {
 		const startedAt = Date.now();
 		const provider = getProvider(candidate.provider, params.cfg);
 		if (!provider) {
@@ -51,13 +57,15 @@ async function generateImage(params, deps = {}) {
 			continue;
 		}
 		try {
+			if (!provider.models.includes(candidate.model)) throw new ImageProviderError(`Unsupported image model: ${candidate.model}`, 400);
 			const modelCapabilities = provider.modelCapabilities?.[candidate.model];
-			const sanitized = resolveImageGenerationOverrides({
+			validateImageGenerationRequest({
 				provider: modelCapabilities ? {
 					...provider,
 					capabilities: modelCapabilities
 				} : provider,
 				size: params.size,
+				count: params.count,
 				aspectRatio: params.aspectRatio,
 				resolution: params.resolution,
 				quality: params.quality,
@@ -68,32 +76,29 @@ async function generateImage(params, deps = {}) {
 			const request = buildProviderRequest({
 				provider,
 				candidate,
-				params,
-				sanitized
+				params
 			});
 			log.debug({
 				provider: candidate.provider,
 				model: candidate.model,
-				phase: "provider_invoked",
-				normalizationCount: sanitized.normalization ? Object.keys(sanitized.normalization).length : 0,
-				ignoredCount: sanitized.ignoredOverrides.length
+				phase: "provider_invoked"
 			}, `image-generation provider invoked: ${candidate.provider}/${candidate.model}`);
 			const result = await provider.generateImage(request);
 			if (!result.images?.length) throw new Error("Image generation provider returned no images.");
-			const normalizationMetadata = buildMediaGenerationNormalizationMetadata({ normalization: sanitized.normalization });
 			return {
 				images: result.images,
 				provider: candidate.provider,
 				model: result.model ?? candidate.model,
 				attempts,
-				...sanitized.normalization ? { normalization: sanitized.normalization } : {},
-				ignoredOverrides: sanitized.ignoredOverrides,
-				metadata: {
-					...result.metadata ?? {},
-					...normalizationMetadata
-				}
+				metadata: result.metadata
 			};
 		} catch (err) {
+			const status = err && typeof err === "object" && "status" in err ? err.status : void 0;
+			if (params.signal?.aborted || err instanceof ImageProviderError && !err.retryable || ![
+				401,
+				403,
+				429
+			].includes(Number(status))) throw err;
 			lastError = err;
 			const durationMs = Date.now() - startedAt;
 			recordCapabilityCandidateFailure({
@@ -127,7 +132,7 @@ function listImageGenerationProvidersSummary() {
 	return listImageGenerationProvidersSummary$1();
 }
 function buildProviderRequest(input) {
-	const { provider, candidate, params, sanitized } = input;
+	const { provider, candidate, params } = input;
 	const inputImages = params.inputImages ? cloneInputImages(params.inputImages) : void 0;
 	return {
 		provider: provider.id,
@@ -140,12 +145,12 @@ function buildProviderRequest(input) {
 		...typeof params.timeoutMs === "number" ? { timeoutMs: params.timeoutMs } : {},
 		...params.signal ? { signal: params.signal } : {},
 		...typeof params.count === "number" ? { count: params.count } : {},
-		...sanitized.size !== void 0 ? { size: sanitized.size } : {},
-		...sanitized.aspectRatio !== void 0 ? { aspectRatio: sanitized.aspectRatio } : {},
-		...sanitized.resolution !== void 0 ? { resolution: sanitized.resolution } : {},
-		...sanitized.quality !== void 0 ? { quality: sanitized.quality } : {},
-		...sanitized.outputFormat !== void 0 ? { outputFormat: sanitized.outputFormat } : {},
-		...sanitized.background !== void 0 ? { background: sanitized.background } : {},
+		...params.size !== void 0 ? { size: params.size } : {},
+		...params.aspectRatio !== void 0 ? { aspectRatio: params.aspectRatio } : {},
+		...params.resolution !== void 0 ? { resolution: params.resolution } : {},
+		...params.quality !== void 0 ? { quality: params.quality } : {},
+		...params.outputFormat !== void 0 ? { outputFormat: params.outputFormat } : {},
+		...params.background !== void 0 ? { background: params.background } : {},
 		...inputImages ? { inputImages } : {},
 		...params.providerOptions ? { providerOptions: params.providerOptions } : {}
 	};

package/dist/src/agent/image/generation/types.d.ts

@@ -1,48 +1,11 @@
 import type { Config } from '../../../config/schema.js';
 import type { AuthProfileStore } from '../../../providers/auth-runtime/index.js';
-import type { MediaNormalizationEntry } from '../../media-generation/normalization.types.js';
 export type ImageGenerationResolution = '1K' | '2K' | '4K';
-export type ImageGenerationQuality = 'low' | 'medium' | 'high' | 'auto';
+export type ImageGenerationQuality = 'low' | 'medium' | 'high' | 'xhigh' | 'max' | 'auto';
 export type ImageGenerationOutputFormat = 'png' | 'jpeg' | 'webp';
 export type ImageGenerationBackground = 'transparent' | 'opaque' | 'auto';
-/** Generation-mode (text → image) capability slice. */
-export interface ImageGenerationGenerateCapability {
-    /** Maximum images per call (defaults to 1 when omitted). */
-    maxCount?: number;
-    /** Provider supports an explicit `size` parameter. */
-    supportsSize?: boolean;
-    /** Provider supports `aspectRatio` parameter. */
-    supportsAspectRatio?: boolean;
-    /** Provider supports `resolution` parameter. */
-    supportsResolution?: boolean;
-}
-/** Edit-mode (image → image) capability slice. */
-export interface ImageGenerationEditCapability {
-    enabled: boolean;
-    /** Max number of input reference images (1 = single ref). */
-    maxInputImages?: number;
-    supportsSize?: boolean;
-    supportsAspectRatio?: boolean;
-}
-/** Geometry constraints (allowed values for size / aspectRatio / resolution). */
-export interface ImageGenerationGeometryCapability {
-    sizes?: string[];
-    aspectRatios?: string[];
-    resolutions?: ImageGenerationResolution[];
-}
-/** Output / styling capability slice. */
-export interface ImageGenerationOutputCapability {
-    qualities?: ImageGenerationQuality[];
-    formats?: ImageGenerationOutputFormat[];
-    backgrounds?: ImageGenerationBackground[];
-}
-/** New nested capability shape. */
-export interface ImageGenerationProviderCapabilities {
-    generate?: ImageGenerationGenerateCapability;
-    edit?: ImageGenerationEditCapability;
-    geometry?: ImageGenerationGeometryCapability;
-    output?: ImageGenerationOutputCapability;
-}
+export type { ImageGeometry as ImageGenerationGeometryCapability } from '../../../../packages/image-providers/src/types.js';
+export type ImageGenerationProviderCapabilities = import('../../../../packages/image-providers/src/types.js').ImageCapabilities;
 export interface ImageGenerationProviderConfiguredContext {
     cfg?: Config;
     agentId?: string;
@@ -112,16 +75,6 @@ export interface ImageGenerationSourceImage {
     fileName?: string;
     metadata?: Record<string, unknown>;
 }
-export type ImageGenerationIgnoredOverrideKey = 'size' | 'aspectRatio' | 'resolution' | 'quality' | 'outputFormat' | 'background';
-export interface ImageGenerationIgnoredOverride {
-    key: ImageGenerationIgnoredOverrideKey;
-    value: string;
-}
-export interface ImageGenerationNormalization {
-    size?: MediaNormalizationEntry<string>;
-    aspectRatio?: MediaNormalizationEntry<string>;
-    resolution?: MediaNormalizationEntry<ImageGenerationResolution>;
-}
 export interface ImageGenerationRequest {
     provider: string;
     model: string;

package/dist/src/agent/image/generation/validation.d.ts

@@ -0,0 +1,6 @@
+import type { ImageGenerationProvider, ImageGenerationRequest } from './types.js';
+export interface ImageGenerationValidationParams extends Pick<ImageGenerationRequest, 'size' | 'count' | 'aspectRatio' | 'resolution' | 'quality' | 'outputFormat' | 'background' | 'inputImages'> {
+    provider: ImageGenerationProvider;
+}
+export declare function validateImageGenerationRequest(params: ImageGenerationValidationParams): void;
+export type { ImageGenerationProviderCapabilities } from './types.js';

package/dist/src/agent/image/generation/validation.js

@@ -0,0 +1,16 @@
+import { validateImageRequest } from "../../../../packages/image-providers/src/validation.js";
+import "../../../../packages/image-providers/src/index.js";
+//#region src/agent/image/generation/validation.ts
+function validateImageGenerationRequest(params) {
+	validateImageRequest({
+		...params,
+		model: params.provider.defaultModel,
+		prompt: "validate",
+		inputImages: params.inputImages?.map((image, index) => ({
+			blob: new Blob([new Uint8Array(image.buffer)], { type: image.mimeType }),
+			fileName: image.fileName ?? `image-${index}`
+		}))
+	}, params.provider.capabilities);
+}
+//#endregion
+export { validateImageGenerationRequest };

package/dist/src/agent/tools/factory.js

@@ -11,6 +11,7 @@ import { init_sqlite } from "../../storage/sqlite/index.js";
 import { init_agent_scope, resolveDefaultAgentId } from "../agent-scope.js";
 import { resolveEffectiveAgentConfigForAgent, resolveEffectiveAgentConfigForSession } from "../../config/agent-profile.js";
 import { resolveUserContextSessionAccess } from "../../user-context/access-policy.js";
+import { createPersonalAttentionTool } from "./personal-attention-tool.js";
 import "../../../packages/browser-control-contract/src/index.js";
 import { PERSONAL_TOOL_DESCRIPTIONS } from "../../personal-agent/policy.js";
 import { getEmbeddedExecutionRunId, getEmbeddedExecutionSession } from "../embedded/execution-context.js";
@@ -508,6 +509,10 @@ var AgentToolsFactory = class AgentToolsFactory {
 				createPersonalTaskTool(productToolDeps),
 				createPersonalReadTool(productToolDeps),
 				...createPersonalRequestTools(productToolDeps),
+				createPersonalAttentionTool({
+					getConversationId: () => this.deps.getCurrentContext()?.conversationId,
+					getConfig: () => this.deps.getConfig?.()
+				}),
 				createPersonalPreferenceTool({
 					getCurrentConversationId: () => this.deps.getCurrentContext()?.conversationId,
 					onAgentCatalogMutate: this.deps.onAgentCatalogMutate