ima2-gen 1.1.13 → 1.1.16

package/routes/multimode.ts

@@ -2,11 +2,12 @@ import { mkdir, writeFile } from "fs/promises";
 import { join } from "path";
 import { randomBytes } from "crypto";
 import type { Express, Request, Response } from "express";
-import { summarizeReferencePayload, validateAndNormalizeRefs } from "../lib/refs.js";
+import { detectImageMimeFromB64, summarizeReferencePayload, validateAndNormalizeRefs } from "../lib/refs.js";
 import { classifyUpstreamError } from "../lib/errorClassify.js";
 import { normalizeOAuthParams } from "../lib/oauthNormalize.js";
 import { resolveProviderOptions } from "../lib/providerOptions.js";
 import { generateMultimodeViaResponses } from "../lib/responsesImageAdapter.js";
+import { generateMultimodeViaGrok } from "../lib/grokMultimodeAdapter.js";
 import { startJob, finishJob, registerJobAbortController, isJobCanceled } from "../lib/inflight.js";
 import {
   isGenerationCanceledError,
@@ -48,6 +49,13 @@ function sequenceStatus(returned: number, requested: number): "empty" | "partial
 interface MultimodeImage {
   b64: string;
   revisedPrompt?: string | null;
+  mime?: string | null;
+}
+
+function imageFormatFromMime(mime: string | null | undefined): "png" | "jpeg" | "webp" {
+  if (mime === "image/jpeg") return "jpeg";
+  if (mime === "image/webp") return "webp";
+  return "png";
 }
 
 type MultimodeRouteItem = {
@@ -195,7 +203,8 @@ export function registerMultimodeRoutes(app: Express, ctxRaw: RouteRuntimeContex
 
       const startTime = Date.now();
       const mimeMap: Record<string, string> = { png: "image/png", jpeg: "image/jpeg", webp: "image/webp" };
-      const mime = mimeMap[String(format)] || "image/png";
+      const mmFormat = activeProvider === "grok" ? "jpeg" : String(format);
+      const mime = mimeMap[mmFormat] || "image/png";
       const sequenceId = `seq_${Date.now().toString(36)}_${randomBytes(4).toString("hex")}`;
       routeMaxImages = maxImages;
       routeSequenceId = sequenceId;
@@ -220,8 +229,12 @@ export function registerMultimodeRoutes(app: Express, ctxRaw: RouteRuntimeContex
       ) => {
         if (persistedIndexes.has(index)) return;
         throwIfJobCanceled(requestId);
+        const resultMime = activeProvider === "grok"
+          ? (image.mime || detectImageMimeFromB64(image.b64) || mime)
+          : mime;
+        const resultFormat = activeProvider === "grok" ? imageFormatFromMime(resultMime) : mmFormat;
         const rand = randomBytes(ctx.config.ids.generatedHexBytes).toString("hex");
-        const filename = `${Date.now()}_${rand}_multimode_${index}.${format}`;
+        const filename = `${Date.now()}_${rand}_multimode_${index}.${resultFormat}`;
         const meta = {
           kind: "multimode-image",
           generationStrategy: "one-call-text-sequence",
@@ -240,9 +253,9 @@ export function registerMultimodeRoutes(app: Express, ctxRaw: RouteRuntimeContex
           composerInsertedPrompts,
           quality,
           size: effectiveSize,
-          format,
+          format: resultFormat,
           moderation,
-          model: imageModel,
+          model: activeProvider === "grok" ? (quality === "high" ? "grok-imagine-image-quality" : imageModel) : imageModel,
           provider: activeProvider,
           createdAt: Date.now(),
           usage: latestUsage,
@@ -251,14 +264,14 @@ export function registerMultimodeRoutes(app: Express, ctxRaw: RouteRuntimeContex
           refsCount: refCheck.refs.length,
         };
         const rawBuffer = Buffer.from(image.b64, "base64");
-        const embedded = await embedImageMetadataBestEffort(rawBuffer, format, meta, {
+        const embedded = await embedImageMetadataBestEffort(rawBuffer, resultFormat, meta, {
           version: ctx.packageVersion,
         });
         await writeFile(join(ctx.config.storage.generatedDir, filename), embedded.buffer);
         await writeFile(join(ctx.config.storage.generatedDir, filename + ".json"), JSON.stringify(meta)).catch(() => {});
         invalidateHistoryIndex();
         const item = {
-          image: `data:${mime};base64,${image.b64}`,
+          image: `data:${resultMime};base64,${image.b64}`,
           filename,
           revisedPrompt: image.revisedPrompt || null,
           sequenceId,
@@ -273,42 +286,56 @@ export function registerMultimodeRoutes(app: Express, ctxRaw: RouteRuntimeContex
       };
 
       sendSse(res, "phase", { phase: "streaming", requestId, sequenceId, maxImages });
-      const generated = await generateMultimodeViaResponses(
-        activeProvider,
-        prompt,
-        quality,
-        effectiveSize,
-        moderation,
-        refCheck.refDetails || refCheck.refs,
-        requestId,
-        normalizedPromptMode,
-        ctx,
-        {
-          model: imageModel,
+
+      let generated: { images: Array<{ b64: string; revisedPrompt?: string | null }>; usage: Record<string, number> | null; webSearchCalls?: number; extraIgnored?: number };
+
+      if (activeProvider === "grok") {
+        const grokModel = quality === "high" ? "grok-imagine-image-quality" : imageModel;
+        generated = await generateMultimodeViaGrok(prompt, ctx, {
+          model: grokModel,
           maxImages,
-          reasoningEffort,
-          webSearchEnabled,
-          onPartialImage: (partial) =>
-            isJobCanceled(requestId)
-              ? undefined
-              : sendSse(res, "partial", {
-                  image: `data:${mime};base64,${partial.b64}`,
-                  requestId,
-                  sequenceId,
-                  index: partial.index,
-                }),
+          size: effectiveSize,
+          signal: cancelController.signal,
+          requestId,
+          references: refCheck.refDetails,
           onFinalImage: async (image, index) => {
             const totalReturned = Math.max(index + 1, images.length + 1);
-            await persistAndSendImage(
-              image,
-              index,
-              totalReturned,
-              sequenceStatus(totalReturned, maxImages),
-            );
+            await persistAndSendImage(image, index, totalReturned, sequenceStatus(totalReturned, maxImages));
           },
-          signal: cancelController.signal,
-        },
-      );
+        });
+      } else {
+        generated = await generateMultimodeViaResponses(
+          activeProvider,
+          prompt,
+          quality,
+          effectiveSize,
+          moderation,
+          refCheck.refDetails || refCheck.refs,
+          requestId,
+          normalizedPromptMode,
+          ctx,
+          {
+            model: imageModel,
+            maxImages,
+            reasoningEffort,
+            webSearchEnabled,
+            onPartialImage: (partial) =>
+              isJobCanceled(requestId)
+                ? undefined
+                : sendSse(res, "partial", {
+                    image: `data:${mime};base64,${partial.b64}`,
+                    requestId,
+                    sequenceId,
+                    index: partial.index,
+                  }),
+            onFinalImage: async (image, index) => {
+              const totalReturned = Math.max(index + 1, images.length + 1);
+              await persistAndSendImage(image, index, totalReturned, sequenceStatus(totalReturned, maxImages));
+            },
+            signal: cancelController.signal,
+          },
+        );
+      }
       throwIfJobCanceled(requestId);
 
       latestUsage = generated.usage || null;
@@ -326,6 +353,20 @@ export function registerMultimodeRoutes(app: Express, ctxRaw: RouteRuntimeContex
       const returned = images.length;
       const status = sequenceStatus(returned, maxImages);
       const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+      if (returned === 0) {
+        finishStatus = "error";
+        finishHttpStatus = 422;
+        finishErrorCode = "EMPTY_RESPONSE";
+        finishMeta = { sequenceId, filenames: [], imageCount: 0, maxImages, status, composerPrompt: routeComposerPrompt, composerInsertedPrompts: routeComposerInsertedPrompts };
+        sendSse(res, "error", {
+          error: "No image data returned from the multimode stream",
+          code: finishErrorCode,
+          status: finishHttpStatus,
+          requestId, sequenceId, requested: maxImages, returned,
+        });
+        logEvent("multimode", "empty_response", { requestId, sequenceId, maxImages, elapsedMs: Date.now() - startTime });
+        return;
+      }
       finishMeta = {
         sequenceId,
         filenames: images.map((image) => image.filename),

package/routes/nodes.js

@@ -2,11 +2,12 @@ import { mkdir } from "fs/promises";
 import { newNodeId, saveNode, loadNodeB64, loadNodeMeta, loadAssetB64, } from "../lib/nodeStore.js";
 import { startJob, finishJob, registerJobAbortController, isJobCanceled } from "../lib/inflight.js";
 import { isGenerationCanceledError, makeGenerationCanceledError, throwIfJobCanceled, } from "../lib/generationCancel.js";
-import { summarizeReferencePayload, validateAndNormalizeRefs } from "../lib/refs.js";
+import { detectImageMimeFromB64, summarizeReferencePayload, validateAndNormalizeRefs } from "../lib/refs.js";
 import { classifyUpstreamError } from "../lib/errorClassify.js";
 import { normalizeOAuthParams } from "../lib/oauthNormalize.js";
 import { resolveProviderOptions } from "../lib/providerOptions.js";
 import { generateViaResponses, editViaResponses } from "../lib/responsesImageAdapter.js";
+import { generateViaGrok } from "../lib/grokImageAdapter.js";
 import { isNonRetryableGenerationError, normalizeGenerationFailure } from "../lib/generationErrors.js";
 import { logEvent, logError } from "../lib/logger.js";
 import { errInfo } from "../lib/errInfo.js";
@@ -49,6 +50,29 @@ function writeNodeError(res, status, code, message, parentNodeId, details = {})
 function dataUrlFromB64(format, b64) {
     return `data:image/${format === "jpeg" ? "jpeg" : format};base64,${b64}`;
 }
+function imageFormatFromMime(mime) {
+    if (mime === "image/jpeg")
+        return "jpeg";
+    if (mime === "image/webp")
+        return "webp";
+    return "png";
+}
+async function loadParentNodeB64(ctx, nodeId) {
+    for (const ext of ["png", "jpeg", "webp"]) {
+        const meta = await loadNodeMeta(ctx.rootDir, nodeId, ext, ctx.config.storage.generatedDir);
+        if (meta)
+            return loadNodeB64(ctx.rootDir, `${nodeId}.${ext}`, ctx.config.storage.generatedDir);
+    }
+    return loadNodeB64(ctx.rootDir, `${nodeId}.png`, ctx.config.storage.generatedDir);
+}
+function toGrokReferences(parentB64, refs) {
+    const parentMime = parentB64 ? detectImageMimeFromB64(parentB64) : null;
+    const parentRefs = parentB64
+        ? [{ b64: parentB64, declaredMime: parentMime, detectedMime: parentMime }]
+        : [];
+    const normalizedRefs = refs.map((ref) => typeof ref === "string" ? { b64: ref } : ref);
+    return [...parentRefs, ...normalizedRefs];
+}
 export function registerNodeRoutes(app, ctxRaw) {
     const ctx = requireRuntimeContext(ctxRaw);
     app.post("/api/node/generate", async (req, res) => {
@@ -111,6 +135,9 @@ export function registerNodeRoutes(app, ctxRaw) {
             const effectiveSize = providerOptions.size;
             const webSearchEnabled = providerOptions.webSearchEnabled;
             const activeProvider = providerOptions.provider;
+            const effectiveImageModel = activeProvider === "grok" && quality === "high"
+                ? "grok-imagine-image-quality"
+                : imageModel;
             if (contextMode === "ancestry") {
                 finishStatus = "error";
                 finishHttpStatus = 400;
@@ -154,7 +181,7 @@ export function registerNodeRoutes(app, ctxRaw) {
             const startTime = Date.now();
             let parentB64 = null;
             if (parentNodeId) {
-                parentB64 = await loadNodeB64(ctx.rootDir, `${parentNodeId}.png`, ctx.config.storage.generatedDir);
+                parentB64 = await loadParentNodeB64(ctx, parentNodeId);
             }
             else if (typeof externalSrc === "string" && externalSrc.length > 0) {
                 parentB64 = await loadAssetB64(ctx.rootDir, externalSrc, ctx.config.storage.generatedDir);
@@ -166,6 +193,19 @@ export function registerNodeRoutes(app, ctxRaw) {
             const refsForRequest = contextMode === "parent-only" ? [] : (refCheck.refDetails || refCheck.refs);
             const parentImagePresent = !!parentB64;
             const inputImageCount = (parentImagePresent ? 1 : 0) + refsForRequest.length;
+            if (activeProvider === "grok" && inputImageCount > 3) {
+                finishStatus = "error";
+                finishHttpStatus = 400;
+                finishErrorCode = "GROK_REF_TOO_MANY";
+                return res.status(400).json({
+                    error: {
+                        code: "GROK_REF_TOO_MANY",
+                        message: "Grok image editing supports up to 3 reference images.",
+                    },
+                    code: "GROK_REF_TOO_MANY",
+                    parentNodeId,
+                });
+            }
             logEvent("node", "request", {
                 requestId,
                 operation,
@@ -173,7 +213,7 @@ export function registerNodeRoutes(app, ctxRaw) {
                 parentNodeId,
                 clientNodeId,
                 quality,
-                model: imageModel,
+                model: effectiveImageModel,
                 size: effectiveSize,
                 moderation,
                 refs: refsForRequest.length,
@@ -198,6 +238,7 @@ export function registerNodeRoutes(app, ctxRaw) {
                 writeSse(res, "phase", { requestId, phase: "streaming" });
             }
             let b64, usage, webSearchCalls = 0, revisedPrompt = null;
+            let resultFormat = activeProvider === "grok" ? "jpeg" : format;
             const MAX_RETRIES = 1;
             let lastErr = null;
             for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
@@ -209,7 +250,7 @@ export function registerNodeRoutes(app, ctxRaw) {
                         sessionId,
                         parentNodeId,
                         clientNodeId,
-                        model: imageModel,
+                        model: effectiveImageModel,
                         moderation,
                         quality,
                         size: effectiveSize,
@@ -220,37 +261,48 @@ export function registerNodeRoutes(app, ctxRaw) {
                         searchMode,
                         webSearchEnabled,
                     });
-                    const r = parentB64
-                        ? await editViaResponses(activeProvider, prompt, parentB64, quality, effectiveSize, moderation, normalizedPromptMode, ctx, requestId, {
-                            model: imageModel,
-                            references: refsForRequest,
-                            searchMode,
-                            reasoningEffort,
-                            webSearchEnabled,
+                    const r = activeProvider === "grok"
+                        ? await generateViaGrok(prompt, ctx, {
+                            model: effectiveImageModel,
+                            size: effectiveSize,
+                            requestId,
                             signal: cancelController.signal,
+                            references: toGrokReferences(parentB64, refsForRequest),
                         })
-                        : await generateViaResponses(activeProvider, prompt, quality, effectiveSize, moderation, refsForRequest, requestId, normalizedPromptMode, ctx, {
-                            model: imageModel,
-                            reasoningEffort,
-                            webSearchEnabled,
-                            signal: cancelController.signal,
-                            partialImages: streamResponse ? 2 : 0,
-                            onPartialImage: streamResponse
-                                ? (partial) => isJobCanceled(requestId)
-                                    ? undefined
-                                    : writeSse(res, "partial", {
-                                        requestId,
-                                        image: dataUrlFromB64(format, partial.b64),
-                                        index: partial.index,
-                                    })
-                                : null,
-                        });
+                        : parentB64
+                            ? await editViaResponses(activeProvider, prompt, parentB64, quality, effectiveSize, moderation, normalizedPromptMode, ctx, requestId, {
+                                model: effectiveImageModel,
+                                references: refsForRequest,
+                                searchMode,
+                                reasoningEffort,
+                                webSearchEnabled,
+                                signal: cancelController.signal,
+                            })
+                            : await generateViaResponses(activeProvider, prompt, quality, effectiveSize, moderation, refsForRequest, requestId, normalizedPromptMode, ctx, {
+                                model: effectiveImageModel,
+                                reasoningEffort,
+                                webSearchEnabled,
+                                signal: cancelController.signal,
+                                partialImages: streamResponse ? 2 : 0,
+                                onPartialImage: streamResponse
+                                    ? (partial) => isJobCanceled(requestId)
+                                        ? undefined
+                                        : writeSse(res, "partial", {
+                                            requestId,
+                                            image: dataUrlFromB64(format, partial.b64),
+                                            index: partial.index,
+                                        })
+                                    : null,
+                            });
                     throwIfJobCanceled(requestId);
                     if (r.b64) {
                         b64 = r.b64;
                         usage = r.usage;
                         webSearchCalls = r.webSearchCalls || 0;
                         revisedPrompt = r.revisedPrompt || null;
+                        if (activeProvider === "grok") {
+                            resultFormat = imageFormatFromMime(("mime" in r ? r.mime : undefined) || detectImageMimeFromB64(r.b64) || "image/jpeg");
+                        }
                         break;
                     }
                     lastErr = { message: "Empty response (safety refusal)" };
@@ -319,8 +371,9 @@ export function registerNodeRoutes(app, ctxRaw) {
                 userPrompt: prompt,
                 revisedPrompt,
                 promptMode: normalizedPromptMode,
-                options: { quality, size: effectiveSize, format, moderation },
-                model: imageModel,
+                options: { quality, size: effectiveSize, format: resultFormat, moderation },
+                model: effectiveImageModel,
+                reasoningEffort,
                 createdAt: Date.now(),
                 createdAtIso: new Date().toISOString(),
                 elapsed,
@@ -335,7 +388,7 @@ export function registerNodeRoutes(app, ctxRaw) {
                 refsCount: refsForRequest.length,
                 quality,
                 size: effectiveSize,
-                format,
+                format: resultFormat,
                 moderation,
             };
             await mkdir(ctx.config.storage.generatedDir, { recursive: true });
@@ -344,7 +397,7 @@ export function registerNodeRoutes(app, ctxRaw) {
                 nodeId,
                 b64,
                 meta,
-                ext: format,
+                ext: resultFormat,
                 generatedDir: ctx.config.storage.generatedDir,
             });
             finishMeta = { nodeId, filename, imageChars: b64.length };
@@ -360,7 +413,7 @@ export function registerNodeRoutes(app, ctxRaw) {
                 nodeId,
                 parentNodeId,
                 requestId,
-                image: dataUrlFromB64(format, b64),
+                image: dataUrlFromB64(resultFormat, b64),
                 filename,
                 url: `/generated/${filename}`,
                 elapsed,
@@ -368,8 +421,10 @@ export function registerNodeRoutes(app, ctxRaw) {
                 webSearchCalls,
                 webSearchEnabled,
                 provider: activeProvider,
-                model: imageModel,
+                model: effectiveImageModel,
+                reasoningEffort,
                 size: effectiveSize,
+                format: resultFormat,
                 moderation,
                 refsCount: refsForRequest.length,
                 contextMode,

package/routes/nodes.ts

@@ -13,11 +13,12 @@ import {
   makeGenerationCanceledError,
   throwIfJobCanceled,
 } from "../lib/generationCancel.js";
-import { summarizeReferencePayload, validateAndNormalizeRefs } from "../lib/refs.js";
+import { detectImageMimeFromB64, summarizeReferencePayload, validateAndNormalizeRefs } from "../lib/refs.js";
 import { classifyUpstreamError } from "../lib/errorClassify.js";
 import { normalizeOAuthParams } from "../lib/oauthNormalize.js";
 import { resolveProviderOptions } from "../lib/providerOptions.js";
 import { generateViaResponses, editViaResponses } from "../lib/responsesImageAdapter.js";
+import { generateViaGrok, type GrokReferenceImage } from "../lib/grokImageAdapter.js";
 import { isNonRetryableGenerationError, normalizeGenerationFailure, type UpstreamErr } from "../lib/generationErrors.js";
 import { logEvent, logError } from "../lib/logger.js";
 
@@ -75,6 +76,29 @@ function dataUrlFromB64(format: string, b64: string) {
   return `data:image/${format === "jpeg" ? "jpeg" : format};base64,${b64}`;
 }
 
+function imageFormatFromMime(mime: string | null | undefined): "png" | "jpeg" | "webp" {
+  if (mime === "image/jpeg") return "jpeg";
+  if (mime === "image/webp") return "webp";
+  return "png";
+}
+
+async function loadParentNodeB64(ctx: RuntimeContext, nodeId: string) {
+  for (const ext of ["png", "jpeg", "webp"] as const) {
+    const meta = await loadNodeMeta(ctx.rootDir, nodeId, ext, ctx.config.storage.generatedDir);
+    if (meta) return loadNodeB64(ctx.rootDir, `${nodeId}.${ext}`, ctx.config.storage.generatedDir);
+  }
+  return loadNodeB64(ctx.rootDir, `${nodeId}.png`, ctx.config.storage.generatedDir);
+}
+
+function toGrokReferences(parentB64: string | null, refs: Array<GrokReferenceImage | string>): GrokReferenceImage[] {
+  const parentMime = parentB64 ? detectImageMimeFromB64(parentB64) : null;
+  const parentRefs = parentB64
+    ? [{ b64: parentB64, declaredMime: parentMime, detectedMime: parentMime }]
+    : [];
+  const normalizedRefs = refs.map((ref) => typeof ref === "string" ? { b64: ref } : ref);
+  return [...parentRefs, ...normalizedRefs];
+}
+
 export function registerNodeRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
   const ctx = requireRuntimeContext(ctxRaw);
   app.post("/api/node/generate", async (req: Request, res: Response) => {
@@ -170,6 +194,9 @@ export function registerNodeRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
       const effectiveSize = providerOptions.size;
       const webSearchEnabled = providerOptions.webSearchEnabled;
       const activeProvider = providerOptions.provider;
+      const effectiveImageModel = activeProvider === "grok" && quality === "high"
+        ? "grok-imagine-image-quality"
+        : imageModel;
       if (contextMode === "ancestry") {
         finishStatus = "error";
         finishHttpStatus = 400;
@@ -215,7 +242,7 @@ export function registerNodeRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
       const startTime = Date.now();
       let parentB64: string | null = null;
       if (parentNodeId) {
-        parentB64 = await loadNodeB64(ctx.rootDir, `${parentNodeId}.png`, ctx.config.storage.generatedDir);
+        parentB64 = await loadParentNodeB64(ctx, parentNodeId);
       } else if (typeof externalSrc === "string" && externalSrc.length > 0) {
         parentB64 = await loadAssetB64(ctx.rootDir, externalSrc, ctx.config.storage.generatedDir);
       }
@@ -226,6 +253,19 @@ export function registerNodeRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
       const refsForRequest = contextMode === "parent-only" ? [] : (refCheck.refDetails || refCheck.refs);
       const parentImagePresent = !!parentB64;
       const inputImageCount = (parentImagePresent ? 1 : 0) + refsForRequest.length;
+      if (activeProvider === "grok" && inputImageCount > 3) {
+        finishStatus = "error";
+        finishHttpStatus = 400;
+        finishErrorCode = "GROK_REF_TOO_MANY";
+        return res.status(400).json({
+          error: {
+            code: "GROK_REF_TOO_MANY",
+            message: "Grok image editing supports up to 3 reference images.",
+          },
+          code: "GROK_REF_TOO_MANY",
+          parentNodeId,
+        });
+      }
       logEvent("node", "request", {
         requestId,
         operation,
@@ -233,7 +273,7 @@ export function registerNodeRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
         parentNodeId,
         clientNodeId,
         quality,
-        model: imageModel,
+        model: effectiveImageModel,
         size: effectiveSize,
         moderation,
         refs: refsForRequest.length,
@@ -260,6 +300,7 @@ export function registerNodeRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
       }
 
       let b64: string | undefined, usage: unknown, webSearchCalls = 0, revisedPrompt: string | null = null;
+      let resultFormat: "png" | "jpeg" | "webp" = activeProvider === "grok" ? "jpeg" : format as "png" | "jpeg" | "webp";
       const MAX_RETRIES = 1;
       let lastErr: UpstreamErr | null = null;
       for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
@@ -271,7 +312,7 @@ export function registerNodeRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
             sessionId,
             parentNodeId,
             clientNodeId,
-            model: imageModel,
+            model: effectiveImageModel,
             moderation,
             quality,
             size: effectiveSize,
@@ -282,49 +323,60 @@ export function registerNodeRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
             searchMode,
             webSearchEnabled,
           });
-          const r = parentB64
-            ? await editViaResponses(activeProvider, prompt, parentB64, quality, effectiveSize, moderation, normalizedPromptMode, ctx, requestId, {
-                model: imageModel,
-                references: refsForRequest,
-                searchMode,
-                reasoningEffort,
-                webSearchEnabled,
+          const r = activeProvider === "grok"
+            ? await generateViaGrok(prompt, ctx, {
+                model: effectiveImageModel,
+                size: effectiveSize,
+                requestId,
                 signal: cancelController.signal,
+                references: toGrokReferences(parentB64, refsForRequest),
               })
-            : await generateViaResponses(
-                activeProvider,
-                prompt,
-                quality,
-                effectiveSize,
-                moderation,
-                refsForRequest,
-                requestId,
-                normalizedPromptMode,
-                ctx,
-                {
-                  model: imageModel,
+            : parentB64
+              ? await editViaResponses(activeProvider, prompt, parentB64, quality, effectiveSize, moderation, normalizedPromptMode, ctx, requestId, {
+                  model: effectiveImageModel,
+                  references: refsForRequest,
+                  searchMode,
                   reasoningEffort,
                   webSearchEnabled,
                   signal: cancelController.signal,
-                  partialImages: streamResponse ? 2 : 0,
-                  onPartialImage: streamResponse
-                    ? (partial) =>
-                        isJobCanceled(requestId)
-                          ? undefined
-                          : writeSse(res, "partial", {
-                              requestId,
-                              image: dataUrlFromB64(format, partial.b64),
-                              index: partial.index,
-                            })
-                    : null,
-                },
-              );
+                })
+              : await generateViaResponses(
+                  activeProvider,
+                  prompt,
+                  quality,
+                  effectiveSize,
+                  moderation,
+                  refsForRequest,
+                  requestId,
+                  normalizedPromptMode,
+                  ctx,
+                  {
+                    model: effectiveImageModel,
+                    reasoningEffort,
+                    webSearchEnabled,
+                    signal: cancelController.signal,
+                    partialImages: streamResponse ? 2 : 0,
+                    onPartialImage: streamResponse
+                      ? (partial) =>
+                          isJobCanceled(requestId)
+                            ? undefined
+                            : writeSse(res, "partial", {
+                                requestId,
+                                image: dataUrlFromB64(format, partial.b64),
+                                index: partial.index,
+                              })
+                      : null,
+                  },
+                );
           throwIfJobCanceled(requestId);
           if (r.b64) {
             b64 = r.b64;
             usage = r.usage;
             webSearchCalls = r.webSearchCalls || 0;
             revisedPrompt = r.revisedPrompt || null;
+            if (activeProvider === "grok") {
+              resultFormat = imageFormatFromMime(("mime" in r ? r.mime : undefined) || detectImageMimeFromB64(r.b64) || "image/jpeg");
+            }
             break;
           }
           lastErr = { message: "Empty response (safety refusal)" };
@@ -400,8 +452,9 @@ export function registerNodeRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
         userPrompt: prompt,
         revisedPrompt,
         promptMode: normalizedPromptMode,
-        options: { quality, size: effectiveSize, format, moderation },
-        model: imageModel,
+        options: { quality, size: effectiveSize, format: resultFormat, moderation },
+        model: effectiveImageModel,
+        reasoningEffort,
         createdAt: Date.now(),
         createdAtIso: new Date().toISOString(),
         elapsed,
@@ -416,7 +469,7 @@ export function registerNodeRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
         refsCount: refsForRequest.length,
         quality,
         size: effectiveSize,
-        format,
+        format: resultFormat,
         moderation,
       };
       await mkdir(ctx.config.storage.generatedDir, { recursive: true });
@@ -425,7 +478,7 @@ export function registerNodeRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
         nodeId,
         b64,
         meta,
-        ext: format,
+        ext: resultFormat,
         generatedDir: ctx.config.storage.generatedDir,
       });
       finishMeta = { nodeId, filename, imageChars: b64.length };
@@ -442,7 +495,7 @@ export function registerNodeRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
         nodeId,
         parentNodeId,
         requestId,
-        image: dataUrlFromB64(format, b64),
+        image: dataUrlFromB64(resultFormat, b64),
         filename,
         url: `/generated/${filename}`,
         elapsed,
@@ -450,8 +503,10 @@ export function registerNodeRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
         webSearchCalls,
         webSearchEnabled,
         provider: activeProvider,
-        model: imageModel,
+        model: effectiveImageModel,
+        reasoningEffort,
         size: effectiveSize,
+        format: resultFormat,
         moderation,
         refsCount: refsForRequest.length,
         contextMode,