ima2-gen 3.13.1 → 3.14.0

package/lib/providers/execution/legacyEdit.js

@@ -0,0 +1,30 @@
+import { detectImageMimeFromB64 } from "../../refs.js";
+import { generateViaAtlasCloud } from "../../atlasCloudImageAdapter.js";
+import { generateViaMinimax } from "../../minimaxImageAdapter.js";
+import { generateViaComfy } from "../../comfyImageAdapter.js";
+function executeImageToImage(ctx, request) {
+    const { provider, prompt, sourceImage, signal, requestId, options } = request;
+    const references = [{ b64: sourceImage, declaredMime: null, detectedMime: detectImageMimeFromB64(sourceImage) || null }];
+    const editPrompt = `Edit this image: ${prompt}`;
+    const params = { model: options.model, size: options.size, signal, ...(requestId !== undefined ? { requestId } : {}), references };
+    switch (provider) {
+        case "atlascloud": return generateViaAtlasCloud(editPrompt, ctx, { ...params, quality: options.quality });
+        case "minimax": return generateViaMinimax(editPrompt, ctx, params);
+        // LoadImage binding owns i2i; missing workflow binding still refuses there.
+        case "comfy": return generateViaComfy(editPrompt, ctx, params);
+        default: throw new Error(`Unsupported legacy edit provider: ${provider}`);
+    }
+}
+async function executeEdit(ctx, request) {
+    return executeImageToImage(ctx, request);
+}
+export async function prepareLegacyEdit(ctx, request, _progress) {
+    return { execute: async () => {
+            try {
+                return { kind: "single", value: await executeEdit(ctx, request) };
+            }
+            catch (error) {
+                throw error;
+            } // Route owns failure normalization and job cleanup.
+        } };
+}

package/lib/providers/execution/legacyMultimode.js

@@ -0,0 +1,34 @@
+import { generateViaAtlasCloud } from "../../atlasCloudImageAdapter.js";
+import { generateViaMinimax } from "../../minimaxImageAdapter.js";
+import { generateViaNai } from "../../naiImageAdapter.js";
+function executeSingleLane(ctx, request) {
+    const { provider, rawPrompt, references, signal, requestId, options } = request;
+    const params = { model: options.model, size: options.size, signal, ...(requestId !== undefined ? { requestId } : {}), references };
+    switch (provider) {
+        case "atlascloud": return generateViaAtlasCloud(rawPrompt, ctx, { ...params, quality: options.quality });
+        case "minimax": return generateViaMinimax(rawPrompt, ctx, params);
+        // Text-to-image only: no references; admission rejects them before startJob.
+        case "nai": return generateViaNai(rawPrompt, ctx, {
+            model: options.model, size: options.size, signal, requestId, ...request.nai,
+        });
+        default: throw new Error(`Unsupported legacy multimode provider: ${provider}`);
+    }
+}
+async function executeSequence(ctx, request, _progress) {
+    const result = await executeSingleLane(ctx, request);
+    // Preserve the old per-lane projection: downstream detects bytes, not MIME here.
+    return {
+        images: [{ b64: result.b64, ...(result.revisedPrompt !== undefined ? { revisedPrompt: result.revisedPrompt } : {}) }],
+        usage: result.usage, webSearchCalls: result.webSearchCalls,
+    };
+}
+export async function prepareLegacyMultimode(ctx, request, progress = {}) {
+    return { execute: async () => {
+            try {
+                return { kind: "sequence", value: await executeSequence(ctx, request, progress) };
+            }
+            catch (error) {
+                throw error;
+            } // Preserve native errors; caller owns timeout recovery.
+        } };
+}

package/lib/providers/execution/legacyNode.js

