ima2-gen 3.20.0 → 3.21.0

package/lib/oauthImages.js

@@ -0,0 +1,269 @@
+/**
+ * GPT OAuth image lane on the Codex backend (the Codex image_gen shape).
+ *
+ * GPT-6 models on the ChatGPT backend cannot call the hosted image_generation tool, so the
+ * lane runs in two steps, the way Codex's image_gen.imagegen and OpenCodex's media bridge do:
+ *   1. plan  — the selected GPT-6 model gets ima2's existing developer/user prompts plus a
+ *              client function tool \`image_gen\` and writes the final prompt(s);
+ *   2. render — each prompt goes to the Images API (gpt-image-2): /generations without
+ *              input images, /edits with the edit source and references.
+ * Direct mode skips the planner and renders the user's prompt verbatim.
+ * The result keeps ParsedResponsesResult's shape so routes, SSE, history and error
+ * diagnostics stay unchanged.
+ */
+import { logEvent } from "./logger.js";
+import { postOAuthImages, postResponses } from "./responsesTransport.js";
+export const OAUTH_IMAGE_TOOL = "image_gen";
+export const OAUTH_RENDER_MODEL = "gpt-image-2";
+/** The ChatGPT images edit endpoint accepts at most five input images. */
+export const OAUTH_MAX_EDIT_IMAGES = 5;
+const RENDER_CONCURRENCY = 3;
+const IMAGES_QUALITY = new Set(["low", "medium", "high"]);
+const PLANNER_NOTE = [
+    "",
+    "",
+    "Rendering: ima2 renders images through the image_gen function tool. Put the final image prompt in its arguments; the renderer sees only that prompt and the attached images, so include every visual detail it needs.",
+    "Call image_gen exactly once. Never answer with text instead of calling it.",
+].join("\n");
+const SEQUENCE_NOTE = (n) => `\nFor this request call image_gen once with \`prompts\`: an ordered array of 1 to ${n} stage prompts. Each entry becomes one separate output image.`;
+/** Point every hosted-tool mention in ima2's prompts at the client function tool. */
+export function toFunctionToolWording(text) {
+    return text.replace(/image_generation_call/g, "image_gen call").replace(/image_generation/g, "image_gen");
+}
+export function imageGenTool(maxImages) {
+    const sequence = maxImages > 1;
+    return {
+        type: "function",
+        name: OAUTH_IMAGE_TOOL,
+        description: sequence
+            ? "Render the requested image sequence. Call once with one prompt per output image."
+            : "Render the final image. Call once with the complete image prompt.",
+        parameters: sequence
+            ? {
+                type: "object",
+                properties: {
+                    prompts: {
+                        type: "array",
+                        items: { type: "string" },
+                        minItems: 1,
+                        maxItems: maxImages,
+                        description: "Ordered stage prompts, one per output image.",
+                    },
+                },
+                required: ["prompts"],
+                additionalProperties: false,
+            }
+            : {
+                type: "object",
+                properties: { prompt: { type: "string", description: "Complete image prompt to render." } },
+                required: ["prompt"],
+                additionalProperties: false,
+            },
+        strict: false,
+    };
+}
+export function buildPlannerPayload(job, retry = false) {
+    const note = PLANNER_NOTE + (job.maxImages > 1 ? SEQUENCE_NOTE(job.maxImages) : "")
+        + (retry ? "\nThe previous attempt did not call image_gen. Call it now." : "");
+    const text = toFunctionToolWording(job.userText);
+    const content = job.images.length
+        ? [
+            ...job.images.map((image) => ({ type: "input_image", image_url: `data:${image.mime};base64,${image.b64}` })),
+            { type: "input_text", text },
+        ]
+        : text;
+    return {
+        model: job.model,
+        input: [
+            { role: "developer", content: toFunctionToolWording(job.developerPrompt) + note },
+            { role: "user", content },
+        ],
+        tools: [...(job.webSearchEnabled ? [{ type: "web_search" }] : []), imageGenTool(job.maxImages)],
+        reasoning: { effort: job.reasoningEffort },
+        stream: true,
+    };
+}
+/** Read the planner's image_gen calls into an ordered prompt list, capped at maxImages. */
+export function promptsFromCalls(calls, maxImages) {
+    const prompts = [];
+    for (const call of calls ?? []) {
+        if (call.name !== OAUTH_IMAGE_TOOL)
+            continue;
+        let args;
+        try {
+            args = JSON.parse(call.arguments || "{}");
+        }
+        catch {
+            continue;
+        }
+        if (!args || typeof args !== "object")
+            continue;
+        const record = args;
+        if (Array.isArray(record.prompts)) {
+            for (const entry of record.prompts)
+                if (typeof entry === "string" && entry.trim())
+                    prompts.push(entry.trim());
+        }
+        else if (typeof record.prompt === "string" && record.prompt.trim()) {
+            prompts.push(record.prompt.trim());
+        }
+    }
+    return prompts.slice(0, Math.max(1, maxImages));
+}
+/** Map ima2's request fields onto what the OAuth Images API accepts. */
+export function renderFields(job) {
+    const fields = {};
+    const quality = job.quality === "xhigh" || job.quality === "max" ? "high" : job.quality;
+    if (quality && IMAGES_QUALITY.has(quality))
+        fields.quality = quality;
+    if (job.size && job.size !== "auto" && /^\d+x\d+$/.test(job.size))
+        fields.size = job.size;
+    if (job.background && ["transparent", "opaque", "auto"].includes(job.background))
+        fields.background = job.background;
+    // Measured 2026-09-25: the ChatGPT Images endpoint accepts moderation "low" (200, one image).
+    if (job.moderation === "auto" || job.moderation === "low")
+        fields.moderation = job.moderation;
+    return fields;
+}
+function extensionFor(mime) {
+    return mime === "image/jpeg" ? "jpg" : mime === "image/webp" ? "webp" : "png";
+}
+async function renderOne(job, prompt) {
+    const fields = renderFields(job);
+    if (!job.images.length) {
+        return postOAuthImages({
+            ctx: job.ctx,
+            scope: job.scope,
+            kind: "generations",
+            json: { model: OAUTH_RENDER_MODEL, prompt, n: 1, ...fields },
+            requestId: job.requestId,
+            signal: job.signal,
+        });
+    }
+    const form = new FormData();
+    form.set("model", OAUTH_RENDER_MODEL);
+    form.set("prompt", prompt);
+    for (const [key, value] of Object.entries(fields))
+        form.set(key, value);
+    job.images.slice(0, OAUTH_MAX_EDIT_IMAGES).forEach((image, index) => {
+        const blob = new Blob([Buffer.from(image.b64, "base64")], { type: image.mime });
+        form.append("image", blob, `input-${index + 1}.${extensionFor(image.mime)}`);
+    });
+    return postOAuthImages({ ctx: job.ctx, scope: job.scope, kind: "edits", form, requestId: job.requestId, signal: job.signal });
+}
+function addUsage(target, usage) {
+    for (const [key, value] of Object.entries(usage ?? {})) {
+        if (typeof value === "number")
+            target[key] = (target[key] ?? 0) + value;
+    }
+}
+function emptyDiagnostics() {
+    return {
+        eventTypes: {},
+        streamStats: {
+            chunkCount: 0, bytesRead: 0, maxChunkBytes: 0, lfBoundaryCount: 0, crlfBoundaryCount: 0,
+            parseSkipCount: 0, finalBufferChars: 0, sawDoneSentinel: false, sawResponseCompleted: false,
+        },
+        outputItemSummary: [],
+        imageCallSeen: false,
+        imageCallCompleted: false,
+        imageCallFailed: false,
+        imageResultCount: 0,
+        webSearchCallSeen: false,
+        messageOutputSeen: false,
+        outputTextChars: 0,
+    };
+}
+async function plan(job) {
+    let result = await postResponses({
+        ctx: job.ctx, provider: "oauth", scope: `${job.scope}-plan`, requestId: job.requestId,
+        signal: job.signal, maxImages: 0, payload: buildPlannerPayload(job),
+    });
+    let prompts = promptsFromCalls(result.functionCalls, job.maxImages);
+    if (!prompts.length) {
+        logEvent(job.scope, "plan_retry", { requestId: job.requestId, events: result.eventCount });
+        result = await postResponses({
+            ctx: job.ctx, provider: "oauth", scope: `${job.scope}-plan`, requestId: job.requestId,
+            signal: job.signal, maxImages: 0, payload: buildPlannerPayload(job, true),
+        });
+        prompts = promptsFromCalls(result.functionCalls, job.maxImages);
+    }
+    return { result, prompts };
+}
+export async function runOAuthImageJob(job) {
+    // Direct mode renders the user's prompt verbatim, but a multi-image request still needs one
+    // prompt per stage, so it goes through the planner (its user text already carries the
+    // sequence instructions and the Direct fidelity rule).
+    const direct = job.mode === "direct" && job.maxImages <= 1;
+    const planned = direct
+        ? { result: null, prompts: Array.from({ length: Math.max(1, job.maxImages) }, () => job.directPrompt) }
+        : await plan(job);
+    const base = planned.result;
+    const usage = {};
+    addUsage(usage, base?.usage);
+    const eventTypes = { ...(base?.eventTypes ?? {}) };
+    const diagnostics = base?.diagnostics ? { ...base.diagnostics } : emptyDiagnostics();
+    const kind = job.images.length ? "images.edits" : "images.generations";
+    logEvent(job.scope, "plan_done", { requestId: job.requestId, direct, prompts: planned.prompts.length });
+    const slots = planned.prompts.map(() => {
+        let resolve;
+        const promise = new Promise((r) => { resolve = r; });
+        return { promise, resolve };
+    });
+    let cursor = 0;
+    const worker = async () => {
+        while (cursor < planned.prompts.length) {
+            const index = cursor++;
+            try {
+                slots[index]?.resolve({ status: "done", value: await renderOne(job, planned.prompts[index]) });
+            }
+            catch (error) {
+                slots[index]?.resolve({ status: "failed", error });
+            }
+        }
+    };
+    const workers = Array.from({ length: Math.min(RENDER_CONCURRENCY, planned.prompts.length) }, () => worker());
+    const images = [];
+    const originalIndexes = [];
+    let firstError;
+    // Deliver in stage order so sequences persist and stream in the order the planner wrote them.
+    for (const [index, slot] of slots.entries()) {
+        const settled = await slot.promise;
+        eventTypes[kind] = (eventTypes[kind] ?? 0) + 1;
+        if (settled.status === "failed") {
+            firstError ??= settled.error;
+            logEvent(job.scope, "render_failed", { requestId: job.requestId, index });
+            continue;
+        }
+        addUsage(usage, settled.value.usage);
+        const b64 = settled.value.images[0]?.b64;
+        if (!b64)
+            continue;
+        const image = { b64, revisedPrompt: direct ? null : planned.prompts[index] };
+        images.push(image);
+        originalIndexes.push(index);
+        await job.onFinalImage?.(image, index);
+    }
+    await Promise.all(workers);
+    // A single render has no partial result to return: surface its own error.
+    if (planned.prompts.length === 1 && firstError !== undefined)
+        throw firstError;
+    diagnostics.eventTypes = eventTypes;
+    diagnostics.imageCallSeen = planned.prompts.length > 0;
+    diagnostics.imageCallCompleted = images.length > 0;
+    diagnostics.imageCallFailed = firstError !== undefined;
+    diagnostics.imageResultCount = images.length;
+    return {
+        images,
+        usage: Object.keys(usage).length ? usage : null,
+        webSearchCalls: base?.webSearchCalls ?? 0,
+        eventCount: (base?.eventCount ?? 0) + planned.prompts.length,
+        eventTypes,
+        extraIgnored: 0,
+        text: base?.text ?? null,
+        diagnostics,
+        ...(base?.functionCalls ? { functionCalls: base.functionCalls } : {}),
+        ...(originalIndexes.length !== planned.prompts.length || firstError !== undefined ? { originalIndexes } : {}),
+        ...(firstError !== undefined ? { error: firstError } : {}),
+    };
+}

