@xopcai/xopc 0.0.166 → 0.0.168

package/dist/src/config/models-json.js

@@ -48,6 +48,55 @@ function validateModelsConfig(config) {
 		const hasModels = providerConfig.models && providerConfig.models.length > 0;
 		const hasModelOverrides = providerConfig.modelOverrides && Object.keys(providerConfig.modelOverrides).length > 0;
 		const hasBaseUrl = !!providerConfig.baseUrl;
+		const imageGeneration = providerConfig.imageGeneration;
+		if (imageGeneration) {
+			if (RESERVED_PROVIDER_IDS.has(providerName)) errors.push({
+				path: `providers.${providerName}.imageGeneration`,
+				message: "Custom image generation cannot override a built-in provider ID",
+				severity: "error"
+			});
+			if (!hasBaseUrl) errors.push({
+				path: `providers.${providerName}.baseUrl`,
+				message: "baseUrl is required when defining image generation models",
+				severity: "error"
+			});
+			const credentialHeaderNames = new Set([
+				"authorization",
+				"proxy-authorization",
+				"cookie",
+				...imageGeneration.auth.type === "header" ? [imageGeneration.auth.headerName.toLowerCase()] : []
+			]);
+			for (const headerName of Object.keys(providerConfig.headers ?? {})) if (credentialHeaderNames.has(headerName.toLowerCase())) errors.push({
+				path: `providers.${providerName}.headers.${headerName}`,
+				message: "Credential headers must be stored in the credential store, not models.json",
+				severity: "error"
+			});
+			for (const [headerName, headerValue] of Object.entries(providerConfig.headers ?? {})) if (!isHttpHeaderValue(headerValue)) errors.push({
+				path: `providers.${providerName}.headers.${headerName}`,
+				message: "Header values must contain only HTTP ByteString characters and no control characters",
+				severity: "error"
+			});
+			const imageModelIds = /* @__PURE__ */ new Set();
+			for (let i = 0; i < imageGeneration.models.length; i++) {
+				const model = imageGeneration.models[i];
+				if (model.id.includes("/")) errors.push({
+					path: `providers.${providerName}.imageGeneration.models[${i}].id`,
+					message: "Image model ID cannot contain \"/\" character",
+					severity: "error"
+				});
+				if (imageModelIds.has(model.id)) errors.push({
+					path: `providers.${providerName}.imageGeneration.models[${i}].id`,
+					message: `Duplicate image model ID "${model.id}"`,
+					severity: "error"
+				});
+				imageModelIds.add(model.id);
+			}
+			if (!imageModelIds.has(imageGeneration.defaultModel)) errors.push({
+				path: `providers.${providerName}.imageGeneration.defaultModel`,
+				message: "defaultModel must reference a configured image generation model",
+				severity: "error"
+			});
+		}
 		if (hasModels) {
 			if (!hasBaseUrl) errors.push({
 				path: `providers.${providerName}.baseUrl`,
@@ -55,7 +104,7 @@ function validateModelsConfig(config) {
 				severity: "error"
 			});
 		}
-		if (!hasModels && !hasBaseUrl && !hasModelOverrides && !providerConfig.apiKey) errors.push({
+		if (!hasModels && !hasBaseUrl && !hasModelOverrides && !providerConfig.apiKey && !imageGeneration) errors.push({
 			path: `providers.${providerName}`,
 			message: "Must specify baseUrl, modelOverrides, models, or apiKey",
 			severity: "error"
@@ -99,6 +148,13 @@ function validateModelsConfig(config) {
 		errors
 	};
 }
+function isHttpHeaderValue(value) {
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code > 255 || code < 32 && code !== 9 || code === 127) return false;
+	}
+	return true;
+}
 function getDefaultModelValues() {
 	return {
 		input: ["text"],
@@ -158,7 +214,7 @@ function saveModelsJson(path, config) {
 function modelsJsonExists(path = resolveModelsJsonPath()) {
 	return existsSync(path);
 }
-var OpenRouterRoutingSchema, VercelGatewayRoutingSchema, OpenAICompletionsCompatSchema, OpenAIResponsesCompatSchema, OpenAICompatSchema, CustomModelSchema, ModelOverrideSchema, ProviderConfigSchema, ModelsJsonSchema, PROVIDER_ID_REGEX, RESERVED_PROVIDER_IDS;
+var OpenRouterRoutingSchema, VercelGatewayRoutingSchema, OpenAICompletionsCompatSchema, OpenAIResponsesCompatSchema, OpenAICompatSchema, ImageGenerationResolutionSchema, ImageGenerationQualitySchema, ImageGenerationOutputFormatSchema, ImageGenerationBackgroundSchema, ImageGenerationCapabilitiesSchema, ImageGenerationModelSchema, ImageGenerationProviderSchema, CustomModelSchema, ModelOverrideSchema, ProviderConfigSchema, ModelsJsonSchema, PROVIDER_ID_REGEX, RESERVED_PROVIDER_IDS;
 var init_models_json = __esmMin((() => {
 	init_write_file_atomic();
 	init_paths();
@@ -191,6 +247,82 @@ var init_models_json = __esmMin((() => {
 	});
 	OpenAIResponsesCompatSchema = z.object({});
 	OpenAICompatSchema = z.union([OpenAICompletionsCompatSchema, OpenAIResponsesCompatSchema]);
+	ImageGenerationResolutionSchema = z.enum([
+		"1K",
+		"2K",
+		"4K"
+	]);
+	ImageGenerationQualitySchema = z.enum([
+		"low",
+		"medium",
+		"high",
+		"auto"
+	]);
+	ImageGenerationOutputFormatSchema = z.enum([
+		"png",
+		"jpeg",
+		"webp"
+	]);
+	ImageGenerationBackgroundSchema = z.enum([
+		"transparent",
+		"opaque",
+		"auto"
+	]);
+	ImageGenerationCapabilitiesSchema = z.object({
+		generate: z.object({
+			maxCount: z.number().int().positive().optional(),
+			supportsSize: z.boolean().optional(),
+			supportsAspectRatio: z.boolean().optional(),
+			supportsResolution: z.boolean().optional()
+		}).strict().optional(),
+		edit: z.object({
+			enabled: z.boolean(),
+			maxInputImages: z.number().int().positive().optional(),
+			supportsSize: z.boolean().optional(),
+			supportsAspectRatio: z.boolean().optional()
+		}).strict().optional(),
+		geometry: z.object({
+			sizes: z.array(z.string().min(1)).optional(),
+			aspectRatios: z.array(z.string().min(1)).optional(),
+			resolutions: z.array(ImageGenerationResolutionSchema).optional()
+		}).strict().optional(),
+		output: z.object({
+			qualities: z.array(ImageGenerationQualitySchema).optional(),
+			formats: z.array(ImageGenerationOutputFormatSchema).optional(),
+			backgrounds: z.array(ImageGenerationBackgroundSchema).optional()
+		}).strict().optional()
+	}).strict();
+	ImageGenerationModelSchema = z.object({
+		id: z.string().min(1),
+		name: z.string().min(1).optional(),
+		capabilities: ImageGenerationCapabilitiesSchema,
+		defaults: z.object({
+			count: z.number().int().positive().optional(),
+			size: z.string().min(1).optional(),
+			outputFormat: ImageGenerationOutputFormatSchema.optional()
+		}).strict().optional()
+	}).strict();
+	ImageGenerationProviderSchema = z.object({
+		api: z.literal("openai-images"),
+		name: z.string().min(1),
+		documentationUrl: z.string().url().optional(),
+		apiKeyUrl: z.string().url().optional(),
+		defaultModel: z.string().min(1),
+		auth: z.discriminatedUnion("type", [
+			z.object({ type: z.literal("bearer") }).strict(),
+			z.object({
+				type: z.literal("header"),
+				headerName: z.string().regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/)
+			}).strict(),
+			z.object({ type: z.literal("none") }).strict()
+		]),
+		paths: z.object({
+			generations: z.string().startsWith("/").optional(),
+			edits: z.string().startsWith("/").optional()
+		}).strict().optional(),
+		network: z.object({ allowedHosts: z.array(z.string().min(1).refine((host) => host === host.trim() && !host.includes("://") && !/[/?#]/.test(host), "Use an exact hostname or IP without scheme, port, or path")).min(1) }).strict().optional(),
+		models: z.array(ImageGenerationModelSchema).min(1)
+	}).strict();
 	CustomModelSchema = z.object({
 		id: z.string().min(1),
 		name: z.string().min(1).optional(),
@@ -251,7 +383,8 @@ var init_models_json = __esmMin((() => {
 		authHeader: z.boolean().optional(),
 		models: z.array(CustomModelSchema).optional(),
 		modelOverrides: z.record(z.string(), ModelOverrideSchema).optional(),
-		modelDiscovery: z.object({ enabled: z.boolean() }).strict().optional()
+		modelDiscovery: z.object({ enabled: z.boolean() }).strict().optional(),
+		imageGeneration: ImageGenerationProviderSchema.optional()
 	});
 	ModelsJsonSchema = z.object({ providers: z.record(z.string(), ProviderConfigSchema) });
 	PROVIDER_ID_REGEX = /^[a-z0-9]([a-z0-9-_]*[a-z0-9])?$/;
@@ -262,7 +395,9 @@ var init_models_json = __esmMin((() => {
 		"cerebras",
 		"cloudflare-ai-gateway",
 		"cloudflare-workers-ai",
+		"dashscope",
 		"deepseek",
+		"fal",
 		"fireworks",
 		"github-copilot",
 		"google",
@@ -294,4 +429,4 @@ var init_models_json = __esmMin((() => {
 }));
 //#endregion
 init_models_json();
-export { CustomModelSchema, ModelOverrideSchema, ModelsJsonSchema, OpenAICompatSchema, OpenAICompletionsCompatSchema, OpenAIResponsesCompatSchema, OpenRouterRoutingSchema, ProviderConfigSchema, VercelGatewayRoutingSchema, getDefaultModelValues, resolveModelsJsonPath as getModelsJsonPath, init_models_json, loadModelsJson, modelsJsonExists, saveModelsJson, validateModelsConfig };
+export { CustomModelSchema, ImageGenerationCapabilitiesSchema, ImageGenerationModelSchema, ImageGenerationProviderSchema, ModelOverrideSchema, ModelsJsonSchema, OpenAICompatSchema, OpenAICompletionsCompatSchema, OpenAIResponsesCompatSchema, OpenRouterRoutingSchema, ProviderConfigSchema, VercelGatewayRoutingSchema, getDefaultModelValues, resolveModelsJsonPath as getModelsJsonPath, init_models_json, loadModelsJson, modelsJsonExists, saveModelsJson, validateModelsConfig };

package/dist/src/extensions/sdk/index.js

@@ -7,8 +7,8 @@ import { SlotRegistry, getSlotRegistry, registerSlotType } from "../slots.js";
 import { ExtensionDiagnostics, ExtensionLoaderCacheImpl, getExtensionCache, getExtensionDiagnostics } from "../diagnostics.js";
 import "../loader.js";
 import { ExtensionHookRunner, createHookContext, isHookEvent } from "../hooks.js";
-import { registerExtensionCliProgram } from "./channel-helpers.js";
 import { defineChannelPluginEntry } from "./channel-entry.js";
+import { registerExtensionCliProgram } from "./channel-helpers.js";
 import { lazyFunction, lazyModule } from "./lazy.js";
 import { createMockExtensionApi, createTestGateway } from "./testing.js";
 //#region src/extensions/sdk/index.ts

package/dist/src/gateway/custom-image-providers.d.ts

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+import { type ModelsJsonConfig } from '../config/models-json.js';
+export declare const CustomImageProviderInputSchema: z.ZodObject<{
+    baseUrl: z.ZodString;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    imageGeneration: z.ZodObject<{
+        api: z.ZodLiteral<"openai-images">;
+        name: z.ZodString;
+        documentationUrl: z.ZodOptional<z.ZodString>;
+        apiKeyUrl: z.ZodOptional<z.ZodString>;
+        defaultModel: z.ZodString;
+        auth: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"bearer">;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"header">;
+            headerName: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"none">;
+        }, z.core.$strict>], "type">;
+        paths: z.ZodOptional<z.ZodObject<{
+            generations: z.ZodOptional<z.ZodString>;
+            edits: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        network: z.ZodOptional<z.ZodObject<{
+            allowedHosts: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        models: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            capabilities: z.ZodObject<{
+                generate: z.ZodOptional<z.ZodObject<{
+                    maxCount: z.ZodOptional<z.ZodNumber>;
+                    supportsSize: z.ZodOptional<z.ZodBoolean>;
+                    supportsAspectRatio: z.ZodOptional<z.ZodBoolean>;
+                    supportsResolution: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
+                edit: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodBoolean;
+                    maxInputImages: z.ZodOptional<z.ZodNumber>;
+                    supportsSize: z.ZodOptional<z.ZodBoolean>;
+                    supportsAspectRatio: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
+                geometry: z.ZodOptional<z.ZodObject<{
+                    sizes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    aspectRatios: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    resolutions: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        "1K": "1K";
+                        "2K": "2K";
+                        "4K": "4K";
+                    }>>>;
+                }, z.core.$strict>>;
+                output: z.ZodOptional<z.ZodObject<{
+                    qualities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        low: "low";
+                        high: "high";
+                        auto: "auto";
+                        medium: "medium";
+                    }>>>;
+                    formats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        png: "png";
+                        jpeg: "jpeg";
+                        webp: "webp";
+                    }>>>;
+                    backgrounds: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        auto: "auto";
+                        transparent: "transparent";
+                        opaque: "opaque";
+                    }>>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            defaults: z.ZodOptional<z.ZodObject<{
+                count: z.ZodOptional<z.ZodNumber>;
+                size: z.ZodOptional<z.ZodString>;
+                outputFormat: z.ZodOptional<z.ZodEnum<{
+                    png: "png";
+                    jpeg: "jpeg";
+                    webp: "webp";
+                }>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CustomImageProviderInput = z.infer<typeof CustomImageProviderInputSchema>;
+export interface CustomImageProviderRecord extends CustomImageProviderInput {
+    providerId: string;
+}
+export declare function listCustomImageProviders(config: ModelsJsonConfig): CustomImageProviderRecord[];
+export declare function upsertCustomImageProvider(config: ModelsJsonConfig, providerIdRaw: string, input: unknown): ModelsJsonConfig;
+export declare function deleteCustomImageProvider(config: ModelsJsonConfig, providerIdRaw: string): ModelsJsonConfig;

package/dist/src/gateway/custom-image-providers.js

@@ -0,0 +1,59 @@
+import { ImageGenerationProviderSchema, init_models_json, validateModelsConfig } from "../config/models-json.js";
+import { z } from "zod";
+//#region src/gateway/custom-image-providers.ts
+init_models_json();
+const PROVIDER_ID_REGEX = /^[a-z0-9]([a-z0-9-_]*[a-z0-9])?$/;
+const CustomImageProviderInputSchema = z.object({
+	baseUrl: z.string().url(),
+	headers: z.record(z.string(), z.string()).optional(),
+	imageGeneration: ImageGenerationProviderSchema
+}).strict();
+function listCustomImageProviders(config) {
+	return Object.entries(config.providers).flatMap(([providerId, provider]) => {
+		if (!provider.imageGeneration) return [];
+		return [{
+			providerId,
+			baseUrl: provider.baseUrl,
+			...provider.headers ? { headers: { ...provider.headers } } : {},
+			imageGeneration: structuredClone(provider.imageGeneration)
+		}];
+	});
+}
+function upsertCustomImageProvider(config, providerIdRaw, input) {
+	const providerId = normalizeProviderId(providerIdRaw);
+	const parsed = CustomImageProviderInputSchema.safeParse(input);
+	if (!parsed.success) throw new Error(parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; "));
+	const { headers: _currentHeaders, ...currentWithoutHeaders } = config.providers[providerId] ?? {};
+	const next = structuredClone(config);
+	next.providers[providerId] = {
+		...currentWithoutHeaders,
+		baseUrl: parsed.data.baseUrl,
+		...parsed.data.headers ? { headers: parsed.data.headers } : {},
+		imageGeneration: parsed.data.imageGeneration
+	};
+	assertValid(next);
+	return next;
+}
+function deleteCustomImageProvider(config, providerIdRaw) {
+	const providerId = normalizeProviderId(providerIdRaw);
+	const current = config.providers[providerId];
+	if (!current?.imageGeneration) throw new Error(`Custom image provider not found: ${providerId}`);
+	const next = structuredClone(config);
+	if (Boolean(current.api || current.apiKey || current.authHeader !== void 0 || current.models?.length || current.modelOverrides && Object.keys(current.modelOverrides).length > 0 || current.modelDiscovery)) {
+		const { imageGeneration: _removed, ...remaining } = current;
+		next.providers[providerId] = remaining;
+	} else delete next.providers[providerId];
+	assertValid(next);
+	return next;
+}
+function normalizeProviderId(value) {
+	const providerId = value.trim();
+	if (!PROVIDER_ID_REGEX.test(providerId)) throw new Error("Provider ID must start/end with alphanumeric and contain only lowercase letters, numbers, hyphens, and underscores");
+	return providerId;
+}
+function assertValid(config) {
+	const validation = validateModelsConfig(config);
+	if (!validation.valid) throw new Error(validation.errors.filter((entry) => entry.severity === "error").map((entry) => `${entry.path}: ${entry.message}`).join("; "));
+}
+//#endregion
+export { CustomImageProviderInputSchema, deleteCustomImageProvider, listCustomImageProviders, upsertCustomImageProvider };

package/dist/src/gateway/hono/routes/models.js

@@ -7,7 +7,9 @@ import { CredentialResolver, init_credentials } from "../../../auth/credentials.
 import "../../../providers/constants.js";
 import { getProviderRegistry, init_plugin_registry } from "../../../providers/plugin-registry.js";
 import { PROVIDER_META, getAllModels, getAllProviders, getAvailableModels, getProviderAuthState, init_providers, isProviderConfigured } from "../../../providers/index.js";
+import { getImageGenerationProvider, reloadImageGenerationProviders } from "../../../agent/image/generation/provider-registry.js";
 import { SessionConfigStore } from "../../../session/config-store.js";
+import { deleteCustomImageProvider, listCustomImageProviders, upsertCustomImageProvider } from "../../custom-image-providers.js";
 import { getDomesticProviderPreset, getDomesticProviderPresetIds } from "../../../providers/domestic-presets.js";
 import { getOnboardingFeaturedProviders, getProviderHint, getRecommendedModelsForProvider, isRecommendedModel, sortModelsForPicker, sortProvidersForPicker } from "../../../providers/presentation.js";
 import { getAgentImageGenerationConfig, getImageGenerationCatalog, prepareImageGenerationSetup, verifyImageGenerationCredential } from "../../image-generation-setup.js";
@@ -119,6 +121,7 @@ function registerModelsRoutes(authenticated, deps) {
 		}, 400);
 		const registry = getModelRegistry();
 		registry.refresh();
+		reloadImageGenerationProviders(config);
 		service.emit("models-json.updated", { modelCount: registry.getAll().length });
 		return c.json({
 			ok: true,
@@ -131,6 +134,7 @@ function registerModelsRoutes(authenticated, deps) {
 	authenticated.post("/api/models-json/reload", async (c) => {
 		const registry = getModelRegistry();
 		registry.refresh();
+		reloadImageGenerationProviders();
 		const error = registry.getError();
 		const models = registry.getAll();
 		service.emit("models-json.reloaded", {
@@ -239,6 +243,182 @@ function registerModelsRoutes(authenticated, deps) {
 			payload: { providers: getImageGenerationCatalog(service.currentConfig) }
 		});
 	});
+	authenticated.get("/api/image-generation/custom-providers", (c) => {
+		const loaded = loadModelsJson(resolveModelsJsonPath());
+		if (loaded.error) return c.json({
+			ok: false,
+			error: { message: loaded.error }
+		}, 409);
+		return c.json({
+			ok: true,
+			payload: { providers: listCustomImageProviders(loaded.config) }
+		});
+	});
+	authenticated.put("/api/image-generation/custom-providers/:providerId", strictRateLimitMiddleware, async (c) => {
+		const loaded = loadModelsJson(resolveModelsJsonPath());
+		if (loaded.error) return c.json({
+			ok: false,
+			error: { message: loaded.error }
+		}, 409);
+		try {
+			const body = await c.req.json();
+			const next = upsertCustomImageProvider(loaded.config, c.req.param("providerId"), body);
+			const saved = saveModelsJson(resolveModelsJsonPath(), next);
+			if (!saved.success) return c.json({
+				ok: false,
+				error: { message: saved.error }
+			}, 400);
+			getModelRegistry().refresh();
+			reloadImageGenerationProviders(next);
+			service.emit("models-json.updated", { modelCount: getModelRegistry().getAll().length });
+			return c.json({
+				ok: true,
+				payload: {
+					provider: listCustomImageProviders(next).find((entry) => entry.providerId === c.req.param("providerId")),
+					providers: getImageGenerationCatalog(service.currentConfig)
+				}
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: { message: error instanceof Error ? error.message : String(error) }
+			}, 400);
+		}
+	});
+	authenticated.delete("/api/image-generation/custom-providers/:providerId", strictRateLimitMiddleware, (c) => {
+		const loaded = loadModelsJson(resolveModelsJsonPath());
+		if (loaded.error) return c.json({
+			ok: false,
+			error: { message: loaded.error }
+		}, 409);
+		try {
+			const next = deleteCustomImageProvider(loaded.config, c.req.param("providerId"));
+			const saved = saveModelsJson(resolveModelsJsonPath(), next);
+			if (!saved.success) return c.json({
+				ok: false,
+				error: { message: saved.error }
+			}, 400);
+			getModelRegistry().refresh();
+			reloadImageGenerationProviders(next);
+			service.emit("models-json.updated", { modelCount: getModelRegistry().getAll().length });
+			return c.json({
+				ok: true,
+				payload: {
+					deleted: c.req.param("providerId"),
+					providers: getImageGenerationCatalog(service.currentConfig)
+				}
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: { message: error instanceof Error ? error.message : String(error) }
+			}, 400);
+		}
+	});
+	authenticated.put("/api/image-generation/providers/:providerId/credential", strictRateLimitMiddleware, async (c) => {
+		const providerId = c.req.param("providerId").trim();
+		const provider = getImageGenerationProvider(providerId);
+		if (!provider) return c.json({
+			ok: false,
+			error: { message: `Unknown image provider: ${providerId}` }
+		}, 404);
+		if (provider.credentialMode === "none") return c.json({
+			ok: false,
+			error: { message: "This provider does not use an API key" }
+		}, 400);
+		const body = await c.req.json().catch(() => null);
+		const apiKey = typeof body?.apiKey === "string" ? body.apiKey.trim() : "";
+		if (!apiKey) return c.json({
+			ok: false,
+			error: { message: "API key is required" }
+		}, 400);
+		await new CredentialResolver().saveApiKey(providerId, apiKey, { profileName: "default" });
+		return c.json({
+			ok: true,
+			payload: {
+				providerId,
+				saved: true
+			}
+		});
+	});
+	authenticated.post("/api/image-generation/providers/:providerId/reveal-api-key", strictRateLimitMiddleware, async (c) => {
+		const providerId = c.req.param("providerId").trim();
+		if (!getImageGenerationProvider(providerId)) return c.json({
+			ok: false,
+			error: { message: `Unknown image provider: ${providerId}` }
+		}, 404);
+		const apiKey = await new CredentialResolver().revealGatewayStoredApiKey(providerId);
+		return c.json({
+			ok: true,
+			payload: {
+				providerId,
+				apiKey: apiKey ?? null,
+				source: apiKey ? "credential" : "none"
+			}
+		});
+	});
+	authenticated.delete("/api/image-generation/providers/:providerId/credential", strictRateLimitMiddleware, async (c) => {
+		const providerId = c.req.param("providerId").trim();
+		if (!getImageGenerationProvider(providerId)) return c.json({
+			ok: false,
+			error: { message: `Unknown image provider: ${providerId}` }
+		}, 404);
+		await new CredentialResolver().deleteProviderCredential(providerId);
+		return c.json({
+			ok: true,
+			payload: {
+				providerId,
+				deleted: true
+			}
+		});
+	});
+	authenticated.post("/api/image-generation/providers/:providerId/test", strictRateLimitMiddleware, async (c) => {
+		const providerId = c.req.param("providerId").trim();
+		const provider = getImageGenerationProvider(providerId);
+		if (!provider) return c.json({
+			ok: false,
+			error: { message: `Unknown image provider: ${providerId}` }
+		}, 404);
+		if (!provider.isConfigured({ cfg: service.currentConfig })) return c.json({
+			ok: false,
+			error: { message: "Provider credential is not configured" }
+		}, 400);
+		const body = await c.req.json().catch(() => ({}));
+		const modelId = typeof body.modelId === "string" && body.modelId.trim() ? body.modelId.trim() : provider.defaultModel;
+		if (!provider.models.includes(modelId)) return c.json({
+			ok: false,
+			error: { message: `Unknown ${providerId} image model: ${modelId}` }
+		}, 400);
+		const prompt = typeof body.prompt === "string" && body.prompt.trim() ? body.prompt.trim() : "A simple blue circle centered on a white background.";
+		try {
+			const result = await provider.generateImage({
+				provider: providerId,
+				model: modelId,
+				prompt,
+				count: 1,
+				cfg: service.currentConfig,
+				timeoutMs: 12e4
+			});
+			return c.json({
+				ok: true,
+				payload: {
+					providerId,
+					modelId: result.model ?? modelId,
+					images: result.images.map((image) => ({
+						mimeType: image.mimeType,
+						fileName: image.fileName,
+						dataUrl: `data:${image.mimeType};base64,${image.buffer.toString("base64")}`,
+						...image.revisedPrompt ? { revisedPrompt: image.revisedPrompt } : {}
+					}))
+				}
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: { message: error instanceof Error ? error.message : String(error) }
+			}, 502);
+		}
+	});
 	authenticated.get("/api/agents/:agentId/image-generation", (c) => {
 		try {
 			return c.json({
@@ -271,7 +451,8 @@ function registerModelsRoutes(authenticated, deps) {
 		const resolver = new CredentialResolver();
 		const previousKey = await resolver.revealGatewayStoredApiKey(prepared.providerId);
 		const suppliedKey = typeof body.apiKey === "string" ? body.apiKey.trim() : "";
-		if (!(suppliedKey || await resolver.resolveApiKey(prepared.providerId))) return c.json({
+		const effectiveKey = suppliedKey || await resolver.resolveApiKey(prepared.providerId);
+		if (getImageGenerationProvider(prepared.providerId).credentialMode !== "none" && !effectiveKey) return c.json({
 			ok: false,
 			error: { message: "API key is required" }
 		}, 400);

package/dist/src/gateway/hono/routes/workflows.js

@@ -7,9 +7,9 @@ import { messagesToClientHistory } from "../../../session/client-history.js";
 import "../../../workflows/domain/index.js";
 import { resolveWorkflowRunArtifactsDir } from "../../../workflows/store/paths.js";
 import { WorkflowDraftService } from "../../../workflows/draft/workflow-draft-service.js";
-import "../../../workflows/draft/index.js";
 import { WorkflowDraftConflictError, WorkflowDraftStore } from "../../../workflows/authoring/workflow-draft-store.js";
 import "../../../workflows/authoring/index.js";
+import "../../../workflows/draft/index.js";
 import { basename, join } from "node:path";
 import { readFile, stat } from "node:fs/promises";
 //#region src/gateway/hono/routes/workflows.ts

package/dist/src/gateway/image-generation-setup.js

@@ -64,7 +64,13 @@ function prepareImageGenerationSetup(config, agentIdRaw, input) {
 		}
 	};
 	const entry = next.agents.list[index];
-	entry.models.imageGenerationModel = { primary: `${providerId}/${modelId}` };
+	entry.models = {
+		...entry.models ?? {
+			defaultRole: resolveEffectiveAgentManifestForAgent(config, agentId).models.defaultRole,
+			roles: {}
+		},
+		imageGenerationModel: { primary: `${providerId}/${modelId}` }
+	};
 	const parsed = ConfigSchema.safeParse(next);
 	if (!parsed.success) return {
 		ok: false,

package/dist/src/gateway/service/config-coordinator.js

@@ -3,6 +3,7 @@ import { init_logger } from "../../utils/logger.js";
 import { loadConfig, saveConfig } from "../../config/loader.js";
 import { getModelRegistry } from "../../providers/model-registry.js";
 import { init_providers } from "../../providers/index.js";
+import { reloadImageGenerationProviders } from "../../agent/image/generation/provider-registry.js";
 import { disposeAllSessionMcpRuntimes } from "../../agent/mcp/bundle-mcp-runtime.js";
 import "../../agent/mcp/bundle-mcp-tools.js";
 import { ConfigHotReloader } from "../../config/reload.js";
@@ -214,6 +215,7 @@ var GatewayConfigCoordinator = class {
 		log.debug("Reloading models config...");
 		this.opts.setConfig(newConfig);
 		getModelRegistry().refresh();
+		reloadImageGenerationProviders();
 		this.opts.emit("config.reload", { section: "models" });
 		log.debug("Models config reloaded");
 	}

package/dist/src/gateway/service.js

@@ -37,11 +37,11 @@ import { AgentService } from "../agent/service.js";
 import { ensureStarterAgentsInitialized } from "../agent/starter-agents.js";
 import { AutomationService } from "../automations/service/automation-service.js";
 import "../automations/index.js";
-import { getWorkspacePath } from "../config/workspace-path-helpers.js";
-import "../config/index.js";
 import { setPairingBroadcastSink } from "../channels/pairing/pairing-events.js";
 import { registerClarifyBridge } from "./clarify-runtime.js";
 import { ChannelManager } from "../channels/manager.js";
+import { getWorkspacePath } from "../config/workspace-path-helpers.js";
+import "../config/index.js";
 import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
 import "../knowledge/index.js";
 import { startConnectorMemorySyncCoordinator } from "../connectors/memory-sync-coordinator.js";

package/dist/src/media-shared/http/index.d.ts

@@ -7,5 +7,5 @@ export { TimeoutAbortError, isTimeoutAbortError, pickEffectiveTimeoutMs, pickTim
 export { BlockedPrivateNetworkError, assertNotPrivateNetwork, classifyHost, defaultPolicy as defaultPrivateNetworkPolicy, privateNetworkPolicyToSsrfGuardOptions, type HostClass, type PrivateNetworkPolicy, } from './private-network.js';
 export { resolveProviderHttpRequestConfig, type ResolvedProviderHttpDefaults, type ResolveProviderHttpRequestConfigOptions, } from './resolve-provider-http-request-config.js';
 export { ProviderHttpError, assertOk, assertOkOrThrowHttpError, assertOkOrThrowProviderError, createProviderHttpError, extractProviderErrorDetail, extractProviderRequestId, extractVendorErrorFields, formatProviderErrorPayload, formatProviderHttpErrorMessage, readResponseTextLimited, truncateErrorDetail, type ProviderHttpErrorParts, } from './provider-http-errors.js';
-export { createProviderOperationDeadline, fetchWithTimeoutGuarded, getJsonRequest, normalizeBaseUrl, postJsonRequest, postMultipartRequest, waitProviderOperationPollInterval, type FetchWithGuardOptions, type GetJsonRequestOptions, type PostJsonRequestOptions, type PostMultipartRequestOptions, type ProviderHttpRequestConfig, type ProviderOperationDeadline, } from './provider-http.js';
+export { createProviderOperationDeadline, fetchWithTimeoutGuarded, getJsonRequest, normalizeBaseUrl, postJsonRequest, postMultipartRequest, readJsonResponseLimited, waitProviderOperationPollInterval, type FetchWithGuardOptions, type GetJsonRequestOptions, type PostJsonRequestOptions, type PostMultipartRequestOptions, type ProviderHttpRequestConfig, type ProviderOperationDeadline, } from './provider-http.js';
 export { SsrfBlockedError, assertSafeUrl, isPrivateIpAddress, isPrivateIpv4, isPrivateIpv6, type ResolvedSsrfTarget, type SsrfGuardOptions, } from './ssrf-guard.js';

package/dist/src/media-shared/http/index.js

@@ -4,5 +4,5 @@ import { BlockedPrivateNetworkError, assertNotPrivateNetwork, classifyHost, defa
 import { resolveProviderHttpRequestConfig } from "./resolve-provider-http-request-config.js";
 import { ProviderHttpError, assertOk, assertOkOrThrowHttpError, assertOkOrThrowProviderError, createProviderHttpError, extractProviderErrorDetail, extractProviderRequestId, extractVendorErrorFields, formatProviderErrorPayload, formatProviderHttpErrorMessage, readResponseTextLimited, truncateErrorDetail } from "./provider-http-errors.js";
 import { SsrfBlockedError, assertSafeUrl, isPrivateIpAddress, isPrivateIpv4, isPrivateIpv6 } from "./ssrf-guard.js";
-import { createProviderOperationDeadline, fetchWithTimeoutGuarded, getJsonRequest, normalizeBaseUrl, postJsonRequest, postMultipartRequest, waitProviderOperationPollInterval } from "./provider-http.js";
-export { BlockedPrivateNetworkError, ProviderHttpError, SsrfBlockedError, TimeoutAbortError, assertNotPrivateNetwork, assertOk, assertOkOrThrowHttpError, assertOkOrThrowProviderError, assertSafeUrl, classifyHost, collectProviderApiKeysForExecution, createProviderHttpError, createProviderOperationDeadline, defaultPolicy as defaultPrivateNetworkPolicy, executeWithApiKeyRotation, extractProviderErrorDetail, extractProviderRequestId, extractVendorErrorFields, fetchWithTimeoutGuarded, formatProviderErrorPayload, formatProviderHttpErrorMessage, getJsonRequest, isPrivateIpAddress, isPrivateIpv4, isPrivateIpv6, isRotatableAuthFailure, isTimeoutAbortError, normalizeBaseUrl, pickEffectiveTimeoutMs, pickTimeoutMsOrFallback, postJsonRequest, postMultipartRequest, privateNetworkPolicyToSsrfGuardOptions, readResponseTextLimited, resolveDeadline, resolveProviderHttpRequestConfig, truncateErrorDetail, waitProviderOperationPollInterval };
+import { createProviderOperationDeadline, fetchWithTimeoutGuarded, getJsonRequest, normalizeBaseUrl, postJsonRequest, postMultipartRequest, readJsonResponseLimited, waitProviderOperationPollInterval } from "./provider-http.js";
+export { BlockedPrivateNetworkError, ProviderHttpError, SsrfBlockedError, TimeoutAbortError, assertNotPrivateNetwork, assertOk, assertOkOrThrowHttpError, assertOkOrThrowProviderError, assertSafeUrl, classifyHost, collectProviderApiKeysForExecution, createProviderHttpError, createProviderOperationDeadline, defaultPolicy as defaultPrivateNetworkPolicy, executeWithApiKeyRotation, extractProviderErrorDetail, extractProviderRequestId, extractVendorErrorFields, fetchWithTimeoutGuarded, formatProviderErrorPayload, formatProviderHttpErrorMessage, getJsonRequest, isPrivateIpAddress, isPrivateIpv4, isPrivateIpv6, isRotatableAuthFailure, isTimeoutAbortError, normalizeBaseUrl, pickEffectiveTimeoutMs, pickTimeoutMsOrFallback, postJsonRequest, postMultipartRequest, privateNetworkPolicyToSsrfGuardOptions, readJsonResponseLimited, readResponseTextLimited, resolveDeadline, resolveProviderHttpRequestConfig, truncateErrorDetail, waitProviderOperationPollInterval };

package/dist/src/media-shared/http/provider-http.d.ts

@@ -39,6 +39,8 @@ export interface GetJsonRequestOptions extends ProviderHttpRequestConfig {
     headers?: Record<string, string> | Headers;
 }
 export declare function getJsonRequest(url: string | URL, options: GetJsonRequestOptions): Promise<Response>;
+/** Read and parse a JSON response without allowing an unbounded body allocation. */
+export declare function readJsonResponseLimited(response: Response, maxBytes: number): Promise<unknown>;
 /**
  * Normalize a base URL: trim trailing slash, force http(s) scheme.
  */