@@ -0,0 +1,41 @@
+import { generateViaAtlasCloud } from "../../atlasCloudImageAdapter.js";
+import { generateViaMinimax } from "../../minimaxImageAdapter.js";
+import { generateViaNai } from "../../naiImageAdapter.js";
+import { requireRuntimeContext } from "../../runtimeContext.js";
+export async function prepareLegacyNode(ctx, request, _progress) {
+    return { execute: async () => {
+            try {
+                return { kind: "single", value: await executeNodeAttempt(ctx, request) };
+            }
+            catch (error) {
+                throw error;
+            } // The caller owns retries and normalization.
+        } };
+}
+// Keep the legacy one-attempt branches together; retry/lifecycle stays at the caller.
+async function executeNodeAttempt(ctx, request) {
+    const { provider, sourceImage: parentB64, rawPrompt: prompt, references, requestId, signal, options } = request;
+    const { model, size, quality } = options;
+    return provider === "atlascloud"
+        ? await generateViaAtlasCloud(parentB64 ? `Edit this image: ${prompt}` : prompt, requireRuntimeContext(ctx), {
+            model, size, quality, signal, requestId,
+            references: parentB64
+                ? [{ b64: parentB64, declaredMime: null, detectedMime: null }, ...references]
+                : references,
+        })
+        : provider === "minimax"
+            ? await generateViaMinimax(parentB64 ? `Edit this image: ${prompt}` : prompt, requireRuntimeContext(ctx), {
+                model, size, signal, requestId,
+                references: parentB64
+                    ? [{ b64: parentB64, declaredMime: null, detectedMime: null }, ...references]
+                    : references,
+            })
+            : provider === "nai"
+                ? await generateViaNai(prompt, requireRuntimeContext(ctx), {
+                    model, size, signal, requestId, ...request.nai,
+                })
+                : unsupportedNodeProvider(provider);
+}
+function unsupportedNodeProvider(provider) {
+    throw new Error(`Unsupported node execution provider: ${provider}`);
+}

package/lib/providers/execution/types.js

@@ -0,0 +1 @@
+export {};

package/lib/providers/registry.js

@@ -1,15 +1,17 @@
-const EDIT = { edit: true, mask: false, streaming: false };
+const EDIT = { generate: true, edit: true, mask: false, streaming: false };
 // OAuth/API image models edit, mask, and stream. Masks are real on the active
 // path: routes/edit.ts excludes only grok/agy/grok-api/gemini-api/atlascloud/
 // minimax from masking and then calls editViaResponses, whose options accept
 // `mask` (lib/responsesImageAdapter.ts). The legacy editViaOAuth path in
 // lib/oauthProxy/multimodeGenerators.ts rejects masks unconditionally, but no
 // route reaches it, so it does not describe current behavior.