package/lib/oauthLegacyModels.js

@@ -0,0 +1,19 @@
+/**
+ * GPT OAuth keeps only GPT-6 (sol / luna / astra). Earlier OAuth ids stay usable in saved
+ * defaults, sessions and scripts by mapping to the matching GPT-6 tier, inside the same lane
+ * and billing. The API-key lane keeps its own list and is never remapped.
+ *
+ * Dependency-free so the CLI resolver can share it without loading server modules.
+ */
+export const LEGACY_OAUTH_IMAGE_MODELS = {
+    "gpt-5.6-sol": "gpt-6-sol",
+    "gpt-5.6-luna": "gpt-6-luna",
+    "gpt-5.6-terra": "gpt-6-luna",
+    "gpt-5.5": "gpt-6-luna",
+    "gpt-5.4": "gpt-6-luna",
+    "gpt-5.4-mini": "gpt-6-luna",
+};
+/** Map a legacy OAuth image model id onto its GPT-6 replacement; anything else is unchanged. */
+export function migrateOAuthImageModel(model) {
+    return LEGACY_OAUTH_IMAGE_MODELS[model] ?? model;
+}

package/lib/oauthProxy/multimodeGenerators.js

@@ -49,7 +49,7 @@ export async function generateMultimodeViaOAuth(prompt, quality, size, moderatio
         const res = await fetchOAuth(`${oauthUrl}/v1/responses`, {
             method: "POST",
             headers: { "Content-Type": "application/json", Accept: "text/event-stream" },
-            signal: options.signal || timeout.signal,
+            signal: options.signal || timeout.signal || null,
             body: JSON.stringify({
                 model,
                 input: [

package/lib/oauthProxy/runtime.js

@@ -1,6 +1,7 @@
 import { config } from "../../config.js";
 import { logEvent } from "../logger.js";
 import { isAbortError, makeOAuthError } from "./errors.js";
+import { oauthFetch } from "../codexBackend/index.js";
 import { errInfo } from "../errInfo.js";
 const FALLBACK_REASONING_EFFORT = "none";
 const VALID_REASONING_EFFORTS = new Set(["none", "low", "medium", "high", "xhigh", "max"]);
@@ -91,6 +92,23 @@ export async function fetchOAuth(url, init, { requestId, scope } = {}) {
         });
     }
 }
+/** Same failure mapping as fetchOAuth, routed through oauthFetch (native Codex client or proxy). */
+export async function fetchOAuthPath(ctx, path, init, { requestId, scope } = {}) {
+    try {
+        return await oauthFetch(ctx, path, init);
+    }
+    catch (e) {
+        const err = errInfo(e);
+        if (isAbortError(err.raw))
+            throw err.raw;
+        logEvent(scope || "oauth", "proxy_unavailable", { requestId, message: err.message });
+        throw makeOAuthError("GPT OAuth is unavailable", {
+            code: "OAUTH_UNAVAILABLE",
+            status: 503,
+            cause: err.raw,
+        });
+    }
+}
 export function summarizeEventTypes(eventTypes = {}) {
     const entries = Object.entries(eventTypes || {});
     const countFor = (needle) => entries.reduce((sum, [key, value]) => sum + (key.includes(needle) && Number.isFinite(value) ? value : 0), 0);

package/lib/promptBuilder/client.js

@@ -1,10 +1,10 @@
 import { errInfo } from "../errInfo.js";
 import { logEvent, logWarn } from "../logger.js";
-import { fetchOAuth } from "../oauthProxy/runtime.js";
+import { fetchOAuth, fetchOAuthPath } from "../oauthProxy/runtime.js";
 import { requireRuntimeContext, } from "../runtimeContext.js";
 import { DEFAULT_PROMPT_BUILDER_MODELS, PROMPT_BUILDER_AUTO_ORDER, } from "./constants.js";
 import { promptBuilderError } from "./errors.js";
-import { lanesForModel, normalizeMessages, normalizePromptBuilderBackend, normalizeRequestModel, } from "./requestSchema.js";
+import { lanesForModel, promptBuilderLaneModel, normalizeMessages, normalizePromptBuilderBackend, normalizeRequestModel, } from "./requestSchema.js";
 import { resolvePromptBuilderTransport, selectPromptBuilderBackend, } from "./router.js";
 import { buildTransportPayload } from "./transport.js";
 import { parseUpstreamError, responseSummary, extractChatText, readResponsesResult, } from "./responseParser.js";
@@ -20,7 +20,9 @@ async function prepareRequest(ctx, input, lanes) {
         : PROMPT_BUILDER_AUTO_ORDER;
     const selection = selectPromptBuilderBackend(requestedBackend, lanes, allowedLanes);
     const model = requestedBackend === "auto"
-        ? (requestedModel === "auto" ? DEFAULT_PROMPT_BUILDER_MODELS[selection.backend] : requestedModel)
+        ? (requestedModel === "auto"
+            ? DEFAULT_PROMPT_BUILDER_MODELS[selection.backend]
+            : promptBuilderLaneModel(selection.backend, requestedModel))
         : requestedModel;
     const messages = normalizeMessages(input.messages);
     if (selection.fallbackFrom)
@@ -44,6 +46,9 @@ function sendUpstream(prepared, signal) {
         signal,
         body: JSON.stringify(prepared.payload.body),
     };
+    if (prepared.target.useOAuthFetch && prepared.target.oauth) {
+        return fetchOAuthPath(prepared.target.oauth.ctx, prepared.target.oauth.path, init, { scope: "prompt-builder" });
+    }
     return prepared.target.useOAuthFetch
         ? fetchOAuth(prepared.target.url, init, { scope: "prompt-builder" })
         : fetch(prepared.target.url, init);

package/lib/promptBuilder/constants.js

@@ -1,16 +1,18 @@
 export const PROMPT_BUILDER_BACKENDS = ["auto", "oauth", "grok", "api", "grok-api"];
-const GPT_MODELS = ["gpt-5.6-luna", "gpt-6-astra", "gpt-5.6-terra", "gpt-5.6-sol", "gpt-5.5", "gpt-5.4", "gpt-5.4-mini"];
+// GPT OAuth runs GPT-6 only; the API-key lane keeps the models the OpenAI API serves.
+const OAUTH_GPT_MODELS = ["gpt-6-luna", "gpt-6-sol", "gpt-6-astra"];
+const API_GPT_MODELS = ["gpt-5.6-luna", "gpt-6-astra", "gpt-5.6-terra", "gpt-5.6-sol", "gpt-5.5", "gpt-5.4", "gpt-5.4-mini"];
 const grokModels = ["grok-4.3", "grok-4.6", "grok-4.5"];
 export const PROMPT_BUILDER_MODELS = {
     auto: ["auto"],
-    oauth: GPT_MODELS,
+    oauth: OAUTH_GPT_MODELS,
     grok: grokModels,
-    api: GPT_MODELS,
+    api: API_GPT_MODELS,
     "grok-api": grokModels,
 };
 export const DEFAULT_PROMPT_BUILDER_MODELS = {
     auto: "auto",
-    oauth: "gpt-5.6-luna",
+    oauth: "gpt-6-luna",
     grok: "grok-4.3",
     api: "gpt-5.6-luna",
     "grok-api": "grok-4.3",

package/lib/promptBuilder/requestSchema.js

@@ -1,3 +1,4 @@
+import { migrateOAuthImageModel } from "../imageModels.js";
 import { DEFAULT_PROMPT_BUILDER_MODELS, MAX_MESSAGES, MAX_MESSAGE_CHARS, PROMPT_BUILDER_AUTO_ORDER, PROMPT_BUILDER_BACKENDS, PROMPT_BUILDER_MODELS, } from "./constants.js";
 import { promptBuilderError } from "./errors.js";
 import { normalizeAttachments } from "./attachments.js";
@@ -15,9 +16,11 @@ export function normalizePromptBuilderBackend(raw, fallback = "auto") {
     throw promptBuilderError(`backend must be one of: ${PROMPT_BUILDER_BACKENDS.join(", ")}`, "PROMPT_BUILDER_BAD_BACKEND");
 }
 export function normalizePromptBuilderModel(backend, raw) {
-    const candidate = typeof raw === "string" && raw.trim()
+    const given = typeof raw === "string" && raw.trim()
         ? raw.trim()
         : DEFAULT_PROMPT_BUILDER_MODELS[backend];
+    // Saved GPT OAuth settings from before GPT-6 keep working on the matching GPT-6 tier.
+    const candidate = backend === "oauth" ? migrateOAuthImageModel(given) : given;
     if (!PROMPT_BUILDER_MODELS[backend].includes(candidate)) {
         throw promptBuilderError(`model for ${backend} must be one of: ${PROMPT_BUILDER_MODELS[backend].join(", ")}`, "PROMPT_BUILDER_BAD_MODEL");
     }
@@ -34,7 +37,12 @@ export function normalizeRequestModel(backend, raw) {
     return normalizePromptBuilderModel(backend, candidate || undefined);
 }
 export function lanesForModel(model) {
-    return PROMPT_BUILDER_AUTO_ORDER.filter((lane) => PROMPT_BUILDER_MODELS[lane].includes(model));
+    // A legacy GPT OAuth id still routes to GPT OAuth, on its GPT-6 tier (see promptBuilderLaneModel).
+    return PROMPT_BUILDER_AUTO_ORDER.filter((lane) => PROMPT_BUILDER_MODELS[lane].includes(promptBuilderLaneModel(lane, model)));
+}
+/** The model id a lane actually receives: GPT OAuth takes the GPT-6 tier of a legacy id. */
+export function promptBuilderLaneModel(lane, model) {
+    return lane === "oauth" ? migrateOAuthImageModel(model) : model;
 }
 export function normalizePromptBuilderConfig(raw, current) {
     const body = raw && typeof raw === "object" ? raw : {};

package/lib/promptBuilder/router.js

@@ -58,10 +58,12 @@ export async function resolvePromptBuilderTransport(ctx, backend, endpoint) {
     try {
         if (backend === "oauth") {
             await waitForOAuthReady(ctx);
+            const path = endpoint === "responses" ? "/v1/responses" : "/v1/chat/completions";
             return {
-                url: `${ctx.oauthUrl}${endpoint === "responses" ? "/v1/responses" : "/v1/chat/completions"}`,
+                url: `${ctx.oauthUrl}${path}`,
                 headers: { "Content-Type": "application/json" },
                 useOAuthFetch: true,
+                oauth: { ctx, path },
             };
         }
         if (backend === "api") {

package/lib/providerOptions.js

@@ -1,6 +1,6 @@
 import { normalizeImageToolModel } from "./oauthNormalize.js";
 import { ATLASCLOUD_TEXT_TO_IMAGE_MODEL } from "./atlasCloudImageAdapter.js";
-import { FALLBACK_IMAGE_MODEL, coerceReasoningEffortForModel, normalizeImageModel, normalizeReasoningEffort, normalizeGrokImageModel, normalizeGeminiApiModel, normalizeMinimaxImageModel, normalizeNaiImageModel, normalizeComfyWorkflowModel } from "./imageModels.js";
+import { API_FALLBACK_IMAGE_MODEL, coerceReasoningEffortForModel, normalizeImageModel, normalizeReasoningEffort, normalizeGrokImageModel, normalizeGeminiApiModel, normalizeMinimaxImageModel, normalizeNaiImageModel, normalizeComfyWorkflowModel } from "./imageModels.js";
 export function resolveProviderOptions(ctx, { provider = "oauth", rawModel, rawImageToolModel, rawReasoningEffort, rawSize = "1024x1024", rawWebSearchEnabled = true, searchMode = "on", } = {}) {
     if (provider === "agy") {
         return {
@@ -13,7 +13,7 @@ export function resolveProviderOptions(ctx, { provider = "oauth", rawModel, rawI
     }
     if (provider === "gemini-api") {
         const geminiModelCheck = normalizeGeminiApiModel(rawModel || "nano-banana-2");
-        if (geminiModelCheck.error)
+        if (geminiModelCheck.error !== undefined)
             return { error: geminiModelCheck.error, code: geminiModelCheck.code, status: geminiModelCheck.status };
         return {
             provider: "gemini-api",
@@ -36,7 +36,7 @@ export function resolveProviderOptions(ctx, { provider = "oauth", rawModel, rawI
         const minimaxCfg = ctx?.config?.minimaxProvider || {};
         const modelInput = rawModel || minimaxCfg.defaultImageModel;
         const minimaxModelCheck = normalizeMinimaxImageModel(modelInput);
-        if (minimaxModelCheck.error)
+        if (minimaxModelCheck.error !== undefined)
             return { error: minimaxModelCheck.error, code: minimaxModelCheck.code, status: minimaxModelCheck.status };
         return {
             provider: "minimax",
@@ -47,9 +47,9 @@ export function resolveProviderOptions(ctx, { provider = "oauth", rawModel, rawI
         };
     }
     if (provider === "nai") {
-        const naiCfg = ctx?.config?.naiProvider || {}; // justified: resolveProviderOptions takes a loosely-typed ctx; every sibling provider branch reads its config block through the same cast
+        const naiCfg = ctx?.config?.naiProvider || {};
         const naiModelCheck = normalizeNaiImageModel(rawModel || naiCfg.defaultImageModel);
-        if (naiModelCheck.error)
+        if (naiModelCheck.error !== undefined)
             return { error: naiModelCheck.error, code: naiModelCheck.code, status: naiModelCheck.status };
         return {
             provider: "nai",
@@ -66,7 +66,7 @@ export function resolveProviderOptions(ctx, { provider = "oauth", rawModel, rawI
         // Shape only here; the pipeline confirms the workflow exists because that
         // read is async and this function is not.
         const comfyCheck = normalizeComfyWorkflowModel(rawModel);
-        if (comfyCheck.error)
+        if (comfyCheck.error !== undefined)
             return { error: comfyCheck.error, code: comfyCheck.code, status: comfyCheck.status };
         const workflow = ctx?.comfyWorkflows?.find((entry) => entry.id === comfyCheck.model);
         if (workflow?.mediaKind === "video") {
@@ -91,7 +91,7 @@ export function resolveProviderOptions(ctx, { provider = "oauth", rawModel, rawI
         const grokCfg = ctx?.config?.grokProvider || {};
         const modelInput = rawModel || grokCfg.defaultImageModel;
         const grokModelCheck = normalizeGrokImageModel(modelInput);
-        if (grokModelCheck.error)
+        if (grokModelCheck.error !== undefined)
             return { error: grokModelCheck.error, code: grokModelCheck.code, status: grokModelCheck.status };
         return {
             provider: "grok",
@@ -107,7 +107,7 @@ export function resolveProviderOptions(ctx, { provider = "oauth", rawModel, rawI
         const grokCfg = ctx?.config?.grokProvider || {};
         const modelInput = rawModel || grokCfg.defaultImageModel;
         const grokModelCheck = normalizeGrokImageModel(modelInput);
-        if (grokModelCheck.error)
+        if (grokModelCheck.error !== undefined)
             return { error: grokModelCheck.error, code: grokModelCheck.code, status: grokModelCheck.status };
         return {
             provider: "grok-api",
@@ -119,20 +119,20 @@ export function resolveProviderOptions(ctx, { provider = "oauth", rawModel, rawI
     }
     const activeProvider = provider === "api" ? "api" : "oauth";
     const toolModelCheck = normalizeImageToolModel(activeProvider, rawImageToolModel);
-    if (toolModelCheck.error)
+    if (toolModelCheck.error !== undefined)
         return { error: toolModelCheck.error, code: toolModelCheck.code, status: toolModelCheck.status };
     const apiConfig = ctx?.config?.apiProvider || {};
     const modelInput = activeProvider === "api"
-        ? (rawModel || apiConfig.defaultImageModel || FALLBACK_IMAGE_MODEL)
+        ? (rawModel || apiConfig.defaultImageModel || API_FALLBACK_IMAGE_MODEL)
         : rawModel;
-    const modelCheck = normalizeImageModel(ctx, modelInput);
-    if (modelCheck.error)
+    const modelCheck = normalizeImageModel(ctx, modelInput, activeProvider);
+    if (modelCheck.error !== undefined)
         return { error: modelCheck.error, code: modelCheck.code, status: modelCheck.status };
     const reasoningInput = activeProvider === "api"
         ? (rawReasoningEffort || apiConfig.defaultReasoningEffort || "low")
         : rawReasoningEffort;
     const reasoningCheck = normalizeReasoningEffort(ctx, reasoningInput);
-    if (reasoningCheck.error) {
+    if (reasoningCheck.error !== undefined) {
         return { error: reasoningCheck.error, code: reasoningCheck.code, status: reasoningCheck.status };
     }
     // Applied after validation so an unsupported model/effort pairing cannot reach

package/lib/providers/adapters/geminiOperations.js

@@ -1,3 +1,4 @@
+import { thrownFields } from "../../errInfo.js";
 import { logEvent } from "../../logger.js";
 import { detectImageMimeFromB64 } from "../../refs.js";
 import { getVertexAccessToken, getVertexProjectId, isVertexInitialized } from "../../vertexAuth.js";
@@ -201,14 +202,15 @@ export async function generateViaGeminiApi(prompt, ctx, options = {}) {
         };
     }
     catch (e) {
-        if (e.name === "AbortError") {
+        const eFields = thrownFields(e);
+        if (eFields.name === "AbortError") {
             if (options.signal?.aborted) {
                 throw geminiApiError("Generation canceled", 499, "GENERATION_CANCELED");
             }
             throw geminiApiError("Gemini API generation timed out", 504, "GENERATION_TIMEOUT");
         }
-        if (e.code && e.status)
+        if (eFields.code && eFields.status)
             throw e;
-        throw geminiApiError(`Gemini API request failed: ${e.message}`, 502, "GEMINI_API_NETWORK_FAILED");
+        throw geminiApiError(`Gemini API request failed: ${eFields.message}`, 502, "GEMINI_API_NETWORK_FAILED");
     }
 }

package/lib/providers/adapters/grokMultimodeOperations.js

@@ -1,4 +1,4 @@
-import { errInfo } from "../../errInfo.js";
+import { errInfo, thrownFields } from "../../errInfo.js";
 import { imageEditPayload, imagePayload, postGrokImages, grokError, downloadGrokImageUrl, } from "../../grokImageCore.js";
 import { planGrokImage } from "../../grokImagePlanner.js";
 import { resolveGrokCredential } from "../../grokRuntime.js";
@@ -18,8 +18,8 @@ export function representativeItemError(errors, returnedImages) {
     return errors.length > 0 ? errors[errors.length - 1] : undefined;
 }
 export async function generateMultimodeViaGrok(prompt, ctx, options = {}) {
-    const model = options.model || ctx.config.grokProvider?.defaultImageModel || "grok-imagine-image-quality";
-    const maxGeneratedImages = Math.max(1, Math.trunc(Number(ctx.config.limits?.maxGeneratedImages) || 24));
+    const model = options.model || ctx.config?.grokProvider?.defaultImageModel || "grok-imagine-image-quality";
+    const maxGeneratedImages = Math.max(1, Math.trunc(Number(ctx.config?.limits?.maxGeneratedImages) || 24));
     const maxImages = Math.min(maxGeneratedImages, Math.max(1, Math.trunc(Number(options.maxImages) || 4)));
     const references = options.references || [];
     // One credential for the whole batch: a per-item resolve would refresh the OAuth
@@ -72,7 +72,8 @@ export async function generateMultimodeViaGrok(prompt, ctx, options = {}) {
             }
         }
         catch (e) {
-            if (e.code === "GENERATION_CANCELED")
+            const eFields = thrownFields(e);
+            if (eFields.code === "GENERATION_CANCELED")
                 throw e;
             logEvent("grok", "multimode:item-error", { requestId: options.requestId, index: i, error: errInfo(e) });
             itemErrors.push(e);

package/lib/providers/adapters/grokOperations.js

@@ -16,7 +16,7 @@ async function requireCredential(ctx, options) {
     return await resolveGrokCredential(ctx, "grok", { ...(options.signal ? { signal: options.signal } : {}) });
 }
 export async function generateViaGrok(prompt, ctx, options = {}) {
-    const model = options.model || ctx.config.grokProvider?.defaultImageModel || "grok-imagine-image-quality";
+    const model = options.model || ctx.config?.grokProvider?.defaultImageModel || "grok-imagine-image-quality";
     const references = options.references || [];
     const credential = await requireCredential(ctx, options);
     const plan = options.plannedPrompt
@@ -53,7 +53,7 @@ export async function generateViaGrok(prompt, ctx, options = {}) {
     return { b64: downloaded.b64, providerUrl: imageUrl, usage, webSearchCalls: plan.webSearchCalls, mime: downloaded.mime, revisedPrompt: plan.prompt };
 }
 export async function editViaGrok(prompt, imageB64, ctx, options = {}) {
-    const model = options.model || ctx.config.grokProvider?.defaultImageModel || "grok-imagine-image-quality";
+    const model = options.model || ctx.config?.grokProvider?.defaultImageModel || "grok-imagine-image-quality";
     const detectedInputMime = detectImageMimeFromB64(imageB64) || "image/png";
     const imageUrl = imageB64.startsWith("data:") ? imageB64 : `data:${detectedInputMime};base64,${imageB64}`;
     const payload = { model, prompt, n: 1, response_format: "url", image: { type: "image_url", url: imageUrl }, ...mapSizeToGrokImageParams(options.size) };