@gobing-ai/knowledge-kit 0.0.13 → 0.0.14

package/plugins/generations/image-gen/dist/index.js

@@ -21848,6 +21848,26 @@ var ResultSchema = exports_external.object({
   metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
 });
 var DocListSchema = exports_external.array(DocSchema);
+var omniVoiceGenContentSchema = ContentSchema.extend({
+  format: exports_external.literal("audio"),
+  metadata: exports_external.looseObject({
+    generator: exports_external.literal("kk:omni-voice-gen"),
+    audioPath: exports_external.string(),
+    duration: exports_external.number(),
+    segments: exports_external.array(exports_external.looseObject({
+      generationId: exports_external.string(),
+      profile: exports_external.string(),
+      speaker: exports_external.string().optional(),
+      emotion: exports_external.string().optional(),
+      duration: exports_external.number(),
+      verifyRetries: exports_external.number(),
+      transcription: exports_external.string().optional(),
+      loudnessDip: exports_external.boolean().optional()
+    })),
+    mp3Path: exports_external.string().optional(),
+    qc: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+  })
+});
 
 // ../../packages/kk-core/src/kinds.ts
 var PLUGIN_KINDS = ["ingestion", "generator", "publish"];
@@ -22115,8 +22135,32 @@ function loadPresets() {
   return { formats, styles, diagnostics };
 }
 