-const RESPONSES = { edit: true, mask: true, streaming: true };
-const UNSUPPORTED = { edit: false, mask: false, streaming: false };
+const RESPONSES = { generate: true, edit: true, mask: true, streaming: true };
+const UNSUPPORTED = { generate: false, edit: false, mask: false, streaming: false };
+const GENERATE_ONLY = { generate: true, edit: false, mask: false, streaming: false };
 export const REGISTRY = [
     {
         id: "oauth",
+        surfaces: ["generate", "edit", "multimode", "node"],
         vendor: "openai",
         credentials: [{
                 kind: "oauth-proxy",
@@ -33,6 +35,7 @@ export const REGISTRY = [
     },
     {
         id: "api",
+        surfaces: ["generate", "edit", "multimode", "node"],
         vendor: "openai",
         credentials: [{
                 kind: "api-key",
@@ -57,6 +60,7 @@ export const REGISTRY = [
     },
     {
         id: "grok",
+        surfaces: ["generate", "edit", "multimode", "node", "video"],
         vendor: "xai",
         credentials: [{ kind: "oauth-proxy", envVars: ["IMA2_GROK_PROXY_HOST", "IMA2_GROK_PROXY_PORT"], configKey: "grokProvider" }],
         models: [
@@ -73,6 +77,7 @@ export const REGISTRY = [
     },
     {
         id: "grok-api",
+        surfaces: ["generate", "edit", "multimode", "node", "video"],
         vendor: "xai",
         credentials: [{
                 kind: "api-key",
@@ -96,6 +101,7 @@ export const REGISTRY = [
     },
     {
         id: "agy",
+        surfaces: ["generate", "edit", "multimode", "node"],
         vendor: "google",
         credentials: [{ kind: "local-cli", envVars: ["IMA2_AGY_BIN"], optionalApiKeyEnv: "GEMINI_API_KEY" }],
         models: [
@@ -109,6 +115,7 @@ export const REGISTRY = [
     },
     {
         id: "gemini-api",
+        surfaces: ["generate", "edit", "multimode", "node"],
         vendor: "google",
         credentials: [
             {
@@ -132,6 +139,7 @@ export const REGISTRY = [
     },
     {
         id: "atlascloud",
+        surfaces: ["generate", "edit", "multimode", "node"],
         vendor: "atlascloud",
         credentials: [{
                 kind: "api-key",
@@ -152,6 +160,7 @@ export const REGISTRY = [
     },
     {
         id: "minimax",
+        surfaces: ["generate", "edit", "multimode", "node"],
         vendor: "minimax",
         credentials: [{
                 kind: "api-key",
@@ -173,6 +182,7 @@ export const REGISTRY = [
     },
     {
         id: "nai",
+        surfaces: ["generate", "multimode", "node"],
         vendor: "novelai",
         credentials: [{
                 kind: "api-key",
@@ -190,17 +200,11 @@ export const REGISTRY = [
                 configKey: "naiApiKey",
             }],
         models: [
-            // EDIT rather than UNSUPPORTED, deliberately. `supports` has no "generate"
-            // bit, so an all-false triple means "listed but cannot produce images at
-            // all" (that is what gpt-5.3-codex-spark is) and would push these models
-            // into UNSUPPORTED_IMAGE_MODEL_IDS — wrong, since V5 generates fine.
-            // Reference input is refused at the ROUTES (NAI_REF_UNSUPPORTED /
-            // NAI_EDIT_UNSUPPORTED) and `referenceLimits` below declares no capacity,
-            // so nothing here advertises an img2img path the adapter lacks.
-            { id: "nai-diffusion-5-full", aliases: ["nai-v5-full"], kind: "image", supports: EDIT },
-            { id: "nai-diffusion-5-curated", aliases: ["nai-v5-curated"], kind: "image", supports: EDIT },
-            { id: "nai-diffusion-4-5-full", aliases: ["nai-v45-full"], kind: "image", supports: EDIT },
-            { id: "nai-diffusion-4-5-curated", aliases: ["nai-v45-curated"], kind: "image", supports: EDIT },
+            // Generation support does not imply reference editing or masks.
+            { id: "nai-diffusion-5-full", aliases: ["nai-v5-full"], kind: "image", supports: GENERATE_ONLY },
+            { id: "nai-diffusion-5-curated", aliases: ["nai-v5-curated"], kind: "image", supports: GENERATE_ONLY },
+            { id: "nai-diffusion-4-5-full", aliases: ["nai-v45-full"], kind: "image", supports: GENERATE_ONLY },
+            { id: "nai-diffusion-4-5-curated", aliases: ["nai-v45-curated"], kind: "image", supports: GENERATE_ONLY },
         ],
         // Empty because the lane accepts no reference input at all; the routes
         // refuse it with NAI_REF_UNSUPPORTED rather than dropping it silently.
@@ -214,6 +218,7 @@ export const REGISTRY = [
     },
     {
         id: "comfy",
+        surfaces: ["generate", "edit", "video"],
         vendor: "comfy",
         credentials: [{
                 kind: "local-http",

package/lib/providers/surfaceSupport.js

@@ -0,0 +1,22 @@
+export const PROVIDER_SURFACES = [
+    "generate", "edit", "multimode", "node", "video",
+];
+/** Project supported operations; a runtime catalog is not an empty static one. */
+export function deriveProviderSurfaceSupportFrom(registry, providerId, surface) {
+    const provider = registry.find((entry) => entry.id === providerId);
+    if (!provider)
+        return null;
+    const catalogAccess = provider.catalogAccess ?? "static";
+    const runtime = catalogAccess === "runtime";
+    const models = provider.models.filter((model) => model.kind === (surface === "video" ? "video" : "image"));
+    const runnable = runtime || models.some((model) => surface === "edit" ? model.supports.edit : model.supports.generate);
+    const supported = provider.surfaces.includes(surface) && runnable;
+    return {
+        supported,
+        references: supported && (runtime || models.some((model) => model.supports.edit)),
+        mask: supported && surface === "edit" && models.some((model) => model.supports.mask),
+        streaming: supported && (surface === "multimode" || surface === "node")
+            && models.some((model) => model.supports.streaming),
+        catalogAccess,
+    };
+}

package/lib/responsesImageAdapter.js

@@ -1,389 +1 @@
-import { logEvent } from "./logger.js";
-import { classifyUpstreamError, classifyUpstreamErrorCode } from "./errorClassify.js";
-import { compressReferenceB64ForOAuth } from "./referenceImageCompress.js";
-import { detectImageMimeFromB64 } from "./refs.js";
-import { errInfo } from "./errInfo.js";
-import { setJobPhase } from "./inflight.js";
-import { requireRuntimeContext } from "./runtimeContext.js";
-import { parseJson, parseStream, safeDiagnosticLabel, } from "./responsesParse.js";
-import { imageToolChoice, imageToolChoiceKind, tools, toolTypes, } from "./responsesTools.js";
-import { emptyResponseError } from "./responsesErrors.js";
-import { retryPromptOnlyJsonImage } from "./responsesFallback.js";
-import { AUTO_PROMPT_FIDELITY_SUFFIX, DIRECT_PROMPT_FIDELITY_SUFFIX, EDIT_DEVELOPER_PROMPT, EDIT_NO_SEARCH_DEVELOPER_PROMPT, GENERATE_DEVELOPER_PROMPT, GENERATE_NO_SEARCH_DEVELOPER_PROMPT, MULTIMODE_DEVELOPER_PROMPT, MULTIMODE_NO_SEARCH_DEVELOPER_PROMPT, buildEditTextPrompt, buildMultimodeSequencePrompt, buildUserTextPrompt, waitForOAuthReady, } from "./oauthProxy.js";
-const RESPONSES_ERROR_MARKER = "ima2ResponsesError";
-function makeError(message, { status = 500, code = "RESPONSES_IMAGE_ERROR", cause, ...rest } = {}) {
-    const err = new Error(message);
-    err.status = status;
-    err.code = code;
-    if (cause)
-        err.cause = cause;
-    Object.assign(err, rest);
-    Object.defineProperty(err, RESPONSES_ERROR_MARKER, { value: true });
-    return err;
-}
-function parseOpenAIErrorBody(text) {
-    try {
-        const parsed = JSON.parse(text);
-        const error = parsed?.error || {};
-        return {
-            message: typeof error.message === "string" && error.message ? error.message : "OpenAI request failed",
-            code: safeDiagnosticLabel(error.code),
-            type: safeDiagnosticLabel(error.type),
-            param: safeDiagnosticLabel(error.param),
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function normalizedCode(upstream) {
-    const byCode = classifyUpstreamErrorCode(upstream?.code);
-    if (byCode !== "UNKNOWN")
-        return byCode;
-    const byType = classifyUpstreamErrorCode(upstream?.type);
-    if (byType !== "UNKNOWN")
-        return byType;
-    const byMessage = classifyUpstreamError(upstream?.message);
-    return byMessage !== "UNKNOWN" ? byMessage : "RESPONSES_IMAGE_ERROR";
-}
-function safeUpstreamClientMessage(upstream, status) {
-    const code = normalizedCode(upstream);
-    if (code === "AUTH_API_KEY_INVALID")
-        return "API key is invalid or unavailable.";
-    if (code === "MODERATION_REFUSED")
-        return "OpenAI refused the image request for safety reasons.";
-    if (code === "INVALID_REQUEST") {
-        return upstream?.param
-            ? "OpenAI rejected the image request parameters."
-            : "OpenAI rejected the image request.";
-    }
-    if (status === 401 || status === 403)
-        return "OpenAI authentication failed.";
-    if (status === 429)
-        return "OpenAI rate limited the image request.";
-    return "OpenAI rejected the image request.";
-}
-function safeBaseUrl(value) {
-    try {
-        const parsed = new URL(value);
-        parsed.username = "";
-        parsed.password = "";
-        return parsed.toString().replace(/\/$/, "");
-    }
-    catch {
-        return value.replace(/\/$/, "");
-    }
-}
-function apiAuthorizationHeader(apiKey) {
-    const key = typeof apiKey === "string" ? apiKey.trim() : "";
-    if (!key) {
-        throw makeError("API key is required for API provider image generation", {
-            status: 401,
-            code: "API_KEY_REQUIRED",
-        });
-    }
-    if (/[\u0000-\u001f\u007f]/.test(key)) {
-        throw makeError("API key contains invalid characters.", {
-            status: 401,
-            code: "AUTH_API_KEY_INVALID",
-        });
-    }
-    return `Bearer ${key}`;
-}
-function isKnownResponsesError(value) {
-    return Boolean(value &&
-        typeof value === "object" &&
-        value.ima2ResponsesError === true);
-}
-async function getEndpoint(ctx, provider, _scope) {
-    if (provider === "api") {
-        return {
-            url: "https://api.openai.com/v1/responses",
-            headers: {
-                "Content-Type": "application/json",
-                Accept: "text/event-stream",
-                Authorization: apiAuthorizationHeader(ctx.apiKey),
-            },
-        };
-    }
-    await waitForOAuthReady(ctx);
-    const port = ctx?.config?.oauth?.proxyPort || 10531;
-    return {
-        url: `${safeBaseUrl(ctx?.oauthUrl || `http://127.0.0.1:${port}`)}/v1/responses`,
-        headers: { "Content-Type": "application/json", Accept: "text/event-stream" },
-    };
-}
-function normalizeRef(ref) {
-    const b64 = typeof ref === "string" ? ref : ref?.b64;
-    const detectedMime = typeof ref === "object" && ref?.detectedMime
-        ? ref.detectedMime
-        : detectImageMimeFromB64(b64);
-    const declaredMime = typeof ref === "object" ? ref?.declaredMime : null;
-    const mime = ["image/png", "image/jpeg", "image/webp"].includes(detectedMime)
-        ? detectedMime
-        : ["image/png", "image/jpeg", "image/webp"].includes(declaredMime)
-            ? declaredMime
-            : "image/png";
-    return { type: "input_image", image_url: `data:${mime};base64,${b64}` };
-}
-function combineAbortSignals(signals) {
-    const only = signals[0];
-    if (signals.length === 1 && only)
-        return only;
-    const controller = new AbortController();
-    for (const signal of signals) {
-        if (signal.aborted) {
-            controller.abort();
-            break;
-        }
-        signal.addEventListener("abort", () => controller.abort(), { once: true });
-    }
-    return controller.signal;
-}
-async function postResponses({ ctx, provider, scope, payload, requestId, maxImages = 1, signal = null, onPartialImage = null, onFinalImage = null, }) {
-    const { url, headers } = await getEndpoint(ctx, provider, scope);
-    const timeoutMs = ctx?.config?.oauth?.generationTimeoutMs || 400 * 1000;
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    const fetchSignal = signal
-        ? combineAbortSignals([controller.signal, signal])
-        : controller.signal;
-    try {
-        const res = await fetch(url, {
-            method: "POST",
-            headers: headers,
-            signal: fetchSignal,
-            body: JSON.stringify(payload),
-        });
-        logEvent(scope, "response", { requestId, provider, status: res.status, contentType: res.headers.get("content-type") });
-        if (!res.ok) {
-            const text = await res.text();
-            const upstream = parseOpenAIErrorBody(text);
-            if (res.status >= 400 && res.status < 500 && upstream?.message) {
-                throw makeError(safeUpstreamClientMessage(upstream, res.status), {
-                    status: res.status,
-                    code: normalizedCode(upstream),
-                    upstreamBodyChars: text.length,
-                    upstreamCode: upstream.code,
-                    upstreamType: upstream.type,
-                    upstreamParam: upstream.param,
-                    upstreamMessageRedacted: true,
-                });
-            }
-            throw makeError(`${provider === "api" ? "OpenAI API" : "OAuth proxy"} returned ${res.status}`, {
-                status: res.status,
-                upstreamBodyChars: text.length,
-            });
-        }
-        if (requestId)
-            setJobPhase(requestId, "streaming");
-        const contentType = res.headers.get("content-type") || "";
-        return contentType.includes("text/event-stream")
-            ? await parseStream(res, { requestId, scope, maxImages, onPartialImage, onFinalImage })
-            : await parseJson(res, maxImages);
-    }
-    catch (e) {
-        const err = errInfo(e);
-        if (err.name === "AbortError") {
-            if (signal?.aborted) {
-                throw makeError("Generation canceled", {
-                    status: 499,
-                    code: "GENERATION_CANCELED",
-                    cause: err.raw,
-                });
-            }
-            throw makeError("Responses image generation timed out", { status: 504, code: "RESPONSES_IMAGE_TIMEOUT", cause: err.raw });
-        }
-        if (isKnownResponsesError(err.raw))
-            throw err.raw;
-        throw makeError("Responses request failed before receiving a response", {
-            status: 502,
-            code: "NETWORK_FAILED",
-            errorName: err.name,
-            upstreamMessageRedacted: true,
-        });
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-export async function generateViaResponses(provider, prompt, quality, size, moderation = "low", references = [], requestId = null, mode = "auto", ctxRaw = {}, options = {}) {
-    const ctx = requireRuntimeContext(ctxRaw);
-    const model = options.model || ctx.config?.imageModels?.default || "gpt-5.6-luna";
-    const webSearchEnabled = options.webSearchEnabled !== false && options.searchMode !== "off";
-    const requestTools = tools(webSearchEnabled, {
-        quality,
-        size,
-        moderation,
-        ...(options.partialImages ? { partial_images: options.partialImages } : {}),
-        ...(options.background ? { background: options.background } : {}),
-        ...(options.outputFormat ? { output_format: options.outputFormat } : {}),
-    });
-    const toolChoice = imageToolChoice(options.forceImageToolChoice ?? ctx.config?.oauth?.forceImageToolChoice !== false);
-    const toolChoiceKind = imageToolChoiceKind(toolChoice);
-    const referenceInputs = references.map(normalizeRef);
-    const userContent = referenceInputs.length
-        ? [...referenceInputs, { type: "input_text", text: buildUserTextPrompt(prompt, mode, { webSearchEnabled, size }) }]
-        : buildUserTextPrompt(prompt, mode, { webSearchEnabled, size });
-    const result = await postResponses({
-        ctx,
-        provider,
-        scope: provider === "api" ? "api-generate" : "oauth",
-        requestId,
-        maxImages: 1,
-        ...(options.signal !== undefined ? { signal: options.signal } : {}),
-        ...(options.onPartialImage !== undefined ? { onPartialImage: options.onPartialImage } : {}),
-        ...(options.onFinalImage !== undefined ? { onFinalImage: options.onFinalImage } : {}),
-        payload: {
-            model,
-            input: [
-                { role: "developer", content: webSearchEnabled ? GENERATE_DEVELOPER_PROMPT : GENERATE_NO_SEARCH_DEVELOPER_PROMPT },
-                { role: "user", content: userContent },
-            ],
-            tools: requestTools,
-            tool_choice: toolChoice,
-            reasoning: { effort: options.reasoningEffort || "low" },
-            stream: true,
-        },
-    });
-    const image = result.images[0];
-    if (!image?.b64) {
-        if (options.allowPromptOnlyOAuthFallback === true) {
-            const fallback = await retryPromptOnlyJsonImage({
-                postResponses,
-                ctx,
-                provider,
-                prompt,
-                mode,
-                model,
-                quality,
-                size,
-                moderation,
-                requestId,
-                ...(options.signal !== undefined ? { signal: options.signal } : {}),
-                initial: result,
-                referenceInputs,
-                webSearchDroppedOnRetry: webSearchEnabled,
-                ...(options.reasoningEffort !== undefined ? { reasoningEffort: options.reasoningEffort } : {}),
-                ...(options.background !== undefined ? { background: options.background } : {}),
-                ...(options.outputFormat !== undefined ? { outputFormat: options.outputFormat } : {}),
-            });
-            if (fallback)
-                return fallback;
-        }
-        throw emptyResponseError("No image data received from Responses API", result, {
-            provider,
-            model,
-            quality,
-            size,
-            moderation,
-            webSearchEnabled,
-            refsCount: referenceInputs.length,
-            inputImageCount: referenceInputs.length,
-            promptChars: typeof prompt === "string" ? prompt.length : 0,
-            toolTypes: toolTypes(requestTools),
-            toolChoiceKind,
-        });
-    }
-    return { b64: image.b64, usage: result.usage, webSearchCalls: result.webSearchCalls, revisedPrompt: image.revisedPrompt, text: result.text };
-}
-export async function generateMultimodeViaResponses(provider, prompt, quality, size, moderation = "low", references = [], requestId = null, mode = "auto", ctxRaw = {}, options = {}) {
-    const ctx = requireRuntimeContext(ctxRaw);
-    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) || 1)));
-    const model = options.model || ctx.config?.imageModels?.default || "gpt-5.6-luna";
-    const webSearchEnabled = options.webSearchEnabled !== false && options.searchMode !== "off";
-    const requestTools = tools(webSearchEnabled, { quality, size, moderation, ...(options.partialImages ? { partial_images: options.partialImages } : {}) });
-    const userText = buildMultimodeSequencePrompt(mode === "direct"
-        ? `${prompt}${DIRECT_PROMPT_FIDELITY_SUFFIX}`
-        : `${prompt}${webSearchEnabled ? "" : ""}${AUTO_PROMPT_FIDELITY_SUFFIX}`, maxImages, { webSearchEnabled, size });
-    const referenceInputs = references.map(normalizeRef);
-    const userContent = referenceInputs.length
-        ? [...referenceInputs, { type: "input_text", text: userText }]
-        : userText;
-    return await postResponses({
-        ctx,
-        provider,
-        scope: provider === "api" ? "api-multimode" : "oauth-multimode",
-        requestId,
-        maxImages,
-        ...(options.signal !== undefined ? { signal: options.signal } : {}),
-        ...(options.onPartialImage !== undefined ? { onPartialImage: options.onPartialImage } : {}),
-        ...(options.onFinalImage !== undefined ? { onFinalImage: options.onFinalImage } : {}),
-        payload: {
-            model,
-            input: [
-                { role: "developer", content: webSearchEnabled ? MULTIMODE_DEVELOPER_PROMPT : MULTIMODE_NO_SEARCH_DEVELOPER_PROMPT },
-                { role: "user", content: userContent },
-            ],
-            tools: requestTools,
-            tool_choice: "required",
-            reasoning: { effort: options.reasoningEffort || "low" },
-            stream: true,
-        },
-    });
-}
-export async function editViaResponses(provider, prompt, imageB64, quality, size, moderation = "low", mode = "auto", ctxRaw = {}, requestId = null, options = {}) {
-    const ctx = requireRuntimeContext(ctxRaw);
-    const model = options.model || ctx.config?.imageModels?.default || "gpt-5.6-luna";
-    const webSearchEnabled = options.webSearchEnabled !== false && options.searchMode !== "off";
-    const requestTools = tools(webSearchEnabled, { quality, size, moderation });
-    const toolChoice = imageToolChoice(options.forceImageToolChoice ?? ctx.config?.oauth?.forceImageToolChoice !== false);
-    const toolChoiceKind = imageToolChoiceKind(toolChoice);
-    const imageForRequest = await compressReferenceB64ForOAuth(imageB64, {
-        maxB64Bytes: ctx.config?.limits?.maxRefB64Bytes,
-        force: true,
-    });
-    const referenceImages = await Promise.all((Array.isArray(options.references) ? options.references : []).map((ref) => compressReferenceB64ForOAuth(typeof ref === "string" ? ref : ref?.b64, {
-        maxB64Bytes: ctx.config?.limits?.maxRefB64Bytes,
-        force: true,
-    })));
-    const maskContent = typeof options.mask === "string" && options.mask.length > 0
-        ? [
-            { type: "input_image", image_url: `data:image/png;base64,${options.mask}` },
-            { type: "input_text", text: "The previous image is an edit mask guide. Use it as prompt guidance for where the edit should apply; it is not a visible final image element." },
-        ]
-        : [];
-    const userContent = [
-        { type: "input_image", image_url: `data:image/jpeg;base64,${imageForRequest.b64}` },
-        ...referenceImages.map(({ b64 }) => ({ type: "input_image", image_url: `data:image/jpeg;base64,${b64}` })),
-        ...maskContent,
-        { type: "input_text", text: buildEditTextPrompt(prompt, mode, { webSearchEnabled, size }) },
-    ];
-    const result = await postResponses({
-        ctx,
-        provider,
-        scope: provider === "api" ? "api-edit" : "oauth-edit",
-        requestId,
-        maxImages: 1,
-        signal: options.signal,
-        payload: {
-            model,
-            input: [
-                { role: "developer", content: webSearchEnabled ? EDIT_DEVELOPER_PROMPT : EDIT_NO_SEARCH_DEVELOPER_PROMPT },
-                { role: "user", content: userContent },
-            ],
-            tools: requestTools,
-            tool_choice: toolChoice,
-            reasoning: { effort: options.reasoningEffort || "low" },
-            stream: true,
-        },
-    });
-    const image = result.images[0];
-    if (!image?.b64) {
-        throw emptyResponseError("No image data received from Responses edit", result, {
-            provider,
-            model,
-            quality,
-            size,
-            moderation,
-            webSearchEnabled,
-            refsCount: referenceImages.length,
-            inputImageCount: 1 + referenceImages.length + (maskContent.length ? 1 : 0),
-            promptChars: typeof prompt === "string" ? prompt.length : 0,
-            toolTypes: toolTypes(requestTools),
-            toolChoiceKind,
-        });
-    }
-    return { b64: image.b64, usage: result.usage, revisedPrompt: image.revisedPrompt, webSearchCalls: result.webSearchCalls };
-}
+export { generateViaResponses, generateMultimodeViaResponses, editViaResponses, } from "./providers/adapters/openaiOperations.js";