imageforge-mcp 0.4.0 → 0.6.0

package/dist/externalProviders.js

@@ -0,0 +1,891 @@
+import { createHmac } from "node:crypto";
+import { z } from "zod";
+import { loadRemoteImage } from "./imageInput.js";
+export const EXTERNAL_PROVIDER_IDS = [
+    "google",
+    "xai",
+    "stability",
+    "ideogram",
+    "recraft",
+    "tencent",
+    "baidu",
+    "playground",
+    "bfl",
+    "luma",
+    "krea",
+    "runway",
+    "leonardo",
+    "bria",
+    "freepik",
+    "alibaba",
+    "volcengine",
+    "kling",
+    "hidream",
+];
+const definitions = [
+    {
+        id: "google", name: "Google Gemini", docsUrl: "https://ai.google.dev/gemini-api/docs/image-generation",
+        baseUrl: "https://generativelanguage.googleapis.com/v1beta", baseUrlEnv: "GOOGLE_BASE_URL",
+        apiKeyEnv: "GOOGLE_API_KEY", modelEnv: "GOOGLE_IMAGE_MODEL", defaultModel: "gemini-3.1-flash-image",
+        models: ["gemini-3.1-flash-image", "gemini-3.1-flash-lite-image"],
+        referenceModes: ["auto", "content", "style"], maxReferences: 14, async: false,
+    },
+    {
+        id: "xai", name: "xAI", docsUrl: "https://docs.x.ai/developers/model-capabilities/images/generation",
+        baseUrl: "https://api.x.ai/v1", baseUrlEnv: "XAI_BASE_URL", apiKeyEnv: "XAI_API_KEY",
+        modelEnv: "XAI_IMAGE_MODEL", defaultModel: "grok-imagine-image-2.0", models: ["grok-imagine-image-2.0"],
+        referenceModes: ["auto", "content"], maxReferences: 1, async: false,
+    },
+    {
+        id: "stability", name: "Stability AI", docsUrl: "https://platform.stability.ai/docs/api-reference",
+        baseUrl: "https://api.stability.ai", baseUrlEnv: "STABILITY_BASE_URL", apiKeyEnv: "STABILITY_API_KEY",
+        modelEnv: "STABILITY_IMAGE_MODEL", defaultModel: "stable-image-ultra",
+        models: ["stable-image-ultra", "stable-image-core", "sd3.5-large", "sd3.5-large-turbo", "sd3.5-medium", "sd3.5-flash"],
+        referenceModes: ["auto", "content"], maxReferences: 1, async: false,
+    },
+    {
+        id: "ideogram", name: "Ideogram", docsUrl: "https://developer.ideogram.ai/api-reference/api-reference/generate-v4",
+        baseUrl: "https://api.ideogram.ai", baseUrlEnv: "IDEOGRAM_BASE_URL", apiKeyEnv: "IDEOGRAM_API_KEY",
+        modelEnv: "IDEOGRAM_IMAGE_MODEL", defaultModel: "ideogram-v4", models: ["ideogram-v4", "p-image-ideogram", "ideogram-v3"],
+        referenceModes: ["character", "style"], maxReferences: 5, async: false,
+    },
+    {
+        id: "recraft", name: "Recraft", docsUrl: "https://www.recraft.ai/docs/api-reference/endpoints",
+        baseUrl: "https://external.api.recraft.ai/v1", baseUrlEnv: "RECRAFT_BASE_URL", apiKeyEnv: "RECRAFT_API_KEY",
+        modelEnv: "RECRAFT_IMAGE_MODEL", defaultModel: "recraftv4_1",
+        models: ["recraftv4_1", "recraftv4_1_pro", "recraftv4_1_utility", "recraftv4_1_utility_pro", "recraftv4", "recraftv4_pro", "recraftv4_styles", "recraftv4_styles_pro", "recraftv3", "recraftv2"],
+        referenceModes: ["style"], maxReferences: 5, async: false,
+    },
+    {
+        id: "tencent", name: "Tencent Hunyuan", docsUrl: "https://cloud.tencent.com/document/product/1823/135745",
+        baseUrl: "https://tokenhub.tencentmaas.com", baseUrlEnv: "TENCENT_BASE_URL", apiKeyEnv: "TENCENT_API_KEY",
+        modelEnv: "TENCENT_IMAGE_MODEL", defaultModel: "hy-image-v3", models: ["hy-image-v3"],
+        referenceModes: ["auto", "content", "character"], maxReferences: 3, async: false,
+    },
+    {
+        id: "baidu", name: "Baidu Qianfan", docsUrl: "https://cloud.baidu.com/doc/qianfan-api/s/8m7u6un8a",
+        baseUrl: "https://qianfan.baidubce.com", baseUrlEnv: "BAIDU_BASE_URL", apiKeyEnv: "BAIDU_API_KEY",
+        modelEnv: "BAIDU_IMAGE_MODEL", defaultModel: "ernie-image", models: ["ernie-image"],
+        referenceModes: ["auto", "content"], maxReferences: 1, async: false,
+    },
+    {
+        id: "playground", name: "Playground AI", docsUrl: "https://docs.playground.com/reference/image-generation",
+        baseUrl: "https://playground.com", baseUrlEnv: "PLAYGROUND_BASE_URL", apiKeyEnv: "PLAYGROUND_API_KEY",
+        modelEnv: "PLAYGROUND_IMAGE_MODEL", defaultModel: "Playground_v3",
+        models: ["Playground_v3", "Playground_v2.5", "Photorealism"],
+        referenceModes: ["auto", "content"], maxReferences: 1, async: false,
+    },
+    {
+        id: "bfl", name: "Black Forest Labs", docsUrl: "https://docs.bfl.ai/flux_2/flux2_overview",
+        baseUrl: "https://api.bfl.ai", baseUrlEnv: "BFL_BASE_URL", apiKeyEnv: "BFL_API_KEY",
+        modelEnv: "BFL_IMAGE_MODEL", defaultModel: "flux-2-pro",
+        models: ["flux-2-max", "flux-2-pro", "flux-2-flex", "flux-2-klein-4b", "flux-2-klein-9b"],
+        referenceModes: ["auto", "content", "style", "character"], maxReferences: 8, async: true,
+    },
+    {
+        id: "luma", name: "Luma", docsUrl: "https://docs.agents.lumalabs.ai/guides/images/generation/",
+        baseUrl: "https://agents.lumalabs.ai/v1", baseUrlEnv: "LUMA_BASE_URL", apiKeyEnv: "LUMA_AGENTS_API_KEY",
+        modelEnv: "LUMA_IMAGE_MODEL", defaultModel: "uni-1", models: ["uni-1", "uni-1-max"],
+        referenceModes: ["auto", "content", "style"], maxReferences: 9, async: true,
+    },
+    {
+        id: "krea", name: "Krea", docsUrl: "https://www.krea.ai/docs/developers/krea-2/overview",
+        baseUrl: "https://api.krea.ai", baseUrlEnv: "KREA_BASE_URL", apiKeyEnv: "KREA_API_KEY",
+        modelEnv: "KREA_IMAGE_MODEL", defaultModel: "krea-2/medium",
+        models: ["krea-2/medium", "krea-2/large", "krea-2/medium-turbo"],
+        referenceModes: ["style"], maxReferences: 4, async: true,
+    },
+    {
+        id: "runway", name: "Runway", docsUrl: "https://docs.dev.runwayml.com/api/",
+        baseUrl: "https://api.dev.runwayml.com", baseUrlEnv: "RUNWAY_BASE_URL", apiKeyEnv: "RUNWAY_API_KEY",
+        modelEnv: "RUNWAY_IMAGE_MODEL", defaultModel: "gen4_image", models: ["gen4_image", "gen4_image_turbo"],
+        referenceModes: ["auto", "content", "style"], maxReferences: 3, async: true,
+    },
+    {
+        id: "leonardo", name: "Leonardo", docsUrl: "https://docs.leonardo.ai/reference/creategeneration-1",
+        baseUrl: "https://cloud.leonardo.ai/api/rest/v2", baseUrlEnv: "LEONARDO_BASE_URL", apiKeyEnv: "LEONARDO_API_KEY",
+        modelEnv: "LEONARDO_IMAGE_MODEL", defaultModel: "phoenix-v1.0",
+        models: ["phoenix-v1.0", "phoenix-v0.9", "lucid-origin", "lucid-realism"],
+        referenceModes: ["auto", "content", "style", "character"], maxReferences: 4, async: true,
+    },
+    {
+        id: "bria", name: "Bria", docsUrl: "https://docs.bria.ai/image-generation/v2-endpoints/image-generate",
+        baseUrl: "https://engine.prod.bria-api.com/v2", baseUrlEnv: "BRIA_BASE_URL", apiKeyEnv: "BRIA_API_KEY",
+        modelEnv: "BRIA_IMAGE_MODEL", defaultModel: "fibo", models: ["fibo", "fibo-lite"],
+        referenceModes: ["auto", "content", "style"], maxReferences: 1, async: true,
+    },
+    {
+        id: "freepik", name: "Freepik Mystic", docsUrl: "https://docs.freepik.com/api-reference/mystic/post-mystic",
+        baseUrl: "https://api.magnific.com", baseUrlEnv: "FREEPIK_BASE_URL", apiKeyEnv: "FREEPIK_API_KEY",
+        modelEnv: "FREEPIK_IMAGE_MODEL", defaultModel: "realism",
+        models: ["realism", "fluid", "zen", "flexible", "super_real", "editorial_portraits"],
+        referenceModes: ["content", "style"], maxReferences: 1, async: true,
+    },
+    {
+        id: "alibaba", name: "Alibaba Model Studio", docsUrl: "https://www.alibabacloud.com/help/en/model-studio/qwen-image-api",
+        baseUrl: "https://dashscope-intl.aliyuncs.com", baseUrlEnv: "ALIBABA_BASE_URL", apiKeyEnv: "ALIBABA_API_KEY",
+        modelEnv: "ALIBABA_IMAGE_MODEL", defaultModel: "qwen-image-3.0-pro",
+        models: ["qwen-image-3.0-pro", "qwen-image-3.0", "wan2.7-image-pro", "wan2.7-image"],
+        referenceModes: ["auto", "content", "style", "character"], maxReferences: 9, async: true,
+    },
+    {
+        id: "volcengine", name: "Volcengine Ark", docsUrl: "https://docs.volcengine.com/docs/82379/1541523",
+        baseUrl: "https://ark.cn-beijing.volces.com/api/v3", baseUrlEnv: "VOLCENGINE_BASE_URL", apiKeyEnv: "VOLCENGINE_API_KEY",
+        modelEnv: "VOLCENGINE_IMAGE_MODEL", defaultModel: "doubao-seedream-5-0-pro-260628",
+        models: ["doubao-seedream-5-0-pro-260628", "doubao-seedream-4-5-250815", "doubao-seedream-4-0-250828"],
+        referenceModes: ["auto", "content", "style", "character"], maxReferences: 10, async: false,
+    },
+    {
+        id: "kling", name: "Kling AI", docsUrl: "https://app.klingai.com/global/dev/document-api/quickStart/userManual",
+        baseUrl: "https://api.klingai.com", baseUrlEnv: "KLING_BASE_URL", apiKeyEnv: "KLING_ACCESS_KEY",
+        modelEnv: "KLING_IMAGE_MODEL", defaultModel: "kling-v3", models: ["kling-v3", "kling-v2-1"],
+        referenceModes: ["auto", "content", "style", "character"], maxReferences: 4, async: true,
+    },
+    {
+        id: "hidream", name: "HiDream", docsUrl: "https://hidreamai.com/doc/txt2img/request",
+        baseUrl: "https://www.hidreamai.com", baseUrlEnv: "HIDREAM_BASE_URL", apiKeyEnv: "HIDREAM_API_TOKEN",
+        modelEnv: "HIDREAM_IMAGE_MODEL", defaultModel: "v2L", models: ["v2L", "v2.1-standard"],
+        referenceModes: ["auto", "content"], maxReferences: 4, async: true,
+    },
+];
+const definitionMap = new Map(definitions.map((definition) => [definition.id, definition]));
+export function isExternalProvider(value) {
+    return definitionMap.has(value);
+}
+export function externalProviderDefinitions() {
+    return definitions;
+}
+function firstValue(...values) {
+    return values.map((value) => value?.trim()).find(Boolean);
+}
+function normalizeBaseUrl(value) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new Error("base_url must be a valid absolute HTTP(S) URL.");
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("base_url must use HTTP or HTTPS.");
+    }
+    return value.replace(/\/+$/, "");
+}
+export function resolveExternalConfig(input) {
+    const definition = definitionMap.get(input.provider);
+    if (input.provider === "kling" && input.apiKey) {
+        throw new Error("Kling credentials must use KLING_ACCESS_KEY and KLING_SECRET_KEY environment variables.");
+    }
+    const apiKey = firstValue(input.apiKey, process.env[definition.apiKeyEnv]);
+    if (!apiKey)
+        throw new Error(`Missing ${definition.name} API credential: set ${definition.apiKeyEnv}.`);
+    if (input.provider === "kling" && !firstValue(process.env.KLING_SECRET_KEY)) {
+        throw new Error("Missing Kling API credential: set KLING_SECRET_KEY.");
+    }
+    const model = firstValue(input.model, process.env[definition.modelEnv], definition.defaultModel);
+    if (!definition.models.includes(model)) {
+        throw new Error(`Unsupported ${definition.name} model '${model}'. Supported models: ${definition.models.join(", ")}.`);
+    }
+    return {
+        provider: input.provider,
+        apiKey,
+        model,
+        baseUrl: normalizeBaseUrl(firstValue(input.baseUrl, process.env[definition.baseUrlEnv], definition.baseUrl)),
+    };
+}
+function parseSize(size) {
+    const match = /^(\d+)x(\d+)$/.exec(size);
+    if (!match)
+        throw new Error("size must use WIDTHxHEIGHT, for example 1024x1024.");
+    const width = Number(match[1]);
+    const height = Number(match[2]);
+    if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width < 1 || height < 1) {
+        throw new Error("size width and height must be positive safe integers.");
+    }
+    return { width, height };
+}
+function gcd(a, b) {
+    return b === 0 ? a : gcd(b, a % b);
+}
+function ratioFor(input) {
+    if (input.aspectRatio)
+        return input.aspectRatio;
+    const { width, height } = parseSize(input.size);
+    const divisor = gcd(width, height);
+    return `${width / divisor}:${height / divisor}`;
+}
+function dataUri(image) {
+    return `data:${image.mimeType};base64,${image.data.toString("base64")}`;
+}
+function validateReferences(input, definition) {
+    const count = input.inputImages?.length ?? 0;
+    if (count > definition.maxReferences) {
+        throw new Error(`${definition.name} supports at most ${definition.maxReferences} reference image${definition.maxReferences === 1 ? "" : "s"}.`);
+    }
+    if (count === 0)
+        return;
+    const mode = input.referenceMode ?? "auto";
+    if (!definition.referenceModes.includes(mode)) {
+        throw new Error(`${definition.name} does not support reference_mode '${mode}'. Supported modes: ${definition.referenceModes.join(", ")}.`);
+    }
+    if (mode === "auto" && !definition.referenceModes.includes("auto")) {
+        throw new Error(`${definition.name} requires an explicit reference_mode: ${definition.referenceModes.join(" or ")}.`);
+    }
+}
+function validateCommonOptions(input) {
+    const provider = input.config.provider;
+    if (input.quality !== "auto") {
+        const ideogramQuality = provider === "ideogram" && input.config.model === "p-image-ideogram";
+        if (provider !== "xai" && !ideogramQuality) {
+            throw new Error(`${definitionMap.get(provider).name} does not expose the common quality option; choose a provider model tier instead.`);
+        }
+        if (provider === "xai" && !new Set(["low", "medium"]).has(input.quality)) {
+            throw new Error("xAI quality must be auto, low, or medium.");
+        }
+        if (ideogramQuality && !new Set(["low", "medium", "high"]).has(input.quality)) {
+            throw new Error("Ideogram P-Image quality must be auto, low, medium, or high.");
+        }
+    }
+    if (input.outputFormat === "webp" && new Set(["luma", "runway", "bria", "freepik", "alibaba", "kling", "hidream"]).has(provider)) {
+        throw new Error(`${definitionMap.get(provider).name} does not support WebP output.`);
+    }
+    if (provider === "freepik" && input.outputFormat && input.outputFormat !== "png") {
+        throw new Error("Freepik Mystic output_format must be png.");
+    }
+    if (provider === "runway" && input.config.model === "gen4_image_turbo" && !input.inputImages?.length) {
+        throw new Error("Runway gen4_image_turbo requires at least one reference image.");
+    }
+    if (input.negativePrompt) {
+        const supportsNegative = new Set([
+            "stability", "playground", "baidu", "leonardo", "bria", "alibaba", "hidream",
+        ]);
+        const modelSupportsNegative = provider === "ideogram" && input.config.model === "ideogram-v3"
+            || provider === "recraft" && new Set(["recraftv3", "recraftv2"]).has(input.config.model);
+        if (!supportsNegative.has(provider) && !modelSupportsNegative) {
+            throw new Error(`${definitionMap.get(provider).name} model ${input.config.model} does not support negative_prompt.`);
+        }
+    }
+    if (input.seed !== undefined) {
+        const supportsSeed = new Set([
+            "stability", "ideogram", "recraft", "tencent", "baidu", "playground", "bfl", "krea",
+            "runway", "leonardo", "bria", "alibaba", "volcengine", "kling",
+        ]);
+        if (!supportsSeed.has(provider)) {
+            throw new Error(`${definitionMap.get(provider).name} does not support the common seed option.`);
+        }
+    }
+}
+function detectMimeType(data) {
+    if (data.length >= 8 && data.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])))
+        return "image/png";
+    if (data.length >= 3 && data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff)
+        return "image/jpeg";
+    if (data.length >= 12 && data.subarray(0, 4).toString("ascii") === "RIFF" && data.subarray(8, 12).toString("ascii") === "WEBP")
+        return "image/webp";
+    return undefined;
+}
+function decodeImage(value, label) {
+    const encoded = value.startsWith("data:") ? value.slice(value.indexOf(",") + 1) : value;
+    const normalized = encoded.replace(/\s+/g, "");
+    if (!normalized || !/^[A-Za-z0-9+/]+={0,2}$/.test(normalized))
+        return undefined;
+    const data = Buffer.from(normalized, "base64");
+    if (data.length === 0 || data.length > 50 * 1024 * 1024)
+        return undefined;
+    const mimeType = detectMimeType(data);
+    if (!mimeType)
+        return undefined;
+    if (data.toString("base64").replace(/=+$/, "") !== normalized.replace(/=+$/, "")) {
+        throw new Error(`${label} response contained invalid base64 image data.`);
+    }
+    return { data, mimeType };
+}
+const urlSchema = z.string().url();
+function findImageValue(value, key = "") {
+    if (typeof value === "string") {
+        if (/poll|status|task|webhook/i.test(key))
+            return undefined;
+        if (/^(https?:\/\/)/.test(value) && urlSchema.safeParse(value).success)
+            return { url: value };
+        if (/base64|b64|image/i.test(key) || value.startsWith("data:image/"))
+            return { base64: value };
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const found = findImageValue(item, key);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    if (value && typeof value === "object") {
+        const entries = Object.entries(value);
+        const priority = entries.sort(([a], [b]) => Number(/url|image|sample|output|base64|b64/i.test(b)) - Number(/url|image|sample|output|base64|b64/i.test(a)));
+        for (const [childKey, childValue] of priority) {
+            const found = findImageValue(childValue, childKey);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+async function imageFromPayload(payload, label, fetchImpl) {
+    const found = findImageValue(payload);
+    if (!found)
+        return undefined;
+    if (found.base64) {
+        const decoded = decodeImage(found.base64, label);
+        if (decoded)
+            return decoded;
+    }
+    if (found.url) {
+        const downloaded = await loadRemoteImage(found.url, fetchImpl, undefined, undefined, false);
+        return { data: downloaded.data, mimeType: downloaded.mimeType };
+    }
+    return undefined;
+}
+async function jsonResponse(response, label) {
+    if (!response.ok) {
+        const detail = (await response.text()).slice(0, 500);
+        throw new Error(`${label} image request failed (${response.status}): ${detail || response.statusText}`);
+    }
+    try {
+        return await response.json();
+    }
+    catch {
+        throw new Error(`${label} image response was not valid JSON.`);
+    }
+}
+function bearer(key) {
+    return { authorization: `Bearer ${key}`, "content-type": "application/json" };
+}
+async function requestGoogle(input) {
+    const parts = [{ text: input.prompt }];
+    for (const image of input.inputImages ?? []) {
+        parts.push({ inlineData: { mimeType: image.mimeType, data: image.data.toString("base64") } });
+    }
+    const body = {
+        contents: [{ role: "user", parts }],
+        generationConfig: {
+            responseModalities: ["TEXT", "IMAGE"],
+            imageConfig: { aspectRatio: ratioFor(input), ...(input.resolution ? { imageSize: input.resolution } : {}) },
+        },
+    };
+    const response = await (input.fetchImpl ?? fetch)(`${input.config.baseUrl}/models/${input.config.model}:generateContent`, {
+        method: "POST",
+        headers: { "x-goog-api-key": input.config.apiKey, "content-type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(120_000),
+    });
+    const payload = await jsonResponse(response, "Google Gemini");
+    const googleImage = z.object({
+        candidates: z.array(z.object({
+            content: z.object({
+                parts: z.array(z.object({
+                    inlineData: z.object({ data: z.string() }).optional(),
+                }).passthrough()),
+            }),
+        })).min(1),
+    }).safeParse(payload);
+    const inlineData = googleImage.success
+        ? googleImage.data.candidates.flatMap((candidate) => candidate.content.parts)
+            .map((part) => part.inlineData?.data).find(Boolean)
+        : undefined;
+    if (inlineData) {
+        const decoded = decodeImage(inlineData, "Google Gemini");
+        if (decoded)
+            return decoded;
+    }
+    const image = await imageFromPayload(payload, "Google Gemini", input.downloadFetchImpl ?? input.fetchImpl ?? fetch);
+    if (!image)
+        throw new Error("Google Gemini image response contained no valid image data.");
+    return image;
+}
+async function requestXai(input) {
+    const hasReferences = Boolean(input.inputImages?.length);
+    const body = {
+        model: input.config.model,
+        prompt: input.prompt,
+        n: 1,
+        aspect_ratio: input.aspectRatio ?? ratioFor(input),
+        resolution: input.resolution?.toLowerCase() ?? "1k",
+        response_format: "b64_json",
+    };
+    if (input.quality !== "auto")
+        body.quality = input.quality;
+    if (hasReferences) {
+        body.image = { url: dataUri(input.inputImages[0]), type: "image_url" };
+    }
+    const response = await (input.fetchImpl ?? fetch)(`${input.config.baseUrl}/images/${hasReferences ? "edits" : "generations"}`, {
+        method: "POST", headers: bearer(input.config.apiKey), body: JSON.stringify(body), signal: AbortSignal.timeout(120_000),
+    });
+    const payload = await jsonResponse(response, "xAI");
+    const image = await imageFromPayload(payload, "xAI", input.downloadFetchImpl ?? input.fetchImpl ?? fetch);
+    if (!image)
+        throw new Error("xAI image response contained no valid image data.");
+    return image;
+}
+async function requestStability(input) {
+    const form = new FormData();
+    form.append("prompt", input.prompt);
+    form.append("output_format", input.outputFormat ?? "png");
+    form.append("aspect_ratio", ratioFor(input));
+    if (input.negativePrompt)
+        form.append("negative_prompt", input.negativePrompt);
+    if (input.seed !== undefined)
+        form.append("seed", String(input.seed));
+    if (input.inputImages?.[0]) {
+        const image = input.inputImages[0];
+        form.append("image", new Blob([new Uint8Array(image.data)], { type: image.mimeType }), image.fileName);
+        form.append("strength", "0.7");
+    }
+    let path;
+    if (input.config.model === "stable-image-ultra")
+        path = "/v2beta/stable-image/generate/ultra";
+    else if (input.config.model === "stable-image-core")
+        path = "/v2beta/stable-image/generate/core";
+    else {
+        path = "/v2beta/stable-image/generate/sd3";
+        form.append("model", input.config.model);
+    }
+    const response = await (input.fetchImpl ?? fetch)(`${input.config.baseUrl}${path}`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${input.config.apiKey}`, accept: "application/json" },
+        body: form,
+        signal: AbortSignal.timeout(120_000),
+    });
+    const payload = await jsonResponse(response, "Stability AI");
+    const image = await imageFromPayload(payload, "Stability AI", input.downloadFetchImpl ?? input.fetchImpl ?? fetch);
+    if (!image)
+        throw new Error("Stability AI image response contained no valid image data.");
+    return image;
+}
+async function requestIdeogram(input) {
+    if (input.config.model !== "ideogram-v3" && input.inputImages?.length) {
+        throw new Error(`${input.config.model} generation does not support reference_images; use ideogram-v3.`);
+    }
+    const form = new FormData();
+    const isV4 = input.config.model === "ideogram-v4";
+    const isPImage = input.config.model === "p-image-ideogram";
+    form.append(isV4 ? "text_prompt" : "prompt", input.prompt);
+    if (isV4)
+        form.append("resolution", input.size);
+    else
+        form.append("aspect_ratio", ratioFor(input).replace(":", "x"));
+    if (isPImage)
+        form.append("resolution", input.resolution ?? "1K");
+    if (isPImage && input.quality !== "auto")
+        form.append("quality", input.quality.toUpperCase());
+    if (!isV4 && input.negativePrompt)
+        form.append("negative_prompt", input.negativePrompt);
+    if (!isV4 && input.seed !== undefined)
+        form.append("seed", String(input.seed));
+    const field = input.referenceMode === "character" ? "character_reference_images" : "style_reference_images";
+    for (const image of input.inputImages ?? []) {
+        form.append(field, new Blob([new Uint8Array(image.data)], { type: image.mimeType }), image.fileName);
+    }
+    const endpoint = isPImage ? "/v1/text-to-image/p-image-ideogram" : `/v1/ideogram-${isV4 ? "v4" : "v3"}/generate`;
+    const response = await (input.fetchImpl ?? fetch)(`${input.config.baseUrl}${endpoint}`, {
+        method: "POST", headers: { "api-key": input.config.apiKey }, body: form, signal: AbortSignal.timeout(120_000),
+    });
+    const payload = await jsonResponse(response, "Ideogram");
+    const image = await imageFromPayload(payload, "Ideogram", input.downloadFetchImpl ?? input.fetchImpl ?? fetch);
+    if (!image)
+        throw new Error("Ideogram image response contained no valid image data.");
+    return image;
+}
+async function requestRecraft(input) {
+    const body = {
+        model: input.config.model,
+        prompt: input.prompt,
+        n: 1,
+        size: input.size,
+        response_format: "b64_json",
+    };
+    if (input.seed !== undefined)
+        body.random_seed = input.seed;
+    if (input.negativePrompt)
+        body.negative_prompt = input.negativePrompt;
+    if (input.inputImages?.length)
+        body.style_reference_urls = input.inputImages.map(dataUri);
+    const response = await (input.fetchImpl ?? fetch)(`${input.config.baseUrl}/images/generations`, {
+        method: "POST", headers: bearer(input.config.apiKey), body: JSON.stringify(body), signal: AbortSignal.timeout(120_000),
+    });
+    const payload = await jsonResponse(response, "Recraft");
+    const image = await imageFromPayload(payload, "Recraft", input.downloadFetchImpl ?? input.fetchImpl ?? fetch);
+    if (!image)
+        throw new Error("Recraft image response contained no valid image data.");
+    return image;
+}
+async function requestTencent(input) {
+    const body = { model: input.config.model, prompt: input.prompt, size: input.size, n: 1 };
+    if (input.inputImages?.length)
+        body.images = input.inputImages.map(dataUri);
+    if (input.seed !== undefined)
+        body.seed = input.seed;
+    if (input.watermarkEnabled)
+        body.footnote = "AI generated";
+    const response = await (input.fetchImpl ?? fetch)(`${input.config.baseUrl}/v1/wand/hunyuan-image/v3-generation`, {
+        method: "POST", headers: bearer(input.config.apiKey), body: JSON.stringify(body), signal: AbortSignal.timeout(120_000),
+    });
+    const payload = await jsonResponse(response, "Tencent Hunyuan");
+    const image = await imageFromPayload(payload, "Tencent Hunyuan", input.downloadFetchImpl ?? input.fetchImpl ?? fetch);
+    if (!image)
+        throw new Error("Tencent Hunyuan image response contained no valid image data.");
+    return image;
+}
+async function requestBaidu(input) {
+    const body = { model: input.config.model, prompt: input.prompt, n: 1, size: input.size };
+    if (input.negativePrompt)
+        body.negative_prompt = input.negativePrompt;
+    if (input.seed !== undefined)
+        body.seed = input.seed;
+    if (input.watermarkEnabled !== undefined)
+        body.watermark = input.watermarkEnabled;
+    if (input.inputImages?.[0])
+        body.image = dataUri(input.inputImages[0]);
+    const response = await (input.fetchImpl ?? fetch)(`${input.config.baseUrl}/v2/images/generations`, {
+        method: "POST", headers: bearer(input.config.apiKey), body: JSON.stringify(body), signal: AbortSignal.timeout(120_000),
+    });
+    const payload = await jsonResponse(response, "Baidu Qianfan");
+    const image = await imageFromPayload(payload, "Baidu Qianfan", input.downloadFetchImpl ?? input.fetchImpl ?? fetch);
+    if (!image)
+        throw new Error("Baidu Qianfan image response contained no valid image data.");
+    return image;
+}
+async function requestPlayground(input) {
+    const { width, height } = parseSize(input.size);
+    const body = { prompt: input.prompt, filter_model: input.config.model, width, height };
+    if (input.negativePrompt)
+        body.negative_prompt = input.negativePrompt;
+    if (input.seed !== undefined)
+        body.seed = input.seed;
+    if (input.inputImages?.[0])
+        body.init_image = input.inputImages[0].data.toString("base64");
+    const response = await (input.fetchImpl ?? fetch)(`${input.config.baseUrl}/api/models/external/v1`, {
+        method: "POST", headers: bearer(input.config.apiKey), body: JSON.stringify(body), signal: AbortSignal.timeout(120_000),
+    });
+    const payload = await jsonResponse(response, "Playground AI");
+    const image = await imageFromPayload(payload, "Playground AI", input.downloadFetchImpl ?? input.fetchImpl ?? fetch);
+    if (!image)
+        throw new Error("Playground AI image response contained no valid image data.");
+    return image;
+}
+function nestedString(payload, paths) {
+    for (const path of paths) {
+        let value = payload;
+        for (const part of path) {
+            if (!value || typeof value !== "object") {
+                value = undefined;
+                break;
+            }
+            value = value[part];
+        }
+        if (typeof value === "string" && value)
+            return value;
+    }
+    return undefined;
+}
+function statusOf(payload) {
+    return nestedString(payload, [
+        ["status"], ["state"], ["task_status"], ["output", "task_status"], ["data", "status"],
+        ["data", "task_status"], ["output", "status"], ["result", "status"], ["result", "state"],
+        ["result", "task_status"], ["result", "sub_task_results", "0", "task_status"],
+    ])?.toLowerCase();
+}
+function asyncSettings() {
+    const bounded = (name, fallback, min, max) => {
+        const raw = process.env[name];
+        if (!raw)
+            return fallback;
+        const parsed = Number(raw);
+        if (!Number.isInteger(parsed) || parsed < min || parsed > max) {
+            throw new Error(`${name} must be an integer between ${min} and ${max}.`);
+        }
+        return parsed;
+    };
+    return {
+        timeoutMs: bounded("IMAGEFORGE_ASYNC_TIMEOUT_MS", 300_000, 30_000, 600_000),
+        intervalMs: bounded("IMAGEFORGE_POLL_INTERVAL_MS", 2_000, 500, 10_000),
+    };
+}
+async function delay(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function submitAndPoll(input, options) {
+    const fetchImpl = input.fetchImpl ?? fetch;
+    const response = await fetchImpl(options.submitUrl, {
+        method: "POST",
+        headers: options.submitHeaders,
+        body: JSON.stringify(options.body),
+        signal: AbortSignal.timeout(120_000),
+    });
+    let payload = await jsonResponse(response, options.label);
+    const downloadFetch = input.downloadFetchImpl ?? fetchImpl;
+    const immediateImage = await imageFromPayload(payload, options.label, downloadFetch);
+    if (immediateImage)
+        return immediateImage;
+    const statusUrl = options.statusUrl(payload);
+    if (!statusUrl)
+        throw new Error(`${options.label} image response contained no task ID or status URL.`);
+    const { timeoutMs, intervalMs } = asyncSettings();
+    const deadline = Date.now() + timeoutMs;
+    let nextDelayMs = intervalMs;
+    while (Date.now() < deadline) {
+        const status = statusOf(payload);
+        if (status && ["fail", "failed", "error", "unknown", "canceled", "cancelled", "rejected"].includes(status)) {
+            throw new Error(`${options.label} image task failed with status '${status}'.`);
+        }
+        const image = await imageFromPayload(payload, options.label, downloadFetch);
+        if (image)
+            return image;
+        await delay(nextDelayMs);
+        const pollResponse = await fetchImpl(statusUrl, {
+            method: "GET",
+            headers: options.statusHeaders ?? options.submitHeaders,
+            signal: AbortSignal.timeout(Math.min(120_000, Math.max(1, deadline - Date.now()))),
+        });
+        const retryAfter = pollResponse.headers.get("retry-after");
+        const retryAfterSeconds = retryAfter === null ? undefined : Number(retryAfter);
+        nextDelayMs = retryAfterSeconds !== undefined && Number.isFinite(retryAfterSeconds)
+            ? Math.min(10_000, Math.max(500, retryAfterSeconds * 1000))
+            : intervalMs;
+        payload = await jsonResponse(pollResponse, options.label);
+    }
+    throw new Error(`${options.label} image task timed out after ${timeoutMs} ms.`);
+}
+function taskId(payload) {
+    return nestedString(payload, [
+        ["id"], ["job_id"], ["task_id"], ["request_id"], ["generation_id"], ["generationId"],
+        ["output", "task_id"], ["data", "task_id"], ["data", "job_id"], ["data", "generation_id"],
+        ["data", "id"], ["result", "task_id"], ["result", "id"], ["sdGenerationJob", "generationId"],
+    ]);
+}
+function absoluteStatusUrl(baseUrl, value) {
+    if (!value)
+        return undefined;
+    if (/^https?:\/\//.test(value))
+        return value;
+    return `${baseUrl}/${value.replace(/^\/+/, "")}`;
+}
+function klingToken(accessKey) {
+    const secret = process.env.KLING_SECRET_KEY;
+    const now = Math.floor(Date.now() / 1000);
+    const encode = (value) => Buffer.from(JSON.stringify(value)).toString("base64url");
+    const signingInput = `${encode({ alg: "HS256", typ: "JWT" })}.${encode({ iss: accessKey, exp: now + 1800, nbf: now - 5 })}`;
+    const signature = createHmac("sha256", secret).update(signingInput).digest("base64url");
+    return `${signingInput}.${signature}`;
+}
+async function requestAsyncProvider(input) {
+    const provider = input.config.provider;
+    let body;
+    let submitUrl;
+    let headers = bearer(input.config.apiKey);
+    let statusBuilder;
+    if (provider === "bfl") {
+        const { width, height } = parseSize(input.size);
+        body = { prompt: input.prompt, width, height, output_format: input.outputFormat ?? "png" };
+        if (input.seed !== undefined)
+            body.seed = input.seed;
+        submitUrl = `${input.config.baseUrl}/v1/${input.config.model}`;
+        headers = { "x-key": input.config.apiKey, "content-type": "application/json" };
+        (input.inputImages ?? []).forEach((image, index) => {
+            body[index === 0 ? "input_image" : `input_image_${index + 1}`] = dataUri(image);
+        });
+        statusBuilder = (payload) => absoluteStatusUrl(input.config.baseUrl, nestedString(payload, [["polling_url"]]))
+            ?? (taskId(payload) ? `${input.config.baseUrl}/v1/get_result?id=${encodeURIComponent(taskId(payload))}` : undefined);
+    }
+    else if (provider === "luma") {
+        body = {
+            prompt: input.prompt,
+            model: input.config.model,
+            type: "image",
+            aspect_ratio: ratioFor(input),
+            output_format: input.outputFormat === "webp" ? undefined : input.outputFormat,
+            image_ref: input.inputImages?.map((image) => ({ data: image.data.toString("base64"), media_type: image.mimeType })),
+        };
+        submitUrl = `${input.config.baseUrl}/generations`;
+        statusBuilder = (payload) => absoluteStatusUrl(input.config.baseUrl, nestedString(payload, [["status_url"]]))
+            ?? (taskId(payload) ? `${input.config.baseUrl}/generations/${taskId(payload)}` : undefined);
+    }
+    else if (provider === "krea") {
+        body = {
+            prompt: input.prompt,
+            aspect_ratio: ratioFor(input),
+            resolution: input.resolution ?? "1K",
+            image_style_references: input.inputImages?.map(dataUri),
+        };
+        if (input.seed !== undefined)
+            body.seed = input.seed;
+        submitUrl = `${input.config.baseUrl}/generate/image/krea/${input.config.model}`;
+        statusBuilder = (payload) => absoluteStatusUrl(input.config.baseUrl, nestedString(payload, [["status_url"], ["urls", "status"]]))
+            ?? (taskId(payload) ? `${input.config.baseUrl}/jobs/${taskId(payload)}` : undefined);
+    }
+    else if (provider === "runway") {
+        body = {
+            model: input.config.model,
+            promptText: input.prompt,
+            ratio: input.size.replace("x", ":"),
+            referenceImages: input.inputImages?.map((image) => ({ uri: dataUri(image) })),
+        };
+        if (input.seed !== undefined)
+            body.seed = input.seed;
+        submitUrl = `${input.config.baseUrl}/v1/text_to_image`;
+        headers = { ...bearer(input.config.apiKey), "x-runway-version": "2024-11-06" };
+        statusBuilder = (payload) => taskId(payload) ? `${input.config.baseUrl}/v1/tasks/${taskId(payload)}` : undefined;
+    }
+    else if (provider === "leonardo") {
+        const { width, height } = parseSize(input.size);
+        body = { model: input.config.model, prompt: input.prompt, width, height, num_images: 1 };
+        if (input.seed !== undefined)
+            body.seed = input.seed;
+        if (input.negativePrompt)
+            body.negative_prompt = input.negativePrompt;
+        submitUrl = `${input.config.baseUrl}/generations`;
+        body.imageReferences = input.inputImages?.map((image) => ({ image: dataUri(image), type: input.referenceMode ?? "content" }));
+        statusBuilder = (payload) => taskId(payload) ? `${input.config.baseUrl}/generations/${taskId(payload)}` : undefined;
+    }
+    else if (provider === "bria") {
+        body = {
+            prompt: input.prompt,
+            images: input.inputImages?.map(dataUri),
+            aspect_ratio: ratioFor(input),
+            seed: input.seed,
+            negative_prompt: input.negativePrompt,
+            output_type: input.outputFormat === "webp" ? undefined : input.outputFormat,
+            sync: false,
+        };
+        submitUrl = `${input.config.baseUrl}/image/${input.config.model === "fibo-lite" ? "generate/lite" : "generate"}`;
+        headers = { api_token: input.config.apiKey, "content-type": "application/json", "user-agent": "BriaPlatform/Sandbox/LLMsAgent" };
+        statusBuilder = (payload) => absoluteStatusUrl(input.config.baseUrl, nestedString(payload, [["status_url"]]))
+            ?? (taskId(payload) ? `${input.config.baseUrl}/status/${taskId(payload)}` : undefined);
+    }
+    else if (provider === "freepik") {
+        body = { prompt: input.prompt, model: input.config.model };
+        submitUrl = `${input.config.baseUrl}/v1/ai/mystic`;
+        headers = { "x-magnific-api-key": input.config.apiKey, "content-type": "application/json" };
+        const reference = input.inputImages?.[0]?.data.toString("base64");
+        if (reference) {
+            body[input.referenceMode === "style" ? "style_reference" : "structure_reference"] = reference;
+        }
+        body.resolution = input.resolution?.toLowerCase() ?? "1k";
+        body.aspect_ratio = {
+            "1:1": "square_1_1", "4:3": "classic_4_3", "3:4": "traditional_3_4",
+            "16:9": "widescreen_16_9", "9:16": "social_story_9_16", "3:2": "standard_3_2",
+            "2:3": "portrait_2_3", "2:1": "horizontal_2_1", "1:2": "vertical_1_2",
+        }[ratioFor(input)];
+        if (!body.aspect_ratio)
+            throw new Error(`Freepik Mystic does not support aspect ratio ${ratioFor(input)}.`);
+        statusBuilder = (payload) => taskId(payload) ? `${input.config.baseUrl}/v1/ai/mystic/${taskId(payload)}` : undefined;
+    }
+    else if (provider === "alibaba") {
+        body = { model: input.config.model };
+        submitUrl = `${input.config.baseUrl}/api/v1/services/aigc/multimodal-generation/generation`;
+        headers = { ...bearer(input.config.apiKey), "x-dashscope-async": "enable" };
+        const content = [
+            ...(input.inputImages ?? []).map((image) => ({ image: dataUri(image) })),
+            { text: input.prompt },
+        ];
+        Object.assign(body, { input: { messages: [{ role: "user", content }] }, parameters: {
+                n: 1, size: input.size.replace("x", "*"), watermark: input.watermarkEnabled,
+                negative_prompt: input.negativePrompt, seed: input.seed,
+            } });
+        statusBuilder = (payload) => taskId(payload) ? `${input.config.baseUrl}/api/v1/tasks/${taskId(payload)}` : undefined;
+    }
+    else if (provider === "kling") {
+        body = {
+            model_name: input.config.model,
+            prompt: input.prompt,
+            n: 1,
+            aspect_ratio: input.aspectRatio ?? ratioFor(input),
+            image_list: input.inputImages?.map((image) => ({ image: dataUri(image), type: input.referenceMode ?? "content" })),
+        };
+        submitUrl = `${input.config.baseUrl}/v1/images/generations`;
+        headers = bearer(klingToken(input.config.apiKey));
+        statusBuilder = (payload) => taskId(payload) ? `${input.config.baseUrl}/v1/images/generations/${taskId(payload)}` : undefined;
+    }
+    else if (provider === "hidream") {
+        const references = input.inputImages ?? [];
+        body = {
+            prompt: input.prompt,
+            negative_prompt: input.negativePrompt,
+            version: input.config.model,
+            resolution: input.size.replace("x", "*"),
+            img_count: 1,
+            image: references.map(dataUri),
+        };
+        submitUrl = `${input.config.baseUrl}/api-pub/gw/v3/image/${references.length ? "img2img" : "txt2img"}/async`;
+        statusBuilder = (payload) => taskId(payload)
+            ? `${input.config.baseUrl}/api-pub/gw/v3/image/${references.length ? "img2img" : "txt2img"}/async/results?task_id=${encodeURIComponent(taskId(payload))}`
+            : undefined;
+    }
+    else {
+        throw new Error(`Unsupported async provider '${provider}'.`);
+    }
+    return submitAndPoll(input, {
+        label: definitionMap.get(provider).name,
+        submitUrl,
+        submitHeaders: headers,
+        body,
+        statusUrl: statusBuilder,
+        statusHeaders: headers,
+    });
+}
+async function requestVolcengine(input) {
+    const body = {
+        model: input.config.model,
+        prompt: input.prompt,
+        size: input.size,
+        response_format: "url",
+        watermark: input.watermarkEnabled,
+        seed: input.seed,
+    };
+    if (input.inputImages?.length)
+        body.image = input.inputImages.map(dataUri);
+    const response = await (input.fetchImpl ?? fetch)(`${input.config.baseUrl}/images/generations`, {
+        method: "POST", headers: bearer(input.config.apiKey), body: JSON.stringify(body), signal: AbortSignal.timeout(120_000),
+    });
+    const payload = await jsonResponse(response, "Volcengine Ark");
+    const image = await imageFromPayload(payload, "Volcengine Ark", input.downloadFetchImpl ?? input.fetchImpl ?? fetch);
+    if (!image)
+        throw new Error("Volcengine Ark image response contained no valid image data.");
+    return image;
+}
+export async function requestExternalImage(input) {
+    const definition = definitionMap.get(input.config.provider);
+    validateReferences(input, definition);
+    validateCommonOptions(input);
+    switch (input.config.provider) {
+        case "google": return requestGoogle(input);
+        case "xai": return requestXai(input);
+        case "stability": return requestStability(input);
+        case "ideogram": return requestIdeogram(input);
+        case "recraft": return requestRecraft(input);
+        case "tencent": return requestTencent(input);
+        case "baidu": return requestBaidu(input);
+        case "playground": return requestPlayground(input);
+        case "volcengine": return requestVolcengine(input);
+        default: return requestAsyncProvider(input);
+    }
+}
+export function externalCapabilities() {
+    return definitions.map((definition) => ({
+        provider: definition.id,
+        name: definition.name,
+        default_model: definition.defaultModel,
+        models: [...definition.models],
+        reference_modes: [...definition.referenceModes],
+        max_reference_images: definition.maxReferences,
+        async: definition.async,
+        credential_environment_variables: definition.id === "kling"
+            ? [definition.apiKeyEnv, "KLING_SECRET_KEY"]
+            : [definition.apiKeyEnv],
+        base_url_environment_variable: definition.baseUrlEnv,
+        model_environment_variable: definition.modelEnv,
+        docs_url: definition.docsUrl,
+        implementation_basis: "official-docs-contract-tests",
+        live_verified: false,
+    }));
+}
+//# sourceMappingURL=externalProviders.js.map