+// ../../plugins/generations/image-gen/src/providers/agnes.ts
+import { Buffer as Buffer3 } from "buffer";
+
+// ../../plugins/generations/image-gen/src/providers/refs.ts
+import { extname as extname2 } from "path";
+function mimeForPath(path2) {
+  const ext = extname2(path2).toLowerCase();
+  if (ext === ".jpg" || ext === ".jpeg")
+    return "image/jpeg";
+  if (ext === ".webp")
+    return "image/webp";
+  if (ext === ".gif")
+    return "image/gif";
+  if (ext === ".bmp")
+    return "image/bmp";
+  return "image/png";
+}
+async function refToDataUri(path2) {
+  if (/^https?:\/\//i.test(path2))
+    return path2;
+  const bytes = await readBytes(path2);
+  return `data:${mimeForPath(path2)};base64,${Buffer.from(bytes).toString("base64")}`;
+}
+
 // ../../plugins/generations/image-gen/src/providers/seedream.ts
-import { Buffer } from "buffer";
+import { Buffer as Buffer2 } from "buffer";
 var DEFAULT_BASE_URL = "https://ark.cn-beijing.volces.com/api/v3";
 var DEFAULT_MODEL = "doubao-seedream-5-0-260128";
 var REF_MODEL_FRAGMENTS = ["doubao-seedream-5-0", "doubao-seedream-4-5-", "doubao-seedream-4-0-"];
@@ -22164,7 +22208,7 @@ var createSeedream = (options) => {
       if (req.referenceImages !== undefined && req.referenceImages.length > 0) {
         const lifted = await Promise.all(req.referenceImages.map(async (path2) => {
           const bytes = await readBytes(path2);
-          return `data:image/png;base64,${Buffer.from(bytes).toString("base64")}`;
+          return `data:image/png;base64,${Buffer2.from(bytes).toString("base64")}`;
         }));
         body.image = lifted.length === 1 ? lifted[0] : lifted;
         body.response_format = "b64_json";
@@ -22193,7 +22237,7 @@ var createSeedream = (options) => {
       }
       if (image.b64_json !== undefined) {
         return {
-          bytes: Uint8Array.from(Buffer.from(image.b64_json, "base64")),
+          bytes: Uint8Array.from(Buffer2.from(image.b64_json, "base64")),
           extension: "png",
           provider: "seedream",
           model: req.model
@@ -22216,52 +22260,2237 @@ var createSeedream = (options) => {
   };
 };
 
-// ../../plugins/generations/image-gen/src/providers/types.ts
-var IMAGE_GEN_PROVIDER_ENV = "IMAGE_GEN_PROVIDER";
-var NEVER_AUTO = new Set(["codex-cli"]);
-function envOnlyProvider(spec) {
-  return (options) => ({
-    name: spec.name,
-    defaultModel: () => spec.defaultModel,
-    isAvailable: () => {
-      const env = options?.env ?? process.env;
-      const present = (key) => (env[key] ?? "") !== "";
-      const anyOf = spec.env.length > 0 ? spec.env.some(present) : spec.envAll !== undefined;
-      return anyOf && (spec.envAll ?? []).every(present);
+// ../../plugins/generations/image-gen/src/providers/agnes.ts
+var DEFAULT_MODEL2 = "agnes-image-2.1-flash";
+var DEFAULT_BASE_URL2 = "https://apihub.agnes-ai.com/v1";
+var DEFAULT_SIZE = "1024x1024";
+function parseAspectRatio(ar) {
+  const match = ar.match(/^(\d+(?:\.\d+)?):(\d+(?:\.\d+)?)$/);
+  if (match === null)
+    return null;
+  const w = Number.parseFloat(match[1]);
+  const h = Number.parseFloat(match[2]);
+  if (w <= 0 || h <= 0)
+    return null;
+  return { width: w, height: h };
+}
+function snapDim(n) {
+  return Math.max(32, Math.round(n / 32) * 32);
+}
+function resolveSize(args) {
+  if (args.width !== undefined && args.height !== undefined)
+    return `${args.width}x${args.height}`;
+  if (args.aspectRatio !== undefined) {
+    const parsed = parseAspectRatio(args.aspectRatio);
+    if (parsed !== null) {
+      if (parsed.width === 1 && parsed.height === 1)
+        return "1024x1024";
+      const maxEdge = 2048;
+      const scale = Math.max(1, Math.floor(maxEdge / Math.max(parsed.width, parsed.height)));
+      return `${snapDim(parsed.width * scale)}x${snapDim(parsed.height * scale)}`;
+    }
+  }
+  return DEFAULT_SIZE;
+}
+function buildRequestBody(prompt, model, args) {
+  const body = { model, prompt, size: resolveSize(args) };
+  if (args.referenceImages.length > 0)
+    body.image = args.referenceImages;
+  body.extra_body = { response_format: "url" };
+  return body;
+}
+async function extractImageFromResponse(result, fetchFn = fetch) {
+  const img = result.data[0];
+  if (img?.b64_json !== undefined && img.b64_json !== "") {
+    return Uint8Array.from(Buffer3.from(img.b64_json, "base64"));
+  }
+  if (img?.url !== undefined) {
+    const imgRes = await fetchFn(img.url);
+    if (!imgRes.ok)
+      throw new Error(`Failed to download image from Agnes: ${imgRes.status}`);
+    return new Uint8Array(await imgRes.arrayBuffer());
+  }
+  throw new Error("No image in Agnes response");
+}
+var createAgnes = (options) => {
+  const fetchFn = options?.fetch ?? fetch;
+  const env = options?.env ?? process.env;
+  const readEnv = (key) => env[key] ?? "";
+  return {
+    name: "agnes",
+    defaultModel: () => DEFAULT_MODEL2,
+    isAvailable: () => readEnv("AGNES_API_KEY") !== "",
+    supportsReferenceImages: () => true,
+    async generate(req) {
+      const apiKey = readEnv("AGNES_API_KEY");
+      if (apiKey === "")
+        throw new Error("AGNES_API_KEY is required. Get one from https://apihub.agnes-ai.com.");
+      const referenceImages = await Promise.all((req.referenceImages ?? []).map(refToDataUri));
+      const body = buildRequestBody(req.prompt, req.model, { ...req, referenceImages });
+      const base = (readEnv("AGNES_BASE_URL") || DEFAULT_BASE_URL2).replace(/\/+$/, "");
+      const res = await fetchFn(`${base}/images/generations`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${apiKey}` },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok)
+        throw new Error(`Agnes API error (${res.status}): ${await res.text()}`);
+      const result = await res.json();
+      const bytes = await extractImageFromResponse(result, fetchFn);
+      const url2 = result.data[0]?.url;
+      return {
+        bytes,
+        extension: url2 === undefined || url2.startsWith("data:") ? "png" : extensionFromUrl(url2),
+        provider: "agnes",
+        model: req.model
+      };
+    }
+  };
+};
+
+// ../../plugins/generations/image-gen/src/providers/azure.ts
+import { extname as extname3 } from "path";
+
+// ../../plugins/generations/image-gen/src/providers/openai.ts
+import { Buffer as Buffer4 } from "buffer";
+import { basename as basename2 } from "path";
+var DEFAULT_MODEL3 = "gpt-image-2";
+function explicitSize(req) {
+  return req.width !== undefined && req.height !== undefined ? `${req.width}x${req.height}` : undefined;
+}
+function parseAspectRatio2(ar) {
+  const match = ar.match(/^(\d+(?:\.\d+)?):(\d+(?:\.\d+)?)$/);
+  if (match === null)
+    return null;
+  const w = Number.parseFloat(match[1]);
+  const h = Number.parseFloat(match[2]);
+  if (w <= 0 || h <= 0)
+    return null;
+  return { width: w, height: h };
+}
+function roundToMultiple(value, multiple) {
+  return Math.max(multiple, Math.round(value / multiple) * multiple);
+}
+function buildGptImage2SizeFromAspectRatio(ratio, quality) {
+  if (Math.abs(ratio - 1) < 0.1) {
+    const edge = quality === "2k" ? 2048 : 1024;
+    return `${edge}x${edge}`;
+  }
+  const targetLongEdge = quality === "2k" ? 2048 : 1024;
+  let width;
+  let height;
+  if (ratio > 1) {
+    width = targetLongEdge;
+    height = roundToMultiple(width / ratio, 16);
+  } else {
+    height = targetLongEdge;
+    width = roundToMultiple(height * ratio, 16);
+  }
+  while (width * height < 655360) {
+    if (ratio > 1) {
+      width += 16;
+      height = roundToMultiple(width / ratio, 16);
+    } else {
+      height += 16;
+      width = roundToMultiple(height * ratio, 16);
+    }
+  }
+  return `${width}x${height}`;
+}
+function getOpenAISize(model, ar, quality) {
+  const isDalle2 = model.includes("dall-e-2");
+  const isDalle3 = model.includes("dall-e-3");
+  const isGptImage2 = model.includes("gpt-image-2");
+  if (isDalle2)
+    return "1024x1024";
+  if (isGptImage2) {
+    const parsed2 = ar === null ? null : parseAspectRatio2(ar);
+    const ratio2 = parsed2 === null ? 1 : parsed2.width / parsed2.height;
+    return buildGptImage2SizeFromAspectRatio(ratio2, quality);
+  }
+  const sizes = isDalle3 ? { square: "1024x1024", landscape: "1792x1024", portrait: "1024x1792" } : { square: "1024x1024", landscape: "1536x1024", portrait: "1024x1536" };
+  if (ar === null)
+    return sizes.square;
+  const parsed = parseAspectRatio2(ar);
+  if (parsed === null)
+    return sizes.square;
+  const ratio = parsed.width / parsed.height;
+  if (Math.abs(ratio - 1) < 0.1)
+    return sizes.square;
+  if (ratio > 1.5)
+    return sizes.landscape;
+  if (ratio < 0.67)
+    return sizes.portrait;
+  return sizes.square;
+}
+function gcd(a, b) {
+  let x = Math.abs(a);
+  let y = Math.abs(b);
+  while (y !== 0) {
+    const next = x % y;
+    x = y;
+    y = next;
+  }
+  return x || 1;
+}
+function inferAspectRatioFromSize(size) {
+  if (size === null)
+    return null;
+  const parsed = size.match(/^(\d+)\s*[xX]\s*(\d+)$/);
+  if (parsed === null)
+    return null;
+  const width = Number.parseInt(parsed[1], 10);
+  const height = Number.parseInt(parsed[2], 10);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0)
+    return null;
+  const divisor = gcd(width, height);
+  return `${width / divisor}:${height / divisor}`;
+}
+function inferResolutionFromSize(size) {
+  if (size === null)
+    return null;
+  const parsed = size.match(/^(\d+)\s*[xX]\s*(\d+)$/);
+  if (parsed === null)
+    return null;
+  const width = Number.parseInt(parsed[1], 10);
+  const height = Number.parseInt(parsed[2], 10);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0)
+    return null;
+  const longestEdge = Math.max(width, height);
+  if (longestEdge <= 1024)
+    return "1K";
+  if (longestEdge <= 2048)
+    return "2K";
+  return "4K";
+}
+function getOpenAIAspectRatio(args) {
+  return args.aspectRatio ?? inferAspectRatioFromSize(args.size ?? null) ?? "1:1";
+}
+function getOpenAIResolution(args) {
+  const inferred = inferResolutionFromSize(args.size ?? null);
+  if (inferred !== null)
+    return inferred;
+  return args.quality === "normal" ? "1K" : "2K";
+}
+function getOpenAIQuality(model, quality) {
+  if (model.includes("dall-e-3"))
+    return quality === "2k" ? "hd" : "standard";
+  if (model.includes("gpt-image"))
+    return quality === "2k" ? "high" : "medium";
+  return null;
+}
+function getOrientationFromAspectRatio(ar) {
+  const parsed = parseAspectRatio2(ar);
+  if (parsed === null)
+    return null;
+  const ratio = parsed.width / parsed.height;
+  if (Math.abs(ratio - 1) < 0.1)
+    return null;
+  return ratio > 1 ? "landscape" : "portrait";
+}
+function buildOpenAIGenerationsBody(prompt, model, args) {
+  if ((args.imageApiDialect ?? "openai-native") === "ratio-metadata") {
+    const aspectRatio = getOpenAIAspectRatio(args);
+    const metadata = {
+      resolution: getOpenAIResolution({ size: args.size, quality: args.quality })
+    };
+    const orientation = getOrientationFromAspectRatio(aspectRatio);
+    if (orientation !== null)
+      metadata.orientation = orientation;
+    return { model, prompt, size: aspectRatio, metadata };
+  }
+  const body = {
+    model,
+    prompt,
+    size: args.size ?? getOpenAISize(model, args.aspectRatio ?? null, args.quality)
+  };
+  const quality = getOpenAIQuality(model, args.quality);
+  if (quality !== null)
+    body.quality = quality;
+  return body;
+}
+function validateGptImage2Size(width, height) {
+  const ratio = Math.max(width, height) / Math.min(width, height);
+  if (Math.max(width, height) > 3840)
+    throw new Error("gpt-image-2 --size maximum edge length must be 3840px or less.");
+  if (width % 16 !== 0 || height % 16 !== 0) {
+    throw new Error("gpt-image-2 --size width and height must both be multiples of 16px.");
+  }
+  if (ratio > 3)
+    throw new Error("gpt-image-2 --size long edge to short edge ratio must not exceed 3:1.");
+  const totalPixels = width * height;
+  if (totalPixels < 655360 || totalPixels > 8294400) {
+    throw new Error("gpt-image-2 --size total pixels must be between 655,360 and 8,294,400.");
+  }
+}
+function getMimeType(filename) {
+  const ext = basename2(filename).toLowerCase();
+  if (ext.includes(".jpg") || ext.includes(".jpeg"))
+    return "image/jpeg";
+  if (ext.includes(".webp"))
+    return "image/webp";
+  if (ext.includes(".gif"))
+    return "image/gif";
+  return "image/png";
+}
+async function extractImageFromResponse2(result, fetchFn = fetch) {
+  const img = result.data[0];
+  if (img?.b64_json !== undefined && img.b64_json !== "") {
+    return Uint8Array.from(Buffer4.from(img.b64_json, "base64"));
+  }
+  if (img?.url !== undefined) {
+    const imgRes = await fetchFn(img.url);
+    if (!imgRes.ok)
+      throw new Error("Failed to download image");
+    return new Uint8Array(await imgRes.arrayBuffer());
+  }
+  throw new Error("No image in response");
+}
+var createOpenai = (options) => {
+  const fetchFn = options?.fetch ?? fetch;
+  const env = options?.env ?? process.env;
+  const readEnv = (key) => env[key] ?? "";
+  const supportsRef = (model) => model.includes("gpt-image");
+  return {
+    name: "openai",
+    defaultModel: () => DEFAULT_MODEL3,
+    isAvailable: () => readEnv("OPENAI_API_KEY") !== "",
+    supportsReferenceImages: supportsRef,
+    validate(req) {
+      if ((req.referenceImages?.length ?? 0) > 0 && !supportsRef(req.model)) {
+        throw new Error(`Reference images with OpenAI require GPT Image models. Use --model gpt-image-2 (or another gpt-image model); '${req.model}' is not one.`);
+      }
+      if (req.width !== undefined && req.height !== undefined && req.model.includes("gpt-image-2")) {
+        validateGptImage2Size(req.width, req.height);
+      }
+    },
+    async generate(req) {
+      const baseURL = readEnv("OPENAI_BASE_URL") || "https://api.openai.com/v1";
+      const apiKey = readEnv("OPENAI_API_KEY");
+      if (apiKey === "") {
+        throw new Error("OPENAI_API_KEY is required. Codex/ChatGPT desktop login does not automatically grant OpenAI Images API access.");
+      }
+      if (readEnv("OPENAI_IMAGE_USE_CHAT") === "true") {
+        const chatRes = await fetchFn(`${baseURL}/chat/completions`, {
+          method: "POST",
+          headers: { "content-type": "application/json", authorization: `Bearer ${apiKey}` },
+          body: JSON.stringify({ model: req.model, messages: [{ role: "user", content: req.prompt }] })
+        });
+        if (!chatRes.ok)
+          throw new Error(`OpenAI API error: ${await chatRes.text()}`);
+        const content = (await chatRes.json()).choices?.[0]?.message?.content ?? "";
+        const match = content.match(/data:image\/[^;]+;base64,([A-Za-z0-9+/=]+)/);
+        if (match !== null && match[1] !== undefined) {
+          return {
+            bytes: Uint8Array.from(Buffer4.from(match[1], "base64")),
+            extension: "png",
+            provider: "openai",
+            model: req.model
+          };
+        }
+        throw new Error("No image found in chat completions response");
+      }
+      const refs = req.referenceImages ?? [];
+      const args = {
+        aspectRatio: req.aspectRatio,
+        size: explicitSize(req),
+        quality: req.quality
+      };
+      const bytes = await (async () => {
+        if (refs.length > 0 && (req.model.includes("dall-e-2") || req.model.includes("dall-e-3"))) {
+          throw new Error(`Reference images with OpenAI require GPT Image models. Use --model gpt-image-2 (or another gpt-image model).`);
+        }
+        if (refs.length > 0) {
+          const size = args.size ?? getOpenAISize(req.model, args.aspectRatio ?? null, args.quality);
+          const form = new FormData;
+          form.append("model", req.model);
+          form.append("prompt", req.prompt);
+          form.append("size", size);
+          const quality = getOpenAIQuality(req.model, args.quality);
+          if (quality !== null && quality !== "standard" && quality !== "hd")
+            form.append("quality", quality);
+          for (const refPath of refs) {
+            const bytes2 = await readBytes(refPath);
+            const filename = basename2(refPath);
+            form.append("image[]", new Blob([bytes2], { type: getMimeType(filename) }), filename);
+          }
+          const res2 = await fetchFn(`${baseURL}/images/edits`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${apiKey}` },
+            body: form
+          });
+          if (!res2.ok)
+            throw new Error(`OpenAI edits API error: ${await res2.text()}`);
+          return extractImageFromResponse2(await res2.json(), fetchFn);
+        }
+        const res = await fetchFn(`${baseURL}/images/generations`, {
+          method: "POST",
+          headers: { "content-type": "application/json", authorization: `Bearer ${apiKey}` },
+          body: JSON.stringify(buildOpenAIGenerationsBody(req.prompt, req.model, args))
+        });
+        if (!res.ok)
+          throw new Error(`OpenAI API error: ${await res.text()}`);
+        return extractImageFromResponse2(await res.json(), fetchFn);
+      })();
+      return { bytes, extension: "png", provider: "openai", model: req.model };
+    }
+  };
+};
+
+// ../../plugins/generations/image-gen/src/providers/azure.ts
+var DEFAULT_AZURE_API_VERSION = "2025-04-01-preview";
+var AZURE_EDIT_IMAGE_EXTENSIONS = new Set([".png", ".jpg", ".jpeg"]);
+function parseAzureBaseURL(url2) {
+  const parsed = new URL(url2);
+  const trimmedPath = parsed.pathname.replace(/\/+$/, "");
+  const deploymentMatch = trimmedPath.match(/^(.*?)(?:\/openai)?\/deployments\/([^/]+)$/);
+  if (deploymentMatch !== null) {
+    parsed.pathname = `${deploymentMatch[1] ?? ""}/openai`;
+    return {
+      resourceBaseURL: parsed.toString().replace(/\/+$/, ""),
+      deployment: decodeURIComponent(deploymentMatch[2])
+    };
+  }
+  parsed.pathname = trimmedPath.endsWith("/openai") ? trimmedPath : `${trimmedPath}/openai`;
+  return { resourceBaseURL: parsed.toString().replace(/\/+$/, ""), deployment: null };
+}
+function azureEndpoint(env) {
+  const url2 = env.AZURE_OPENAI_BASE_URL ?? "";
+  if (url2 === "") {
+    throw new Error("AZURE_OPENAI_BASE_URL is required. Set it to your Azure resource or deployment endpoint, e.g.: https://your-resource.openai.azure.com or https://your-resource.openai.azure.com/openai/deployments/your-deployment");
+  }
+  return parseAzureBaseURL(url2);
+}
+function getApiKey(env) {
+  const key = env.AZURE_OPENAI_API_KEY ?? "";
+  if (key === "") {
+    throw new Error("AZURE_OPENAI_API_KEY is required. Get it from Azure Portal \u2192 your OpenAI resource \u2192 Keys and Endpoint.");
+  }
+  return key;
+}
+function buildURL(endpoint, deployment, pathSuffix, env) {
+  const apiVersion = env.AZURE_API_VERSION ?? DEFAULT_AZURE_API_VERSION;
+  return `${endpoint.resourceBaseURL}/deployments/${encodeURIComponent(deployment)}${pathSuffix}?api-version=${apiVersion}`;
+}
+function getAzureQuality(quality) {
+  return quality === "2k" ? "high" : "medium";
+}
+function validateReferenceImages(referenceImages) {
+  for (const refPath of referenceImages) {
+    if (!AZURE_EDIT_IMAGE_EXTENSIONS.has(extname3(refPath).toLowerCase())) {
+      throw new Error(`Azure OpenAI reference images must be PNG or JPG/JPEG. Unsupported file: ${refPath}`);
+    }
+  }
+}
+var createAzure = (options) => {
+  const fetchFn = options?.fetch ?? fetch;
+  const env = options?.env ?? process.env;
+  function defaultModel() {
+    const explicit = env.AZURE_OPENAI_DEPLOYMENT?.trim();
+    if (explicit !== undefined && explicit !== "")
+      return explicit;
+    const baseURL = env.AZURE_OPENAI_BASE_URL;
+    if (baseURL !== undefined) {
+      try {
+        const { deployment } = parseAzureBaseURL(baseURL);
+        if (deployment !== null)
+          return deployment;
+      } catch {}
+    }
+    return "gpt-image-2";
+  }
+  const supportsRef = () => true;
+  return {
+    name: "azure",
+    defaultModel,
+    isAvailable: () => (env.AZURE_OPENAI_API_KEY ?? "") !== "",
+    supportsReferenceImages: supportsRef,
+    validate(req) {
+      validateReferenceImages(req.referenceImages ?? []);
     },
-    supportsReferenceImages: (model) => spec.refModels === undefined ? true : spec.refModels.some((fragment) => model.includes(fragment)),
-    generate: () => {
-      throw new Error(`Provider '${spec.name}' has no adapter yet (feature K phase plan, task 0103 Design).`);
+    async generate(req) {
+      const apiKey = getApiKey(env);
+      const endpoint = azureEndpoint(env);
+      const deployment = req.model.trim();
+      if (deployment === "") {
+        throw new Error("Azure deployment name is required. Use --model <deployment>, AZURE_OPENAI_DEPLOYMENT, AZURE_OPENAI_IMAGE_MODEL, or embed the deployment in AZURE_OPENAI_BASE_URL.");
+      }
+      const size = (req.width !== undefined && req.height !== undefined ? `${req.width}x${req.height}` : undefined) ?? getOpenAISize(req.model, req.aspectRatio ?? null, req.quality);
+      const refs = req.referenceImages ?? [];
+      const bytes = await (async () => {
+        if (refs.length > 0) {
+          const form = new FormData;
+          form.append("prompt", req.prompt);
+          form.append("size", size);
+          form.append("n", "1");
+          form.append("quality", getAzureQuality(req.quality));
+          for (const refPath of refs) {
+            const fileBytes = await readBytes(refPath);
+            const filename = refPath.split("/").pop() ?? refPath;
+            const mimeType = extname3(filename).toLowerCase() === ".png" ? "image/png" : "image/jpeg";
+            form.append("image[]", new Blob([fileBytes], { type: mimeType }), filename);
+          }
+          const res2 = await fetchFn(buildURL(endpoint, deployment, "/images/edits", env), {
+            method: "POST",
+            headers: { "api-key": apiKey },
+            body: form
+          });
+          if (!res2.ok)
+            throw new Error(`Azure OpenAI edits API error: ${await res2.text()}`);
+          return extractImageFromResponse2(await res2.json(), fetchFn);
+        }
+        const res = await fetchFn(buildURL(endpoint, deployment, "/images/generations", env), {
+          method: "POST",
+          headers: { "content-type": "application/json", "api-key": apiKey },
+          body: JSON.stringify({ prompt: req.prompt, size, n: 1, quality: getAzureQuality(req.quality) })
+        });
+        if (!res.ok)
+          throw new Error(`Azure OpenAI API error: ${await res.text()}`);
+        return extractImageFromResponse2(await res.json(), fetchFn);
+      })();
+      return { bytes, extension: "png", provider: "azure", model: req.model };
+    }
+  };
+};
+
+// ../../plugins/generations/image-gen/src/providers/codex-cli.ts
+import { spawn } from "child_process";
+import { randomBytes } from "crypto";
+import { access as access2, mkdir, rm, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { resolve as resolve2 } from "path";
+var DEFAULT_MODEL4 = "codex-image-gen";
+async function exists(filePath) {
+  try {
+    await access2(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveWrapperPath(readEnv) {
+  const override = readEnv("BAOYU_CODEX_IMAGEGEN_BIN");
+  if (override.length > 0) {
+    if (!await exists(override)) {
+      throw new Error(`Invalid BAOYU_CODEX_IMAGEGEN_BIN: ${override} does not exist.`);
     }
+    return override;
+  }
+  throw new Error("codex-cli wrapper not found. Set BAOYU_CODEX_IMAGEGEN_BIN to a codex-imagegen main.ts (or .sh) path.");
+}
+function spawnWrapper(wrapperPath, cliArgs) {
+  return new Promise((resolveSpawn, rejectSpawn) => {
+    const isTs = wrapperPath.endsWith(".ts");
+    const command = isTs ? "bun" : wrapperPath;
+    const args = isTs ? [wrapperPath, ...cliArgs] : cliArgs;
+    const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      const text = chunk.toString("utf8");
+      stderr += text;
+    });
+    child.on("error", (err) => rejectSpawn(err));
+    child.on("close", (code) => resolveSpawn({ stdout, stderr, code: code ?? 1 }));
   });
 }
-function defineProvider(spec) {
-  return { ...spec, create: envOnlyProvider(spec) };
+function parseWrapperJson(stdout) {
+  const trimmed = stdout.trim();
+  if (trimmed === "")
+    throw new Error("Invalid codex-cli response: empty stdout from wrapper.");
+  const lastLine = trimmed.split(/\r?\n/).pop() ?? trimmed;
+  try {
+    return JSON.parse(lastLine);
+  } catch (parseErr) {
+    throw new Error(`Invalid codex-cli response: could not parse JSON from wrapper stdout (${parseErr instanceof Error ? parseErr.message : String(parseErr)}).`);
+  }
+}
+function parsePositiveInt(value) {
+  if (value === "")
+    return null;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+var createCodexCli = (options) => {
+  const env = options?.env ?? process.env;
+  const readEnv = (key) => env[key] ?? "";
+  return {
+    name: "codex-cli",
+    defaultModel: () => DEFAULT_MODEL4,
+    isAvailable: () => false,
+    supportsReferenceImages: () => true,
+    validate(req) {
+      if ((req.n ?? 1) > 1) {
+        throw new Error("codex-cli provider supports only n=1 (Codex image_gen returns a single image per call).");
+      }
+    },
+    async generate(req) {
+      const wrapperPath = await resolveWrapperPath(readEnv);
+      const sessionDir = resolve2(tmpdir(), "kk-image-gen-codex-cli");
+      await mkdir(sessionDir, { recursive: true });
+      const token = randomBytes(8).toString("hex");
+      const tmpOutput = resolve2(sessionDir, `out-${token}.png`);
+      const tmpPrompt = resolve2(sessionDir, `prompt-${token}.md`);
+      await writeFile2(tmpPrompt, req.prompt, "utf8");
+      const cliArgs = [
+        "--image",
+        tmpOutput,
+        "--prompt-file",
+        tmpPrompt,
+        "--aspect",
+        req.aspectRatio ?? "1:1"
+      ];
+      for (const ref of req.referenceImages ?? []) {
+        cliArgs.push("--ref", resolve2(ref));
+      }
+      const cacheDir = readEnv("BAOYU_CODEX_IMAGEGEN_CACHE_DIR");
+      if (cacheDir !== "")
+        cliArgs.push("--cache-dir", cacheDir);
+      const timeoutMs = parsePositiveInt(readEnv("BAOYU_CODEX_IMAGEGEN_TIMEOUT_MS"));
+      if (timeoutMs !== null)
+        cliArgs.push("--timeout", String(timeoutMs));
+      const retries = parsePositiveInt(readEnv("BAOYU_CODEX_IMAGEGEN_RETRIES"));
+      if (retries !== null)
+        cliArgs.push("--retries", String(retries));
+      const logFile = readEnv("BAOYU_CODEX_IMAGEGEN_LOG_FILE");
+      if (logFile !== "")
+        cliArgs.push("--log-file", logFile);
+      try {
+        const spawnResult = await spawnWrapper(wrapperPath, cliArgs);
+        const parsed = parseWrapperJson(spawnResult.stdout);
+        if (parsed.status === "error") {
+          throw new Error(`Invalid codex-cli result (${parsed.error_kind}): ${parsed.error}`);
+        }
+        if (spawnResult.code !== 0) {
+          throw new Error(`Invalid codex-cli result: wrapper exited with code ${spawnResult.code} despite reporting status=ok.`);
+        }
+        const bytes = await readBytes(parsed.path ?? tmpOutput);
+        return { bytes, extension: "png", provider: "codex-cli", model: req.model };
+      } finally {
+        await Promise.allSettled([rm(tmpOutput, { force: true }), rm(tmpPrompt, { force: true })]);
+      }
+    }
+  };
+};
+
+// ../../plugins/generations/image-gen/src/providers/dashscope.ts
+init_dist();
+import { Buffer as Buffer5 } from "buffer";
+var DEFAULT_MODEL5 = "qwen-image-2.0-pro";
+var MIN_QWEN_2_TOTAL_PIXELS = 512 * 512;
+var MAX_QWEN_2_TOTAL_PIXELS = 2048 * 2048;
+var SIZE_STEP = 16;
+var QWEN_NEGATIVE_PROMPT = "\u4F4E\u5206\u8FA8\u7387\uFF0C\u4F4E\u753B\u8D28\uFF0C\u80A2\u4F53\u7578\u5F62\uFF0C\u624B\u6307\u7578\u5F62\uFF0C\u753B\u9762\u8FC7\u9971\u548C\uFF0C\u8721\u50CF\u611F\uFF0C\u4EBA\u8138\u65E0\u7EC6\u8282\uFF0C\u8FC7\u5EA6\u5149\u6ED1\uFF0C\u753B\u9762\u5177\u6709AI\u611F\uFF0C\u6784\u56FE\u6DF7\u4E71\uFF0C\u6587\u5B57\u6A21\u7CCA\uFF0C\u626D\u66F2";
+var QWEN_2_TARGET_PIXELS = { normal: 1024 * 1024, "2k": 1536 * 1536 };
+var MIN_WAN27_TOTAL_PIXELS = 768 * 768;
+var MAX_WAN27_PRO_T2I_PIXELS = 4096 * 4096;
+var MAX_WAN27_GENERAL_PIXELS = 2048 * 2048;
+var WAN27_MAX_REFERENCE_IMAGES = 9;
+var WAN27_TARGET_PIXELS = { normal: 1024 * 1024, "2k": 2048 * 2048 };
+var QWEN_2_RECOMMENDED = {
+  "1:1": { normal: "1024*1024", "2k": "1536*1536" },
+  "2:3": { normal: "768*1152", "2k": "1024*1536" },
+  "3:2": { normal: "1152*768", "2k": "1536*1024" },
+  "3:4": { normal: "960*1280", "2k": "1080*1440" },
+  "4:3": { normal: "1280*960", "2k": "1440*1080" },
+  "9:16": { normal: "720*1280", "2k": "1080*1920" },
+  "16:9": { normal: "1280*720", "2k": "1920*1080" },
+  "21:9": { normal: "1344*576", "2k": "2048*872" }
+};
+var QWEN_FIXED_SIZES_BY_RATIO = {
+  "16:9": "1664*928",
+  "4:3": "1472*1104",
+  "1:1": "1328*1328",
+  "3:4": "1104*1472",
+  "9:16": "928*1664"
+};
+var QWEN_FIXED_SPEC_DEFAULT = QWEN_FIXED_SIZES_BY_RATIO["16:9"];
+var LEGACY_STANDARD_SIZES = [
+  [1024, 1024],
+  [1280, 720],
+  [720, 1280],
+  [1024, 768],
+  [768, 1024],
+  [1536, 1024],
+  [1024, 1536],
+  [1536, 864],
+  [864, 1536]
+];
+var LEGACY_STANDARD_SIZES_2K = [
+  [1536, 1536],
+  [2048, 1152],
+  [1152, 2048],
+  [1536, 1024],
+  [1024, 1536],
+  [1536, 864],
+  [864, 1536],
+  [2048, 2048]
+];
+var MODEL_SPEC_ALIASES = {
+  "qwen-image-2.0-pro": { family: "qwen2", defaultSize: "1024*1024" },
+  "qwen-image-2.0-pro-2026-03-03": { family: "qwen2", defaultSize: "1024*1024" },
+  "qwen-image-2.0": { family: "qwen2", defaultSize: "1024*1024" },
+  "qwen-image-2.0-2026-03-03": { family: "qwen2", defaultSize: "1024*1024" },
+  "qwen-image-max": { family: "qwenFixed", defaultSize: QWEN_FIXED_SPEC_DEFAULT },
+  "qwen-image-max-2025-12-30": { family: "qwenFixed", defaultSize: QWEN_FIXED_SPEC_DEFAULT },
+  "qwen-image-plus": { family: "qwenFixed", defaultSize: QWEN_FIXED_SPEC_DEFAULT },
+  "qwen-image-plus-2026-01-09": { family: "qwenFixed", defaultSize: QWEN_FIXED_SPEC_DEFAULT },
+  "qwen-image": { family: "qwenFixed", defaultSize: QWEN_FIXED_SPEC_DEFAULT },
+  "wan2.7-image-pro": { family: "wan27", defaultSize: "2048*2048" },
+  "wan2.7-image": { family: "wan27", defaultSize: "2048*2048" }
+};
+function getModelSpec(model) {
+  return MODEL_SPEC_ALIASES[model.trim().toLowerCase()] ?? { family: "legacy", defaultSize: "1536*1536" };
+}
+function resolveSizeForModel(model, args) {
+  const spec = getModelSpec(model);
+  const referenceCount = args.referenceImages?.length ?? 0;
+  const quality = args.quality === "normal" ? "normal" : "2k";
+  if (spec.family === "wan27") {
+    const maxPixels = isWan27ProModel(model) && referenceCount === 0 ? MAX_WAN27_PRO_T2I_PIXELS : MAX_WAN27_GENERAL_PIXELS;
+    if (args.size !== undefined)
+      return validateWan27Size(args.size, maxPixels, model);
+    return getWan27SizeFromAspectRatio(args.aspectRatio, quality, maxPixels);
+  }
+  if (args.size !== undefined) {
+    if (spec.family === "qwen2")
+      return validateQwen2Size(args.size);
+    if (spec.family === "qwenFixed")
+      return validateQwenFixedSize(args.size);
+    validateSizeFormat(args.size);
+    return normalizeSize(args.size);
+  }
+  if (spec.family === "qwen2")
+    return getQwen2SizeFromAspectRatio(args.aspectRatio, quality);
+  if (spec.family === "qwenFixed")
+    return getQwenFixedSizeFromAspectRatio(args.aspectRatio, quality);
+  return getSizeFromAspectRatio(args.aspectRatio, quality);
+}
+function getSizeFromAspectRatio(ar, quality) {
+  const sizes = quality === "2k" ? LEGACY_STANDARD_SIZES_2K : LEGACY_STANDARD_SIZES;
+  const defaultSize = quality === "2k" ? "1536*1536" : "1024*1024";
+  const parsed = ar === undefined ? null : parseAspectRatio3(ar);
+  if (parsed === null)
+    return defaultSize;
+  const targetRatio = parsed.width / parsed.height;
+  let best = defaultSize;
+  let bestDiff = Number.POSITIVE_INFINITY;
+  for (const [width, height] of sizes) {
+    const diff = Math.abs(width / height - targetRatio);
+    if (diff < bestDiff) {
+      bestDiff = diff;
+      best = `${width}*${height}`;
+    }
+  }
+  return best;
+}
+function getQwen2SizeFromAspectRatio(ar, quality) {
+  if (ar === undefined) {
+    return QWEN_2_RECOMMENDED["1:1"]?.[quality];
+  }
+  const recommendedRatio = findKnownRatioKey(ar, Object.keys(QWEN_2_RECOMMENDED));
+  if (recommendedRatio !== null) {
+    return QWEN_2_RECOMMENDED[recommendedRatio]?.[quality];
+  }
+  const parsed = parseAspectRatio3(ar);
+  if (parsed === null) {
+    return QWEN_2_RECOMMENDED["1:1"]?.[quality];
+  }
+  const targetRatio = parsed.width / parsed.height;
+  const targetPixels = QWEN_2_TARGET_PIXELS[quality];
+  const rawWidth = Math.sqrt(targetPixels * targetRatio);
+  const rawHeight = Math.sqrt(targetPixels / targetRatio);
+  const fitted = fitToPixelBudget(rawWidth, rawHeight, MIN_QWEN_2_TOTAL_PIXELS, MAX_QWEN_2_TOTAL_PIXELS);
+  return `${fitted.width}*${fitted.height}`;
+}
+function findKnownRatioKey(ar, candidates, tolerance = 0.02) {
+  const parsed = parseAspectRatio3(ar);
+  if (parsed === null)
+    return null;
+  const targetRatio = parsed.width / parsed.height;
+  let bestKey = null;
+  let bestDiff = Number.POSITIVE_INFINITY;
+  for (const candidate of candidates) {
+    const candidateParsed = parseAspectRatio3(candidate);
+    if (candidateParsed === null)
+      continue;
+    const diff = Math.abs(candidateParsed.width / candidateParsed.height - targetRatio);
+    if (diff < bestDiff) {
+      bestDiff = diff;
+      bestKey = candidate;
+    }
+  }
+  return bestDiff <= tolerance ? bestKey : null;
+}
+function fitToPixelBudget(width, height, minPixels, maxPixels) {
+  let nextWidth = width;
+  let nextHeight = height;
+  let pixels = nextWidth * nextHeight;
+  if (pixels > maxPixels) {
+    const scale = Math.sqrt(maxPixels / pixels);
+    nextWidth *= scale;
+    nextHeight *= scale;
+  } else if (pixels < minPixels) {
+    const scale = Math.sqrt(minPixels / pixels);
+    nextWidth *= scale;
+    nextHeight *= scale;
+  }
+  let roundedWidth = roundToStep(nextWidth);
+  let roundedHeight = roundToStep(nextHeight);
+  pixels = roundedWidth * roundedHeight;
+  while (pixels > maxPixels && (roundedWidth > SIZE_STEP || roundedHeight > SIZE_STEP)) {
+    if (roundedWidth >= roundedHeight && roundedWidth > SIZE_STEP) {
+      roundedWidth -= SIZE_STEP;
+    } else if (roundedHeight > SIZE_STEP) {
+      roundedHeight -= SIZE_STEP;
+    } else {
+      break;
+    }
+    pixels = roundedWidth * roundedHeight;
+  }
+  while (pixels < minPixels) {
+    if (roundedWidth <= roundedHeight) {
+      roundedWidth += SIZE_STEP;
+    } else {
+      roundedHeight += SIZE_STEP;
+    }
+    pixels = roundedWidth * roundedHeight;
+  }
+  return { width: roundedWidth, height: roundedHeight };
+}
+function roundToStep(value) {
+  return Math.max(SIZE_STEP, Math.round(value / SIZE_STEP) * SIZE_STEP);
+}
+function floorToStep(value) {
+  return Math.max(SIZE_STEP, Math.floor(value / SIZE_STEP) * SIZE_STEP);
+}
+function getWan27SizeFromAspectRatio(ar, quality, maxPixels) {
+  const targetPixels = Math.min(WAN27_TARGET_PIXELS[quality], maxPixels);
+  if (ar === undefined) {
+    const side = roundToStep(Math.sqrt(targetPixels));
+    return `${side}*${side}`;
+  }
+  const parsed = parseAspectRatio3(ar);
+  if (parsed === null) {
+    const side = roundToStep(Math.sqrt(targetPixels));
+    return `${side}*${side}`;
+  }
+  const ratio = parsed.width / parsed.height;
+  if (ratio < 1 / 8 || ratio > 8) {
+    throw new Error(`DashScope wan2.7 image models support aspect ratios in [1:8, 8:1]. Received "${ar}".`);
+  }
+  const rawWidth = Math.sqrt(targetPixels * ratio);
+  const rawHeight = Math.sqrt(targetPixels / ratio);
+  const fitted = fitToPixelBudget(rawWidth, rawHeight, MIN_WAN27_TOTAL_PIXELS, maxPixels);
+  const bounded = clampWan27DerivedSizeToRatioBounds(fitted);
+  return `${bounded.width}*${bounded.height}`;
+}
+function clampWan27DerivedSizeToRatioBounds(size) {
+  let { width, height } = size;
+  const ratio = width / height;
+  if (ratio > 8) {
+    width = floorToStep(height * 8);
+  } else if (ratio < 1 / 8) {
+    height = floorToStep(width * 8);
+  }
+  return { width, height };
+}
+function isWan27ProModel(model) {
+  return model.trim().toLowerCase() === "wan2.7-image-pro";
+}
+function normalizeSize(size) {
+  return size.replace("x", "*");
+}
+function parseAspectRatio3(ar) {
+  const match = ar.match(/^(\d+(?:\.\d+)?):(\d+(?:\.\d+)?)$/);
+  if (match === null)
+    return null;
+  const w = Number.parseFloat(match[1]);
+  const h = Number.parseFloat(match[2]);
+  if (w <= 0 || h <= 0)
+    return null;
+  return { width: w, height: h };
+}
+function parseSize(size) {
+  const match = normalizeSize(size).match(/^(\d+)\*(\d+)$/);
+  if (match === null)
+    return null;
+  const width = Number(match[1]);
+  const height = Number(match[2]);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0)
+    return null;
+  return { width, height };
+}
+function validateSizeFormat(size) {
+  const parsed = parseSize(size);
+  if (parsed === null) {
+    throw new Error(`Invalid DashScope size "${size}". Expected <width>x<height> or <width>*<height>.`);
+  }
+  return parsed;
+}
+function validateQwen2Size(size) {
+  const normalized = normalizeSize(size);
+  const parsed = validateSizeFormat(normalized);
+  const totalPixels = parsed.width * parsed.height;
+  if (totalPixels < MIN_QWEN_2_TOTAL_PIXELS || totalPixels > MAX_QWEN_2_TOTAL_PIXELS) {
+    throw new Error(`DashScope qwen-image-2.0* models require total pixels between ${MIN_QWEN_2_TOTAL_PIXELS} ` + `and ${MAX_QWEN_2_TOTAL_PIXELS}. Received ${normalized} (${totalPixels} pixels).`);
+  }
+  return normalized;
+}
+function validateQwenFixedSize(size) {
+  const normalized = normalizeSize(size);
+  validateSizeFormat(normalized);
+  if (!Object.values(QWEN_FIXED_SIZES_BY_RATIO).includes(normalized)) {
+    throw new Error(`DashScope qwen-image-max/plus/image models support only these sizes: ` + `${Object.values(QWEN_FIXED_SIZES_BY_RATIO).join(", ")}. Received ${normalized}.`);
+  }
+  return normalized;
+}
+function validateWan27Size(size, maxPixels, model) {
+  const normalized = normalizeSize(size);
+  const parsed = validateSizeFormat(normalized);
+  const totalPixels = parsed.width * parsed.height;
+  if (totalPixels < MIN_WAN27_TOTAL_PIXELS || totalPixels > maxPixels) {
+    throw new Error(`DashScope ${model} requires total pixels between 768*768 and ` + `${maxPixels === MAX_WAN27_PRO_T2I_PIXELS ? "4096*4096" : "2048*2048"} for the current request. ` + `Received ${normalized} (${totalPixels} pixels).`);
+  }
+  const ratio = parsed.width / parsed.height;
+  if (ratio < 1 / 8 || ratio > 8) {
+    throw new Error(`DashScope wan2.7 image models support aspect ratios in [1:8, 8:1]. Received ${normalized} (ratio ${ratio.toFixed(3)}).`);
+  }
+  return normalized;
+}
+function getQwenFixedSizeFromAspectRatio(ar, quality) {
+  if (quality === "normal") {
+    echoError("DashScope qwen-image-max/plus/image models use fixed output sizes; quality does not change the resolution.");
+  }
+  if (ar === undefined)
+    return QWEN_FIXED_SPEC_DEFAULT;
+  const ratioKey = findKnownRatioKey(ar, Object.keys(QWEN_FIXED_SIZES_BY_RATIO));
+  if (ratioKey === null) {
+    throw new Error(`DashScope model supports only fixed ratios ${Object.keys(QWEN_FIXED_SIZES_BY_RATIO).join(", ")}. ` + `For custom ratios like "${ar}", use --model qwen-image-2.0-pro.`);
+  }
+  return QWEN_FIXED_SIZES_BY_RATIO[ratioKey];
+}
+function buildParameters(family, size) {
+  if (family === "wan27") {
+    return { size, n: 1, watermark: false };
+  }
+  const parameters = { prompt_extend: false, size };
+  if (family === "qwen2" || family === "qwenFixed") {
+    parameters.watermark = false;
+    parameters.negative_prompt = QWEN_NEGATIVE_PROMPT;
+  }
+  return parameters;
+}
+async function extractImageFromResponse3(result, fetchFn) {
+  let imageData = null;
+  if (result.output?.result_image !== undefined) {
+    imageData = result.output.result_image;
+  } else if (result.output?.choices?.[0]?.message?.content !== undefined) {
+    for (const item of result.output.choices[0].message.content) {
+      if (item.image !== undefined) {
+        imageData = item.image;
+        break;
+      }
+    }
+  }
+  if (imageData === null)
+    throw new Error("No image in response");
+  if (imageData.startsWith("http://") || imageData.startsWith("https://")) {
+    const imgRes = await fetchFn(imageData);
+    if (!imgRes.ok)
+      throw new Error("Failed to download image");
+    return new Uint8Array(await imgRes.arrayBuffer());
+  }
+  return Uint8Array.from(Buffer5.from(imageData, "base64"));
+}
+var createDashscope = (options) => {
+  const fetchFn = options?.fetch ?? fetch;
+  const env = options?.env ?? process.env;
+  const readEnv = (key) => env[key] ?? "";
+  const supportsRef = (model) => model.includes("wan2.7");
+  return {
+    name: "dashscope",
+    defaultModel: () => DEFAULT_MODEL5,
+    isAvailable: () => readEnv("DASHSCOPE_API_KEY") !== "",
+    supportsReferenceImages: supportsRef,
+    validate(req) {
+      const spec = getModelSpec(req.model);
+      if ((req.referenceImages?.length ?? 0) > 0 && spec.family !== "wan27") {
+        throw new Error("Reference images are not supported with this DashScope model. Use a wan2.7 image model (--model wan2.7-image-pro or wan2.7-image), or switch to --provider google with a Gemini multimodal model.");
+      }
+    },
+    async generate(req) {
+      const apiKey = readEnv("DASHSCOPE_API_KEY");
+      if (apiKey === "")
+        throw new Error("DASHSCOPE_API_KEY is required");
+      const spec = getModelSpec(req.model);
+      const refs = req.referenceImages ?? [];
+      if (refs.length > 0 && spec.family !== "wan27") {
+        throw new Error("Reference images are not supported with this DashScope model. Use a wan2.7 image model (--model wan2.7-image-pro or wan2.7-image), or switch to --provider google with a Gemini multimodal model.");
+      }
+      if (refs.length > WAN27_MAX_REFERENCE_IMAGES) {
+        throw new Error(`DashScope wan2.7 image models accept at most ${WAN27_MAX_REFERENCE_IMAGES} reference images. Received ${refs.length}.`);
+      }
+      if (spec.family === "wan27" && (req.n ?? 1) !== 1) {
+        throw new Error("DashScope wan2.7 image models in kk image-gen support exactly one output image per request (extra images would be billed but discarded). Remove --n or use --n 1.");
+      }
+      const size = resolveSizeForModel(req.model, {
+        ...req.width !== undefined && req.height !== undefined ? { size: `${req.width}x${req.height}` } : {},
+        aspectRatio: req.aspectRatio,
+        quality: req.quality,
+        referenceImages: refs
+      });
+      const base = (readEnv("DASHSCOPE_BASE_URL") || "https://dashscope.aliyuncs.com").replace(/\/+$/g, "");
+      const url2 = `${base}/api/v1/services/aigc/multimodal-generation/generation`;
+      const content = [];
+      if (spec.family === "wan27" && refs.length > 0) {
+        for (const refPath of refs) {
+          content.push({ image: await refToDataUri(refPath) });
+        }
+      }
+      content.push({ text: req.prompt });
+      const body = {
+        model: req.model,
+        input: { messages: [{ role: "user", content }] },
+        parameters: buildParameters(spec.family, size)
+      };
+      const res = await fetchFn(url2, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${apiKey}` },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok)
+        throw new Error(`DashScope API error (${res.status}): ${await res.text()}`);
+      const bytes = await extractImageFromResponse3(await res.json(), fetchFn);
+      return { bytes, extension: "png", provider: "dashscope", model: req.model };
+    }
+  };
+};
+
+// ../../plugins/generations/image-gen/src/providers/google.ts
+import { Buffer as Buffer6 } from "buffer";
+import { execFileSync } from "child_process";
+var GOOGLE_MULTIMODAL_MODELS = [
+  "gemini-3-pro-image",
+  "gemini-3.1-flash-image",
+  "gemini-3-pro-image-preview",
+  "gemini-3-flash-preview",
+  "gemini-3.1-flash-image-preview"
+];
+var GOOGLE_IMAGEN_MODELS = ["imagen-3.0-generate-002", "imagen-3.0-generate-001"];
+var DEFAULT_MODEL6 = "gemini-3-pro-image";
+function normalizeGoogleModelId(model) {
+  return model.startsWith("models/") ? model.slice("models/".length) : model;
+}
+function isGoogleMultimodal(model) {
+  const normalized = normalizeGoogleModelId(model);
+  return GOOGLE_MULTIMODAL_MODELS.some((fragment) => normalized.includes(fragment));
+}
+function isGoogleImagen(model) {
+  const normalized = normalizeGoogleModelId(model);
+  return GOOGLE_IMAGEN_MODELS.some((fragment) => normalized.includes(fragment));
+}
+function buildGoogleUrl(base, pathname) {
+  const cleaned = base.replace(/\/+$/g, "").replace(/^\/+/g, "");
+  const cleanedPath = pathname.replace(/^\/+/g, "");
+  if (cleaned.endsWith("/v1beta"))
+    return `${cleaned}/${cleanedPath}`;
+  return `${cleaned}/v1beta/${cleanedPath}`;
+}
+function buildPromptWithAspect(prompt, aspectRatio, quality) {
+  let result = prompt;
+  if (aspectRatio !== undefined)
+    result += ` Aspect ratio: ${aspectRatio}.`;
+  if (quality === "2k")
+    result += " High resolution 2048px.";
+  return result;
+}
+function extractInlineImageData(response) {
+  for (const candidate of response.candidates ?? []) {
+    for (const part of candidate.content?.parts ?? []) {
+      const data = part.inlineData?.data;
+      if (typeof data === "string" && data.length > 0)
+        return data;
+    }
+  }
+  return null;
+}
+function extractPredictedImageData(response) {
+  for (const candidate of [...response.predictions ?? [], ...response.generatedImages ?? []]) {
+    if (candidate === null || typeof candidate !== "object")
+      continue;
+    const fields = [candidate.imageBytes, candidate.bytesBase64Encoded, candidate.data].flatMap((value) => typeof value === "string" && value.length > 0 ? [value] : []);
+    if (fields.length > 0)
+      return fields[0] ?? null;
+    const image = candidate.image;
+    if (image !== null && typeof image === "object") {
+      const record2 = image;
+      for (const value of [record2.imageBytes, record2.bytesBase64Encoded, record2.data]) {
+        if (typeof value === "string" && value.length > 0)
+          return value;
+      }
+    }
+  }
+  return null;
+}
+function resolveSize2(req) {
+  if (req.width !== undefined && req.height !== undefined) {
+    return Math.max(req.width, req.height) <= 1024 ? "1K" : Math.max(req.width, req.height) <= 2048 ? "2K" : "4K";
+  }
+  return;
+}
+function getHttpProxy(readEnv) {
+  return readEnv("https_proxy") || readEnv("HTTPS_PROXY") || readEnv("http_proxy") || readEnv("HTTP_PROXY") || readEnv("ALL_PROXY") || null;
+}
+var createGoogle = (options) => {
+  const fetchFn = options?.fetch ?? fetch;
+  const env = options?.env ?? process.env;
+  const readEnv = (key) => env[key] ?? "";
+  const refModels = [
+    "gemini-3-pro-image",
+    "gemini-3.1-flash-image",
+    "gemini-3-pro-image-preview",
+    "gemini-3-flash-preview",
+    "gemini-3.1-flash-image-preview"
+  ];
+  const supportsRef = (model) => refModels.some((fragment) => normalizeGoogleModelId(model).includes(fragment));
+  async function postGoogleJson(pathname, body) {
+    const apiKey = readEnv("GOOGLE_API_KEY") || readEnv("GEMINI_API_KEY");
+    if (apiKey === "")
+      throw new Error("GOOGLE_API_KEY or GEMINI_API_KEY is required");
+    const base = readEnv("GOOGLE_BASE_URL") || "https://generativelanguage.googleapis.com";
+    const url2 = buildGoogleUrl(base, pathname);
+    const proxy = getHttpProxy(readEnv);
+    if (proxy !== null && options?.fetch === undefined) {
+      const result = (() => {
+        try {
+          return execFileSync("curl", [
+            "-s",
+            "--connect-timeout",
+            "30",
+            "--max-time",
+            "300",
+            "-x",
+            proxy,
+            url2,
+            "-H",
+            "Content-Type: application/json",
+            "-H",
+            `x-goog-api-key: ${apiKey}`,
+            "-d",
+            "@-"
+          ], { input: JSON.stringify(body), encoding: "utf8", timeout: 310000 });
+        } catch (error51) {
+          const e = error51;
+          const details = (typeof e.stderr === "string" ? e.stderr.trim() : "") || e.message || "curl request failed";
+          throw new Error(`Google API request failed via curl: ${details}`);
+        }
+      })();
+      const parsed = JSON.parse(result);
+      if (parsed.error !== undefined) {
+        throw new Error(`Google API error (${parsed.error.code}): ${parsed.error.message}`);
+      }
+      return parsed;
+    }
+    const res = await fetchFn(url2, {
+      method: "POST",
+      headers: { "content-type": "application/json", "x-goog-api-key": apiKey },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Google API error (${res.status}): ${err}`);
+    }
+    return await res.json();
+  }
+  async function generateWithGemini(req) {
+    const promptWithAspect = buildPromptWithAspect(req.prompt, req.aspectRatio, req.quality);
+    const parts = [];
+    for (const refPath of req.referenceImages ?? []) {
+      parts.push({
+        inlineData: {
+          data: Buffer6.from(await readBytes(refPath)).toString("base64"),
+          mimeType: mimeForPath(refPath)
+        }
+      });
+    }
+    parts.push({ text: promptWithAspect });
+    const response = await postGoogleJson(`models/${normalizeGoogleModelId(req.model)}:generateContent`, {
+      contents: [{ role: "user", parts }],
+      generationConfig: {
+        responseModalities: ["IMAGE"],
+        imageConfig: { imageSize: resolveSize2(req) ?? (req.quality === "2k" ? "2K" : "1K") }
+      }
+    });
+    const imageData = extractInlineImageData(response);
+    if (imageData !== null)
+      return Uint8Array.from(Buffer6.from(imageData, "base64"));
+    throw new Error("No image in response");
+  }
+  async function generateWithImagen(req) {
+    const fullPrompt = buildPromptWithAspect(req.prompt, req.aspectRatio, req.quality);
+    const imageSize = resolveSize2(req) ?? (req.quality === "2k" ? "2K" : "1K");
+    const parameters = { sampleCount: req.n ?? 1 };
+    if (req.aspectRatio !== undefined)
+      parameters.aspectRatio = req.aspectRatio;
+    parameters.imageSize = imageSize === "4K" ? "2K" : imageSize;
+    const response = await postGoogleJson(`models/${normalizeGoogleModelId(req.model)}:predict`, {
+      instances: [{ prompt: fullPrompt }],
+      parameters
+    });
+    const imageData = extractPredictedImageData(response);
+    if (imageData !== null)
+      return Uint8Array.from(Buffer6.from(imageData, "base64"));
+    throw new Error("No image in response");
+  }
+  async function generate(req) {
+    const refs = req.referenceImages;
+    if (isGoogleImagen(req.model)) {
+      if (refs !== undefined && refs.length > 0) {
+        throw new Error("Reference images are not supported with Imagen models. Use a Gemini multimodal model such as gemini-3-pro-image, gemini-3.1-flash-image, gemini-3-pro-image-preview, gemini-3-flash-preview, or gemini-3.1-flash-image-preview.");
+      }
+      return { bytes: await generateWithImagen(req), extension: "png", provider: "google", model: req.model };
+    }
+    if (!isGoogleMultimodal(req.model) && refs !== undefined && refs.length > 0) {
+      throw new Error("Reference images are only supported with Gemini multimodal models such as gemini-3-pro-image, gemini-3.1-flash-image, gemini-3-pro-image-preview, gemini-3-flash-preview, or gemini-3.1-flash-image-preview.");
+    }
+    const bytes = await generateWithGemini(req);
+    return { bytes, extension: "png", provider: "google", model: req.model };
+  }
+  return {
+    name: "google",
+    defaultModel: () => DEFAULT_MODEL6,
+    isAvailable: () => (readEnv("GOOGLE_API_KEY") || readEnv("GEMINI_API_KEY")) !== "",
+    supportsReferenceImages: supportsRef,
+    validate(req) {
+      if ((req.referenceImages?.length ?? 0) > 0 && !supportsRef(req.model)) {
+        throw new Error(`google model '${req.model}' does not accept reference images; use a Gemini multimodal model`);
+      }
+    },
+    generate
+  };
+};
+
+// ../../plugins/generations/image-gen/src/providers/huggingface.ts
+var DEFAULT_MODEL7 = "stabilityai/stable-diffusion-xl-base-1.0";
+var BASE_URL = "https://api-inference.huggingface.co/models";
+var buildPayload = (req) => ({
+  inputs: req.prompt,
+  parameters: {
+    width: req.width ?? 1024,
+    height: req.height ?? 1024,
+    num_inference_steps: req.quality === "normal" ? 30 : 50
+  }
+});
+var createHuggingface = (options) => {
+  const fetchFn = options?.fetch ?? fetch;
+  const env = options?.env ?? process.env;
+  const readEnv = (key) => env[key] ?? "";
+  return {
+    name: "huggingface",
+    defaultModel: () => readEnv("HUGGINGFACE_MODEL") || DEFAULT_MODEL7,
+    isAvailable: () => readEnv("HUGGINGFACE_API_TOKEN") !== "",
+    supportsReferenceImages: () => false,
+    async generate(req) {
+      const token = readEnv("HUGGINGFACE_API_TOKEN");
+      if (token === "") {
+        throw new Error("HUGGINGFACE_API_TOKEN is required. Get one at https://huggingface.co/settings/tokens");
+      }
+      const model = req.model.startsWith("hf:") ? req.model.slice(3) : req.model;
+      const res = await fetchFn(`${BASE_URL}/${model}`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+        body: JSON.stringify(buildPayload(req))
+      });
+      if (!res.ok) {
+        const text = (await res.text()).slice(0, 200);
+        if (res.status === 503)
+          throw new Error(`HuggingFace model loading (HTTP 503): ${text}`);
+        throw new Error(`HuggingFace HTTP ${res.status}: ${text}`);
+      }
+      const bytes = new Uint8Array(await res.arrayBuffer());
+      const ct = res.headers.get("content-type") ?? "";
+      const extension = ct.includes("jpeg") ? "jpg" : ct.includes("webp") ? "webp" : "png";
+      return { bytes, extension, provider: "huggingface", model };
+    }
+  };
+};
+
+// ../../plugins/generations/image-gen/src/providers/jimeng.ts
+import * as crypto from "crypto";
+var DEFAULT_MODEL8 = "jimeng_t2i_v40";
+var SIZE_PRESETS = {
+  normal: {
+    "1:1": "1024x1024",
+    "4:3": "1360x1020",
+    "16:9": "1536x864",
+    "3:2": "1440x960",
+    "21:9": "1920x824"
+  },
+  "2k": {
+    "1:1": "2048x2048",
+    "4:3": "2304x1728",
+    "16:9": "2560x1440",
+    "3:2": "2496x1664",
+    "21:9": "3024x1296"
+  },
+  "4k": {
+    "1:1": "4096x4096",
+    "4:3": "4694x3520",
+    "16:9": "5404x3040",
+    "3:2": "4992x3328",
+    "21:9": "6198x2656"
+  }
+};
+function generateSignature(method, query, headers, body, accessKey, secretKey, region, service, canonicalUri) {
+  const sortedQuery = Object.entries(query).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+  const sortedHeaders = Object.entries(headers).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k.toLowerCase()}:${v.trim()}
+`).join("");
+  const signedHeaders = Object.keys(headers).sort().map((k) => k.toLowerCase()).join(";");
+  const hashedPayload = crypto.createHash("sha256").update(body, "utf8").digest("hex");
+  const canonicalRequest = [method, canonicalUri, sortedQuery, sortedHeaders, signedHeaders, hashedPayload].join(`
+`);
+  const hashedCanonicalRequest = crypto.createHash("sha256").update(canonicalRequest, "utf8").digest("hex");
+  const algorithm = "HMAC-SHA256";
+  const timestamp = headers["X-Date"] ?? headers["x-date"];
+  if (timestamp === undefined)
+    throw new Error("Jimeng signature generation requires an X-Date header.");
+  const dateStamp = timestamp.slice(0, 8);
+  const credentialScope = `${dateStamp}/${region}/${service}/request`;
+  const stringToSign = [algorithm, timestamp, credentialScope, hashedCanonicalRequest].join(`
+`);
+  const kDate = crypto.createHmac("sha256", secretKey).update(dateStamp).digest();
+  const kRegion = crypto.createHmac("sha256", kDate).update(region).digest();
+  const kService = crypto.createHmac("sha256", kRegion).update(service).digest();
+  const kSigning = crypto.createHmac("sha256", kService).update("request").digest();
+  const signature = crypto.createHmac("sha256", kSigning).update(stringToSign).digest("hex");
+  return `${algorithm} Credential=${accessKey}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+}
+function resolveEndpoint(baseUrl, query) {
+  let parsed;
+  try {
+    parsed = new URL(baseUrl);
+  } catch {
+    throw new Error(`Invalid JIMENG_BASE_URL: ${baseUrl}`);
+  }
+  parsed.search = "";
+  for (const [key, value] of Object.entries(query).sort(([a], [b]) => a.localeCompare(b))) {
+    parsed.searchParams.set(key, value);
+  }
+  return { url: parsed.toString(), host: parsed.host, canonicalUri: parsed.pathname || "/" };
+}
+function getClosestPresetSize(ar, qualityLevel) {
+  const presets = SIZE_PRESETS[qualityLevel];
+  const defaultSize = presets["1:1"];
+  if (ar === undefined)
+    return defaultSize;
+  const match = ar.match(/^(\d+(?:\.\d+)?):(\d+(?:\.\d+)?)$/);
+  if (match === null)
+    return defaultSize;
+  const targetRatio = Number(match[1]) / Number(match[2]);
+  let bestMatch = defaultSize;
+  let bestDiff = Number.POSITIVE_INFINITY;
+  for (const [ratio, size] of Object.entries(presets)) {
+    const [w, h] = ratio.split(":").map(Number);
+    const diff = Math.abs(w / h - targetRatio);
+    if (diff < bestDiff) {
+      bestDiff = diff;
+      bestMatch = size;
+    }
+  }
+  return bestMatch;
+}
+function getImageSize(ar, quality, width, height) {
+  if (width !== undefined && height !== undefined)
+    return `${width}x${height}`;
+  const qualityLevel = quality === "normal" ? "normal" : "2k";
+  return getClosestPresetSize(ar, qualityLevel);
+}
+function timestampHeader() {
+  return new Date().toISOString().replace(/[:-]|\.\d{3}/g, "");
+}
+var createJimeng = (options) => {
+  const fetchFn = options?.fetch ?? fetch;
+  const env = options?.env ?? process.env;
+  const readEnv = (key) => env[key] ?? "";
+  async function signedPost(query, body, accessKey, secretKey, region) {
+    const base = readEnv("JIMENG_BASE_URL") || "https://visual.volcengineapi.com";
+    const endpoint = resolveEndpoint(base, query);
+    const headers = {
+      "content-type": "application/json",
+      "X-Date": timestampHeader(),
+      Host: endpoint.host
+    };
+    const authorization = generateSignature("POST", query, headers, body, accessKey, secretKey, region, "cv", endpoint.canonicalUri);
+    return fetchFn(endpoint.url, { method: "POST", headers: { ...headers, authorization }, body });
+  }
+  async function submitTask(req, size, accessKey, secretKey, region) {
+    const query = { Action: "CVSync2AsyncSubmitTask", Version: "2022-08-31" };
+    const [width, height] = size.split("x").map(Number);
+    const body = JSON.stringify({ req_key: req.model, prompt: req.prompt, width, height });
+    const res = await signedPost(query, body, accessKey, secretKey, region);
+    if (!res.ok)
+      throw new Error(`Jimeng API submit error (${res.status}): ${await res.text()}`);
+    const result = await res.json();
+    if (result.code !== 1e4 || result.data?.task_id === undefined) {
+      throw new Error(`Failed to submit task: ${result.message ?? "Unknown error"}`);
+    }
+    return result.data.task_id;
+  }
+  async function pollForResult(taskId, req, accessKey, secretKey, region) {
+    const maxAttempts = 60;
+    const pollIntervalMs = 2000;
+    for (let attempt = 0;attempt < maxAttempts; attempt++) {
+      const query = { Action: "CVSync2AsyncGetResult", Version: "2022-08-31" };
+      const body = JSON.stringify({ req_key: req.model, task_id: taskId });
+      const res = await signedPost(query, body, accessKey, secretKey, region);
+      if (!res.ok)
+        throw new Error(`Jimeng API poll error (${res.status}): ${await res.text()}`);
+      const result = await res.json();
+      if (result.code === 1e4 && result.data !== undefined) {
+        const { status, image_urls, binary_data_base64 } = result.data;
+        if (binary_data_base64 !== undefined && binary_data_base64.length > 0) {
+          return new Uint8Array(Buffer.from(binary_data_base64[0], "base64"));
+        }
+        if (status === "done" && image_urls !== undefined && image_urls.length > 0) {
+          const url2 = image_urls[0];
+          const imgRes = await fetchFn(url2);
+          if (!imgRes.ok)
+            throw new Error(`Failed to download image from ${url2}`);
+          return new Uint8Array(await imgRes.arrayBuffer());
+        }
+        if (status === "in_queue" || status === "generating") {
+          await new Promise((resolve3) => setTimeout(resolve3, pollIntervalMs));
+          continue;
+        }
+        if (status === "fail")
+          throw new Error(`Jimeng task failed: ${result.message ?? "Generation failed"}`);
+      }
+      throw new Error(`Unexpected response during polling: ${result.message ?? "Unknown error"}`);
+    }
+    throw new Error("Task timeout: image generation took too long");
+  }
+  async function generate(req) {
+    if ((req.referenceImages?.length ?? 0) > 0) {
+      throw new Error("Jimeng does not support reference images. Use --provider google, openai, openrouter, or replicate.");
+    }
+    const accessKey = readEnv("JIMENG_ACCESS_KEY_ID");
+    const secretKey = readEnv("JIMENG_SECRET_ACCESS_KEY");
+    if (accessKey === "" || secretKey === "") {
+      throw new Error("JIMENG_ACCESS_KEY_ID and JIMENG_SECRET_ACCESS_KEY are required. Get your credentials from https://console.volcengine.com/iam/keymanage");
+    }
+    const region = readEnv("JIMENG_REGION") || "cn-north-1";
+    const size = getImageSize(req.aspectRatio, req.quality, req.width, req.height);
+    const taskId = await submitTask(req, size, accessKey, secretKey, region);
+    const bytes = await pollForResult(taskId, req, accessKey, secretKey, region);
+    return { bytes, extension: "png", provider: "jimeng", model: req.model };
+  }
+  return {
+    name: "jimeng",
+    defaultModel: () => DEFAULT_MODEL8,
+    isAvailable: () => readEnv("JIMENG_ACCESS_KEY_ID") !== "" && readEnv("JIMENG_SECRET_ACCESS_KEY") !== "",
+    supportsReferenceImages: () => true,
+    generate
+  };
+};
+
+// ../../plugins/generations/image-gen/src/providers/minimax.ts
+import { Buffer as Buffer7 } from "buffer";
+var DEFAULT_MODEL9 = "image-01";
+var MAX_REFERENCE_IMAGE_BYTES = 10 * 1024 * 1024;
+var SUPPORTED_ASPECT_RATIOS = new Set(["1:1", "16:9", "4:3", "3:2", "2:3", "3:4", "9:16", "21:9"]);
+function validatePixelSize(width, height) {
+  if (width < 512 || width > 2048 || height < 512 || height > 2048) {
+    throw new Error("MiniMax custom size must keep width and height between 512 and 2048.");
+  }
+  if (width % 8 !== 0 || height % 8 !== 0) {
+    throw new Error("MiniMax custom size requires width and height divisible by 8.");
+  }
+}
+function requestBody(prompt, model, req) {
+  if ((req.n ?? 1) > 9)
+    throw new Error("MiniMax supports at most 9 images per request.");
+  if (req.aspectRatio !== undefined && !SUPPORTED_ASPECT_RATIOS.has(req.aspectRatio)) {
+    throw new Error(`MiniMax aspect_ratio must be one of: ${Array.from(SUPPORTED_ASPECT_RATIOS).join(", ")}.`);
+  }
+  if (req.width !== undefined && req.height !== undefined && req.aspectRatio === undefined) {
+    if (model !== "image-01") {
+      throw new Error("MiniMax custom --size is only supported with model image-01. Use --model image-01 or pass --ar instead.");
+    }
+    validatePixelSize(req.width, req.height);
+  }
+  if (req.referenceImages !== undefined && req.referenceImages.length > 0) {
+    for (const refPath of req.referenceImages) {
+      const ext = refPath.toLowerCase();
+      if (!ext.includes(".jpg") && !ext.includes(".jpeg") && !ext.includes(".png")) {
+        throw new Error(`MiniMax subject_reference only supports JPG, JPEG, or PNG files: ${refPath}`);
+      }
+    }
+  }
+  const body = { model, prompt, response_format: "base64" };
+  if (req.aspectRatio !== undefined) {
+    body.aspect_ratio = req.aspectRatio;
+  } else if (req.width !== undefined && req.height !== undefined) {
+    body.width = req.width;
+    body.height = req.height;
+  }
+  if ((req.n ?? 1) > 1)
+    body.n = req.n;
+  return body;
+}
+async function buildSubjectReference(referenceImages) {
+  if (referenceImages.length === 0)
+    return;
+  const subjectReference = [];
+  for (const refPath of referenceImages) {
+    const ext = refPath.toLowerCase();
+    if (!ext.includes(".jpg") && !ext.includes(".jpeg") && !ext.includes(".png")) {
+      throw new Error(`MiniMax subject_reference only supports JPG, JPEG, or PNG files: ${refPath}`);
+    }
+    const bytes = Buffer7.from(await readBytes(refPath));
+    if (bytes.length > MAX_REFERENCE_IMAGE_BYTES) {
+      throw new Error(`MiniMax subject_reference images must be smaller than 10MB: ${refPath}`);
+    }
+    subjectReference.push({
+      type: "character",
+      image_file: `data:${mimeForPath(refPath)};base64,${bytes.toString("base64")}`
+    });
+  }
+  return subjectReference;
+}
+async function extractImageFromResponse4(result, fetchFn = fetch) {
+  const baseResp = result.base_resp;
+  if (baseResp?.status_code !== undefined && baseResp.status_code !== 0) {
+    throw new Error(baseResp.status_msg ?? `MiniMax API returned status_code=${baseResp.status_code}`);
+  }
+  const base64Image = result.data?.image_base64?.[0];
+  if (base64Image !== undefined)
+    return Uint8Array.from(Buffer7.from(base64Image, "base64"));
+  const url2 = result.data?.image_urls?.[0];
+  if (url2 !== undefined) {
+    const response = await fetchFn(url2);
+    if (!response.ok)
+      throw new Error(`Failed to download image from MiniMax: ${response.status}`);
+    return new Uint8Array(await response.arrayBuffer());
+  }
+  throw new Error("No image data in MiniMax response");
+}
+var createMinimax = (options) => {
+  const fetchFn = options?.fetch ?? fetch;
+  const env = options?.env ?? process.env;
+  const readEnv = (key) => env[key] ?? "";
+  return {
+    name: "minimax",
+    defaultModel: () => DEFAULT_MODEL9,
+    isAvailable: () => readEnv("MINIMAX_API_KEY") !== "",
+    supportsReferenceImages: () => true,
+    validate(req) {
+      requestBody(req.prompt, req.model, req);
+    },
+    async generate(req) {
+      const apiKey = readEnv("MINIMAX_API_KEY");
+      if (apiKey === "")
+        throw new Error("MINIMAX_API_KEY is required. Get one from https://platform.minimaxi.com/");
+      const body = requestBody(req.prompt, req.model, req);
+      const subjectReference = await buildSubjectReference(req.referenceImages ?? []);
+      if (subjectReference !== undefined)
+        body.subject_reference = subjectReference;
+      const base = (readEnv("MINIMAX_BASE_URL") || "https://api.minimaxi.com").replace(/\/+$/g, "");
+      const url2 = base.endsWith("/v1") ? `${base}/image_generation` : `${base}/v1/image_generation`;
+      const response = await fetchFn(url2, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${apiKey}` },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        throw new Error(`MiniMax API error (${response.status}): ${await response.text()}`);
+      }
+      const bytes = await extractImageFromResponse4(await response.json(), fetchFn);
+      return { bytes, extension: "jpg", provider: "minimax", model: req.model };
+    }
+  };
+};
+
+// ../../plugins/generations/image-gen/src/providers/openrouter.ts
+import { Buffer as Buffer8 } from "buffer";
+var DEFAULT_MODEL10 = "google/gemini-3.1-flash-image";
+var COMMON_ASPECT_RATIOS = ["1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"];
+var GEMINI_EXTENDED_ASPECT_RATIOS = ["1:4", "4:1", "1:8", "8:1"];
+function normalizeModelId(model) {
+  return model.trim().toLowerCase().split(":")[0];
+}
+function isTextAndImageModel(model) {
+  const normalized = normalizeModelId(model);
+  if (normalized === "openrouter/auto")
+    return true;
+  if (normalized.startsWith("google/gemini-") && normalized.includes("image"))
+    return true;
+  if (normalized.startsWith("openai/gpt-") && normalized.includes("image"))
+    return true;
+  return false;
+}
+function getSupportedAspectRatios(model) {
+  const normalized = normalizeModelId(model);
+  if (normalized !== "google/gemini-3.1-flash-image" && normalized !== "google/gemini-3.1-flash-image-preview") {
+    return new Set(COMMON_ASPECT_RATIOS);
+  }
+  return new Set([...COMMON_ASPECT_RATIOS, ...GEMINI_EXTENDED_ASPECT_RATIOS]);
+}
+function gcd2(a, b) {
+  let x = Math.abs(a);
+  let y = Math.abs(b);
+  while (y !== 0) {
+    const next = x % y;
+    x = y;
+    y = next;
+  }
+  return x || 1;
+}
+function inferAspectRatio(size) {
+  if (size === null)
+    return null;
+  const parsed = size.match(/^(\d+)\s*[xX]\s*(\d+)$/);
+  if (parsed === null)
+    return null;
+  const width = Number.parseInt(parsed[1], 10);
+  const height = Number.parseInt(parsed[2], 10);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0)
+    return null;
+  const divisor = gcd2(width, height);
+  return `${width / divisor}:${height / divisor}`;
 }
+function inferImageSize(size) {
+  if (size === null)
+    return null;
+  const parsed = size.match(/^(\d+)\s*[xX]\s*(\d+)$/);
+  if (parsed === null)
+    return null;
+  const width = Number.parseInt(parsed[1], 10);
+  const height = Number.parseInt(parsed[2], 10);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0)
+    return null;
+  const longestEdge = Math.max(width, height);
+  if (longestEdge <= 1024)
+    return "1K";
+  if (longestEdge <= 2048)
+    return "2K";
+  return "4K";
+}
+function getImageSize2(req) {
+  if (req.width !== undefined && req.height !== undefined)
+    return inferImageSize(`${req.width}x${req.height}`);
+  if (req.quality === "normal")
+    return "1K";
+  if (req.quality === "2k")
+    return "2K";
+  return null;
+}
+function getAspectRatio(preferred, size, model) {
+  if (preferred !== null)
+    return preferred;
+  const inferred = inferAspectRatio(size);
+  if (inferred === null || !getSupportedAspectRatios(model).has(inferred))
+    return null;
+  return inferred;
+}
+function validateAspectRatio(model, aspectRatio, size) {
+  const requested = aspectRatio ?? inferAspectRatio(size);
+  if (requested === null)
+    return;
+  const supported = getSupportedAspectRatios(model);
+  if (supported.has(requested))
+    return;
+  const requestedValue = aspectRatio !== null ? `aspect ratio ${requested}` : `size ${size} (aspect ratio ${requested})`;
+  throw new Error(`OpenRouter model ${model} does not support ${requestedValue}. Supported values: ${Array.from(supported).join(", ")}`);
+}
+function buildContent(prompt, referenceImages) {
+  if (referenceImages.length === 0)
+    return prompt;
+  const content = [{ type: "text", text: prompt }];
+  for (const imageUrl of referenceImages) {
+    content.push({ type: "image_url", image_url: { url: imageUrl } });
+  }
+  return content;
+}
+function extractImageUrl(entry) {
+  const value = entry.image_url ?? entry.imageUrl;
+  if (value === null || value === undefined)
+    return null;
+  if (typeof value === "string")
+    return value;
+  return value.url ?? null;
+}
+function decodeDataUrl(value) {
+  const match = value.match(/^data:image\/[^;]+;base64,([A-Za-z0-9+/=]+)$/);
+  if (match === null)
+    return null;
+  return Uint8Array.from(Buffer8.from(match[1], "base64"));
+}
+async function downloadImage(value, fetchFn) {
+  const inline = decodeDataUrl(value);
+  if (inline !== null)
+    return inline;
+  if (value.startsWith("http://") || value.startsWith("https://")) {
+    const response = await fetchFn(value);
+    if (!response.ok)
+      throw new Error(`Failed to download OpenRouter image: ${response.status}`);
+    return new Uint8Array(await response.arrayBuffer());
+  }
+  return Uint8Array.from(Buffer8.from(value, "base64"));
+}
+async function extractImageFromResponse5(result, fetchFn = fetch) {
+  const choice = result.choices?.[0];
+  const message = choice?.message;
+  for (const image of message?.images ?? []) {
+    const imageUrl = extractImageUrl(image);
+    if (imageUrl !== null)
+      return downloadImage(imageUrl, fetchFn);
+  }
+  if (Array.isArray(message?.content)) {
+    for (const item of message.content) {
+      const imageUrl = extractImageUrl(item);
+      if (imageUrl !== null)
+        return downloadImage(imageUrl, fetchFn);
+      if (item.type === "text" && item.text !== undefined) {
+        const inline = decodeDataUrl(item.text);
+        if (inline !== null)
+          return inline;
+      }
+    }
+  } else if (typeof message?.content === "string") {
+    const inline = decodeDataUrl(message.content);
+    if (inline !== null)
+      return inline;
+  }
+  const finishReason = choice?.native_finish_reason || choice?.finish_reason || "unknown";
+  throw new Error(`No image in OpenRouter response (finish_reason=${finishReason})`);
+}
+function buildRequestBody2(prompt, model, req, referenceImages) {
+  validateAspectRatio(model, req.aspectRatio ?? null, req.width !== undefined && req.height !== undefined ? `${req.width}x${req.height}` : null);
+  const imageConfig = {};
+  const imageSize = getImageSize2(req);
+  if (imageSize !== null)
+    imageConfig.image_size = imageSize;
+  const aspectRatio = getAspectRatio(req.aspectRatio ?? null, req.width !== undefined && req.height !== undefined ? `${req.width}x${req.height}` : null, model);
+  if (aspectRatio !== null)
+    imageConfig.aspect_ratio = aspectRatio;
+  const body = {
+    messages: [{ role: "user", content: buildContent(prompt, referenceImages) }],
+    modalities: isTextAndImageModel(model) ? ["image", "text"] : ["image"],
+    stream: false
+  };
+  if (Object.keys(imageConfig).length > 0) {
+    body.image_config = imageConfig;
+    body.provider = { require_parameters: true };
+  }
+  return body;
+}
+var createOpenrouter = (options) => {
+  const fetchFn = options?.fetch ?? fetch;
+  const env = options?.env ?? process.env;
+  const readEnv = (key) => env[key] ?? "";
+  return {
+    name: "openrouter",
+    defaultModel: () => DEFAULT_MODEL10,
+    isAvailable: () => readEnv("OPENROUTER_API_KEY") !== "",
+    supportsReferenceImages: () => true,
+    async generate(req) {
+      const apiKey = readEnv("OPENROUTER_API_KEY");
+      if (apiKey === "")
+        throw new Error("OPENROUTER_API_KEY is required. Get one at https://openrouter.ai/settings/keys");
+      const headers = {
+        "content-type": "application/json",
+        authorization: `Bearer ${apiKey}`
+      };
+      const referer = readEnv("OPENROUTER_HTTP_REFERER").trim();
+      if (referer !== "")
+        headers["HTTP-Referer"] = referer;
+      const title = readEnv("OPENROUTER_TITLE").trim();
+      if (title !== "") {
+        headers["X-OpenRouter-Title"] = title;
+        headers["X-Title"] = title;
+      }
+      const referenceImages = [];
+      for (const refPath of req.referenceImages ?? []) {
+        referenceImages.push(await refToDataUri(refPath));
+      }
+      const body = { model: req.model, ...buildRequestBody2(req.prompt, req.model, req, referenceImages) };
+      const base = (readEnv("OPENROUTER_BASE_URL") || "https://openrouter.ai/api/v1").replace(/\/+$/g, "");
+      const response = await fetchFn(`${base}/chat/completions`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        throw new Error(`OpenRouter API error (${response.status}): ${await response.text()}`);
+      }
+      const bytes = await extractImageFromResponse5(await response.json(), fetchFn);
+      return { bytes, extension: "png", provider: "openrouter", model: req.model };
+    }
+  };
+};
+
+// ../../plugins/generations/image-gen/src/providers/replicate.ts
+var DEFAULT_MODEL11 = "google/nano-banana-2";
+var SYNC_WAIT_SECONDS = 60;
+var POLL_INTERVAL_MS = 2000;
+var MAX_POLL_MS = 300000;
+var DOCUMENTED_REPLICATE_ASPECT_RATIOS = new Set([
+  "1:1",
+  "2:3",
+  "3:2",
+  "3:4",
+  "4:3",
+  "5:4",
+  "4:5",
+  "9:16",
+  "16:9",
+  "21:9"
+]);
+function parseModelId(model) {
+  const [ownerName, version2] = model.split(":");
+  const parts = (ownerName ?? "").split("/");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new Error(`Invalid Replicate model format: "${model}". Expected "owner/name" or "owner/name:version".`);
+  }
+  return { owner: parts[0], name: parts[1], version: version2 ?? null };
+}
+function getModelFamily(model) {
+  const normalized = model.trim().toLowerCase().split(":")[0];
+  if (["google/nano-banana", "google/nano-banana-pro", "google/nano-banana-2"].includes(normalized))
+    return "nano-banana";
+  if (normalized === "bytedance/seedream-4.5")
+    return "seedream45";
+  if (normalized === "bytedance/seedream-5-lite")
+    return "seedream5lite";
+  if (normalized === "wan-video/wan-2.7-image")
+    return "wan27image";
+  if (normalized === "wan-video/wan-2.7-image-pro")
+    return "wan27imagepro";
+  return "unknown";
+}
+function validateDocumentedAspectRatio(model, aspectRatio) {
+  if (aspectRatio === "match_input_image" || DOCUMENTED_REPLICATE_ASPECT_RATIOS.has(aspectRatio))
+    return;
+  throw new Error(`Replicate model ${model} does not support aspect ratio ${aspectRatio}. Supported values: ${Array.from(DOCUMENTED_REPLICATE_ASPECT_RATIOS).join(", ")}`);
+}
+function getNanoBananaResolution(req) {
+  if (req.width !== undefined && req.height !== undefined) {
+    const longestEdge = Math.max(req.width, req.height);
+    if (longestEdge <= 1024)
+      return "1K";
+    if (longestEdge <= 2048)
+      return "2K";
+    throw new Error("Replicate nano-banana only supports sizes that map to 1K or 2K output.");
+  }
+  return req.quality === "normal" ? "1K" : "2K";
+}
+function resolveSeedream45Size(req) {
+  if (req.width !== undefined && req.height !== undefined) {
+    if (req.width < 1024 || req.width > 4096 || req.height < 1024 || req.height > 4096) {
+      throw new Error("Replicate Seedream 4.5 custom --size must keep width and height between 1024 and 4096.");
+    }
+    return { width: req.width, height: req.height };
+  }
+  return req.quality === "normal" ? "2K" : "4K";
+}
+function resolveSeedream5LiteSize(req) {
+  return req.quality === "normal" ? "2K" : "3K";
+}
+function resolveWanSizeFromAspectRatio(aspectRatio, maxDimension) {
+  const match = aspectRatio.trim().match(/^(\d+)\s*:\s*(\d+)$/);
+  if (match === null)
+    throw new Error(`Replicate Wan aspect ratio must be in W:H format, got ${aspectRatio}.`);
+  const ratioWidth = Number.parseInt(match[1], 10);
+  const ratioHeight = Number.parseInt(match[2], 10);
+  if (!Number.isFinite(ratioWidth) || !Number.isFinite(ratioHeight) || ratioWidth <= 0 || ratioHeight <= 0) {
+    throw new Error(`Replicate Wan aspect ratio must be in W:H format, got ${aspectRatio}.`);
+  }
+  const scale = Math.min(maxDimension / ratioWidth, maxDimension / ratioHeight);
+  const width = Math.max(1, Math.floor(ratioWidth * scale));
+  const height = Math.max(1, Math.floor(ratioHeight * scale));
+  return `${width}*${height}`;
+}
+function resolveWanSize(family, req) {
+  const referenceMode = (req.referenceImages?.length ?? 0) > 0;
+  const maxDimension = family === "wan27imagepro" && !referenceMode ? 4096 : 2048;
+  if (req.width !== undefined && req.height !== undefined) {
+    const parsed = { width: req.width, height: req.height };
+    if (req.width === undefined || req.height === undefined || parsed.width > maxDimension || parsed.height > maxDimension) {
+      throw new Error(`Replicate ${family === "wan27imagepro" ? "Wan 2.7 Image Pro" : "Wan 2.7 Image"} custom --size must keep width and height at or below ${maxDimension}px in the current mode.`);
+    }
+    return `${parsed.width}*${parsed.height}`;
+  }
+  if (req.aspectRatio !== undefined) {
+    return resolveWanSizeFromAspectRatio(req.aspectRatio, req.quality === "normal" ? 1024 : 2048);
+  }
+  return req.quality === "normal" ? "1K" : "2K";
+}
+function buildInput(req) {
+  const family = getModelFamily(req.model);
+  const referenceImages = req.referenceImages ?? [];
+  if (family === "nano-banana") {
+    const input = {
+      prompt: req.prompt,
+      resolution: getNanoBananaResolution(req),
+      output_format: "png"
+    };
+    if (req.aspectRatio !== undefined) {
+      validateDocumentedAspectRatio(req.model, req.aspectRatio);
+      input.aspect_ratio = req.aspectRatio;
+    } else if (referenceImages.length > 0) {
+      input.aspect_ratio = "match_input_image";
+    }
+    if (referenceImages.length > 0)
+      input.image_input = referenceImages;
+    return input;
+  }
+  if (family === "seedream45" || family === "seedream5lite") {
+    const size = family === "seedream45" ? resolveSeedream45Size(req) : resolveSeedream5LiteSize(req);
+    const input = { prompt: req.prompt };
+    if (family === "seedream45" && typeof size === "object") {
+      input.size = "custom";
+      input.width = size.width;
+      input.height = size.height;
+    } else {
+      input.size = size;
+    }
+    if (referenceImages.length > 0)
+      input.image_input = referenceImages;
+    if (req.aspectRatio !== undefined) {
+      validateDocumentedAspectRatio(req.model, req.aspectRatio);
+      input.aspect_ratio = req.aspectRatio;
+    } else if (referenceImages.length > 0 && family === "seedream45") {
+      input.aspect_ratio = "match_input_image";
+    }
+    return input;
+  }
+  if (family === "wan27image" || family === "wan27imagepro") {
+    const input = { prompt: req.prompt, size: resolveWanSize(family, req) };
+    if (referenceImages.length > 0)
+      input.images = referenceImages;
+    return input;
+  }
+  return { prompt: req.prompt };
+}
+function extractOutputUrl(prediction) {
+  const output2 = prediction.output;
+  if (typeof output2 === "string")
+    return output2;
+  if (Array.isArray(output2)) {
+    if (output2.length !== 1) {
+      throw new Error(`Replicate returned ${output2.length} outputs, but kk image-gen currently supports saving exactly one image per request.`);
+    }
+    const first = output2[0];
+    if (typeof first === "string")
+      return first;
+  }
+  if (output2 !== null && typeof output2 === "object" && "url" in output2) {
+    const url2 = output2.url;
+    if (typeof url2 === "string")
+      return url2;
+  }
+  throw new Error(`Unexpected Replicate output format: ${JSON.stringify(output2)}`);
+}
+var createReplicate = (options) => {
+  const fetchFn = options?.fetch ?? fetch;
+  const env = options?.env ?? process.env;
+  const readEnv = (key) => env[key] ?? "";
+  async function downloadImage2(url2) {
+    const res = await fetchFn(url2);
+    if (!res.ok)
+      throw new Error(`Failed to download image from Replicate: ${res.status}`);
+    return new Uint8Array(await res.arrayBuffer());
+  }
+  async function pollPrediction(apiToken, getUrl) {
+    const start = Date.now();
+    while (Date.now() - start < MAX_POLL_MS) {
+      const res = await fetchFn(getUrl, { headers: { authorization: `Bearer ${apiToken}` } });
+      if (!res.ok)
+        throw new Error(`Replicate poll error (${res.status}): ${await res.text()}`);
+      const prediction = await res.json();
+      if (prediction.status === "succeeded")
+        return prediction;
+      if (prediction.status === "failed" || prediction.status === "canceled") {
+        throw new Error(`Replicate prediction ${prediction.status}: ${prediction.error ?? "unknown error"}`);
+      }
+      await new Promise((resolve3) => setTimeout(resolve3, POLL_INTERVAL_MS));
+    }
+    throw new Error(`Replicate prediction timed out after ${MAX_POLL_MS / 1000}s`);
+  }
+  return {
+    name: "replicate",
+    defaultModel: () => DEFAULT_MODEL11,
+    isAvailable: () => readEnv("REPLICATE_API_TOKEN") !== "",
+    supportsReferenceImages: () => true,
+    async generate(req) {
+      const apiToken = readEnv("REPLICATE_API_TOKEN");
+      if (apiToken === "") {
+        throw new Error("REPLICATE_API_TOKEN is required. Get one at https://replicate.com/account/api-tokens");
+      }
+      const model = parseModelId(req.model);
+      const refDataUrls = [];
+      for (const refPath of req.referenceImages ?? []) {
+        refDataUrls.push(await refToDataUri(refPath));
+      }
+      const input = buildInput({ ...req, referenceImages: refDataUrls });
+      const baseUrl = (readEnv("REPLICATE_BASE_URL") || "https://api.replicate.com").replace(/\/+$/g, "");
+      const url2 = model.version !== null ? `${baseUrl}/v1/predictions` : `${baseUrl}/v1/models/${model.owner}/${model.name}/predictions`;
+      const body = { input };
+      if (model.version !== null)
+        body.version = model.version;
+      const headers = {
+        authorization: `Bearer ${apiToken}`,
+        "content-type": "application/json",
+        Prefer: `wait=${SYNC_WAIT_SECONDS}`
+      };
+      let prediction = await (await fetchFn(url2, { method: "POST", headers, body: JSON.stringify(body) })).json();
+      if (prediction.status !== "succeeded") {
+        if (prediction.urls?.get === undefined)
+          throw new Error("Replicate prediction did not return a poll URL");
+        prediction = await pollPrediction(apiToken, prediction.urls.get);
+      }
+      const outputUrl = extractOutputUrl(prediction);
+      return {
+        bytes: await downloadImage2(outputUrl),
+        extension: extensionFromUrl(outputUrl),
+        provider: "replicate",
+        model: req.model
+      };
+    }
+  };
+};
+
+// ../../plugins/generations/image-gen/src/providers/zai.ts
+var GLM_MAX_PIXELS = 2 ** 22;
+var LEGACY_MAX_PIXELS = 2 ** 21;
+var GLM_SIZE_STEP = 32;
+var LEGACY_SIZE_STEP = 16;
+var GLM_RECOMMENDED_SIZES = {
+  "1:1": "1280x1280",
+  "3:2": "1568x1056",
+  "2:3": "1056x1568",
+  "4:3": "1472x1088",
+  "3:4": "1088x1472",
+  "16:9": "1728x960",
+  "9:16": "960x1728"
+};
+var LEGACY_RECOMMENDED_SIZES = {
+  "1:1": "1024x1024",
+  "9:16": "768x1344",
+  "3:4": "864x1152",
+  "16:9": "1344x768",
+  "4:3": "1152x864",
+  "2:1": "1440x720",
+  "1:2": "720x1440"
+};
+function buildZaiUrl(base) {
+  const cleaned = base.replace(/\/+$/g, "");
+  if (cleaned.endsWith("/images/generations"))
+    return cleaned;
+  if (cleaned.endsWith("/api/paas/v4") || cleaned.endsWith("/v4"))
+    return `${cleaned}/images/generations`;
+  return `${cleaned}/api/paas/v4/images/generations`;
+}
+function getModelFamily2(model) {
+  return model.trim().toLowerCase() === "glm-image" ? "glm" : "legacy";
+}
+function parseAspectRatio4(ar) {
+  const match = ar.match(/^(\d+(?:\.\d+)?):(\d+(?:\.\d+)?)$/);
+  if (match === null)
+    return null;
+  const width = Number(match[1]);
+  const height = Number(match[2]);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0)
+    return null;
+  return { width, height };
+}
+function parseSize2(size) {
+  const match = size.trim().match(/^(\d+)\s*[xX*]\s*(\d+)$/);
+  if (match === null)
+    return null;
+  const width = Number.parseInt(match[1], 10);
+  const height = Number.parseInt(match[2], 10);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0)
+    return null;
+  return { width, height };
+}
+function roundToStep2(value, step) {
+  return Math.max(step, Math.round(value / step) * step);
+}
+var DEFAULT_MODEL12 = "glm-image";
+function getRatioValue(ar) {
+  const parsed = parseAspectRatio4(ar);
+  return parsed === null ? null : parsed.width / parsed.height;
+}
+function findClosestRatioKey(ar, candidates) {
+  const targetRatio = getRatioValue(ar);
+  if (targetRatio === null)
+    return null;
+  let bestKey = null;
+  let bestDiff = Number.POSITIVE_INFINITY;
+  for (const candidate of candidates) {
+    const candidateRatio = getRatioValue(candidate);
+    if (candidateRatio === null)
+      continue;
+    const diff = Math.abs(candidateRatio - targetRatio);
+    if (diff < bestDiff) {
+      bestDiff = diff;
+      bestKey = candidate;
+    }
+  }
+  return bestDiff <= 0.05 ? bestKey : null;
+}
+function fitToPixelBudget2(width, height, targetPixels, maxPixels, step) {
+  let nextWidth = width;
+  let nextHeight = height;
+  const pixels = nextWidth * nextHeight;
+  const scaleTo = pixels > maxPixels ? maxPixels : targetPixels;
+  const scale = Math.sqrt(scaleTo / pixels);
+  nextWidth *= scale;
+  nextHeight *= scale;
+  let roundedWidth = roundToStep2(nextWidth, step);
+  let roundedHeight = roundToStep2(nextHeight, step);
+  let roundedPixels = roundedWidth * roundedHeight;
+  while (roundedPixels > maxPixels && (roundedWidth > step || roundedHeight > step)) {
+    if (roundedWidth >= roundedHeight && roundedWidth > step) {
+      roundedWidth -= step;
+    } else if (roundedHeight > step) {
+      roundedHeight -= step;
+    } else {
+      break;
+    }
+    roundedPixels = roundedWidth * roundedHeight;
+  }
+  return { width: roundedWidth, height: roundedHeight };
+}
+function resolveSizeForModel2(model, args) {
+  const family = getModelFamily2(model);
+  if (args.size !== undefined) {
+    const parsed = parseSize2(args.size);
+    if (parsed === null)
+      throw new Error("Z.AI --size must be in WxH format, for example 1280x1280.");
+    const widthStep = family === "glm" ? GLM_SIZE_STEP : LEGACY_SIZE_STEP;
+    const minEdge = family === "glm" ? 1024 : 512;
+    const maxPixels2 = family === "glm" ? GLM_MAX_PIXELS : LEGACY_MAX_PIXELS;
+    if (parsed.width < minEdge || parsed.width > 2048 || parsed.height < minEdge || parsed.height > 2048) {
+      throw new Error(family === "glm" ? "GLM-image custom size requires width and height between 1024 and 2048." : "Z.AI legacy image models require width and height between 512 and 2048.");
+    }
+    if (parsed.width % widthStep !== 0 || parsed.height % widthStep !== 0) {
+      throw new Error(family === "glm" ? "GLM-image custom size requires width and height divisible by 32." : "Z.AI legacy image models require width and height divisible by 16.");
+    }
+    if (parsed.width * parsed.height > maxPixels2) {
+      throw new Error(family === "glm" ? "GLM-image custom size must not exceed 2^22 total pixels." : "Z.AI legacy image size must not exceed 2^21 total pixels.");
+    }
+    return `${parsed.width}x${parsed.height}`;
+  }
+  const recommended = family === "glm" ? GLM_RECOMMENDED_SIZES : LEGACY_RECOMMENDED_SIZES;
+  const defaultSize = family === "glm" ? "1280x1280" : "1024x1024";
+  if (args.aspectRatio === undefined)
+    return defaultSize;
+  const recommendedRatio = findClosestRatioKey(args.aspectRatio, Object.keys(recommended));
+  if (recommendedRatio !== null) {
+    return recommended[recommendedRatio];
+  }
+  const parsedRatio = parseAspectRatio4(args.aspectRatio);
+  if (parsedRatio === null)
+    return defaultSize;
+  const targetPixels = args.quality === "normal" ? 1024 * 1024 : 1536 * 1536;
+  const maxPixels = family === "glm" ? GLM_MAX_PIXELS : LEGACY_MAX_PIXELS;
+  const step = family === "glm" ? GLM_SIZE_STEP : LEGACY_SIZE_STEP;
+  const fit = fitToPixelBudget2(parsedRatio.width, parsedRatio.height, targetPixels, maxPixels, step);
+  return `${fit.width}x${fit.height}`;
+}
+var createZai = (options) => {
+  const fetchFn = options?.fetch ?? fetch;
+  const env = options?.env ?? process.env;
+  const readEnv = (key) => env[key] ?? "";
+  return {
+    name: "zai",
+    defaultModel: () => DEFAULT_MODEL12,
+    isAvailable: () => (readEnv("ZAI_API_KEY") || readEnv("BIGMODEL_API_KEY")) !== "",
+    supportsReferenceImages: () => false,
+    validate(req) {
+      if ((req.referenceImages?.length ?? 0) > 0) {
+        throw new Error("Z.AI GLM-image currently supports text-to-image only in kk image-gen. Remove --ref or choose another provider.");
+      }
+    },
+    async generate(req) {
+      const refs = req.referenceImages ?? [];
+      if (refs.length > 0) {
+        throw new Error("Z.AI GLM-image currently supports text-to-image only in kk image-gen. Remove --ref or choose another provider.");
+      }
+      const apiKey = readEnv("ZAI_API_KEY") || readEnv("BIGMODEL_API_KEY");
+      if (apiKey === "")
+        throw new Error("ZAI_API_KEY is required. Get one from https://docs.z.ai/.");
+      const size = resolveSizeForModel2(req.model, {
+        size: req.width !== undefined && req.height !== undefined ? `${req.width}x${req.height}` : undefined,
+        aspectRatio: req.aspectRatio,
+        quality: req.quality
+      });
+      const base = readEnv("ZAI_BASE_URL") || readEnv("BIGMODEL_BASE_URL") || "https://api.z.ai/api/paas/v4";
+      const response = await fetchFn(buildZaiUrl(base), {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${apiKey}` },
+        body: JSON.stringify({
+          model: req.model,
+          prompt: req.prompt,
+          quality: req.quality === "normal" ? "standard" : "hd",
+          size
+        })
+      });
+      if (!response.ok)
+        throw new Error(`Z.AI API error (${response.status}): ${await response.text()}`);
+      const url2 = (await response.json()).data?.[0]?.url;
+      if (url2 === undefined)
+        throw new Error("No image URL in Z.AI response");
+      const imageResponse = await fetchFn(url2);
+      if (!imageResponse.ok)
+        throw new Error(`Failed to download image from Z.AI: ${imageResponse.status}`);
+      return {
+        bytes: new Uint8Array(await imageResponse.arrayBuffer()),
+        extension: "png",
+        provider: "zai",
+        model: req.model
+      };
+    }
+  };
+};
+
+// ../../plugins/generations/image-gen/src/providers/types.ts
+var IMAGE_GEN_PROVIDER_ENV = "IMAGE_GEN_PROVIDER";
+var NEVER_AUTO = new Set(["codex-cli"]);
 var PROVIDERS = {
-  agnes: defineProvider({
+  agnes: {
     name: "agnes",
     env: ["AGNES_API_KEY"],
-    defaultModel: "agnes-image-2.1-flash"
-  }),
-  azure: defineProvider({
+    defaultModel: "agnes-image-2.1-flash",
+    create: createAgnes
+  },
+  azure: {
     name: "azure",
     env: ["AZURE_OPENAI_API_KEY"],
-    defaultModel: "gpt-image-2"
-  }),
-  "codex-cli": defineProvider({
+    defaultModel: "gpt-image-2",
+    create: createAzure
+  },
+  "codex-cli": {
     name: "codex-cli",
     env: [],
     defaultModel: "codex-image-gen",
-    note: "requires the 'codex' CLI on PATH with an active login (never auto-selected)"
-  }),
-  dashscope: defineProvider({
+    note: "requires the 'codex' CLI on PATH with an active login (never auto-selected)",
+    create: createCodexCli
+  },
+  dashscope: {
     name: "dashscope",
     env: ["DASHSCOPE_API_KEY"],
     defaultModel: "qwen-image-2.0-pro",
-    refModels: ["wan2.7"]
-  }),
-  google: defineProvider({
+    refModels: ["wan2.7"],
+    create: createDashscope
+  },
+  google: {
     name: "google",
     env: ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
     defaultModel: "gemini-3-pro-image",
@@ -22271,35 +24500,47 @@ var PROVIDERS = {
       "gemini-3-pro-image-preview",
       "gemini-3-flash-preview",
       "gemini-3.1-flash-image-preview"
-    ]
-  }),
-  jimeng: defineProvider({
+    ],
+    create: createGoogle
+  },
+  huggingface: {
+    name: "huggingface",
+    env: ["HUGGINGFACE_API_TOKEN"],
+    defaultModel: "stabilityai/stable-diffusion-xl-base-1.0",
+    create: createHuggingface
+  },
+  jimeng: {
     name: "jimeng",
     env: [],
     envAll: ["JIMENG_ACCESS_KEY_ID", "JIMENG_SECRET_ACCESS_KEY"],
-    defaultModel: "jimeng_t2i_v40"
-  }),
-  minimax: defineProvider({
+    defaultModel: "jimeng_t2i_v40",
+    create: createJimeng
+  },
+  minimax: {
     name: "minimax",
     env: ["MINIMAX_API_KEY"],
-    defaultModel: "image-01"
-  }),
-  openai: defineProvider({
+    defaultModel: "image-01",
+    create: createMinimax
+  },
+  openai: {
     name: "openai",
     env: ["OPENAI_API_KEY"],
     defaultModel: "gpt-image-2",
-    refModels: ["gpt-image"]
-  }),
-  openrouter: defineProvider({
+    refModels: ["gpt-image"],
+    create: createOpenai
+  },
+  openrouter: {
     name: "openrouter",
     env: ["OPENROUTER_API_KEY"],
-    defaultModel: "google/gemini-3.1-flash-image"
-  }),
-  replicate: defineProvider({
+    defaultModel: "google/gemini-3.1-flash-image",
+    create: createOpenrouter
+  },
+  replicate: {
     name: "replicate",
     env: ["REPLICATE_API_TOKEN"],
-    defaultModel: "google/nano-banana-2"
-  }),
+    defaultModel: "google/nano-banana-2",
+    create: createReplicate
+  },
   seedream: {
     name: "seedream",
     env: ["ARK_API_KEY"],
@@ -22307,14 +24548,16 @@ var PROVIDERS = {
     refModels: ["doubao-seedream-5-0", "doubao-seedream-4-5-", "doubao-seedream-4-0-"],
     create: createSeedream
   },
-  zai: defineProvider({
+  zai: {
     name: "zai",
     env: ["ZAI_API_KEY", "BIGMODEL_API_KEY"],
     defaultModel: "glm-image",
-    refModels: []
-  })
+    refModels: [],
+    create: createZai
+  }
 };
 var AUTO_ORDER = [
+  "huggingface",
   "google",
   "openai",
   "replicate",