ima2-gen 2.0.1 → 2.0.2

package/routes/multimode.js

@@ -11,7 +11,7 @@ import { generateMultimodeViaResponses } from "../lib/responsesImageAdapter.js";
 import { generateMultimodeViaGrok } from "../lib/grokMultimodeAdapter.js";
 import { generateViaAgy } from "../lib/agyImageAdapter.js";
 import { generateViaGeminiApi } from "../lib/geminiApiImageAdapter.js";
-import { startJob, finishJob, registerJobAbortController, isJobCanceled } from "../lib/inflight.js";
+import { startJob, finishJob, registerJobAbortController, isJobCanceled, isStartJobFailure, INFLIGHT_RETRY_AFTER_SECONDS } from "../lib/inflight.js";
 import { isGenerationCanceledError, makeGenerationCanceledError, throwIfJobCanceled, } from "../lib/generationCancel.js";
 import { logEvent, logError } from "../lib/logger.js";
 import { embedImageMetadataBestEffort } from "../lib/imageMetadataStore.js";
@@ -19,37 +19,35 @@ import { invalidateHistoryIndex } from "../lib/historyIndex.js";
 import { normalizeComposerInsertedPrompts, normalizeComposerPrompt, } from "../lib/composerSnapshot.js";
 import { errInfo } from "../lib/errInfo.js";
 import { requireRuntimeContext } from "../lib/runtimeContext.js";
