ima2-gen 3.20.0 → 3.21.0

package/lib/grokSizeMapper.js

@@ -60,7 +60,7 @@ export function mapSizeToGrokImageParams(size) {
         const res = parts[parts.length - 1];
         const aspect = parts.slice(1, -1).join(":");
         return {
-            aspect_ratio: SUPPORTED_ASPECTS.includes(aspect) ? aspect : "auto",
+            aspect_ratio: SUPPORTED_ASPECTS.some((supported) => supported === aspect) ? aspect : "auto",
             resolution: res === "2k" ? "2k" : "1k",
         };
     }

package/lib/grokVideoAdapter.js

@@ -1,3 +1,4 @@
+import { thrownFields } from "./errInfo.js";
 import { logEvent, logWarn } from "./logger.js";
 import { grokError, searchGrokVisualContext } from "./grokImageAdapter.js";
 import { grokFetchWithRetry } from "./grokUpstreamRetry.js";
@@ -25,7 +26,8 @@ export { isRecoverablePollError, pollVideoOnce, pollVideoUntilDone } from "./gro
  * malfunctioned, which is a judgment about the request rather than an availability problem.
  * Billing a video start on the back of a refusal is worse for the user than an honest error.
  */
-export function isDegradablePlannerFailure(err) {
+export function isDegradablePlannerFailure(failure) {
+    const err = thrownFields(failure);
     const message = typeof err?.message === "string" ? err.message : "planner unavailable";
     if (err?.name === "AbortError")
         return { reason: "timeout", message };
@@ -186,7 +188,8 @@ export async function planGrokVideo(prompt, ctx, options = {}) {
             const search = await searchGrokVisualContext(prompt, ctx, { signal: phaseSignal, ...(options.requestId ? { requestId: options.requestId } : {}), credential, plannerModel });
             searchSummary = search.summary;
         }
-        catch (e) { // justified: adapter rejections are untyped; the shape is narrowed here
+        catch (e) {
+            const eFields = thrownFields(e);
             // A user cancellation is a real cancellation and must never be swallowed. Neither is
             // the planning-phase ceiling: searchGrokVisualContext reports an inherited abort as its
             // own cancellation, so without this check a ceiling hit would "degrade" and then start
@@ -195,11 +198,11 @@ export async function planGrokVideo(prompt, ctx, options = {}) {
                 throw e;
             if (phaseExpired())
                 throw grokError("Grok video planning timed out", 504, "GROK_VIDEO_PLAN_TIMEOUT");
-            if (e?.code === "GENERATION_CANCELED")
+            if (eFields.code === "GENERATION_CANCELED")
                 throw e;
             searchDegraded = {
-                reason: e?.code === "GROK_SEARCH_TIMEOUT" ? "timeout" : "failed",
-                message: typeof e?.message === "string" ? e.message : "web search unavailable",
+                reason: eFields.code === "GROK_SEARCH_TIMEOUT" ? "timeout" : "failed",
+                message: typeof eFields.message === "string" ? eFields.message : "web search unavailable",
             };
             logWarn("grok", "video:search:degraded", {
                 requestId: options.requestId,
@@ -247,15 +250,16 @@ export async function planGrokVideo(prompt, ctx, options = {}) {
             };
         }
         catch (e) {
+            const eFields = thrownFields(e);
             clearTimeout(timer);
             // Real cancellation and the planning-phase ceiling are always fatal.
             if (options.signal?.aborted)
                 throw grokError("Generation canceled", 499, "GENERATION_CANCELED");
             if (phaseExpired())
                 throw grokError("Grok video planning timed out", 504, "GROK_VIDEO_PLAN_TIMEOUT");
-            const normalized = e.name === "AbortError"
+            const normalized = eFields.name === "AbortError"
                 ? grokError("Grok video planner timed out", 504, "GROK_PLANNER_TIMEOUT")
-                : (e.code && e.status ? e : grokError(`Grok video planner request failed: ${e.message}`, 502, "GROK_PLANNER_NETWORK_FAILED"));
+                : (eFields.code && eFields.status ? e : grokError(`Grok video planner request failed: ${eFields.message}`, 502, "GROK_PLANNER_NETWORK_FAILED"));
             // A stalled or broken planner must not cost the user their video: the user's own
             // prompt is already usable, so compose one locally and continue. 4xx stays fatal.
             // devlog/_plan/260817_grok_video_planner_timeout/040_planner_fallback.md
@@ -364,15 +368,16 @@ export async function startVideoRequest(ctx, payload, options) {
         return requestId;
     }
     catch (e) {
+        const eFields = thrownFields(e);
         clearTimeout(timer);
-        if (e.name === "AbortError") {
+        if (eFields.name === "AbortError") {
             if (options.signal?.aborted)
                 throw grokError("Generation canceled", 499, "GENERATION_CANCELED");
             throw grokError("Grok video start timed out", 504, "GROK_VIDEO_TIMEOUT");
         }
-        if (e.code && e.status)
+        if (eFields.code && eFields.status)
             throw e;
-        throw grokError(`Grok video start request failed: ${e.message}`, 502, "GROK_VIDEO_REQUEST_FAILED");
+        throw grokError(`Grok video start request failed: ${eFields.message}`, 502, "GROK_VIDEO_REQUEST_FAILED");
     }
 }
 export async function generateVideoViaGrok(prompt, ctx, options = {}) {
@@ -412,7 +417,8 @@ export async function generateVideoViaGrok(prompt, ctx, options = {}) {
     try {
         xaiVideoRequestId = await startVideoRequest(ctx, effectivePayload, effective);
     }
-    catch (e) {
+    catch (caught) {
+        const e = thrownFields(caught);
         // Fallback: if 1.5-preview still fails, retry with base model.
         // Not when voices are attached: the base model rejects reference_audios outright, so
         // the retry would only replace one 400 with a more confusing one. Dropping the voice
@@ -424,7 +430,7 @@ export async function generateVideoViaGrok(prompt, ctx, options = {}) {
             logEvent("grok", "video:fallback", { requestId: options.requestId, from: model, to: effectiveModel });
         }
         else {
-            throw e;
+            throw caught;
         }
     }
     const modelFallback = effectiveModel === model ? null : { from: model, to: effectiveModel };

package/lib/grokVideoDownload.js

@@ -2,7 +2,7 @@ import { grokError } from "./grokImageAdapter.js";
 import { grokFetchWithRetry } from "./grokUpstreamRetry.js";
 const MAX_VIDEO_DOWNLOAD_BYTES = 100 * 1024 * 1024;
 function downloadTimeoutMs(ctx) {
-    const g = ctx.config.grokProvider || {};
+    const g = ctx.config?.grokProvider || {};
     return g.videoDownloadTimeoutMs || 300_000;
 }
 function withTimeoutSignal(signal, timeoutMs) {

package/lib/grokVideoPoll.js

@@ -1,3 +1,4 @@
+import { thrownFields } from "./errInfo.js";
 import { grokError } from "./grokImageCore.js";
 import { grokFetchWithRetry } from "./grokUpstreamRetry.js";
 import { FAILED_CODE_MAP, STALE_PROGRESS_MS, normalizeVideoPoll, sleep, videoConfig, videoEndpoint, withTimeoutSignal, } from "./grokVideoShared.js";
@@ -27,16 +28,17 @@ export async function pollVideoOnce(ctx, requestId, signal, credential) {
         const pollData = await res.json();
         return normalizeVideoPoll(pollData);
     }
-    catch (e) { // justified: fetch/JSON rejections are untyped; the shape is narrowed below
+    catch (e) {
+        const eFields = thrownFields(e);
         clearTimeout(timer);
-        if (e.name === "AbortError") {
+        if (eFields.name === "AbortError") {
             if (signal?.aborted)
                 throw grokError("Generation canceled", 499, "GENERATION_CANCELED");
             throw grokError("Grok video poll timed out", 504, "GROK_VIDEO_TIMEOUT");
         }
-        if (e.code && e.status)
+        if (eFields.code && eFields.status)
             throw e;
-        throw grokError(`Grok video poll request failed: ${e.message}`, 502, "GROK_VIDEO_POLL_FAILED");
+        throw grokError(`Grok video poll request failed: ${eFields.message}`, 502, "GROK_VIDEO_POLL_FAILED");
     }
 }
 export function failedToError(poll) {
@@ -61,16 +63,17 @@ export async function pollVideoUntilDone(ctx, requestId, options) {
             poll = await pollVideoOnce(ctx, requestId, options.signal, options.credential);
             consecutiveErrors = 0;
         }
-        catch (e) { // justified: grokError attaches code/status at runtime
+        catch (e) {
+            const eFields = thrownFields(e);
             // The upstream job outlives a transient poll failure, so a blip must not discard a
             // fifteen-minute render. Cancellation and a genuinely dead job still end the wait,
             // and the outer deadline still caps the total.
-            if (e?.code === "GENERATION_CANCELED" || !isRecoverablePollError(e))
+            if (eFields.code === "GENERATION_CANCELED" || !isRecoverablePollError(e))
                 throw e;
             consecutiveErrors += 1;
             if (consecutiveErrors > cfg.pollMaxConsecutiveErrors)
                 throw e;
-            console.warn(`[grok] video poll failed (${consecutiveErrors}/${cfg.pollMaxConsecutiveErrors}) — ${e.message}`);
+            console.warn(`[grok] video poll failed (${consecutiveErrors}/${cfg.pollMaxConsecutiveErrors}) — ${eFields.message}`);
             options.onEvent?.({ phase: "progress", progress: lastProgress >= 0 ? lastProgress : undefined, stalled: true });
             await sleep(cfg.pollIntervalMs, options.signal);
             continue;

package/lib/grokVideoShared.js

@@ -11,7 +11,7 @@ export const FAILED_CODE_MAP = {
     internal_error: { code: "GROK_VIDEO_FAILED", status: 502 },
 };
 export function videoConfig(ctx) {
-    const g = ctx.config.grokProvider || {}; // justified: RouteRuntimeContext.config is a loose runtime bag; every Grok adapter reads grokProvider this way
+    const g = ctx.config?.grokProvider || {};
     const plannerTimeoutMs = g.plannerTimeoutMs || 900_000;
     const searchTimeoutMs = g.searchTimeoutMs || 300_000;
     // The planning ceiling must stay STRICTLY greater than the two stages it contains, or a

package/lib/historyList.js

@@ -98,13 +98,13 @@ export async function listHistoryRows(baseDir = config.storage.generatedDir) {
             sequenceStatus: meta?.sequenceStatus || null,
         };
     }));
-    rows.push(...setRows);
-    rows.sort((a, b) => {
+    const allRows = [...rows, ...setRows];
+    allRows.sort((a, b) => {
         if (b.createdAt !== a.createdAt)
             return b.createdAt - a.createdAt;
         return b.filename < a.filename ? -1 : b.filename > a.filename ? 1 : 0;
     });
-    return rows;
+    return allRows;
 }
 async function readImageSidecar(full, rel) {
     const sibling = full.replace(/\.(png|jpe?g|webp)$/i, ".json");
@@ -140,6 +140,54 @@ async function readImageMetadata(full, rel) {
         return null;
     }
 }
+function cardNewsSetRow(entryName, manifestPath, manifest) {
+    const first = (manifest.cards || []).find((card) => card.imageFilename);
+    const filename = `cardnews/${entryName}/manifest.json`;
+    return {
+        filename,
+        url: first?.imageFilename
+            ? `/generated/cardnews/${encodeURIComponent(entryName)}/${encodeURIComponent(first.imageFilename)}`
+            : "",
+        createdAt: manifest.createdAt || 0,
+        prompt: null,
+        userPrompt: null,
+        revisedPrompt: null,
+        promptMode: null,
+        composerPrompt: null,
+        composerInsertedPrompts: null,
+        quality: null,
+        size: manifest.size || null,
+        format: "card-news-set",
+        model: null,
+        provider: "oauth",
+        usage: null,
+        webSearchCalls: 0,
+        sessionId: manifest.sessionId || null,
+        nodeId: null,
+        parentNodeId: null,
+        clientNodeId: null,
+        requestId: manifest.requestId || null,
+        kind: "card-news-set",
+        setId: manifest.setId || entryName,
+        cardId: null,
+        cardOrder: null,
+        title: manifest.title || "Untitled card news",
+        headline: manifest.title || "Untitled card news",
+        body: null,
+        cards: (manifest.cards || []).map((card) => ({
+            url: card.imageFilename
+                ? `/generated/cardnews/${encodeURIComponent(entryName)}/${encodeURIComponent(card.imageFilename)}`
+                : "",
+            headline: card.headline,
+            body: card.body,
+            cardOrder: card.cardOrder,
+            imageFilename: card.imageFilename,
+            status: card.status || "generated",
+        })),
+        refsCount: 0,
+        dir: dirname(manifestPath),
+    };
+}
 async function listCardNewsSetRows(baseDir) {
     const root = join(baseDir, "cardnews");
     const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
@@ -150,52 +198,7 @@ async function listCardNewsSetRows(baseDir) {
         try {
             const manifestPath = join(root, entry.name, "manifest.json");
             const manifest = JSON.parse(await readFile(manifestPath, "utf-8"));
-            const first = (manifest.cards || []).find((card) => card.imageFilename);
-            const filename = `cardnews/${entry.name}/manifest.json`;
-            rows.push({
-                filename,
-                url: first?.imageFilename
-                    ? `/generated/cardnews/${encodeURIComponent(entry.name)}/${encodeURIComponent(first.imageFilename)}`
-                    : "",
-                createdAt: manifest.createdAt || 0,
-                prompt: null,
-                userPrompt: null,
-                revisedPrompt: null,
-                promptMode: null,
-                composerPrompt: null,
-                composerInsertedPrompts: null,
-                quality: null,
-                size: manifest.size || null,
-                format: "card-news-set",
-                model: null,
-                provider: "oauth",
-                usage: null,
-                webSearchCalls: 0,
-                sessionId: manifest.sessionId || null,
-                nodeId: null,
-                parentNodeId: null,
-                clientNodeId: null,
-                requestId: manifest.requestId || null,
-                kind: "card-news-set",
-                setId: manifest.setId || entry.name,
-                cardId: null,
-                cardOrder: null,
-                title: manifest.title || "Untitled card news",
-                headline: manifest.title || "Untitled card news",
-                body: null,
-                cards: (manifest.cards || []).map((card) => ({
-                    url: card.imageFilename
-                        ? `/generated/cardnews/${encodeURIComponent(entry.name)}/${encodeURIComponent(card.imageFilename)}`
-                        : "",
-                    headline: card.headline,
-                    body: card.body,
-                    cardOrder: card.cardOrder,
-                    imageFilename: card.imageFilename,
-                    status: card.status || "generated",
-                })),
-                refsCount: 0,
-                dir: dirname(manifestPath),
-            });
+            rows.push(cardNewsSetRow(entry.name, manifestPath, manifest));
         }
         catch (e) {
             const err = errInfo(e);

package/lib/imageMetadata.js

@@ -1,5 +1,5 @@
 export const IMA2_METADATA_SCHEMA = "ima2.generation.v1";
-export const IMA2_XMP_NAMESPACE = "https://github.com/lidge-jun/ima2-gen/ns/1.0/";
+export const IMA2_XMP_NAMESPACE = "https://github.com/lidge-ai/ima2-gen/ns/1.0/";
 export const IMA2_XMP_PROPERTY = "GenerationMetadata";
 export const MAX_EMBEDDED_METADATA_CHARS = 64 * 1024;
 function isPlainObject(value) {
@@ -32,7 +32,8 @@ function xmlUnescape(value) {
         .replace(/>/g, ">")
         .replace(/&/g, "&");
 }
-export function buildIma2MetadataPayload(meta = {}, context = {}) {
+export function buildIma2MetadataPayload(metaInput = {}, context = {}) {
+    const meta = isPlainObject(metaInput) ? metaInput : {};
     const payload = {
         schema: IMA2_METADATA_SCHEMA,
         app: "ima2-gen",
@@ -64,8 +65,8 @@ export function buildIma2MetadataPayload(meta = {}, context = {}) {
         parentNodeId: stringOrNull(meta.parentNodeId, 120),
         clientNodeId: stringOrNull(meta.clientNodeId, 120),
         requestId: stringOrNull(meta.requestId, 160),
-        refsCount: Number.isFinite(meta.refsCount) ? meta.refsCount : 0,
-        webSearchCalls: Number.isFinite(meta.webSearchCalls) ? meta.webSearchCalls : 0,
+        refsCount: numberOrNull(meta.refsCount) ?? 0,
+        webSearchCalls: numberOrNull(meta.webSearchCalls) ?? 0,
         styleSheetApplied: Boolean(meta.styleSheetApplied),
         presetIds: stringArray(meta.presetIds),
         elementIds: stringArray(meta.elementIds),

package/lib/imageMetadataStore.js

@@ -1,3 +1,4 @@
+import { thrownFields } from "./errInfo.js";
 import { readFile } from "node:fs/promises";
 import sharp from "sharp";
 import { buildIma2MetadataPayload, buildIma2Xmp, parseIma2Xmp } from "./imageMetadata.js";
@@ -11,9 +12,12 @@ export function normalizeImageMetadataFormat(format) {
 export function isSupportedMetadataFormat(format) {
     return SUPPORTED_FORMATS.has(String(format || "").toLowerCase());
 }
+function isMetadataFormat(format) {
+    return format === "png" || format === "jpeg" || format === "webp";
+}
 export async function embedImageMetadata(buffer, format, metadata, context = {}) {
     const normalizedFormat = normalizeImageMetadataFormat(format);
-    if (!isSupportedMetadataFormat(normalizedFormat)) {
+    if (!isMetadataFormat(normalizedFormat)) {
         const err = new Error(`Unsupported image metadata format: ${format}`);
         err.code = "IMAGE_METADATA_UNSUPPORTED_FORMAT";
         throw err;
@@ -31,11 +35,12 @@ export async function embedImageMetadataBestEffort(buffer, format, metadata, con
         return await embedImageMetadata(buffer, format, metadata, context);
     }
     catch (error) {
+        const errorFields = thrownFields(error);
         return {
             buffer,
             embedded: false,
-            warning: error?.message || "metadata embedding failed",
-            code: error?.code || "IMAGE_METADATA_EMBED_FAILED",
+            warning: errorFields.message || "metadata embedding failed",
+            code: errorFields.code || "IMAGE_METADATA_EMBED_FAILED",
         };
     }
 }

package/lib/imageModels.js

@@ -1,6 +1,11 @@
 import { deriveModels, deriveSupportedImageModels, deriveUnsupportedImageModels } from "./providers/derive.js";
-export const FALLBACK_IMAGE_MODEL = "gpt-5.6-luna";
+export const FALLBACK_IMAGE_MODEL = "gpt-6-luna";
+/** The API-key lane keeps its own list; its fallback is never a GPT OAuth-only id. */
+export const API_FALLBACK_IMAGE_MODEL = "gpt-5.6-luna";
 const VALID_IMAGE_MODELS = deriveSupportedImageModels("oauth");
+const VALID_API_IMAGE_MODELS = deriveSupportedImageModels("api");
+export { LEGACY_OAUTH_IMAGE_MODELS, migrateOAuthImageModel } from "./oauthLegacyModels.js";
+import { migrateOAuthImageModel } from "./oauthLegacyModels.js";
 const UNSUPPORTED_IMAGE_MODELS = deriveUnsupportedImageModels();
 const FALLBACK_REASONING_EFFORT = "none";
 const VALID_REASONING_EFFORTS = new Set(["none", "low", "medium", "high", "xhigh", "max"]);
@@ -60,29 +65,35 @@ export function normalizeReasoningEffort(ctx, rawEffort) {
     }
     return { effort: rawEffort };
 }
-export function normalizeImageModel(ctx, rawModel) {
-    const configured = ctx?.config?.imageModels;
-    const fallback = configured?.default ?? FALLBACK_IMAGE_MODEL;
-    const valid = configured?.valid ?? VALID_IMAGE_MODELS;
+export function normalizeImageModel(ctx, rawModel, provider = "oauth") {
+    const runtimeConfig = ctx?.config;
+    const configured = runtimeConfig?.imageModels;
+    const oauth = provider === "oauth";
+    const laneFallback = oauth ? FALLBACK_IMAGE_MODEL : API_FALLBACK_IMAGE_MODEL;
+    const fallback = oauth
+        ? migrateOAuthImageModel(configured?.default ?? FALLBACK_IMAGE_MODEL)
+        : runtimeConfig?.apiProvider?.defaultImageModel ?? API_FALLBACK_IMAGE_MODEL;
+    const valid = oauth ? (configured?.valid ?? VALID_IMAGE_MODELS) : VALID_API_IMAGE_MODELS;
     const unsupported = configured?.unsupported ?? UNSUPPORTED_IMAGE_MODELS;
     if (typeof rawModel !== "string" || rawModel.length === 0) {
-        return { model: valid.has(fallback) ? fallback : FALLBACK_IMAGE_MODEL };
+        return { model: valid.has(fallback) ? fallback : laneFallback };
     }
-    if (unsupported.has(rawModel)) {
+    const model = oauth ? migrateOAuthImageModel(rawModel) : rawModel;
+    if (unsupported.has(model)) {
         return {
-            error: "model is listed by OAuth but does not support image_generation: gpt-5.3-codex-spark",
+            error: `model does not support image generation: ${model}`,
             code: "IMAGE_MODEL_UNSUPPORTED",
             status: 400,
         };
     }
-    if (!valid.has(rawModel)) {
+    if (!valid.has(model)) {
         return {
-            error: "model must be one of: gpt-5.5, gpt-5.4, gpt-5.4-mini, gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna, gpt-6-astra",
+            error: `model must be one of: ${[...valid].join(", ")}`,
             code: "INVALID_IMAGE_MODEL",
             status: 400,
         };
     }
-    return { model: rawModel };
+    return { model };
 }
 export function normalizeGrokImageModel(rawModel) {
     if (typeof rawModel !== "string" || rawModel.length === 0) {

package/lib/localAccessPolicy.js

@@ -65,6 +65,13 @@ function literalHost(address) {
     }
     return isIP(address) === 6 ? `[${address}]` : address;
 }
+/** True when a socket peer is this computer (127.0.0.0/8, ::1, IPv4-mapped loopback). */
+export function isLoopbackPeer(address) {
+    if (!address)
+        return false;
+    const host = literalHost(address);
+    return host === "[::1]" || /^127\.\d+\.\d+\.\d+$/.test(host);
+}
 function servingOrigins(req, host, publicOrigins) {
     const origins = new Map();
     const port = req.socket.localPort;

package/lib/localLanAccess.js

@@ -23,7 +23,7 @@ function readCredentials(req, name, maxBytes) {
     const header = singleHeader(req, "x-ima2-token", "LAN_TOKEN_REQUIRED");
     const params = new URLSearchParams((req.originalUrl || req.url).split("?").slice(1).join("?"));
     const queries = params.getAll("token");
-    const invalidQuery = [...params.keys()].some(key => /^token[\[.]/.test(key));
+    const invalidQuery = [...params.keys()].some(key => /^token[[.]/.test(key));
     if (queries.length > 1 || invalidQuery)
         throw localAccessError("LAN_TOKEN_REQUIRED", 401);
     const query = queries[0];
@@ -117,7 +117,7 @@ class LocalLanAccess {
         }
         catch {
             const prefix = (req.originalUrl || req.url).replace(/%([\da-f]{2})/ig, (_match, hex) => String.fromCharCode(parseInt(hex, 16)));
-            if (this.lan && /^\/generated(?:[\/\\]|$)/i.test(prefix))
+            if (this.lan && /^\/generated(?:[/\\]|$)/i.test(prefix))
                 privateMediaHeaders(res);
         }
         next();

package/lib/logger.js

@@ -52,7 +52,7 @@ function sanitizeLogString(value) {
     const oneLine = value
         .replace(/data:image\/[a-z0-9.+-]+;base64,[A-Za-z0-9+/=]+/gi, "data:image/[redacted]")
         .replace(/\b[a-z][a-z0-9+.-]*:\/\/[^\s"'<>]+/gi, "[redacted-url]")
-        .replace(/(^|[\s("'<>=,\[{])\/\/[^\s"'<>]+/g, "$1[redacted-url]")
+        .replace(/(^|[\s("'<>=,[{])\/\/[^\s"'<>]+/g, "$1[redacted-url]")
         .replace(/Bearer\s+[^\s"'<>]+/gi, "Bearer [redacted]")
         .replace(/([?&][^=\s?&#"'<>]+)=([^&\s"'<>]*)/g, "$1=[redacted]")
         .replace(/\s+/g, " ")

package/lib/minimaxImageAdapter.js

@@ -1,14 +1,4 @@
-// lib/minimaxImageAdapter.ts — MiniMax image-generation adapter.
-//
-// Calls the MiniMax /v1/image_generation endpoint directly with a Bearer API
-// key. Supports text-to-image and image-to-image: when reference images are
-// attached they are mapped to the `subject_reference` array (character subject
-// type, data URL or public URL). Responses are returned as `url` or `base64`;
-// both shapes are parsed into a single base64 payload for the shared pipeline.
-//
-// Region selects the global (.io) or China (.minimaxi.com) OpenAI-compatible
-// base URL. The endpoint, models, request fields, output formats, and response
-// fields follow the MiniMax image-generation API reference.
+import { thrownFields } from "./errInfo.js";
 import { detectImageMimeFromB64 } from "./refs.js";
 import { logEvent } from "./logger.js";
 import { deriveReferenceLimit } from "./providers/derive.js";
@@ -274,18 +264,19 @@ export async function generateViaMinimax(prompt, ctx, options = {}) {
         };
     }
     catch (e) {
+        const eFields = thrownFields(e);
         // AbortSignal.timeout() rejects with a TimeoutError, not an AbortError.
-        if (e.name === "TimeoutError") {
+        if (eFields.name === "TimeoutError") {
             throw minimaxError("MiniMax image generation timed out", 504, "GENERATION_TIMEOUT");
         }
-        if (e.name === "AbortError") {
+        if (eFields.name === "AbortError") {
             if (options.signal?.aborted) {
                 throw minimaxError("Generation canceled", 499, "GENERATION_CANCELED");
             }
             throw minimaxError("MiniMax image generation timed out", 504, "GENERATION_TIMEOUT");
         }
-        if (e.code && e.status)
+        if (eFields.code && eFields.status)
             throw e;
-        throw minimaxError(`MiniMax request failed: ${e.message}`, 502, "MINIMAX_NETWORK_FAILED");
+        throw minimaxError(`MiniMax request failed: ${eFields.message}`, 502, "MINIMAX_NETWORK_FAILED");
     }
 }