ima2-gen 1.1.3 → 1.1.4

package/bin/commands/edit.js

@@ -2,6 +2,7 @@ import { parseArgs } from "../lib/args.js";
 import { resolveServer, request } from "../lib/client.js";
 import { fileToDataUri, dataUriToFile, defaultOutName } from "../lib/files.js";
 import { out, die, dieWithError, color, json } from "../lib/output.js";
+import { config } from "../../config.js";
 
 const VALID_MODES = new Set(["auto", "direct"]);
 const VALID_MODERATION = new Set(["auto", "low"]);
@@ -87,7 +88,7 @@ export default async function editCmd(argv) {
 
   const image = resp.image;
   if (!image) die(1, "server returned no image");
-  const target = args.out || defaultOutName(0, 1);
+  const target = args.out || `${config.storage.generatedDir}/${defaultOutName(0, 1)}`;
   await dataUriToFile(image, target);
 
   if (args.json) {

package/bin/commands/gen.js

@@ -2,6 +2,7 @@ import { parseArgs } from "../lib/args.js";
 import { resolveServer, request, normalizeGenerate } from "../lib/client.js";
 import { fileToDataUri, dataUriToFile, defaultOutName, readStdin } from "../lib/files.js";
 import { out, die, dieWithError, color, json } from "../lib/output.js";
+import { config } from "../../config.js";
 
 const VALID_MODES = new Set(["auto", "direct"]);
 const VALID_MODERATION = new Set(["auto", "low"]);
@@ -139,7 +140,7 @@ export default async function genCmd(argv) {
     } else if (outDir) {
       target = `${outDir}/${defaultOutName(i, norm.images.length)}`;
     } else {
-      target = defaultOutName(i, norm.images.length);
+      target = `${config.storage.generatedDir}/${defaultOutName(i, norm.images.length)}`;
     }
     await dataUriToFile(im.image, target);
     savedPaths.push(target);

package/docs/API.md

@@ -207,6 +207,7 @@ Style-sheet extraction can require an API key/openai client. This does not reope
 | `APIKEY_DISABLED` | API-key image generation is disabled |
 | `INVALID_IMAGE_MODEL` | Model name is unknown or unsupported |
 | `IMAGE_MODEL_UNSUPPORTED` | Model exists but cannot use image generation |
+| `INVALID_REQUEST` | Upstream request parameters are invalid; raw provider details may be included as `upstreamCode`, `upstreamType`, and `upstreamParam` |
 | `INVALID_MODERATION` | Moderation value is not `auto` or `low` |
 | `SAFETY_REFUSAL` | Upstream safety refusal |
 | `MODERATION_REFUSED` | Content generation refused by moderation |

package/lib/errorClassify.js

@@ -2,7 +2,33 @@
 // Pattern-match upstream OpenAI / OAuth / network errors into stable ImaErrorCode
 // values so the UI can surface localized, actionable messages with CTAs.
 
-/** @typedef {"REF_TOO_LARGE"|"REF_NOT_BASE64"|"REF_EMPTY"|"REF_TOO_MANY"|"MODERATION_REFUSED"|"UPSTREAM_5XX"|"AUTH_CHATGPT_EXPIRED"|"AUTH_API_KEY_INVALID"|"NETWORK_FAILED"|"OAUTH_UNAVAILABLE"|"INVALID_MODERATION"|"APIKEY_DISABLED"|"SAFETY_REFUSAL"|"DB_ERROR"|"UNKNOWN"} ImaErrorCode */
+/** @typedef {"REF_TOO_LARGE"|"REF_NOT_BASE64"|"REF_EMPTY"|"REF_TOO_MANY"|"MODERATION_REFUSED"|"UPSTREAM_5XX"|"AUTH_CHATGPT_EXPIRED"|"AUTH_API_KEY_INVALID"|"NETWORK_FAILED"|"OAUTH_UNAVAILABLE"|"INVALID_REQUEST"|"INVALID_MODERATION"|"APIKEY_DISABLED"|"SAFETY_REFUSAL"|"EMPTY_RESPONSE"|"OAUTH_UPSTREAM_ERROR"|"DB_ERROR"|"UNKNOWN"} ImaErrorCode */
+
+const INVALID_REQUEST_CODES = new Set([
+  "bad_request",
+  "invalid_request",
+  "invalid_request_error",
+  "invalid_value",
+  "invalid_size",
+  "invalid_type",
+  "invalid_parameter",
+  "missing_required_parameter",
+  "unsupported_parameter",
+  "unsupported_value",
+]);
+
+/**
+ * Normalize provider-specific request/validation codes into app codes.
+ * @param {string | undefined | null} code
+ * @returns {ImaErrorCode}
+ */
+export function classifyUpstreamErrorCode(code) {
+  const s = String(code || "").toLowerCase();
+  if (!s) return "UNKNOWN";
+  if (INVALID_REQUEST_CODES.has(s)) return "INVALID_REQUEST";
+  if (s.includes("moderation_blocked") || s.includes("moderation refused")) return "MODERATION_REFUSED";
+  return "UNKNOWN";
+}
 
 /**
  * Classify an upstream error message into an ImaErrorCode.
@@ -54,6 +80,18 @@ export function classifyUpstreamError(msg) {
     return "OAUTH_UNAVAILABLE";
   }
 
+  if (
+    s.includes("invalid_request_error") ||
+    s.includes("invalid_value") ||
+    s.includes("invalid size") ||
+    s.includes("invalid request") ||
+    s.includes("requested resolution") ||
+    s.includes("minimum pixel budget") ||
+    s.includes("unsupported value")
+  ) {
+    return "INVALID_REQUEST";
+  }
+
   if (s.includes("an error occurred while processing") || /\b5\d\d\b/.test(s)) {
     return "UPSTREAM_5XX";
   }

package/lib/generationErrors.js

@@ -1,4 +1,4 @@
-import { classifyUpstreamError } from "./errorClassify.js";
+import { classifyUpstreamError, classifyUpstreamErrorCode } from "./errorClassify.js";
 
 const PASSTHROUGH_CODES = new Set([
   "OAUTH_UNAVAILABLE",
@@ -6,23 +6,45 @@ const PASSTHROUGH_CODES = new Set([
   "AUTH_CHATGPT_EXPIRED",
   "AUTH_API_KEY_INVALID",
   "UPSTREAM_5XX",
+  "INVALID_REQUEST",
+  "OAUTH_UPSTREAM_ERROR",
 ]);
 
 const SAFETY_CODES = new Set(["SAFETY_REFUSAL", "MODERATION_REFUSED", "moderation_blocked"]);
 
 export function errorCodeFrom(err) {
   if (!err) return "UNKNOWN";
-  if (typeof err.code === "string" && err.code) return err.code;
+  const upstreamCode = classifyUpstreamErrorCode(err.upstreamCode);
+  if (upstreamCode !== "UNKNOWN") return upstreamCode;
+  const upstreamType = classifyUpstreamErrorCode(err.upstreamType);
+  if (upstreamType !== "UNKNOWN") return upstreamType;
+  // Known app-level codes pass through directly (before message heuristic)
+  if (PASSTHROUGH_CODES.has(err.code) || SAFETY_CODES.has(err.code)) return err.code;
+  const rawCode = classifyUpstreamErrorCode(err.code);
+  if (rawCode !== "UNKNOWN") return rawCode;
   const direct = classifyUpstreamError(err.message);
   if (direct !== "UNKNOWN") return direct;
+  const status = Number(err.status);
+  if (Number.isFinite(status) && status >= 400 && status < 500 && !SAFETY_CODES.has(err.code)) {
+    return "INVALID_REQUEST";
+  }
+  if (typeof err.code === "string" && err.code) return err.code;
   if (err.cause) return errorCodeFrom(err.cause);
   return "UNKNOWN";
 }
 
+export function isNonRetryableGenerationError(err) {
+  const code = errorCodeFrom(err);
+  if (SAFETY_CODES.has(code)) return false;
+  const status = Number(err?.status);
+  return code === "INVALID_REQUEST" || (Number.isFinite(status) && status >= 400 && status < 500);
+}
+
 export function statusForErrorCode(code, fallback = 500) {
   if (code === "OAUTH_UNAVAILABLE" || code === "NETWORK_FAILED") return 503;
   if (code === "AUTH_CHATGPT_EXPIRED" || code === "AUTH_API_KEY_INVALID") return 401;
   if (code === "UPSTREAM_5XX") return 502;
+  if (code === "INVALID_REQUEST") return 400;
   if (code === "SAFETY_REFUSAL" || code === "MODERATION_REFUSED" || code === "moderation_blocked") return 422;
   return fallback;
 }
@@ -34,6 +56,11 @@ export function normalizeGenerationFailure(lastErr, options = {}) {
     err.code = code;
     err.status = lastErr?.status || statusForErrorCode(code);
     err.cause = lastErr;
+    if (lastErr?.upstreamCode) err.upstreamCode = lastErr.upstreamCode;
+    if (lastErr?.upstreamType) err.upstreamType = lastErr.upstreamType;
+    if (lastErr?.upstreamParam) err.upstreamParam = lastErr.upstreamParam;
+    if (lastErr?.eventType) err.eventType = lastErr.eventType;
+    if (typeof lastErr?.eventCount === "number") err.eventCount = lastErr.eventCount;
     return err;
   }
   if (SAFETY_CODES.has(code)) {
@@ -43,9 +70,28 @@ export function normalizeGenerationFailure(lastErr, options = {}) {
     err.cause = lastErr;
     return err;
   }
-  const err = new Error(options.safetyMessage || "Content generation refused after retries");
-  err.code = "SAFETY_REFUSAL";
-  err.status = 422;
+  // Empty response with metadata → likely a technical limitation (unsupported size/quality/model)
+  if (typeof lastErr?.eventCount === "number") {
+    const meta = [];
+    if (lastErr.size) meta.push(`size=${lastErr.size}`);
+    if (lastErr.quality) meta.push(`quality=${lastErr.quality}`);
+    if (lastErr.model) meta.push(`model=${lastErr.model}`);
+    const msg = meta.length
+      ? `No image data returned. This may be an unsupported ${meta.join(", ")} combination. Try a different size or model.`
+      : "No image data returned from the image backend. Try a different size, quality, or prompt.";
+    const err = new Error(msg);
+    err.code = "EMPTY_RESPONSE";
+    err.status = 422;
+    err.cause = lastErr;
+    if (lastErr.size) err.size = lastErr.size;
+    if (lastErr.quality) err.quality = lastErr.quality;
+    if (lastErr.model) err.model = lastErr.model;
+    return err;
+  }
+  // Unrecognized errors → UNKNOWN (do not pretend they are safety refusals)
+  const err = new Error(lastErr?.message || options.proxyMessage || "Image generation failed");
+  err.code = "UNKNOWN";
+  err.status = lastErr?.status || 500;
   err.cause = lastErr;
   return err;
 }

package/lib/oauthProxy.js

@@ -1,6 +1,8 @@
 import { setJobPhase } from "./inflight.js";
 import { config } from "../config.js";
 import { logEvent } from "./logger.js";
+import { classifyUpstreamError, classifyUpstreamErrorCode } from "./errorClassify.js";
+import { compressReferenceB64ForOAuth } from "./referenceImageCompress.js";
 
 const RESEARCH_SUFFIX = config.oauth.researchSuffix;
 
@@ -87,17 +89,88 @@ function extractPartialImage(data) {
   return { b64, index, eventType: data.type };
 }
 
-function makeOAuthError(message, { status, code = "OAUTH_UPSTREAM_ERROR", upstreamBodyChars, eventType, eventCount, cause } = {}) {
+function makeOAuthError(
+  message,
+  {
+    status,
+    code = "OAUTH_UPSTREAM_ERROR",
+    upstreamBodyChars,
+    upstreamCode,
+    upstreamType,
+    upstreamParam,
+    eventType,
+    eventCount,
+    cause,
+  } = {},
+) {
   const err = new Error(message);
   err.code = code;
   if (status) err.status = status;
   if (typeof upstreamBodyChars === "number") err.upstreamBodyChars = upstreamBodyChars;
+  if (upstreamCode) err.upstreamCode = upstreamCode;
+  if (upstreamType) err.upstreamType = upstreamType;
+  if (upstreamParam) err.upstreamParam = upstreamParam;
   if (eventType) err.eventType = eventType;
   if (typeof eventCount === "number") err.eventCount = eventCount;
   if (cause) err.cause = cause;
   return err;
 }
 
+export function parseOpenAIErrorBody(text) {
+  try {
+    const parsed = JSON.parse(text);
+    const error = parsed?.error;
+    if (!error || typeof error !== "object") return null;
+    const message = typeof error.message === "string" ? error.message : "";
+    if (!message) return null;
+    return {
+      message,
+      code: typeof error.code === "string" ? error.code : null,
+      type: typeof error.type === "string" ? error.type : null,
+      param: typeof error.param === "string" ? error.param : null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function normalizedOAuthCode(upstreamError) {
+  const byCode = classifyUpstreamErrorCode(upstreamError?.code);
+  if (byCode !== "UNKNOWN") return byCode;
+  const byType = classifyUpstreamErrorCode(upstreamError?.type);
+  if (byType !== "UNKNOWN") return byType;
+  const byMessage = classifyUpstreamError(upstreamError?.message);
+  if (byMessage !== "UNKNOWN") return byMessage;
+  return "OAUTH_UPSTREAM_ERROR";
+}
+
+function throwOAuthHttpError(res, text, { requestId, scope, fallbackMessage }) {
+  const upstream = parseOpenAIErrorBody(text);
+  const isClientError = res.status >= 400 && res.status < 500;
+  if (isClientError && upstream?.message) {
+    logEvent(scope || "oauth", "upstream_client_error", {
+      requestId,
+      status: res.status,
+      code: upstream.code,
+      type: upstream.type,
+      param: upstream.param,
+      errorChars: text.length,
+    });
+    throw makeOAuthError(upstream.message, {
+      status: res.status,
+      code: normalizedOAuthCode(upstream),
+      upstreamBodyChars: text.length,
+      upstreamCode: upstream.code,
+      upstreamType: upstream.type,
+      upstreamParam: upstream.param,
+    });
+  }
+  throw makeOAuthError(fallbackMessage, {
+    status: res.status,
+    upstreamBodyChars: text.length,
+  });
+}
+
 async function fetchOAuth(url, init, { requestId, scope } = {}) {
   try {
     return await fetch(url, init);
@@ -112,6 +185,9 @@ async function fetchOAuth(url, init, { requestId, scope } = {}) {
 }
 
 async function readImageStream(res, { requestId = null, scope = "oauth", onPartialImage = null } = {}) {
+  /** @type {Record<string, number>} */
+  const eventTypes = {};
+  let parseSkipCount = 0;
   const reader = res.body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
@@ -136,6 +212,8 @@ async function readImageStream(res, { requestId = null, scope = "oauth", onParti
       try {
         const data = JSON.parse(eventData);
         eventCount++;
+        const t = typeof data.type === "string" ? data.type : "_unknown";
+        eventTypes[t] = (eventTypes[t] || 0) + 1;
 
         const partial = extractPartialImage(data);
         if (partial) {
@@ -177,11 +255,16 @@ async function readImageStream(res, { requestId = null, scope = "oauth", onParti
         }
       } catch (e) {
         if (e.message && !e.message.startsWith("Unexpected")) throw e;
+        parseSkipCount++;
       }
     }
   }
 
-  return { imageB64, usage, webSearchCalls, revisedPrompt, eventCount };
+  if (parseSkipCount > 0) {
+    logEvent(scope, "parse_skip", { requestId, count: parseSkipCount });
+  }
+
+  return { imageB64, usage, webSearchCalls, revisedPrompt, eventCount, eventTypes };
 }
 
 export async function generateViaOAuth(
@@ -245,9 +328,10 @@ export async function generateViaOAuth(
   if (!res.ok) {
     const text = await res.text();
     logEvent("oauth", "error_response", { requestId, status: res.status, errorChars: text.length });
-    throw makeOAuthError(`OAuth proxy returned ${res.status}`, {
-      status: res.status,
-      upstreamBodyChars: text.length,
+    throwOAuthHttpError(res, text, {
+      requestId,
+      scope: "oauth",
+      fallbackMessage: `OAuth proxy returned ${res.status}`,
     });
   }
 
@@ -268,12 +352,12 @@ export async function generateViaOAuth(
     throw new Error("No image data in response (non-stream mode)");
   }
 
-  const { imageB64, usage, webSearchCalls, revisedPrompt, eventCount } = await readImageStream(res, {
+  const { imageB64, usage, webSearchCalls, revisedPrompt, eventCount, eventTypes } = await readImageStream(res, {
     requestId,
     scope: "oauth",
     onPartialImage: options.onPartialImage,
   });
-  logEvent("oauth", "stream_end", { requestId, events: eventCount, hasImage: !!imageB64 });
+  logEvent("oauth", "stream_end", { requestId, events: eventCount, hasImage: !!imageB64, eventTypes });
 
   if (!imageB64) {
     logEvent("oauth", "retry_json", { requestId });
@@ -297,9 +381,23 @@ export async function generateViaOAuth(
           return { b64: item.result, usage: json.usage, webSearchCalls, revisedPrompt: retryRevised };
         }
       }
+    } else {
+      const text = await retryRes.text();
+      logEvent("oauth", "retry_error_response", { requestId, status: retryRes.status, errorChars: text.length });
+      throwOAuthHttpError(retryRes, text, {
+        requestId,
+        scope: "oauth",
+        fallbackMessage: `OAuth proxy returned ${retryRes.status}`,
+      });
     }
 
-    throw new Error("No image data received from OAuth proxy (parsed " + eventCount + " events)");
+    const emptyErr = new Error("No image data received from OAuth proxy (parsed " + eventCount + " events)");
+    emptyErr.eventCount = eventCount;
+    emptyErr.eventTypes = eventTypes;
+    emptyErr.size = size;
+    emptyErr.quality = quality;
+    emptyErr.model = model;
+    throw emptyErr;
   }
 
   return { b64: imageB64, usage, webSearchCalls, revisedPrompt };
@@ -313,10 +411,22 @@ export async function editViaOAuth(prompt, imageB64, quality, size, moderation =
   const textPrompt = searchMode === "on"
     ? buildEditResearchTextPrompt(prompt, mode)
     : buildEditTextPrompt(prompt, mode);
+  const imageForRequest = await compressReferenceB64ForOAuth(imageB64, {
+    maxB64Bytes: ctx.config?.limits?.maxRefB64Bytes,
+    force: true,
+  });
   const references = Array.isArray(options.references) ? options.references : [];
-  const referenceContent = references.map((b64) => ({
+  const referenceImagesForRequest = await Promise.all(
+    references.map((b64) =>
+      compressReferenceB64ForOAuth(b64, {
+        maxB64Bytes: ctx.config?.limits?.maxRefB64Bytes,
+        force: true,
+      }),
+    ),
+  );
+  const referenceContent = referenceImagesForRequest.map(({ b64 }) => ({
     type: "input_image",
-    image_url: `data:image/png;base64,${b64}`,
+    image_url: `data:image/jpeg;base64,${b64}`,
   }));
   const tools = [
     ...(searchMode === "on" ? [{ type: "web_search" }] : []),
@@ -330,6 +440,9 @@ export async function editViaOAuth(prompt, imageB64, quality, size, moderation =
     inputImageCount: 1 + references.length,
     parentImagePresent: true,
     webSearchEnabled: searchMode === "on",
+    inputImageCompressed: imageForRequest.compressed,
+    inputImageChars: imageForRequest.inputBytes,
+    inputImageRequestChars: imageForRequest.outputBytes,
   });
 
   const res = await fetchOAuth(`${oauthUrl}/v1/responses`, {
@@ -342,7 +455,7 @@ export async function editViaOAuth(prompt, imageB64, quality, size, moderation =
         {
           role: "user",
           content: [
-            { type: "input_image", image_url: `data:image/png;base64,${imageB64}` },
+            { type: "input_image", image_url: `data:image/jpeg;base64,${imageForRequest.b64}` },
             ...referenceContent,
             { type: "input_text", text: textPrompt },
           ],
@@ -364,9 +477,10 @@ export async function editViaOAuth(prompt, imageB64, quality, size, moderation =
   if (!res.ok) {
     const text = await res.text();
     logEvent("oauth-edit", "error_response", { requestId, status: res.status, errorChars: text.length });
-    throw makeOAuthError(`OAuth edit returned ${res.status}`, {
-      status: res.status,
-      upstreamBodyChars: text.length,
+    throwOAuthHttpError(res, text, {
+      requestId,
+      scope: "oauth-edit",
+      fallbackMessage: `OAuth edit returned ${res.status}`,
     });
   }
 

package/lib/openDirectory.js

@@ -5,6 +5,7 @@ export async function openDirectory(dir, options = {}) {
   await mkdir(dir, { recursive: true });
   const platform = options.platform || process.platform;
   const spawnImpl = options.spawnImpl || spawn;
+  const settleMs = Number.isFinite(options.settleMs) ? options.settleMs : 250;
   const command =
     platform === "darwin" ? "open"
     : platform === "win32" ? "explorer"
@@ -12,10 +13,11 @@ export async function openDirectory(dir, options = {}) {
 
   return new Promise((resolve) => {
     try {
-      const child = spawnImpl(command, [dir], {
-        detached: true,
+      const isWin = platform === "win32";
+      const child = spawnImpl(command, isWin ? [`"${dir}"`] : [dir], {
+        detached: !isWin,
         stdio: "ignore",
-        windowsHide: true,
+        windowsHide: !isWin,
       });
       let settled = false;
       const done = (result) => {
@@ -26,8 +28,16 @@ export async function openDirectory(dir, options = {}) {
       child.on("error", (err) => {
         done({ ok: false, error: err.message || String(err) });
       });
+      child.on("exit", (code) => {
+        if (platform === "win32") {
+          done({ ok: true });
+          return;
+        }
+        if (code === 0) done({ ok: true });
+        else if (code != null) done({ ok: false, error: `${command} exited with code ${code}` });
+      });
       child.unref?.();
-      setTimeout(() => done({ ok: true }), 50).unref?.();
+      setTimeout(() => done({ ok: true }), settleMs).unref?.();
     } catch (err) {
       resolve({ ok: false, error: err?.message || String(err) });
     }

package/lib/referenceImageCompress.js

@@ -0,0 +1,75 @@
+import sharp from "sharp";
+
+const DEFAULT_MAX_B64_BYTES = 6 * 1024 * 1024;
+const DEFAULT_MAX_EDGE = 3840;
+const DEFAULT_QUALITY_LADDER = [85, 75, 65, 55];
+const FALLBACK_MAX_EDGE = 2048;
+const FALLBACK_QUALITY_LADDER = [75, 65, 55];
+
+function stripDataUrlPrefix(value) {
+  return String(value || "").replace(/^data:[^;]+;base64,/, "");
+}
+
+function toBase64(buffer) {
+  return buffer.toString("base64");
+}
+
+async function encodeJpegWithinBudget(input, {
+  maxB64Bytes,
+  maxEdge,
+  qualityLadder,
+}) {
+  for (const quality of qualityLadder) {
+    const out = await sharp(input, { failOn: "none" })
+      .rotate()
+      .resize({
+        width: maxEdge,
+        height: maxEdge,
+        fit: "inside",
+        withoutEnlargement: true,
+      })
+      .flatten({ background: "#ffffff" })
+      .jpeg({ quality, progressive: true })
+      .toBuffer();
+    const b64 = toBase64(out);
+    if (b64.length <= maxB64Bytes) return { b64, compressed: true, quality, maxEdge };
+  }
+  return null;
+}
+
+export async function compressReferenceB64ForOAuth(imageB64, options = {}) {
+  const rawB64 = stripDataUrlPrefix(imageB64);
+  const maxB64Bytes = options.maxB64Bytes ?? DEFAULT_MAX_B64_BYTES;
+  const maxEdge = options.maxEdge ?? DEFAULT_MAX_EDGE;
+  const qualityLadder = options.qualityLadder ?? DEFAULT_QUALITY_LADDER;
+  if (!rawB64) return { b64: rawB64, compressed: false, inputBytes: 0, outputBytes: 0 };
+
+  const input = Buffer.from(rawB64, "base64");
+  const inputBytes = rawB64.length;
+  if (!options.force && inputBytes <= maxB64Bytes) {
+    return { b64: rawB64, compressed: false, inputBytes, outputBytes: inputBytes };
+  }
+
+  const primary = await encodeJpegWithinBudget(input, {
+    maxB64Bytes,
+    maxEdge,
+    qualityLadder,
+  });
+  if (primary) {
+    return { ...primary, inputBytes, outputBytes: primary.b64.length };
+  }
+
+  const fallback = await encodeJpegWithinBudget(input, {
+    maxB64Bytes,
+    maxEdge: options.fallbackMaxEdge ?? FALLBACK_MAX_EDGE,
+    qualityLadder: options.fallbackQualityLadder ?? FALLBACK_QUALITY_LADDER,
+  });
+  if (fallback) {
+    return { ...fallback, inputBytes, outputBytes: fallback.b64.length };
+  }
+
+  const err = new Error(`Reference image remains above ${maxB64Bytes} base64 bytes after compression`);
+  err.code = "REF_TOO_LARGE";
+  err.status = 400;
+  throw err;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ima2-gen",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "Local OAuth image generation studio with classic and node workflows",
   "type": "module",
   "bin": {
@@ -56,6 +56,7 @@
     "express": "^5.1.0",
     "openai": "^5.8.2",
     "openai-oauth": "^1.0.2",
+    "sharp": "^0.34.5",
     "ulid": "^3.0.2"
   }
 }

package/routes/generate.js

@@ -6,7 +6,7 @@ import { classifyUpstreamError } from "../lib/errorClassify.js";
 import { normalizeOAuthParams } from "../lib/oauthNormalize.js";
 import { normalizeImageModel } from "../lib/imageModels.js";
 import { generateViaOAuth } from "../lib/oauthProxy.js";
-import { normalizeGenerationFailure } from "../lib/generationErrors.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";
@@ -146,6 +146,7 @@ export function registerGenerateRoutes(app, ctx) {
             lastErr = new Error("Empty response (safety refusal)");
           } catch (e) {
             lastErr = e;
+            if (isNonRetryableGenerationError(e)) break;
           }
           if (attempt < MAX_RETRIES) {
             logEvent("generate", "retry", { requestId, attempt: attempt + 1, errorCode: lastErr?.code });
@@ -207,7 +208,14 @@ export function registerGenerateRoutes(app, ctx) {
           finishStatus = "error";
           finishHttpStatus = status;
           finishErrorCode = firstErr.code;
-          return res.status(status).json({ error: firstErr.message, code: firstErr.code, requestId });
+          return res.status(status).json({
+            error: firstErr.message,
+            code: firstErr.code,
+            upstreamCode: firstErr.upstreamCode || null,
+            upstreamType: firstErr.upstreamType || null,
+            upstreamParam: firstErr.upstreamParam || null,
+            requestId,
+          });
         }
         finishStatus = "error";
         finishHttpStatus = 500;
@@ -256,7 +264,14 @@ export function registerGenerateRoutes(app, ctx) {
       finishHttpStatus = err.status || 500;
       finishErrorCode = fallbackCode || "GENERATE_FAILED";
       logError("generate", "error", err, { requestId, code: finishErrorCode });
-      res.status(err.status || 500).json({ error: err.message, code: fallbackCode, requestId });
+      res.status(err.status || 500).json({
+        error: err.message,
+        code: fallbackCode,
+        upstreamCode: err.upstreamCode || null,
+        upstreamType: err.upstreamType || null,
+        upstreamParam: err.upstreamParam || null,
+        requestId,
+      });
     } finally {
       finishJob(requestId, {
         status: finishStatus,

package/routes/nodes.js

@@ -12,7 +12,7 @@ import { classifyUpstreamError } from "../lib/errorClassify.js";
 import { normalizeOAuthParams } from "../lib/oauthNormalize.js";
 import { normalizeImageModel } from "../lib/imageModels.js";
 import { generateViaOAuth, editViaOAuth } from "../lib/oauthProxy.js";
-import { normalizeGenerationFailure } from "../lib/generationErrors.js";
+import { isNonRetryableGenerationError, normalizeGenerationFailure } from "../lib/generationErrors.js";
 import { getStyleSheet } from "../lib/sessionStore.js";
 import { renderStyleSheetPrefix } from "../lib/styleSheet.js";
 import { logEvent, logError } from "../lib/logger.js";
@@ -48,6 +48,7 @@ function writeNodeError(res, status, code, message, parentNodeId, details = {})
   res.status(status).json({
     error: { code, message },
     parentNodeId,
+    status,
     ...details,
   });
 }
@@ -271,6 +272,7 @@ export function registerNodeRoutes(app, ctx) {
           lastErr = new Error("Empty response (safety refusal)");
         } catch (e) {
           lastErr = e;
+          if (isNonRetryableGenerationError(e)) break;
         }
         if (attempt < MAX_RETRIES) {
           logEvent("node", "retry", {
@@ -297,7 +299,7 @@ export function registerNodeRoutes(app, ctx) {
           requestId,
           operation,
           finalCode: finishErrorCode,
-          upstreamCode: lastErr?.code,
+          upstreamCode: lastErr?.upstreamCode || lastErr?.code,
           errorEventType: lastErr?.eventType,
           errorEventCount: lastErr?.eventCount,
           attempts: MAX_RETRIES + 1,
@@ -311,7 +313,9 @@ export function registerNodeRoutes(app, ctx) {
           finalErr.message,
           parentNodeId,
           {
-            upstreamCode: lastErr?.code || null,
+            upstreamCode: lastErr?.upstreamCode || lastErr?.code || null,
+            upstreamType: lastErr?.upstreamType || null,
+            upstreamParam: lastErr?.upstreamParam || null,
             errorEventType: lastErr?.eventType || null,
             errorEventCount: lastErr?.eventCount ?? null,
           },
@@ -401,7 +405,11 @@ export function registerNodeRoutes(app, ctx) {
       finishHttpStatus = err.status || 500;
       finishErrorCode = code;
       logError("node", "error", err, { requestId, code, parentNodeId, sessionId, clientNodeId });
-      writeNodeError(res, err.status || 500, code, err.message, parentNodeId);
+      writeNodeError(res, err.status || 500, code, err.message, parentNodeId, {
+        upstreamCode: err.upstreamCode || null,
+        upstreamType: err.upstreamType || null,
+        upstreamParam: err.upstreamParam || null,
+      });
     } finally {
       finishJob(requestId, {
         status: finishStatus,