ima2-gen 3.13.1 → 3.14.0

package/lib/mcp/downloadMediaResult.js

@@ -3,39 +3,32 @@
 // (routes/mcpMedia.ts) owns the atomic commit. Signed URLs are never persisted.
 import { createWriteStream } from "node:fs";
 import { mkdtemp, rm } from "node:fs/promises";
-import { lookup } from "node:dns/promises";
-import { setDefaultResultOrder } from "node:dns";
-import https from "node:https";
-import { isIP } from "node:net";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
-// 260718 RCA: CloudFront AAAA records + hosts without working IPv6 made
-// Node fetch die with ETIMEDOUT while curl/python (IPv4) worked — this was
-// the actual "fetch failed" that dropped completed Runway results. Prefer
-// IPv4 for outbound fetches in this process.
-try {
-    setDefaultResultOrder("ipv4first");
-}
-catch { /* older runtimes */ }
+import { pinnedHttpGet } from "../pinnedHttpGet.js";
+import { resolvePublicDownloadTarget } from "../grokImageDownloadPolicy.js";
 const MAX_REDIRECTS = 5;
-const PRIVATE_V4 = [/^10\./, /^127\./, /^169\.254\./, /^192\.168\./, /^172\.(1[6-9]|2\d|3[01])\./, /^0\./];
-function isPrivateAddress(address) {
-    if (isIP(address) === 6) {
-        const lower = address.toLowerCase();
-        return lower === "::1" || lower.startsWith("fe80:") || lower.startsWith("fc") || lower.startsWith("fd") || lower.startsWith("::ffff:127.");
+async function resolvePublicHttps(url, signal) {
+    if (url.protocol !== "https:")
+        throw new Error(`MCP_DOWNLOAD_INSECURE:${url.protocol}`);
+    try {
+        return await resolvePublicDownloadTarget(url, signal, "ipv4first");
+    }
+    catch (error) {
+        signal.throwIfAborted();
+        if (!(error instanceof Error) || Reflect.get(error, "code") !== "GROK_IMAGE_DOWNLOAD_FAILED")
+            throw error;
+        throw new Error(`MCP_DOWNLOAD_PRIVATE_IP:${url.hostname}`);
     }
-    return PRIVATE_V4.some((pattern) => pattern.test(address));
 }
 export async function assertPublicHttps(url) {
-    if (url.protocol !== "https:")
-        throw new Error(`MCP_DOWNLOAD_INSECURE:${url.protocol}`);
-    const host = url.hostname;
-    const addresses = isIP(host) ? [{ address: host }] : await lookup(host, { all: true });
-    for (const { address } of addresses) {
-        if (isPrivateAddress(address))
-            throw new Error(`MCP_DOWNLOAD_PRIVATE_IP:${host}`);
+    try {
+        await resolvePublicHttps(url, new AbortController().signal);
+    }
+    catch (error) {
+        throw error;
     }
 }
 /** Transient right after task completion: network-level failures and
@@ -75,42 +68,49 @@ export async function downloadMediaResult(rawUrl, options) {
 async function downloadMediaResultOnce(rawUrl, options) {
     const maxBytes = options.maxBytes ?? (options.kind === "video" ? 800 * 1024 * 1024 : 40 * 1024 * 1024);
     let url = new URL(rawUrl);
-    let response = null;
-    for (let hop = 0; hop <= MAX_REDIRECTS; hop += 1) {
-        await assertPublicHttps(url);
-        response = await openGet(url, options.timeoutMs ?? 120_000, options.v4Fallback !== false);
-        if (response.status >= 300 && response.status < 400) {
-            const location = response.headers.get("location");
-            if (!location)
-                throw new Error("MCP_DOWNLOAD_REDIRECT_INVALID");
-            response.body?.resume?.();
-            url = new URL(location, url);
-            continue;
+    let response;
+    try {
+        for (let hop = 0; hop <= MAX_REDIRECTS; hop += 1) {
+            response = await openGet(url, options.timeoutMs ?? 120_000, options.v4Fallback !== false);
+            if (response.status >= 300 && response.status < 400) {
+                const location = response.headers.get("location");
+                response.cancel();
+                if (!location?.trim())
+                    throw new Error("MCP_DOWNLOAD_REDIRECT_INVALID");
+                url = new URL(location, url);
+                continue;
+            }
+            break;
+        }
+        if (!response || response.status < 200 || response.status >= 300 || !response.body) {
+            throw new Error(`MCP_DOWNLOAD_FAILED:${response?.status ?? "no-response"}`);
         }
-        break;
+        const contentType = response.headers.get("content-type") ?? "";
+        const expected = options.kind === "video" ? /^(video\/|application\/octet-stream)/ : /^image\//;
+        if (!expected.test(contentType))
+            throw new Error(`MCP_RESULT_TYPE_MISMATCH:${contentType}`);
+        if (Number(response.headers.get("content-length")) > maxBytes)
+            throw new Error("MCP_DOWNLOAD_TOO_LARGE");
+        return await writeMediaResult(response, url, contentType, maxBytes);
     }
-    if (!response || response.status < 200 || response.status >= 300 || !response.body) {
-        throw new Error(`MCP_DOWNLOAD_FAILED:${response?.status ?? "no-response"}`);
+    finally {
+        response?.cancel();
     }
-    const contentType = response.headers.get("content-type") ?? "";
-    const expected = options.kind === "video" ? /^(video\/|application\/octet-stream)/ : /^image\//;
-    if (!expected.test(contentType))
-        throw new Error(`MCP_RESULT_TYPE_MISMATCH:${contentType}`);
+}
+async function writeMediaResult(response, url, contentType, maxBytes) {
     const dir = await mkdtemp(join(tmpdir(), "ima2-mcp-dl-"));
     const tempPath = join(dir, "result");
     let bytes = 0;
     try {
-        const webBody = Readable.toWeb(response.body);
-        const capped = webBody.pipeThrough(new TransformStream({
-            transform(chunk, controller) {
+        const capped = async function* () {
+            for await (const chunk of response.body) {
                 bytes += chunk.byteLength;
                 if (bytes > maxBytes)
-                    controller.error(new Error("MCP_DOWNLOAD_TOO_LARGE"));
-                else
-                    controller.enqueue(chunk);
-            },
-        }));
-        await pipeline(Readable.fromWeb(capped), createWriteStream(tempPath));
+                    throw new Error("MCP_DOWNLOAD_TOO_LARGE");
+                yield chunk;
+            }
+        };
+        await pipeline(Readable.from(capped()), createWriteStream(tempPath));
     }
     catch (error) {
         await rm(dir, { recursive: true, force: true });
@@ -124,37 +124,31 @@ async function downloadMediaResultOnce(rawUrl, options) {
         cleanup: () => rm(dir, { recursive: true, force: true }),
     };
 }
-/** fetch first; on a network-level failure (broken-IPv6 hosts stall in
- *  undici/https happy-eyeballs), fall back to https.request with family 4 —
- *  this was the actual ETIMEDOUT behind the lost Runway results (260718). */
+/** Retain IPv4 preference and one optional network fallback without fresh DNS. */
 async function openGet(url, timeoutMs, v4Fallback) {
+    let target;
     try {
-        const response = await fetch(url, { redirect: "manual", signal: AbortSignal.timeout(timeoutMs) });
-        return {
-            status: response.status,
-            headers: { get: (name) => response.headers.get(name) },
-            body: response.body ? Readable.fromWeb(response.body) : null,
-        };
+        return await timedGet(async (signal) => {
+            target = await resolvePublicHttps(url, signal);
+            return target;
+        }, timeoutMs);
     }
     catch (error) {
-        if (!v4Fallback)
+        if (!v4Fallback || !target?.addresses.some(({ family }) => family === 4) || !isRetryableDownloadError(error))
             throw error;
-        if (!isRetryableDownloadError(error))
-            throw error;
-        return httpsGetV4(url, timeoutMs);
+        return timedGet(async () => target, timeoutMs, 4);
     }
 }
-function httpsGetV4(url, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        const request = https.request(url, { method: "GET", family: 4, timeout: timeoutMs }, (response) => {
-            resolve({
-                status: response.statusCode ?? 0,
-                headers: { get: (name) => response.headers[name.toLowerCase()] ?? null },
-                body: response,
-            });
-        });
-        request.on("timeout", () => { request.destroy(new Error("MCP_DOWNLOAD_TIMEOUT")); });
-        request.on("error", reject);
-        request.end();
-    });
+async function timedGet(resolve, timeoutMs, family) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new Error("MCP_DOWNLOAD_TIMEOUT")), timeoutMs);
+    try {
+        const target = await resolve(controller.signal);
+        const response = await pinnedHttpGet(target, controller.signal, family ? { family } : {});
+        return { ...response, cancel: (reason) => { clearTimeout(timer); response.cancel(reason); } };
+    }
+    catch (error) {
+        clearTimeout(timer);
+        throw error;
+    }
 }

