ima2-gen 1.1.4 → 1.1.6

package/routes/edit.js

@@ -5,8 +5,6 @@ import { editViaOAuth } from "../lib/oauthProxy.js";
 import { classifyUpstreamError } from "../lib/errorClassify.js";
 import { normalizeOAuthParams } from "../lib/oauthNormalize.js";
 import { normalizeImageModel } from "../lib/imageModels.js";
-import { getStyleSheet } from "../lib/sessionStore.js";
-import { renderStyleSheetPrefix } from "../lib/styleSheet.js";
 import { startJob, finishJob } from "../lib/inflight.js";
 import { logEvent, logError } from "../lib/logger.js";
 
@@ -57,7 +55,6 @@ export function registerEditRoutes(app, ctx) {
           quality,
           model: imageModel,
           size,
-          styleSheetApplied: false,
         },
       });
 
@@ -81,21 +78,6 @@ export function registerEditRoutes(app, ctx) {
         return res.status(403).json({ error: "API key provider is disabled. Use OAuth (Codex login).", code: "APIKEY_DISABLED" });
       }
 
-      let effectivePrompt = prompt;
-      let styleSheetApplied = null;
-      if (sessionId) {
-        try {
-          const data = getStyleSheet(sessionId);
-          if (data && data.enabled && data.styleSheet) {
-            const prefix = renderStyleSheetPrefix(data.styleSheet);
-            if (prefix) {
-              effectivePrompt = `${prefix} ${prompt}`.slice(0, 4000);
-              styleSheetApplied = data.styleSheet;
-            }
-          }
-        } catch {}
-      }
-
       logEvent("edit", "request", {
         requestId,
         client: req.get("x-ima2-client") || "ui",
@@ -107,12 +89,11 @@ export function registerEditRoutes(app, ctx) {
         sessionId,
         promptChars: typeof prompt === "string" ? prompt.length : 0,
         promptMode: normalizedPromptMode,
-        styleSheetApplied: !!styleSheetApplied,
         inputImageChars: typeof imageB64 === "string" ? imageB64.length : 0,
       });
       const startTime = Date.now();
       const { b64: resultB64, usage, revisedPrompt } = await editViaOAuth(
-        effectivePrompt,
+        prompt,
         imageB64,
         quality,
         size,
@@ -132,8 +113,6 @@ export function registerEditRoutes(app, ctx) {
         userPrompt: prompt,
         revisedPrompt: revisedPrompt || null,
         promptMode: normalizedPromptMode,
-        effectivePrompt: styleSheetApplied ? effectivePrompt : undefined,
-        styleSheetApplied: styleSheetApplied || undefined,
         quality,
         size,
         moderation,

package/routes/generate.js

@@ -8,9 +8,8 @@ import { normalizeImageModel } from "../lib/imageModels.js";
 import { generateViaOAuth } from "../lib/oauthProxy.js";
 import { isNonRetryableGenerationError, normalizeGenerationFailure } from "../lib/generationErrors.js";
 import { startJob, finishJob } from "../lib/inflight.js";
-import { getStyleSheet } from "../lib/sessionStore.js";
-import { renderStyleSheetPrefix } from "../lib/styleSheet.js";
 import { logEvent, logError } from "../lib/logger.js";
+import { embedImageMetadataBestEffort } from "../lib/imageMetadataStore.js";
 
 function validateModeration(ctx, moderation) {
   if (typeof moderation !== "string" || !ctx.config.oauth.validModeration.has(moderation)) {
@@ -57,25 +56,10 @@ export function registerGenerateRoutes(app, ctx) {
       if (moderationCheck.error) return res.status(400).json({ error: moderationCheck.error });
       const count = Math.min(Math.max(parseInt(n) || 1, 1), 8);
 
-      let effectivePrompt = prompt;
-      let styleSheetApplied = null;
-      if (sessionId) {
-        try {
-          const data = getStyleSheet(sessionId);
-          if (data && data.enabled && data.styleSheet) {
-            const prefix = renderStyleSheetPrefix(data.styleSheet);
-            if (prefix) {
-              effectivePrompt = `${prefix} ${prompt}`.slice(0, 4000);
-              styleSheetApplied = data.styleSheet;
-            }
-          }
-        } catch {}
-      }
-
       startJob({
         requestId,
         kind: "classic",
-        prompt: effectivePrompt,
+        prompt,
         meta: {
           kind: "classic",
           sessionId,
@@ -85,7 +69,6 @@ export function registerGenerateRoutes(app, ctx) {
           model: imageModel,
           size,
           n: count,
-          styleSheetApplied: !!styleSheetApplied,
         },
       });
 
@@ -104,6 +87,8 @@ export function registerGenerateRoutes(app, ctx) {
         return res.status(403).json({ error: "API key provider is disabled. Use OAuth (Codex login).", code: "APIKEY_DISABLED" });
       }
       const client = req.get("x-ima2-client") || "ui";
+      const referenceDiagnostics = refCheck.referenceDiagnostics || [];
+      const referenceMismatchCount = referenceDiagnostics.filter((ref) => ref.warnings?.includes("mime_mismatch")).length;
       logEvent("generate", "request", {
         requestId,
         client,
@@ -114,11 +99,13 @@ export function registerGenerateRoutes(app, ctx) {
         moderation,
         n: count,
         refs: refCheck.refs.length,
+        referenceMismatchCount,
+        refDetectedMimes: [...new Set(referenceDiagnostics.map((ref) => ref.detectedMime).filter(Boolean))].join(","),
+        refDeclaredMimes: [...new Set(referenceDiagnostics.map((ref) => ref.declaredMime).filter(Boolean))].join(","),
         sessionId,
         clientNodeId,
         promptChars: typeof prompt === "string" ? prompt.length : 0,
         promptMode: normalizedPromptMode,
-        styleSheetApplied: !!styleSheetApplied,
       });
       const startTime = Date.now();
 
@@ -132,11 +119,11 @@ export function registerGenerateRoutes(app, ctx) {
         for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
           try {
             const r = await generateViaOAuth(
-              effectivePrompt,
+              prompt,
               quality,
               size,
               moderation,
-              refCheck.refs,
+              refCheck.refDetails || refCheck.refs,
               requestId,
               normalizedPromptMode,
               ctx,
@@ -165,14 +152,15 @@ export function registerGenerateRoutes(app, ctx) {
         if (r.status === "fulfilled" && r.value.b64) {
           const rand = randomBytes(ctx.config.ids.generatedHexBytes).toString("hex");
           const filename = `${Date.now()}_${rand}_${images.length}.${format}`;
-          await writeFile(join(ctx.config.storage.generatedDir, filename), Buffer.from(r.value.b64, "base64"));
           const meta = {
+            kind: "classic",
+            requestId,
+            sessionId,
+            clientNodeId,
             prompt,
             userPrompt: prompt,
             revisedPrompt: r.value.revisedPrompt || null,
             promptMode: normalizedPromptMode,
-            effectivePrompt: styleSheetApplied ? effectivePrompt : undefined,
-            styleSheetApplied: styleSheetApplied || undefined,
             quality,
             size,
             format,
@@ -182,7 +170,21 @@ export function registerGenerateRoutes(app, ctx) {
             createdAt: Date.now(),
             usage: r.value.usage || null,
             webSearchCalls: r.value.webSearchCalls || 0,
+            refsCount: refCheck.refs.length,
           };
+          const rawBuffer = Buffer.from(r.value.b64, "base64");
+          const embedded = await embedImageMetadataBestEffort(rawBuffer, format, meta, {
+            version: ctx.packageVersion,
+          });
+          if (!embedded.embedded) {
+            logEvent("generate", "metadata_embed_skipped", {
+              requestId,
+              filename,
+              code: embedded.code,
+              warning: embedded.warning,
+            });
+          }
+          await writeFile(join(ctx.config.storage.generatedDir, filename), embedded.buffer);
           await writeFile(join(ctx.config.storage.generatedDir, filename + ".json"), JSON.stringify(meta)).catch(() => {});
           images.push({
             image: `data:${mime};base64,${r.value.b64}`,
@@ -214,6 +216,10 @@ export function registerGenerateRoutes(app, ctx) {
             upstreamCode: firstErr.upstreamCode || null,
             upstreamType: firstErr.upstreamType || null,
             upstreamParam: firstErr.upstreamParam || null,
+            diagnosticReason: firstErr.diagnosticReason || null,
+            retryKind: firstErr.retryKind || null,
+            referencesDroppedOnRetry: firstErr.referencesDroppedOnRetry ?? null,
+            errorEventCount: firstErr.eventCount ?? null,
             requestId,
           });
         }
@@ -270,6 +276,10 @@ export function registerGenerateRoutes(app, ctx) {
         upstreamCode: err.upstreamCode || null,
         upstreamType: err.upstreamType || null,
         upstreamParam: err.upstreamParam || null,
+        diagnosticReason: err.diagnosticReason || null,
+        retryKind: err.retryKind || null,
+        referencesDroppedOnRetry: err.referencesDroppedOnRetry ?? null,
+        errorEventCount: err.eventCount ?? null,
         requestId,
       });
     } finally {

package/routes/history.js

@@ -1,7 +1,8 @@
 import { listHistoryRows } from "../lib/historyList.js";
-import { trashAsset, restoreAsset } from "../lib/assetLifecycle.js";
+import { trashAsset, restoreAsset, deleteAssetPermanent } from "../lib/assetLifecycle.js";
 import { getSessionTitleMap } from "../lib/sessionStore.js";
 import { logError, logEvent } from "../lib/logger.js";
+import { getDb } from "../lib/db.js";
 
 export function registerHistoryRoutes(app, ctx) {
   app.get("/api/history", async (req, res) => {
@@ -16,9 +17,18 @@ export function registerHistoryRoutes(app, ctx) {
       const sinceTs = parseInt(req.query.since);
       const sessionId = typeof req.query.sessionId === "string" ? req.query.sessionId : null;
       const groupBy = req.query.groupBy === "session" ? "session" : null;
+      const browserId = req.headers["x-ima2-browser-id"] || null;
 
       const rows = await listHistoryRows(ctx.config.storage.generatedDir);
 
+      // Enrich with favorite status
+      let favoriteSet = new Set();
+      if (browserId) {
+        const db = getDb();
+        const favRows = db.prepare("SELECT filename FROM gallery_favorites WHERE browser_id = ?").all(browserId);
+        favoriteSet = new Set(favRows.map((r) => r.filename));
+      }
+
       let filtered = rows;
       if (Number.isFinite(sinceTs)) {
         filtered = filtered.filter((r) => r.createdAt > sinceTs);
@@ -34,7 +44,7 @@ export function registerHistoryRoutes(app, ctx) {
         filtered = filtered.filter((r) => r.sessionId === sessionId);
       }
 
-      const page = filtered.slice(0, limit);
+      const page = filtered.slice(0, limit).map((r) => ({ ...r, isFavorite: favoriteSet.has(r.filename) }));
       const nextCursor = page.length === limit && filtered.length > limit
         ? { before: page[page.length - 1].createdAt, beforeFilename: page[page.length - 1].filename }
         : null;
@@ -78,6 +88,16 @@ export function registerHistoryRoutes(app, ctx) {
     }
   });
 
+  app.delete("/api/history/:filename/permanent", async (req, res) => {
+    try {
+      const filename = decodeURIComponent(req.params.filename);
+      const result = await deleteAssetPermanent(ctx.rootDir, filename);
+      res.json(result);
+    } catch (err) {
+      res.status(err.status || 500).json({ error: err.message, code: err.code });
+    }
+  });
+
   app.delete("/api/history/:filename", async (req, res) => {
     try {
       const filename = decodeURIComponent(req.params.filename);
@@ -99,4 +119,35 @@ export function registerHistoryRoutes(app, ctx) {
       res.status(err.status || 500).json({ error: err.message });
     }
   });
+
+  app.post("/api/history/favorite", async (req, res) => {
+    try {
+      const db = getDb();
+      const { filename } = req.body || {};
+      const browserId = req.headers["x-ima2-browser-id"];
+
+      if (!filename || typeof filename !== "string") {
+        return res.status(400).json({ error: "filename is required" });
+      }
+      if (!browserId || typeof browserId !== "string") {
+        return res.status(400).json({ error: "X-Ima2-Browser-Id header is required" });
+      }
+
+      const existing = db.prepare("SELECT id FROM gallery_favorites WHERE browser_id = ? AND filename = ?").get(browserId, filename);
+
+      if (existing) {
+        db.prepare("DELETE FROM gallery_favorites WHERE browser_id = ? AND filename = ?").run(browserId, filename);
+        res.json({ isFavorite: false });
+      } else {
+        const id = `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+        db.prepare(
+          "INSERT INTO gallery_favorites (id, browser_id, filename, favorited_at) VALUES (?, ?, ?, ?)"
+        ).run(id, browserId, filename, Math.floor(Date.now() / 1000));
+        res.json({ isFavorite: true });
+      }
+    } catch (err) {
+      logError("history", "favorite_error", err);
+      res.status(500).json({ error: err.message });
+    }
+  });
 }

package/routes/index.js

@@ -4,16 +4,22 @@ import { registerSessionRoutes } from "./sessions.js";
 import { registerEditRoutes } from "./edit.js";
 import { registerNodeRoutes } from "./nodes.js";
 import { registerGenerateRoutes } from "./generate.js";
+import { registerMultimodeRoutes } from "./multimode.js";
 import { registerStorageRoutes } from "./storage.js";
 import { registerCardNewsRoutes } from "./cardNews.js";
+import { registerMetadataRoutes } from "./metadata.js";
+import { registerPromptRoutes } from "./prompts.js";
 
 export function configureRoutes(app, ctx) {
   registerHealthRoutes(app, ctx);
   registerStorageRoutes(app, ctx);
+  registerMetadataRoutes(app, ctx);
   registerHistoryRoutes(app, ctx);
   registerSessionRoutes(app, ctx);
   registerEditRoutes(app, ctx);
   registerNodeRoutes(app, ctx);
   if (ctx.config.features.cardNews) registerCardNewsRoutes(app, ctx);
+  registerMultimodeRoutes(app, ctx);
   registerGenerateRoutes(app, ctx);
+  registerPromptRoutes(app, ctx);
 }

package/routes/metadata.js

@@ -0,0 +1,71 @@
+import { Buffer } from "node:buffer";
+import {
+  isSupportedMetadataFormat,
+  normalizeImageMetadataFormat,
+  readEmbeddedImageMetadata,
+} from "../lib/imageMetadataStore.js";
+
+const MIME_FORMATS = {
+  "image/png": "png",
+  "image/jpeg": "jpeg",
+  "image/webp": "webp",
+};
+
+function parseDataUrl(dataUrl) {
+  if (typeof dataUrl !== "string") return null;
+  const match = /^data:([^;,]+);base64,(.+)$/s.exec(dataUrl);
+  if (!match) return null;
+  return { mime: match[1].toLowerCase(), rawB64: match[2] };
+}
+
+export function registerMetadataRoutes(app, ctx) {
+  app.post("/api/metadata/read", async (req, res) => {
+    try {
+      const parsed = parseDataUrl(req.body?.dataUrl);
+      if (!parsed) {
+        return res.status(400).json({
+          ok: false,
+          code: "IMAGE_METADATA_INVALID",
+          error: "A base64 image data URL is required.",
+        });
+      }
+      if (parsed.rawB64.length > ctx.config.limits.maxMetadataReadB64Bytes) {
+        return res.status(413).json({
+          ok: false,
+          code: "IMAGE_METADATA_TOO_LARGE",
+          error: "Image is too large to inspect for metadata.",
+        });
+      }
+      const format = normalizeImageMetadataFormat(MIME_FORMATS[parsed.mime]);
+      if (!isSupportedMetadataFormat(format)) {
+        return res.status(400).json({
+          ok: false,
+          code: "IMAGE_METADATA_UNSUPPORTED_FORMAT",
+          error: "Only PNG, JPEG, and WebP metadata can be inspected.",
+        });
+      }
+      const result = await readEmbeddedImageMetadata(Buffer.from(parsed.rawB64, "base64"));
+      if (!result.metadata) {
+        return res.json({
+          ok: true,
+          metadata: null,
+          source: null,
+          code: "IMAGE_METADATA_NOT_FOUND",
+          warnings: result.warnings,
+        });
+      }
+      return res.json({
+        ok: true,
+        metadata: result.metadata,
+        source: result.source,
+        warnings: result.warnings,
+      });
+    } catch (error) {
+      return res.status(400).json({
+        ok: false,
+        code: error?.code || "IMAGE_METADATA_INVALID",
+        error: error?.message || "Could not read image metadata.",
+      });
+    }
+  });
+}

package/routes/multimode.js

@@ -0,0 +1,264 @@
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { randomBytes } from "crypto";
+import { validateAndNormalizeRefs } from "../lib/refs.js";
+import { classifyUpstreamError } from "../lib/errorClassify.js";
+import { normalizeOAuthParams } from "../lib/oauthNormalize.js";
+import { normalizeImageModel } from "../lib/imageModels.js";
+import { generateMultimodeViaOAuth } from "../lib/oauthProxy.js";
+import { startJob, finishJob } from "../lib/inflight.js";
+import { logEvent, logError } from "../lib/logger.js";
+import { embedImageMetadataBestEffort } from "../lib/imageMetadataStore.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" };
+  }
+  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";
+}
+
+export function registerMultimodeRoutes(app, ctx) {
+  app.post("/api/generate/multimode", async (req, res) => {
+    const requestId = typeof req.body?.requestId === "string" ? req.body.requestId : req.id;
+    let finishStatus = "completed";
+    let finishHttpStatus = 200;
+    let finishErrorCode;
+    let finishMeta = {};
+
+    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,
+      } = req.body;
+      const maxImages = normalizeMaxImages(req.body?.maxImages);
+      const normalizedPromptMode = promptMode === "direct" ? "direct" : "auto";
+      const { quality, warnings: qualityWarnings } = normalizeOAuthParams({ provider, quality: rawQuality });
+      const modelCheck = normalizeImageModel(ctx, rawModel);
+      if (modelCheck.error) {
+        finishStatus = "error";
+        finishHttpStatus = modelCheck.status;
+        finishErrorCode = modelCheck.code;
+        sendSse(res, "error", { error: modelCheck.error, code: modelCheck.code, status: modelCheck.status, requestId });
+        return;
+      }
+      const imageModel = modelCheck.model;
+      if (!prompt) {
+        finishStatus = "error";
+        finishHttpStatus = 400;
+        finishErrorCode = "PROMPT_REQUIRED";
+        sendSse(res, "error", { error: "Prompt is required", code: finishErrorCode, status: 400, requestId });
+        return;
+      }
+      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;
+      }
+      if (provider === "api") {
+        finishStatus = "error";
+        finishHttpStatus = 403;
+        finishErrorCode = "APIKEY_DISABLED";
+        sendSse(res, "error", {
+          error: "API key provider is disabled. Use OAuth (Codex login).",
+          code: finishErrorCode,
+          status: 403,
+          requestId,
+        });
+        return;
+      }
+
+      const refCheck = validateAndNormalizeRefs(references);
+      if (refCheck.error) {
+        finishStatus = "error";
+        finishHttpStatus = 400;
+        finishErrorCode = refCheck.code;
+        sendSse(res, "error", { error: refCheck.error, code: refCheck.code, status: 400, requestId });
+        return;
+      }
+
+      startJob({
+        requestId,
+        kind: "multimode",
+        prompt,
+        meta: { kind: "multimode", quality, model: imageModel, size, maxImages },
+      });
+
+      logEvent("multimode", "request", {
+        requestId,
+        quality,
+        model: imageModel,
+        size,
+        moderation,
+        maxImages,
+        refs: refCheck.refs.length,
+        promptChars: typeof prompt === "string" ? prompt.length : 0,
+      });
+
+      const startTime = Date.now();
+      const mimeMap = { png: "image/png", jpeg: "image/jpeg", webp: "image/webp" };
+      const mime = mimeMap[format] || "image/png";
+      const sequenceId = `seq_${Date.now().toString(36)}_${randomBytes(4).toString("hex")}`;
+      await mkdir(ctx.config.storage.generatedDir, { recursive: true });
+
+      sendSse(res, "phase", { phase: "streaming", requestId, sequenceId, maxImages });
+      const generated = await generateMultimodeViaOAuth(
+        prompt,
+        quality,
+        size,
+        moderation,
+        refCheck.refDetails || refCheck.refs,
+        requestId,
+        normalizedPromptMode,
+        ctx,
+        {
+          model: imageModel,
+          maxImages,
+          onPartialImage: (partial) =>
+            sendSse(res, "partial", {
+              image: `data:${mime};base64,${partial.b64}`,
+              requestId,
+              sequenceId,
+              index: partial.index,
+            }),
+        },
+      );
+
+      const returned = generated.images.length;
+      const status = sequenceStatus(returned, maxImages);
+      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+      const images = [];
+
+      for (const [index, image] of generated.images.entries()) {
+        const rand = randomBytes(ctx.config.ids.generatedHexBytes).toString("hex");
+        const filename = `${Date.now()}_${rand}_multimode_${index}.${format}`;
+        const meta = {
+          kind: "multimode-image",
+          generationStrategy: "one-call-text-sequence",
+          sequenceId,
+          sequenceIndex: index + 1,
+          sequenceTotalRequested: maxImages,
+          sequenceTotalReturned: returned,
+          sequenceStatus: status,
+          stageLabel: String.fromCharCode(65 + index),
+          requestId,
+          prompt,
+          userPrompt: prompt,
+          revisedPrompt: image.revisedPrompt || null,
+          promptMode: normalizedPromptMode,
+          quality,
+          size,
+          format,
+          moderation,
+          model: imageModel,
+          provider: "oauth",
+          createdAt: Date.now(),
+          usage: generated.usage || null,
+          webSearchCalls: generated.webSearchCalls || 0,
+          refsCount: refCheck.refs.length,
+        };
+        const rawBuffer = Buffer.from(image.b64, "base64");
+        const embedded = await embedImageMetadataBestEffort(rawBuffer, format, 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(() => {});
+        const item = {
+          image: `data:${mime};base64,${image.b64}`,
+          filename,
+          revisedPrompt: image.revisedPrompt || null,
+          sequenceId,
+          sequenceIndex: index + 1,
+          sequenceTotalRequested: maxImages,
+          sequenceTotalReturned: returned,
+          sequenceStatus: status,
+        };
+        images.push(item);
+        sendSse(res, "image", item);
+      }
+
+      finishMeta = { sequenceId, imageCount: returned, maxImages, status };
+      finishHttpStatus = 200;
+      sendSse(res, "done", {
+        ok: true,
+        requestId,
+        sequenceId,
+        requested: maxImages,
+        returned,
+        status,
+        elapsed,
+        images,
+        provider: "oauth",
+        quality,
+        size,
+        moderation,
+        model: imageModel,
+        usage: generated.usage || null,
+        webSearchCalls: generated.webSearchCalls || 0,
+        warnings: qualityWarnings,
+        extraIgnored: generated.extraIgnored || 0,
+        promptMode: normalizedPromptMode,
+      });
+      logEvent("multimode", "saved", {
+        requestId,
+        sequenceId,
+        imageCount: returned,
+        maxImages,
+        status,
+        elapsedMs: Date.now() - startTime,
+      });
+    } catch (err) {
+      const fallbackCode = err.code || classifyUpstreamError(err.message);
+      finishStatus = "error";
+      finishHttpStatus = err.status || 500;
+      finishErrorCode = fallbackCode || "MULTIMODE_GENERATE_FAILED";
+      logError("multimode", "error", err, { requestId, code: finishErrorCode });
+      sendSse(res, "error", {
+        error: err.message,
+        code: finishErrorCode,
+        status: finishHttpStatus,
+        requestId,
+        upstreamCode: err.upstreamCode || null,
+        upstreamType: err.upstreamType || null,
+        upstreamParam: err.upstreamParam || null,
+      });
+    } finally {
+      finishJob(requestId, {
+        status: finishStatus,
+        httpStatus: finishHttpStatus,
+        errorCode: finishErrorCode,
+        meta: finishMeta,
+      });
+      res.end();
+    }
+  });
+}