-function sendSse(res, event, data) {
-    res.write(`event: ${event}\n`);
-    res.write(`data: ${JSON.stringify(data)}\n\n`);
-}
-function validateModeration(ctx, moderation) {
-    if (typeof moderation !== "string" || !ctx.config.oauth.validModeration.has(moderation)) {
-        return { error: "moderation must be one of: auto, low" };
+import { validateModeration, imageFormatFromMime, writeSse } from "../lib/routeHelpers.js";
+import { publish } from "../lib/eventBus.js";
+import { publishJobEvent } from "../lib/ssePublish.js";
+import { normalizeMaxImages, sequenceStatus, } from "../lib/multimodeHelpers.js";
+function dualEmitMultimode(res, requestId, event, data) {
+    if (!res.writableEnded)
+        writeSse(res, event, data);
+    if (event === "done") {
+        publishJobEvent(requestId, event, data);
+    }
+    else {
+        publish(requestId, event, data);
     }
-    return { moderation };
-}
-function normalizeMaxImages(value) {
-    return Math.min(8, Math.max(1, Math.trunc(Number(value) || 1)));
-}
-function sequenceStatus(returned, requested) {
-    if (returned <= 0)
-        return "empty";
-    if (returned < requested)
-        return "partial";
-    return "complete";
 }
-function imageFormatFromMime(mime) {
-    if (mime === "image/jpeg")
-        return "jpeg";
-    if (mime === "image/webp")
-        return "webp";
-    return "png";
+function respondMultimodeValidationError(res, requestId, asyncMode, status, payload) {
+    publish(requestId, "error", payload);
+    if (asyncMode && !res.headersSent) {
+        return res.status(status).json(payload);
+    }
+    if (!res.writableEnded) {
+        writeSse(res, "error", payload);
+        res.end();
+    }
 }
 export function registerMultimodeRoutes(app, ctxRaw) {
     const ctx = requireRuntimeContext(ctxRaw);
     app.post("/api/generate/multimode", async (req, res) => {
         const requestId = typeof req.body?.requestId === "string" ? req.body.requestId : req.id;
+        const asyncMode = req.body?.async === true;
         let finishStatus = "completed";
         let finishHttpStatus = 200;
         let finishErrorCode;
@@ -74,10 +72,12 @@ export function registerMultimodeRoutes(app, ctxRaw) {
         let latestUsage = null;
         let latestWebSearchCalls = 0;
         let latestExtraIgnored = 0;
-        res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
-        res.setHeader("Cache-Control", "no-cache, no-transform");
-        res.setHeader("Connection", "keep-alive");
-        res.flushHeaders?.();
+        if (!asyncMode) {
+            res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+            res.setHeader("Cache-Control", "no-cache, no-transform");
+            res.setHeader("Connection", "keep-alive");
+            res.flushHeaders?.();
+        }
         try {
             const { prompt, quality: rawQuality = "medium", size = "1024x1024", format = "png", moderation = "low", provider = "auto", references = [], mode: promptMode = "auto", model: rawModel, reasoningEffort: rawReasoningEffort, webSearchEnabled: rawWebSearchEnabled = true, } = req.body;
             const composerPrompt = normalizeComposerPrompt(req.body?.composerPrompt);
@@ -96,8 +96,12 @@ export function registerMultimodeRoutes(app, ctxRaw) {
                 finishStatus = "error";
                 finishHttpStatus = providerOptions.status;
                 finishErrorCode = providerOptions.code;
-                sendSse(res, "error", { error: providerOptions.error, code: providerOptions.code, status: providerOptions.status, requestId });
-                return;
+                return respondMultimodeValidationError(res, requestId, asyncMode, providerOptions.status, {
+                    error: providerOptions.error,
+                    code: providerOptions.code,
+                    status: providerOptions.status,
+                    requestId,
+                });
             }
             const imageModel = providerOptions.model;
             const reasoningEffort = providerOptions.reasoningEffort;
@@ -108,28 +112,41 @@ export function registerMultimodeRoutes(app, ctxRaw) {
                 finishStatus = "error";
                 finishHttpStatus = 400;
                 finishErrorCode = "PROMPT_REQUIRED";
-                sendSse(res, "error", { error: "Prompt is required", code: finishErrorCode, status: 400, requestId });
-                return;
+                return respondMultimodeValidationError(res, requestId, asyncMode, 400, {
+                    error: "Prompt is required",
+                    code: finishErrorCode,
+                    status: 400,
+                    requestId,
+                });
             }
             const moderationCheck = validateModeration(ctx, moderation);
             if (moderationCheck.error) {
                 finishStatus = "error";
                 finishHttpStatus = 400;
                 finishErrorCode = "INVALID_MODERATION";
-                sendSse(res, "error", { error: moderationCheck.error, code: finishErrorCode, status: 400, requestId });
-                return;
+                return respondMultimodeValidationError(res, requestId, asyncMode, 400, {
+                    error: moderationCheck.error,
+                    code: finishErrorCode,
+                    status: 400,
+                    requestId,
+                });
             }
             const refCheckResult = validateAndNormalizeRefs(references);
             if (refCheckResult.error) {
                 finishStatus = "error";
                 finishHttpStatus = 400;
                 finishErrorCode = refCheckResult.code;
-                sendSse(res, "error", { error: refCheckResult.error, code: refCheckResult.code, status: 400, requestId });
-                return;
+                return respondMultimodeValidationError(res, requestId, asyncMode, 400, {
+                    error: refCheckResult.error,
+                    code: refCheckResult.code,
+                    status: 400,
+                    requestId,
+                });
             }
             const refCheck = refCheckResult;
+            const incomingProviderUrl = typeof req.body?.providerUrl === "string" && req.body.providerUrl.startsWith("http") ? req.body.providerUrl : null;
             const referencePayload = summarizeReferencePayload(references);
-            startJob({
+            const started = startJob({
                 requestId,
                 kind: "multimode",
                 prompt,
@@ -146,7 +163,25 @@ export function registerMultimodeRoutes(app, ctxRaw) {
                     composerInsertedPrompts,
                 },
             });
+            if (started && isStartJobFailure(started)) {
+                finishStatus = "error";
+                finishHttpStatus = started.code === "TOO_MANY_JOBS" ? 429 : 409;
+                finishErrorCode = started.code;
+                if (started.code === "TOO_MANY_JOBS") {
+                    res.setHeader("Retry-After", String(INFLIGHT_RETRY_AFTER_SECONDS));
+                }
+                return respondMultimodeValidationError(res, requestId, asyncMode, finishHttpStatus, {
+                    error: started.code === "TOO_MANY_JOBS"
+                        ? "Too many concurrent generation jobs"
+                        : "Request ID already in use",
+                    code: started.code,
+                    status: finishHttpStatus,
+                    requestId,
+                });
+            }
             registerJobAbortController(requestId, cancelController);
+            if (asyncMode)
+                res.status(202).json({ requestId });
             logEvent("multimode", "request", {
                 requestId,
                 quality,
@@ -188,6 +223,7 @@ export function registerMultimodeRoutes(app, ctxRaw) {
                 const resultFormat = activeProvider === "grok" || activeProvider === "agy" || activeProvider === "grok-api" || activeProvider === "gemini-api" ? imageFormatFromMime(resultMime) : mmFormat;
                 const rand = randomBytes(ctx.config.ids.generatedHexBytes).toString("hex");
                 const filename = `${Date.now()}_${rand}_multimode_${index}.${resultFormat}`;
+                const createdAt = Date.now();
                 const meta = {
                     kind: "multimode-image",
                     generationStrategy: "one-call-text-sequence",
@@ -210,11 +246,12 @@ export function registerMultimodeRoutes(app, ctxRaw) {
                     moderation,
                     model: activeProvider === "grok" ? (quality === "high" ? "grok-imagine-image-quality" : imageModel) : imageModel,
                     provider: activeProvider,
-                    createdAt: Date.now(),
+                    createdAt,
                     usage: latestUsage,
                     webSearchCalls: latestWebSearchCalls,
                     webSearchEnabled,
                     refsCount: refCheck.refs.length,
+                    ...(image.providerUrl ? { providerUrl: image.providerUrl } : {}),
                 };
                 const rawBuffer = Buffer.from(image.b64, "base64");
                 const embedded = await embedImageMetadataBestEffort(rawBuffer, resultFormat, meta, {
@@ -228,6 +265,8 @@ export function registerMultimodeRoutes(app, ctxRaw) {
                 const item = {
                     image: `data:${resultMime};base64,${image.b64}`,
                     filename,
+                    createdAt,
+                    ...(image.providerUrl ? { providerUrl: image.providerUrl } : {}),
                     revisedPrompt: image.revisedPrompt || null,
                     sequenceId,
                     sequenceIndex: index + 1,
@@ -237,9 +276,9 @@ export function registerMultimodeRoutes(app, ctxRaw) {
                 };
                 persistedIndexes.add(index);
                 images.push(item);
-                sendSse(res, "image", item);
+                dualEmitMultimode(res, requestId, "image", item);
             };
-            sendSse(res, "phase", { phase: "streaming", requestId, sequenceId, maxImages });
+            dualEmitMultimode(res, requestId, "phase", { phase: "streaming", requestId, sequenceId, maxImages });
             let generated;
             if (activeProvider === "gemini-api") {
                 const r = await generateViaGeminiApi(prompt, requireRuntimeContext(ctx), {
@@ -270,13 +309,16 @@ export function registerMultimodeRoutes(app, ctxRaw) {
             else if (activeProvider === "grok" || activeProvider === "grok-api") {
                 const directApiKey = activeProvider === "grok-api" ? ctx.xaiApiKey : undefined;
                 const grokModel = quality === "high" ? "grok-imagine-image-quality" : imageModel;
+                const grokRefs = incomingProviderUrl
+                    ? [{ b64: "", url: incomingProviderUrl }, ...refCheck.refDetails]
+                    : refCheck.refDetails;
                 generated = await generateMultimodeViaGrok(prompt, ctx, {
                     model: grokModel,
                     maxImages,
                     size: effectiveSize,
                     signal: cancelController.signal,
                     requestId,
-                    references: refCheck.refDetails,
+                    references: grokRefs,
                     directApiKey,
                     onFinalImage: async (image, index) => {
                         const totalReturned = Math.max(index + 1, images.length + 1);
@@ -290,14 +332,14 @@ export function registerMultimodeRoutes(app, ctxRaw) {
                     maxImages,
                     reasoningEffort,
                     webSearchEnabled,
-                    onPartialImage: (partial) => isJobCanceled(requestId)
-                        ? undefined
-                        : sendSse(res, "partial", {
-                            image: `data:${mime};base64,${partial.b64}`,
-                            requestId,
-                            sequenceId,
-                            index: partial.index,
-                        }),
+                    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));
@@ -320,7 +362,7 @@ export function registerMultimodeRoutes(app, ctxRaw) {
                 finishHttpStatus = 422;
                 finishErrorCode = "EMPTY_RESPONSE";
                 finishMeta = { sequenceId, filenames: [], imageCount: 0, maxImages, status, composerPrompt: routeComposerPrompt, composerInsertedPrompts: routeComposerInsertedPrompts };
-                sendSse(res, "error", {
+                dualEmitMultimode(res, requestId, "error", {
                     error: "No image data returned from the multimode stream",
                     code: finishErrorCode,
                     status: finishHttpStatus,
@@ -339,7 +381,7 @@ export function registerMultimodeRoutes(app, ctxRaw) {
                 composerInsertedPrompts: routeComposerInsertedPrompts,
             };
             finishHttpStatus = 200;
-            sendSse(res, "done", {
+            dualEmitMultimode(res, requestId, "done", {
                 ok: true,
                 requestId,
                 sequenceId,
@@ -378,7 +420,7 @@ export function registerMultimodeRoutes(app, ctxRaw) {
                 finishCanceled = true;
                 finishHttpStatus = canceled.status;
                 finishErrorCode = canceled.code;
-                sendSse(res, "error", {
+                dualEmitMultimode(res, requestId, "error", {
                     error: canceled.message,
                     code: canceled.code,
                     status: canceled.status,
@@ -401,7 +443,7 @@ export function registerMultimodeRoutes(app, ctxRaw) {
                     composerPrompt: routeComposerPrompt,
                     composerInsertedPrompts: routeComposerInsertedPrompts,
                 };
-                sendSse(res, "done", {
+                dualEmitMultimode(res, requestId, "done", {
                     ok: true,
                     partial: true,
                     requestId,
@@ -439,7 +481,7 @@ export function registerMultimodeRoutes(app, ctxRaw) {
             finishHttpStatus = err.status || 500;
             finishErrorCode = fallbackCode || "MULTIMODE_GENERATE_FAILED";
             logError("multimode", "error", err.raw, { requestId, code: finishErrorCode });
-            sendSse(res, "error", {
+            dualEmitMultimode(res, requestId, "error", {
                 error: err.message,
                 code: finishErrorCode,
                 status: finishHttpStatus,
@@ -457,7 +499,8 @@ export function registerMultimodeRoutes(app, ctxRaw) {
                 errorCode: finishErrorCode,
                 meta: finishMeta,
             });
-            res.end();
+            if (!res.writableEnded)
+                res.end();
         }
     });
 }

package/routes/nodes.js

@@ -1,6 +1,6 @@
 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 { newNodeId, saveNode, loadNodeMeta, loadAssetB64, } from "../lib/nodeStore.js";
+import { startJob, finishJob, registerJobAbortController, isJobCanceled, isStartJobFailure, INFLIGHT_RETRY_AFTER_SECONDS } from "../lib/inflight.js";
 import { isGenerationCanceledError, makeGenerationCanceledError, throwIfJobCanceled, } from "../lib/generationCancel.js";
 import { detectImageMimeFromB64, summarizeReferencePayload, validateAndNormalizeRefs } from "../lib/refs.js";
 import { classifyUpstreamError } from "../lib/errorClassify.js";
@@ -14,72 +14,16 @@ import { isNonRetryableGenerationError, normalizeGenerationFailure } from "../li
 import { logEvent, logError } from "../lib/logger.js";
 import { errInfo } from "../lib/errInfo.js";
 import { requireRuntimeContext } from "../lib/runtimeContext.js";
-function asUpstream(e) {
-    return (e && typeof e === "object" ? e : {});
-}
-function validateModeration(ctx, moderation) {
-    if (typeof moderation !== "string" || !ctx.config.oauth.validModeration.has(moderation)) {
-        return { error: "moderation must be one of: auto, low" };
-    }
-    return { moderation };
-}
-function wantsSse(req) {
-    const accept = typeof req.headers.accept === "string" ? req.headers.accept : "";
-    return accept.includes("text/event-stream");
-}
-function writeSse(res, event, data) {
-    res.write(`event: ${event}\n`);
-    res.write(`data: ${JSON.stringify(data)}\n\n`);
-}
-function writeNodeError(res, status, code, message, parentNodeId, details = {}) {
-    if (res.headersSent) {
-        writeSse(res, "error", {
-            error: { code, message },
-            parentNodeId,
-            status,
-            ...details,
-        });
-        res.end();
-        return;
-    }
-    res.status(status).json({
-        error: { code, message },
-        parentNodeId,
-        status,
-        ...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];
-}
+import { validateModeration, imageFormatFromMime, writeSse, dataUrlFromB64 } from "../lib/routeHelpers.js";
+import { publish } from "../lib/eventBus.js";
+import { publishJobEvent } from "../lib/ssePublish.js";
+import { asUpstream, wantsSse, writeNodeError, loadParentNodeB64, toGrokReferences, nodeErrorDetails, } from "../lib/nodeHelpers.js";
 export function registerNodeRoutes(app, ctxRaw) {
     const ctx = requireRuntimeContext(ctxRaw);
     app.post("/api/node/generate", async (req, res) => {
         const body = (req.body ?? {});
-        const streamResponse = wantsSse(req);
+        const asyncMode = body.async === true;
+        const streamResponse = !asyncMode && wantsSse(req);
         const parentNodeId = (typeof body.parentNodeId === "string" ? body.parentNodeId : null);
         const requestId = typeof body.requestId === "string" ? body.requestId : (req.id ?? "");
         const sessionId = typeof body.sessionId === "string" ? body.sessionId : null;
@@ -91,21 +35,6 @@ export function registerNodeRoutes(app, ctxRaw) {
         let finishCanceled = false;
         const cancelController = new AbortController();
         const referencePayload = summarizeReferencePayload(body.references);
-        startJob({
-            requestId,
-            kind: "node",
-            prompt: body.prompt,
-            meta: {
-                kind: "node",
-                sessionId,
-                parentNodeId,
-                clientNodeId,
-                refsCount: referencePayload.refsCount,
-                referenceBytes: referencePayload.referenceBytes,
-                referenceB64Chars: referencePayload.referenceB64Chars,
-            },
-        });
-        registerJobAbortController(requestId, cancelController);
         try {
             const { prompt, quality: rawQuality = "medium", size = "1024x1024", format = "png", moderation = "low", references = [], externalSrc = null, mode: promptMode = "auto", contextMode: rawContextMode = "parent-plus-refs", searchMode: rawSearchMode = "on", model: rawModel, reasoningEffort: rawReasoningEffort, } = body;
             const { provider = "oauth" } = body;
@@ -208,6 +137,34 @@ export function registerNodeRoutes(app, ctxRaw) {
                     parentNodeId,
                 });
             }
+            const started = startJob({
+                requestId,
+                kind: "node",
+                prompt: body.prompt,
+                meta: {
+                    kind: "node",
+                    sessionId,
+                    parentNodeId,
+                    clientNodeId,
+                    refsCount: referencePayload.refsCount,
+                    referenceBytes: referencePayload.referenceBytes,
+                    referenceB64Chars: referencePayload.referenceB64Chars,
+                },
+            });
+            if (started && isStartJobFailure(started)) {
+                finishStatus = "error";
+                finishHttpStatus = started.code === "TOO_MANY_JOBS" ? 429 : 409;
+                finishErrorCode = started.code;
+                if (started.code === "TOO_MANY_JOBS") {
+                    res.setHeader("Retry-After", String(INFLIGHT_RETRY_AFTER_SECONDS));
+                }
+                return writeNodeError(res, finishHttpStatus, started.code, started.code === "TOO_MANY_JOBS"
+                    ? "Too many concurrent generation jobs"
+                    : "Request ID already in use", parentNodeId, {}, requestId);
+            }
+            registerJobAbortController(requestId, cancelController);
+            if (asyncMode)
+                res.status(202).json({ requestId });
             logEvent("node", "request", {
                 requestId,
                 operation,
@@ -231,6 +188,7 @@ export function registerNodeRoutes(app, ctxRaw) {
                 promptChars: prompt.length,
                 promptMode: normalizedPromptMode,
             });
+            const emitProgress = streamResponse || asyncMode;
             if (streamResponse) {
                 res.writeHead(200, {
                     "Content-Type": "text/event-stream; charset=utf-8",
@@ -238,6 +196,10 @@ export function registerNodeRoutes(app, ctxRaw) {
                     Connection: "keep-alive",
                 });
                 writeSse(res, "phase", { requestId, phase: "streaming" });
+                publish(requestId, "phase", { requestId, phase: "streaming" });
+            }
+            else if (asyncMode) {
+                publish(requestId, "phase", { requestId, phase: "streaming" });
             }
             let b64, usage, webSearchCalls = 0, revisedPrompt = null;
             const grokDirectApiKey = activeProvider === "grok-api" ? ctx.xaiApiKey : undefined;
@@ -305,15 +267,16 @@ export function registerNodeRoutes(app, ctxRaw) {
                                         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,
-                                                })
+                                        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,
                                     });
                     throwIfJobCanceled(requestId);
@@ -368,18 +331,7 @@ export function registerNodeRoutes(app, ctxRaw) {
                     outerHttpAlreadyCommitted: res.headersSent,
                     sseErrorSent: streamResponse,
                 });
-                return writeNodeError(res, finishHttpStatus ?? 500, finishErrorCode ?? "NODE_GEN_FAILED", finalErr.message, parentNodeId, {
-                    upstreamCode: lastErr?.upstreamCode || lastErr?.code || null,
-                    upstreamType: lastErr?.upstreamType || null,
-                    upstreamParam: lastErr?.upstreamParam || null,
-                    errorEventType: lastErr?.eventType || null,
-                    errorEventCount: lastErr?.eventCount ?? null,
-                    diagnosticReason: finalErr.diagnosticReason || lastErr?.diagnosticReason || null,
-                    retryKind: finalErr.retryKind || lastErr?.retryKind || null,
-                    referencesDroppedOnRetry: finalErr.referencesDroppedOnRetry ?? lastErr?.referencesDroppedOnRetry ?? null,
-                    refsCount: finalErr.refsCount ?? lastErr?.refsCount ?? null,
-                    inputImageCount: finalErr.inputImageCount ?? lastErr?.inputImageCount ?? null,
-                });
+                return writeNodeError(res, finishHttpStatus ?? 500, finishErrorCode ?? "NODE_GEN_FAILED", finalErr.message, parentNodeId, nodeErrorDetails(finalErr, lastErr), requestId);
             }
             const nodeId = newNodeId();
             throwIfJobCanceled(requestId);
@@ -455,7 +407,11 @@ export function registerNodeRoutes(app, ctxRaw) {
                 revisedPrompt,
                 promptMode: normalizedPromptMode,
             };
-            if (streamResponse) {
+            publishJobEvent(requestId, "done", payload);
+            if (res.writableEnded) {
+                // async mode — response already sent
+            }
+            else if (streamResponse) {
                 writeSse(res, "done", payload);
                 res.end();
             }
@@ -472,7 +428,7 @@ export function registerNodeRoutes(app, ctxRaw) {
                 finishCanceled = true;
                 finishHttpStatus = canceled.status;
                 finishErrorCode = canceled.code;
-                return writeNodeError(res, canceled.status, canceled.code, canceled.message, parentNodeId);
+                return writeNodeError(res, canceled.status, canceled.code, canceled.message, parentNodeId, {}, requestId);
             }
             finishStatus = "error";
             finishHttpStatus = err.status || 500;
@@ -482,7 +438,7 @@ export function registerNodeRoutes(app, ctxRaw) {
                 upstreamCode: ext.upstreamCode || null,
                 upstreamType: ext.upstreamType || null,
                 upstreamParam: ext.upstreamParam || null,
-            });
+            }, requestId);
         }
         finally {
             finishJob(requestId, {