package/lib/multimodePipeline.js

@@ -8,14 +8,9 @@ import { generateImageThumbnailFromBuffer } from "./imageThumb.js";
 import { classifyUpstreamError } from "./errorClassify.js";
 import { normalizeOAuthParams } from "./oauthNormalize.js";
 import { resolveProviderOptions } from "./providerOptions.js";
-import { generateMultimodeViaResponses } from "./responsesImageAdapter.js";
-import { generateMultimodeViaGrok } from "./grokMultimodeAdapter.js";
+import { prepareImageExecution } from "./providers/execution/index.js";
+import { checkImageExecutionAdmission } from "./providers/execution/admission.js";
 import { resolveGrokQualityModel } from "./imageModels.js";
-import { generateViaAgy } from "./agyImageAdapter.js";
-import { generateViaGeminiApi } from "./geminiApiImageAdapter.js";
-import { generateViaAtlasCloud } from "./atlasCloudImageAdapter.js";
-import { generateViaMinimax } from "./minimaxImageAdapter.js";
-import { generateViaNai } from "./naiImageAdapter.js";
 import { composerNegativePromptMeta, readNaiOptions } from "./naiOptions.js";
 import { startJob, finishJob, registerJobAbortController, isJobCanceled, isStartJobFailure, INFLIGHT_RETRY_AFTER_SECONDS } from "./inflight.js";
 import { isGenerationCanceledError, makeGenerationCanceledError, throwIfJobCanceled, } from "./generationCancel.js";
@@ -24,7 +19,6 @@ import { embedImageMetadataBestEffort } from "./imageMetadataStore.js";
 import { invalidateHistoryIndex } from "./historyIndex.js";
 import { normalizeComposerInsertedPrompts, normalizeComposerPrompt, } from "./composerSnapshot.js";
 import { errInfo } from "./errInfo.js";
-import { requireRuntimeContext } from "./runtimeContext.js";
 import { validateModeration, imageFormatFromMime, writeSse } from "./routeHelpers.js";
 import { publish } from "./eventBus.js";
 import { publishJobEvent } from "./ssePublish.js";
@@ -33,6 +27,7 @@ import { normalizeBodyRequestId, validateBoundedCount, validateGenerationPrompt
 import { getElementById } from "./assetsStore.js";
 import { compileElements, ELEMENT_CAPACITY_DEFAULTS } from "./elementCompiler.js";
 import { errorEnvelopeFields } from "./errors/envelope.js";
+import { getProviderSurfaceSupport } from "./providers/derive.js";
 async function resolveMultimodeElements(elementIds, references, activeProvider, requestId) {
     let notesFragment = "";
     const resolvedRefs = [];
@@ -142,7 +137,7 @@ export async function runMultimodePipeline(req, res, ctx) {
         // request would reach generateViaResponses and bill OAuth for an image
         // the user asked ComfyUI to make — silently, with no error to trace.
         // Removed in wp7 when this surface gains a real comfy branch.
-        if (provider === "comfy") {
+        if (getProviderSurfaceSupport(provider, "multimode")?.supported === false) {
             finishStatus = "error";
             finishHttpStatus = 400;
             finishErrorCode = "COMFY_SURFACE_UNSUPPORTED";
@@ -160,7 +155,7 @@ export async function runMultimodePipeline(req, res, ctx) {
             rawSize: size,
             rawWebSearchEnabled,
         });
-        if (providerOptions.error) {
+        if (providerOptions.error !== undefined) {
             finishStatus = "error";
             finishHttpStatus = providerOptions.status;
             finishErrorCode = providerOptions.code;
@@ -211,6 +206,17 @@ export async function runMultimodePipeline(req, res, ctx) {
             });
         }
         const refCheck = refCheckResult;
+        const admission = checkImageExecutionAdmission(ctx, {
+            provider: activeProvider, surface: "multimode", referenceCount: refCheck.refs.length,
+        });
+        if (admission) {
+            finishStatus = "error";
+            finishHttpStatus = admission.status;
+            finishErrorCode = admission.code;
+            return respondMultimodeValidationError(res, requestId, asyncMode, admission.status, {
+                error: admission.message, code: admission.code, status: admission.status, requestId,
+            });
+        }
         const incomingProviderUrl = typeof req.body?.providerUrl === "string" && req.body.providerUrl.startsWith("http") ? req.body.providerUrl : null;
         const referencePayload = summarizeReferencePayload(mergedReferences);
         const started = startJob({
@@ -347,126 +353,33 @@ export async function runMultimodePipeline(req, res, ctx) {
             dualEmitMultimode(res, requestId, "image", item);
         };
         dualEmitMultimode(res, requestId, "phase", { phase: "streaming", requestId, sequenceId, maxImages });
-        let generated;
-        if (activeProvider === "gemini-api") {
-            const r = await generateViaGeminiApi(generationPrompt, requireRuntimeContext(ctx), {
-                model: imageModel,
-                size: effectiveSize,
-                signal: cancelController.signal,
-                requestId,
-                references: refCheck.refDetails,
-            });
-            generated = {
-                images: [{ b64: r.b64, ...(r.revisedPrompt !== undefined ? { revisedPrompt: r.revisedPrompt } : {}) }],
-                usage: r.usage,
-                webSearchCalls: r.webSearchCalls,
-            };
-        }
-        else if (activeProvider === "agy") {
-            const r = await generateViaAgy(generationPrompt, {
-                references: refCheck.refDetails,
-                signal: cancelController.signal,
-                requestId,
-            });
-            generated = {
-                images: [{ b64: r.b64, ...(r.revisedPrompt !== undefined ? { revisedPrompt: r.revisedPrompt } : {}) }],
-                usage: r.usage,
-                webSearchCalls: r.webSearchCalls,
-            };
-        }
-        else if (activeProvider === "atlascloud") {
-            const r = await generateViaAtlasCloud(prompt, requireRuntimeContext(ctx), {
-                model: imageModel,
-                size: effectiveSize,
-                quality: routeQuality,
-                signal: cancelController.signal,
-                requestId,
-                references: refCheck.refDetails,
-            });
-            generated = {
-                images: [{ b64: r.b64, ...(r.revisedPrompt !== undefined ? { revisedPrompt: r.revisedPrompt } : {}) }],
-                usage: r.usage,
-                webSearchCalls: r.webSearchCalls,
-            };
-        }
-        else if (activeProvider === "minimax") {
-            const r = await generateViaMinimax(prompt, requireRuntimeContext(ctx), {
-                model: imageModel,
-                size: effectiveSize,
-                signal: cancelController.signal,
-                requestId,
-                references: refCheck.refDetails,
-            });
-            generated = {
-                images: [{ b64: r.b64, ...(r.revisedPrompt !== undefined ? { revisedPrompt: r.revisedPrompt } : {}) }],
-                usage: r.usage,
-                webSearchCalls: r.webSearchCalls,
-            };
-        }
-        else if (activeProvider === "nai") {
-            // No references: the adapter is text-to-image only (see the refusal in
-            // lib/generatePipeline.ts), so none are forwarded here either.
-            const r = await generateViaNai(prompt, requireRuntimeContext(ctx), {
-                model: imageModel,
-                size: effectiveSize,
-                signal: cancelController.signal,
-                requestId,
-                ...readNaiOptions(req.body),
-            });
-            generated = {
-                // No mime field on this shape; the persist step below detects PNG
-                // from the magic bytes, which is authoritative anyway.
-                images: [{ b64: r.b64, ...(r.revisedPrompt !== undefined ? { revisedPrompt: r.revisedPrompt } : {}) }],
-                usage: r.usage,
-                webSearchCalls: r.webSearchCalls,
-            };
-        }
-        else if (activeProvider === "grok" || activeProvider === "grok-api") {
-            const directApiKey = activeProvider === "grok-api" ? ctx.xaiApiKey : undefined;
-            const grokModel = resolveGrokQualityModel(imageModel, quality);
-            const grokRefs = incomingProviderUrl
-                ? [{ b64: "", url: incomingProviderUrl }, ...refCheck.refDetails]
-                : refCheck.refDetails;
-            generated = await generateMultimodeViaGrok(generationPrompt, ctx, {
-                model: grokModel,
-                maxImages,
-                size: effectiveSize,
-                signal: cancelController.signal,
-                requestId,
-                references: grokRefs,
-                directApiKey,
-                onFinalImage: async (image, index) => {
-                    const totalReturned = Math.max(index + 1, images.length + 1);
-                    await persistAndSendImage(image, index, totalReturned, sequenceStatus(totalReturned, maxImages));
-                },
-            });
-        }
-        else {
-            generated = await generateMultimodeViaResponses(activeProvider, generationPrompt, quality, effectiveSize, moderation, refCheck.refDetails || refCheck.refs, requestId, normalizedPromptMode, ctx, {
-                model: imageModel,
-                maxImages,
-                reasoningEffort,
-                webSearchEnabled,
-                onPartialImage: (partial) => {
-                    if (isJobCanceled(requestId))
-                        return;
-                    const pd = { image: `data:${mime};base64,${partial.b64}`, requestId, sequenceId, index: partial.index };
-                    if (!res.writableEnded && !res.destroyed)
-                        writeSse(res, "partial", pd);
-                    publish(requestId, "partial", pd);
-                },
-                onFinalImage: async (image, index) => {
-                    const totalReturned = Math.max(index + 1, images.length + 1);
-                    await persistAndSendImage(image, index, totalReturned, sequenceStatus(totalReturned, maxImages));
-                },
-                signal: cancelController.signal,
-            });
-        }
+        const { value: generated } = await (await prepareImageExecution(ctx, {
+            surface: "multimode", provider: activeProvider, requestId,
+            signal: cancelController.signal, prompt: generationPrompt, rawPrompt: prompt,
+            references: refCheck.refDetails, providerUrl: incomingProviderUrl, maxImages,
+            options: { model: imageModel, quality, size: effectiveSize, moderation,
+                mode: normalizedPromptMode, reasoningEffort, webSearchEnabled },
+            nai: activeProvider === "nai" ? readNaiOptions(req.body) : {},
+        }, {
+            onPartialImage: (partial) => {
+                if (isJobCanceled(requestId))
+                    return;
+                const pd = { image: `data:${mime};base64,${partial.b64}`, requestId, sequenceId, index: partial.index };
+                if (!res.writableEnded && !res.destroyed)
+                    writeSse(res, "partial", pd);
+                publish(requestId, "partial", pd);
+            },
+            onFinalImage: async (image, index) => {
+                const totalReturned = images.length + 1;
+                await persistAndSendImage(image, index, totalReturned, sequenceStatus(totalReturned, maxImages));
+            },
+        })).execute();
         throwIfJobCanceled(requestId);
         latestUsage = generated.usage || null;
         latestWebSearchCalls = generated.webSearchCalls || 0;
         latestExtraIgnored = generated.extraIgnored || 0;
-        for (const [index, image] of generated.images.entries()) {
+        for (const [position, image] of generated.images.entries()) {
+            const index = generated.originalIndexes?.[position] ?? position;
             await persistAndSendImage(image, index, generated.images.length, sequenceStatus(generated.images.length, maxImages));
         }
         const returned = images.length;

package/lib/nodeGeneration.js

@@ -6,26 +6,20 @@ import { detectImageMimeFromB64, summarizeReferencePayload } from "./refs.js";
 import { classifyUpstreamError } from "./errorClassify.js";
 import { normalizeOAuthParams } from "./oauthNormalize.js";
 import { resolveProviderOptions } from "./providerOptions.js";
-import { generateViaResponses, editViaResponses } from "./responsesImageAdapter.js";
-import { generateViaGrok } from "./grokImageAdapter.js";
 import { resolveGrokQualityModel } from "./imageModels.js";
-import { generateViaAgy } from "./agyImageAdapter.js";
-import { generateViaGeminiApi } from "./geminiApiImageAdapter.js";
-import { generateViaAtlasCloud } from "./atlasCloudImageAdapter.js";
-import { generateViaMinimax } from "./minimaxImageAdapter.js";
-import { generateViaNai } from "./naiImageAdapter.js";
+import { prepareImageExecution } from "./providers/execution/index.js";
+import { checkImageExecutionAdmission } from "./providers/execution/admission.js";
 import { readNaiOptions } from "./naiOptions.js";
 import { isNonRetryableGenerationError, normalizeGenerationFailure } from "./generationErrors.js";
 import { logEvent, logError } from "./logger.js";
 import { errInfo } from "./errInfo.js";
-import { requireRuntimeContext } from "./runtimeContext.js";
 import { imageFormatFromMime, writeSse, dataUrlFromB64 } from "./routeHelpers.js";
 import { validateNodeInputs } from "./nodeValidation.js";
 import { publish } from "./eventBus.js";
 import { publishJobEvent } from "./ssePublish.js";
-import { asUpstream, wantsSse, writeNodeError, loadParentNodeB64, toGrokReferences, nodeErrorDetails, } from "./nodeHelpers.js";
+import { asUpstream, wantsSse, writeNodeError, loadParentNodeB64, nodeErrorDetails, } from "./nodeHelpers.js";
 import { normalizeBodyRequestId, validateGenerationPrompt } from "./generationInputValidation.js";
-import { deriveReferenceLimit } from "./providers/derive.js";
+import { deriveReferenceLimit, getProviderSurfaceSupport } from "./providers/derive.js";
 import { errorEnvelopeFields } from "./errors/envelope.js";
 export async function runNodeGeneration(req, res, ctx) {
     const body = (req.body ?? {});
@@ -51,15 +45,15 @@ export async function runNodeGeneration(req, res, ctx) {
         const { provider = "oauth" } = body;
         const { quality, warnings: qualityWarnings } = normalizeOAuthParams({ provider, quality: rawQuality });
         const normalizedPromptMode = promptMode === "direct" ? "direct" : "auto";
-        const contextMode = ["parent-plus-refs", "parent-only", "ancestry"].includes(rawContextMode)
-            ? rawContextMode
-            : "parent-plus-refs";
-        const searchMode = ["off", "auto", "on"].includes(rawSearchMode) ? rawSearchMode : "on";
+        const contextMode = rawContextMode === "parent-only" ? "parent-only"
+            : rawContextMode === "ancestry" ? "ancestry" : "parent-plus-refs";
+        const searchMode = rawSearchMode === "off" || rawSearchMode === "auto"
+            ? rawSearchMode : "on";
         // Node mode has no comfy dispatch in this unit; without this the request
         // falls through to generateViaResponses and bills OAuth. The envelope is
         // this file's nested shape, not the flat one generate uses.
         // Removed in wp7.
-        if (provider === "comfy") {
+        if (getProviderSurfaceSupport(provider, "node")?.supported === false) {
             finishStatus = "error";
             finishHttpStatus = 400;
             finishErrorCode = "COMFY_SURFACE_UNSUPPORTED";
@@ -76,7 +70,7 @@ export async function runNodeGeneration(req, res, ctx) {
             rawWebSearchEnabled: body.webSearchEnabled,
             searchMode,
         });
-        if (providerOptions.error) {
+        if (providerOptions.error !== undefined) {
             finishStatus = "error";
             finishHttpStatus = providerOptions.status;
             finishErrorCode = providerOptions.code;
@@ -102,7 +96,8 @@ export async function runNodeGeneration(req, res, ctx) {
                 parentNodeId,
             });
         }
-        const validation = validateNodeInputs(ctx, rawPrompt, references, moderation);
+        // Only API/OAuth persist the requested format; other providers select their output format.
+        const validation = validateNodeInputs(ctx, rawPrompt, references, moderation, activeProvider === "api" || activeProvider === "oauth" ? format : undefined);
         if (validation.error) {
             finishStatus = "error";
             finishHttpStatus = 400;
@@ -177,7 +172,7 @@ export async function runNodeGeneration(req, res, ctx) {
         }
         // Node mode chains images, so a parent node is exactly the reference the
         // adapter cannot use. Refuse instead of generating something unrelated.
-        if (activeProvider === "nai" && inputImageCount > 0) {
+        if (getProviderSurfaceSupport(activeProvider ?? "", "node")?.references === false && inputImageCount > 0) {
             finishStatus = "error";
             finishHttpStatus = 400;
             return res.status(400).json({
@@ -189,6 +184,18 @@ export async function runNodeGeneration(req, res, ctx) {
                 parentNodeId,
             });
         }
+        const admission = checkImageExecutionAdmission(ctx, {
+            provider: activeProvider, surface: "node", referenceCount: inputImageCount,
+        });
+        if (admission) {
+            finishStatus = "error";
+            finishHttpStatus = admission.status;
+            finishErrorCode = admission.code;
+            return res.status(admission.status).json({
+                error: { code: admission.code, message: admission.message },
+                code: admission.code, parentNodeId, requestId,
+            });
+        }
         const started = startJob({
             requestId,
             kind: "node",
@@ -255,7 +262,24 @@ export async function runNodeGeneration(req, res, ctx) {
             publish(requestId, "phase", { requestId, phase: "streaming" });
         }
         let b64, usage, webSearchCalls = 0, revisedPrompt = null;
-        const grokDirectApiKey = activeProvider === "grok-api" ? ctx.xaiApiKey : undefined;
+        const execution = await prepareImageExecution(ctx, {
+            surface: "node", provider: activeProvider, requestId,
+            signal: cancelController.signal, prompt: generationPrompt, rawPrompt: prompt,
+            references: refCheck.refDetails, sourceImage: parentB64, contextMode, searchMode,
+            partialImages: emitProgress ? 2 : 0,
+            options: { model: effectiveImageModel, quality, size: effectiveSize, moderation,
+                mode: normalizedPromptMode, reasoningEffort, webSearchEnabled },
+            nai: activeProvider === "nai" ? readNaiOptions(req.body) : {},
+        }, emitProgress ? {
+            onPartialImage: (partial) => {
+                if (isJobCanceled(requestId))
+                    return;
+                const pd = { requestId, image: dataUrlFromB64(format, partial.b64 ?? ""), index: partial.index };
+                if (streamResponse)
+                    writeSse(res, "partial", pd);
+                publish(requestId, "partial", pd);
+            },
+        } : undefined);
         let resultFormat = activeProvider === "grok" || activeProvider === "agy" || activeProvider === "grok-api" || activeProvider === "gemini-api" || activeProvider === "atlascloud" || activeProvider === "minimax" ? "jpeg" : format;
         const maxAttempts = inputImageCount > 0 ? 1 : 2;
         let lastErr = null;
@@ -279,88 +303,7 @@ export async function runNodeGeneration(req, res, ctx) {
                     searchMode,
                     webSearchEnabled,
                 });
-                const r = activeProvider === "gemini-api"
-                    ? await generateViaGeminiApi(parentB64 ? `Edit this image: ${generationPrompt}` : generationPrompt, requireRuntimeContext(ctx), {
-                        model: effectiveImageModel,
-                        size: effectiveSize,
-                        signal: cancelController.signal,
-                        requestId,
-                        references: parentB64
-                            ? [{ b64: parentB64, declaredMime: null, detectedMime: null }, ...(refCheck.refDetails || [])]
-                            : refCheck.refDetails,
-                    })
-                    : activeProvider === "agy"
-                        ? await generateViaAgy(parentB64 ? `Edit this image: ${generationPrompt}` : generationPrompt, {
-                            ...(parentB64
-                                ? { references: [{ b64: parentB64, declaredMime: null, detectedMime: null }] }
-                                : {}),
-                            signal: cancelController.signal,
-                            requestId,
-                        })
-                        : activeProvider === "atlascloud"
-                            ? await generateViaAtlasCloud(parentB64 ? `Edit this image: ${prompt}` : prompt, requireRuntimeContext(ctx), {
-                                model: effectiveImageModel,
-                                size: effectiveSize,
-                                quality,
-                                signal: cancelController.signal,
-                                requestId,
-                                references: parentB64
-                                    ? [{ b64: parentB64, declaredMime: null, detectedMime: null }, ...(refCheck.refDetails || [])]
-                                    : refCheck.refDetails,
-                            })
-                            : activeProvider === "minimax"
-                                ? await generateViaMinimax(parentB64 ? `Edit this image: ${prompt}` : prompt, requireRuntimeContext(ctx), {
-                                    model: effectiveImageModel,
-                                    size: effectiveSize,
-                                    signal: cancelController.signal,
-                                    requestId,
-                                    references: parentB64
-                                        ? [{ b64: parentB64, declaredMime: null, detectedMime: null }, ...(refCheck.refDetails || [])]
-                                        : refCheck.refDetails,
-                                })
-                                : activeProvider === "nai"
-                                    ? await generateViaNai(prompt, requireRuntimeContext(ctx), {
-                                        model: effectiveImageModel,
-                                        size: effectiveSize,
-                                        signal: cancelController.signal,
-                                        requestId,
-                                        ...readNaiOptions(req.body),
-                                    })
-                                    : activeProvider === "grok" || activeProvider === "grok-api"
-                                        ? await generateViaGrok(generationPrompt, ctx, {
-                                            model: effectiveImageModel,
-                                            size: effectiveSize,
-                                            requestId,
-                                            signal: cancelController.signal,
-                                            references: toGrokReferences(parentB64, refsForRequest),
-                                            directApiKey: grokDirectApiKey,
-                                        })
-                                        : parentB64
-                                            ? await editViaResponses(activeProvider, generationPrompt, parentB64, quality, effectiveSize, moderation, normalizedPromptMode, ctx, requestId, {
-                                                model: effectiveImageModel,
-                                                references: refsForRequest,
-                                                searchMode,
-                                                reasoningEffort,
-                                                webSearchEnabled,
-                                                signal: cancelController.signal,
-                                            })
-                                            : await generateViaResponses(activeProvider, generationPrompt, quality, effectiveSize, moderation, refsForRequest, requestId, normalizedPromptMode, ctx, {
-                                                model: effectiveImageModel,
-                                                reasoningEffort,
-                                                webSearchEnabled,
-                                                signal: cancelController.signal,
-                                                partialImages: emitProgress ? 2 : 0,
-                                                onPartialImage: emitProgress
-                                                    ? (partial) => {
-                                                        if (isJobCanceled(requestId))
-                                                            return;
-                                                        const pd = { requestId, image: dataUrlFromB64(format, partial.b64 ?? ""), index: partial.index };
-                                                        if (streamResponse)
-                                                            writeSse(res, "partial", pd);
-                                                        publish(requestId, "partial", pd);
-                                                    }
-                                                    : null,
-                                            });
+                const { value: r } = await execution.execute();
                 throwIfJobCanceled(requestId);
                 if (r.b64) {
                     b64 = r.b64;