vidspotai-shared 1.0.124 → 1.0.126

package/lib/services/aiGen/providers/google/google.service.js

@@ -11,6 +11,7 @@ const aiModels_1 = require("../../../../globals/aiModels");
 const types_1 = require("../../../../globals/types");
 const firebase_1 = require("../../../../libs/firebase");
 const storage_1 = require("../../../../libs/storage");
+const mp4Duration_1 = require("../../../../utils/mp4Duration");
 const helpers_1 = require("../../../../utils/helpers");
 const logger_1 = require("../../../../utils/logger");
 const errors_1 = require("../../../../utils/errors");
@@ -81,6 +82,31 @@ async function mp4IsComplete(path) {
     return (buf.includes(Buffer.from("ftyp", "ascii")) &&
         buf.includes(Buffer.from("moov", "ascii")));
 }
+// ── Gemini Omni (Interactions API) ─────────────────────────────────────────
+// Omni is not a Veo `generateVideos` model: it is served by the Interactions
+// API, which the pinned @google/genai (1.23) predates, so it is called over
+// REST. Docs: ai.google.dev/gemini-api/docs/omni + /api/interactions-api.
+const INTERACTIONS_BASE = "https://generativelanguage.googleapis.com/v1beta/interactions";
+/** Task prefix that routes checkVideoStatus to the Omni poller (Veo operation
+ * names are `models/…/operations/…`, so the two can't collide). */
+const OMNI_TASK_PREFIX = "interactions/";
+function isOmniModelId(modelId) {
+    return modelId.startsWith("gemini-omni");
+}
+/** Throw a Google REST error body verbatim as the Error message — the same
+ * JSON shape the SDK's ApiError carries, so classifyGoogleApiError /
+ * classifyGoogleKeyHealth work unchanged. */
+async function omniFetch(url, apiKey, init) {
+    const res = await fetch(url, {
+        ...init,
+        headers: { "Content-Type": "application/json", "x-goog-api-key": apiKey },
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        throw new Error(text || JSON.stringify({ error: { code: res.status, message: res.statusText } }));
+    }
+    return JSON.parse(text);
+}
 const VEO_3_1_MODELS = new Set([
     aiModels_1.EVideoGenModels.GOOGLE_VEO_3_1,
     aiModels_1.EVideoGenModels.GOOGLE_VEO_3_1_FAST,
@@ -209,6 +235,8 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
         (0, helpers_2.validateParams)(params);
         const modelConfig = aiModels_1.aiModelConfigs[params.modelKey];
         const modelId = modelConfig.modelId;
+        if (isOmniModelId(modelId))
+            return this.generateOmniVideo(params, modelId);
         const isVeo3_1 = VEO_3_1_MODELS.has(params.modelKey);
         // ── Veo generation mode ──────────────────────────────────────────────
         // Several Veo constraints are MODE-dependent (not just model-dependent),
@@ -475,11 +503,157 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
         // covers the no-key-left case) — surface the last error.
         throw lastErr ?? new Error("Failed to initiate video generation task");
     }
+    /**
+     * Gemini Omni submit (Interactions API, `background: true`). Input mapping per
+     * the Omni guide: one image = image-to-video, two images = first/last-frame
+     * interpolation, several images = subject references. Omni has no
+     * negativePrompt / seed / duration-seconds params, so a negative prompt and
+     * the requested length are folded into the prompt text (the guide's own
+     * advice for negatives: "Do not do X").
+     */
+    async generateOmniVideo(params, modelId) {
+        if (params.lastFrameImageUrl && !params.inputImageUrl) {
+            throw new errors_1.UserFacingError("Gemini Omni needs a starting image as well as a last-frame image to interpolate between them. " +
+                "Please add a first-frame image or remove the last-frame image.", errors_1.USER_FACING_ERROR_CODES.CAPABILITY_MISMATCH);
+        }
+        // Frames and subject references are both plain image parts to Omni; mixing
+        // them is undocumented and would make two frames + refs ambiguous, so
+        // explicit frames win and references are dropped (logged).
+        const frameUrls = params.inputImageUrl
+            ? [params.inputImageUrl, ...(params.lastFrameImageUrl ? [params.lastFrameImageUrl] : [])]
+            : [];
+        const refUrls = (params.referenceImageUrls ?? []).slice(0, 3);
+        if (frameUrls.length && refUrls.length) {
+            logger_1.logger.warn("Gemini Omni: frame image(s) and reference images both supplied — using frames only", {
+                modelKey: params.modelKey,
+                referenceImageCount: refUrls.length,
+            });
+        }
+        const imageUrls = frameUrls.length ? frameUrls : refUrls;
+        const images = await Promise.all(imageUrls.map((url) => this.withTransientRetry("omni image fetch", () => (0, googleFetch_1.fetchAsImage)(url))));
+        const textParts = [params.prompt];
+        if (params.duration)
+            textParts.push(`The video is about ${params.duration} seconds long.`);
+        if (params.negativePrompt)
+            textParts.push(`Do not include: ${params.negativePrompt}.`);
+        const text = textParts.join("\n\n");
+        // `task` is only set where the image count alone is ambiguous (the guide
+        // recommends letting the model infer otherwise — the field adds constraints).
+        const task = !frameUrls.length && refUrls.length ? "reference_to_video" : undefined;
+        const body = JSON.stringify({
+            model: modelId,
+            input: images.length
+                ? [
+                    ...images.map((img) => ({ type: "image", data: img.imageBytes, mime_type: img.mimeType })),
+                    { type: "text", text },
+                ]
+                : text,
+            response_format: {
+                type: "video",
+                ...(params.aspectRatio ? { aspect_ratio: params.aspectRatio } : {}),
+                ...(params.resolution ? { resolution: params.resolution } : {}),
+                // URI delivery: the guide's advice for anything over ~4 MB (>720p), and
+                // it keeps multi-MB base64 out of every status poll.
+                delivery: "uri",
+            },
+            ...(task ? { generation_config: { video_config: { task } } } : {}),
+            // Async: returns an interaction id immediately; checkVideoStatus polls it.
+            // (Requires store=true, the default.)
+            background: true,
+        });
+        const modelConfig = aiModels_1.aiModelConfigs[params.modelKey];
+        const keyEntry = await this.keyPool.pickForSubmit(modelId, modelConfig.requestPerMin ?? 0, modelConfig.requestPerDay ?? 0);
+        try {
+            const interaction = await this.withTransientRetry("interactions.create", () => omniFetch(INTERACTIONS_BASE, keyEntry.apiKey, { method: "POST", body }));
+            if (!interaction?.id)
+                throw new Error("Failed to initiate Gemini Omni interaction");
+            return {
+                task: (0, googleApiKeys_1.encodeVeoTask)(keyEntry.id, `${OMNI_TASK_PREFIX}${interaction.id}`, this.keyPool.size),
+                status: types_1.EVideoSceneStatus.TRIGGERED,
+            };
+        }
+        catch (err) {
+            const keyFailure = (0, googleErrors_1.classifyGoogleKeyHealth)(err);
+            if (keyFailure && keyFailure.kind !== "quota") {
+                await this.keyPool.markDepleted(keyEntry.id, keyFailure.ttlSeconds, keyFailure.reason);
+            }
+            logger_1.logger.warn("Gemini Omni: request rejected — submitted shape", {
+                modelKey: params.modelKey,
+                modelId,
+                keyId: keyEntry.id,
+                aspectRatio: params.aspectRatio,
+                resolution: params.resolution,
+                duration: params.duration,
+                frameCount: frameUrls.length,
+                referenceImageCount: frameUrls.length ? 0 : refUrls.length,
+                task: task ?? null,
+                promptChars: text.length,
+                error: err instanceof Error ? err.message.slice(0, 500) : String(err),
+            });
+            throw err;
+        }
+    }
+    async checkOmniStatus(keyId, client, interactionId, outputFilename, outputFilePath) {
+        const apiKey = this.keyPool.apiKeyById(keyId);
+        const interaction = await this.withTransientRetry("interactions.get", () => omniFetch(`${INTERACTIONS_BASE}/${encodeURIComponent(interactionId)}`, apiKey));
+        if (interaction.status === "in_progress")
+            return { status: types_1.EVideoSceneStatus.PENDING };
+        if (interaction.status !== "completed") {
+            const apiErr = interaction.errors?.[0] ?? interaction.error;
+            const classified = apiErr ? (0, googleErrors_1.classifyGoogleApiError)({ message: JSON.stringify({ error: apiErr }) }) : null;
+            return {
+                status: types_1.EVideoSceneStatus.FAILED,
+                errorMessage: classified
+                    ? JSON.stringify(classified.toJSON())
+                    : `Gemini Omni interaction ${interaction.status}` +
+                        (apiErr?.message ? `: ${apiErr.message}` : ""),
+            };
+        }
+        const outputs = (interaction.steps ?? []).filter((s) => s.type === "model_output");
+        const contents = outputs.flatMap((s) => s.content ?? []);
+        const videoPart = contents.find((c) => c.type === "video" && (c.data || c.uri));
+        logger_1.logger.info("Gemini Omni: interaction completed", {
+            interactionId,
+            outputTokens: interaction.usage?.total_output_tokens ?? null,
+            delivery: videoPart?.data ? "inline" : videoPart?.uri ? "uri" : "none",
+        });
+        if (!videoPart) {
+            // Omni answers a blocked/refused prompt with text instead of a video.
+            // Surface it as a user-input error (sceneMonitor demotes the log level).
+            const reply = contents.filter((c) => c.type === "text" && c.text).map((c) => c.text).join(" ").trim();
+            return {
+                status: types_1.EVideoSceneStatus.FAILED,
+                errorMessage: `user_input_error: ${reply.slice(0, 500) || "Gemini Omni returned no video"}`,
+            };
+        }
+        // GET returns the video inline even for `delivery: "uri"` (Omni guide), so
+        // this branch is a fallback. It bills the requested duration, since the
+        // shared Veo persist path doesn't measure the file.
+        if (videoPart.uri) {
+            return this.persistFilesApiVideo(client, { uri: videoPart.uri, mimeType: videoPart.mime_type ?? "video/mp4" }, outputFilename, outputFilePath);
+        }
+        // Inline delivery (the API may still inline small outputs).
+        const bytes = Buffer.from(videoPart.data, "base64");
+        if (!bytes.includes(Buffer.from("ftyp", "ascii")) || !bytes.includes(Buffer.from("moov", "ascii"))) {
+            return {
+                status: types_1.EVideoSceneStatus.FAILED,
+                errorMessage: "Generated video failed integrity validation (incomplete inline payload).",
+            };
+        }
+        const videoUrl = await storage_1.mediaStorage.put(`${outputFilePath}/${outputFilename}.mp4`, bytes, videoPart.mime_type ?? "video/mp4");
+        // Omni picks its own length (3–10s; the requested duration is only a prompt
+        // hint), so report the delivered length and finalization bills that.
+        const durationSec = (0, mp4Duration_1.readMp4DurationSec)(bytes);
+        return { videoUrl, status: types_1.EVideoSceneStatus.COMPLETED, ...(durationSec !== undefined ? { durationSec } : {}) };
+    }
     async checkVideoStatus({ task, outputFilename, outputFilePath = "videos", }) {
         // Re-select the key that submitted this task (Veo operations are
         // project-scoped). Un-tagged / unknown ids fall back to the legacy client.
         const { keyId, operationName } = (0, googleApiKeys_1.decodeVeoTask)(task);
         const client = this.keyPool.clientById(keyId) ?? this.ai;
+        if (operationName.startsWith(OMNI_TASK_PREFIX)) {
+            return this.checkOmniStatus(keyId, client, operationName.slice(OMNI_TASK_PREFIX.length), outputFilename, outputFilePath);
+        }
         const operation = new genai_1.GenerateVideosOperation();
         operation.name = operationName;
         const result = await this.withTransientRetry("getVideosOperation", () => client.operations.getVideosOperation({ operation }));
@@ -524,94 +698,102 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
                 };
             }
             const video = result.response?.generatedVideos?.[0]?.video;
-            const localPath = `${outputFilename}.mp4`; // use /tmp for cloud functions
-            const filePath = `${outputFilePath}/${outputFilename}.mp4`;
-            const file = (0, firebase_1.getBucket)().file(filePath);
-            // Download with the SAME key that submitted the task. The Veo output is
-            // stored via the Files API in the issuing key's GCP project, so it is
-            // project-scoped exactly like the operation — the default `this.ai`
-            // (legacy GOOGLE_API_KEY) client can only read files from its own
-            // project. With the multi-key pool, the drain-first key (k0) lives in a
-            // separate project, so downloading its videos via `this.ai` would 403/404.
-            // Use the re-selected `client` (falls back to `this.ai` for un-tagged
-            // legacy tasks, which were submitted on GOOGLE_API_KEY anyway).
-            // Download → validate-complete → upload, retried as a unit. The Files API
-            // downloader intermittently resolves before the clip is fully flushed to
-            // disk; uploading then truncates the scene at a chunk boundary (commonly
-            // exactly 4 MiB), dropping the trailing `moov` atom and yielding a corrupt
-            // MP4 that ffprobe rejects downstream (poster/watermark "moov atom not
-            // found", and a broken deliverable). Guard with (1) a stable-size wait so
-            // we only read a fully-written file, (2) a structural ftyp+moov check, and
-            // (3) a stored-vs-local size match after upload. Any failure re-runs the
-            // whole download instead of shipping corruption.
-            //
-            // GCS-PRIMARY (not mediaStorage.put): the size-verified integrity guard
-            // above needs GCS's own writeFromFile + getMetadata size readback: R2
-            // gets a best-effort mirror via mediaStorage.mirrorFromFile once the
-            // GCS copy is confirmed intact. See notes/R2_MEDIA_MIGRATION_PLAN.md §10.
-            const MAX_FETCH_ATTEMPTS = 3;
-            let uploaded = false;
-            for (let attempt = 1; attempt <= MAX_FETCH_ATTEMPTS && !uploaded; attempt++) {
-                await this.withTransientRetry("files.download", () => client.files.download({ file: video, downloadPath: localPath }));
-                const localSize = await waitForStableFile(localPath, 30000, 500);
-                if (await mp4IsComplete(localPath)) {
-                    await (0, promises_2.pipeline)((0, fs_1.createReadStream)(localPath), file.createWriteStream({ contentType: "video/mp4" }));
-                    const [meta] = await file.getMetadata();
-                    const storedSize = Number(meta.size);
-                    if (Number.isFinite(storedSize) && storedSize === localSize) {
-                        uploaded = true;
-                        break; // faithful, complete upload
-                    }
-                    logger_1.logger.warn("google: scene upload size mismatch — retrying", {
-                        filePath,
-                        attempt,
-                        localSize,
-                        storedSize,
-                    });
-                }
-                else {
-                    logger_1.logger.warn("google: downloaded scene missing moov atom — retrying", {
-                        filePath,
-                        attempt,
-                        localSize,
-                    });
+            return this.persistFilesApiVideo(client, video, outputFilename, outputFilePath);
+        }
+        return { status: types_1.EVideoSceneStatus.PENDING };
+    }
+    /**
+     * Download a Files-API video (Veo output, or Gemini Omni `delivery:"uri"`
+     * output) with the key that produced it and persist it GCS-primary with the
+     * truncation guards below. Returns the scene's terminal status.
+     */
+    async persistFilesApiVideo(client, video, outputFilename, outputFilePath) {
+        const localPath = `${outputFilename}.mp4`; // use /tmp for cloud functions
+        const filePath = `${outputFilePath}/${outputFilename}.mp4`;
+        const file = (0, firebase_1.getBucket)().file(filePath);
+        // Download with the SAME key that submitted the task. The Veo output is
+        // stored via the Files API in the issuing key's GCP project, so it is
+        // project-scoped exactly like the operation — the default `this.ai`
+        // (legacy GOOGLE_API_KEY) client can only read files from its own
+        // project. With the multi-key pool, the drain-first key (k0) lives in a
+        // separate project, so downloading its videos via `this.ai` would 403/404.
+        // Use the re-selected `client` (falls back to `this.ai` for un-tagged
+        // legacy tasks, which were submitted on GOOGLE_API_KEY anyway).
+        // Download → validate-complete → upload, retried as a unit. The Files API
+        // downloader intermittently resolves before the clip is fully flushed to
+        // disk; uploading then truncates the scene at a chunk boundary (commonly
+        // exactly 4 MiB), dropping the trailing `moov` atom and yielding a corrupt
+        // MP4 that ffprobe rejects downstream (poster/watermark "moov atom not
+        // found", and a broken deliverable). Guard with (1) a stable-size wait so
+        // we only read a fully-written file, (2) a structural ftyp+moov check, and
+        // (3) a stored-vs-local size match after upload. Any failure re-runs the
+        // whole download instead of shipping corruption.
+        //
+        // GCS-PRIMARY (not mediaStorage.put): the size-verified integrity guard
+        // above needs GCS's own writeFromFile + getMetadata size readback: R2
+        // gets a best-effort mirror via mediaStorage.mirrorFromFile once the
+        // GCS copy is confirmed intact. See notes/R2_MEDIA_MIGRATION_PLAN.md §10.
+        const MAX_FETCH_ATTEMPTS = 3;
+        let uploaded = false;
+        for (let attempt = 1; attempt <= MAX_FETCH_ATTEMPTS && !uploaded; attempt++) {
+            await this.withTransientRetry("files.download", () => client.files.download({ file: video, downloadPath: localPath }));
+            const localSize = await waitForStableFile(localPath, 30000, 500);
+            if (await mp4IsComplete(localPath)) {
+                await (0, promises_2.pipeline)((0, fs_1.createReadStream)(localPath), file.createWriteStream({ contentType: "video/mp4" }));
+                const [meta] = await file.getMetadata();
+                const storedSize = Number(meta.size);
+                if (Number.isFinite(storedSize) && storedSize === localSize) {
+                    uploaded = true;
+                    break; // faithful, complete upload
                 }
-                // Failed validation — discard the partial file before the next attempt.
-                await promises_1.default.unlink(localPath).catch(() => { });
-            }
-            if (!uploaded) {
-                logger_1.logger.error("google: scene download/upload failed integrity validation — giving up", { filePath });
-                return {
-                    status: types_1.EVideoSceneStatus.FAILED,
-                    errorMessage: "Generated video failed integrity validation (incomplete/truncated download).",
-                };
+                logger_1.logger.warn("google: scene upload size mismatch — retrying", {
+                    filePath,
+                    attempt,
+                    localSize,
+                    storedSize,
+                });
             }
-            const [signedUrl] = await file.getSignedUrl({
-                action: "read",
-                expires: "03-09-2491",
-            });
-            // mediaStorage: best-effort R2 mirror of the integrity-validated local clip
-            // (zero-egress delivery) — the GCS streaming write above stays the guarded
-            // system-of-record; this only runs when R2_WRITE_ENABLED. Before cleanup.
-            await storage_1.mediaStorage.mirrorFromFile(filePath, localPath, "video/mp4");
-            // Optionally clean up local file
-            await promises_1.default
-                .unlink(localPath)
-                .then(() => {
-                // console.log("Local file deleted:", localPath);
-            })
-                .catch((err) => {
-                logger_1.logger.warn("google: local file cleanup failed", {
-                    localPath,
-                    err: err?.stack ?? err?.message ?? String(err),
+            else {
+                logger_1.logger.warn("google: downloaded scene missing moov atom — retrying", {
+                    filePath,
+                    attempt,
+                    localSize,
                 });
-            });
+            }
+            // Failed validation — discard the partial file before the next attempt.
+            await promises_1.default.unlink(localPath).catch(() => { });
+        }
+        if (!uploaded) {
+            logger_1.logger.error("google: scene download/upload failed integrity validation — giving up", { filePath });
             return {
-                videoUrl: signedUrl,
-                status: types_1.EVideoSceneStatus.COMPLETED,
+                status: types_1.EVideoSceneStatus.FAILED,
+                errorMessage: "Generated video failed integrity validation (incomplete/truncated download).",
             };
         }
-        return { status: types_1.EVideoSceneStatus.PENDING };
+        const [signedUrl] = await file.getSignedUrl({
+            action: "read",
+            expires: "03-09-2491",
+        });
+        // mediaStorage: best-effort R2 mirror of the integrity-validated local clip
+        // (zero-egress delivery) — the GCS streaming write above stays the guarded
+        // system-of-record; this only runs when R2_WRITE_ENABLED. Before cleanup.
+        await storage_1.mediaStorage.mirrorFromFile(filePath, localPath, "video/mp4");
+        // Optionally clean up local file
+        await promises_1.default
+            .unlink(localPath)
+            .then(() => {
+            // console.log("Local file deleted:", localPath);
+        })
+            .catch((err) => {
+            logger_1.logger.warn("google: local file cleanup failed", {
+                localPath,
+                err: err?.stack ?? err?.message ?? String(err),
+            });
+        });
+        return {
+            videoUrl: signedUrl,
+            status: types_1.EVideoSceneStatus.COMPLETED,
+        };
     }
     async generateImage(params) {
         try {
@@ -654,6 +836,9 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
         // 200 with the images filtered out — so the reason is only available here.
         // Mirrors the Veo video path (raiMediaFilteredReasons, above).
         const blockReasons = [];
+        // Nano Banana declining with a text-only answer instead of an image —
+        // see the 2026-09-30 comment below where this is populated.
+        const textDeclines = [];
         if (isImagen) {
             const resp = await this.ai.models.generateImages({
                 model: modelId,
@@ -698,12 +883,28 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
             // Prefix the requested ratio so the model produces an output that at
             // least matches orientation (Gemini still won't honor exact pixel
             // dimensions, but landscape vs portrait is reliable).
-            const aspectHint = params.aspectRatio
-                ? `Generate the image with a ${params.aspectRatio} aspect ratio (${params.aspectRatio === "9:16" || params.aspectRatio === "3:4" || params.aspectRatio === "4:5"
-                    ? "vertical portrait"
-                    : params.aspectRatio === "1:1"
-                        ? "square"
-                        : "horizontal landscape"} orientation). `
+            //
+            // 2026-09-29: the Gemini 3.x image models take a structured
+            // `imageConfig { aspectRatio, imageSize }` (ai.google.dev image-generation
+            // "Aspect ratios and image size"). When the model declares the requested
+            // ratio we send it structurally and skip the prompt hint; the hint stays
+            // the fallback for a ratio the model's allowedValues don't list.
+            const declaredAspects = modelConfig.fields?.aspectRatio
+                ?.allowedValues;
+            const structuredAspect = params.aspectRatio && declaredAspects?.includes(params.aspectRatio) ? params.aspectRatio : undefined;
+            // imageSize was declared + PRICED per size (nano-banana-pro) but never sent,
+            // so a 4K request billed $0.24 and returned the 1K default. "auto_2K" is
+            // the picker's legacy default → 2K.
+            const declaredSizes = modelConfig.fields?.imageSize
+                ?.allowedValues;
+            const requestedSize = params.imageSize === "auto_2K" ? "2K" : params.imageSize;
+            const structuredSize = requestedSize && declaredSizes?.includes(requestedSize) ? requestedSize : undefined;
+            // Orientation is derived from the ratio itself (a fixed portrait list
+            // mislabeled 2:3 / 1:4 / 1:8 as landscape).
+            const [aw, ah] = (params.aspectRatio ?? "").split(":").map(Number);
+            const orientation = aw && ah ? (aw < ah ? "vertical portrait" : aw === ah ? "square" : "horizontal landscape") : "";
+            const aspectHint = params.aspectRatio && !structuredAspect
+                ? `Generate the image with a ${params.aspectRatio} aspect ratio${orientation ? ` (${orientation} orientation)` : ""}. `
                 : "";
             const parts = [{ text: `${aspectHint}${params.prompt}` }];
             const refs = [
@@ -714,34 +915,71 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
                 const ref = await (0, googleFetch_1.fetchAsImage)(url);
                 parts.push({ inlineData: { mimeType: ref.mimeType, data: ref.imageBytes } });
             }
-            const resp = await this.ai.models.generateContent({
+            // The pinned SDK's ImageConfig type predates `imageSize`, but its request
+            // transformer copies `imageConfig` through verbatim, so the field reaches
+            // the API. (Newer SDKs type it: `imageSize?: string`.)
+            const imageConfig = {
+                ...(structuredAspect ? { aspectRatio: structuredAspect } : {}),
+                ...(structuredSize ? { imageSize: structuredSize } : {}),
+            };
+            // generateContent returns ONE image per call, but the route bills
+            // numImages (1–8) up front with no shortfall reconciliation — so issue one
+            // call per requested image instead of charging N× for a single output.
+            const responses = await Promise.all(Array.from({ length: Math.max(1, params.numImages ?? 1) }, () => this.ai.models.generateContent({
                 model: modelId,
                 contents: [{ role: "user", parts }],
-            });
-            const candidates = resp.candidates ?? [];
-            for (const cand of candidates) {
-                for (const part of cand.content?.parts ?? []) {
-                    const inline = part.inlineData;
-                    if (inline?.data) {
-                        allBytes.push({
-                            bytes: Buffer.from(inline.data, "base64"),
-                            mime: inline.mimeType ?? "image/png",
-                        });
+                ...(Object.keys(imageConfig).length ? { config: { imageConfig } } : {}),
+            })));
+            for (const resp of responses) {
+                const candidates = resp.candidates ?? [];
+                let gotImageThisResponse = false;
+                for (const cand of candidates) {
+                    for (const part of cand.content?.parts ?? []) {
+                        const inline = part.inlineData;
+                        if (inline?.data) {
+                            allBytes.push({
+                                bytes: Buffer.from(inline.data, "base64"),
+                                mime: inline.mimeType ?? "image/png",
+                            });
+                            gotImageThisResponse = true;
+                        }
                     }
                 }
-            }
-            // Gemini reports a safety stop two ways, neither of which throws:
-            // promptFeedback.blockReason (whole prompt rejected → candidates empty)
-            // and candidate.finishReason (generation halted: IMAGE_SAFETY,
-            // PROHIBITED_CONTENT, RECITATION, SPII).
-            const promptBlock = resp
-                .promptFeedback?.blockReason;
-            if (promptBlock)
-                blockReasons.push(promptBlock);
-            for (const cand of candidates) {
-                const finish = cand.finishReason;
-                if (finish && finish !== "STOP" && finish !== "MAX_TOKENS") {
-                    blockReasons.push(finish);
+                // Gemini reports a safety stop two ways, neither of which throws:
+                // promptFeedback.blockReason (whole prompt rejected → candidates empty)
+                // and candidate.finishReason (generation halted: IMAGE_SAFETY,
+                // PROHIBITED_CONTENT, RECITATION, SPII).
+                const promptBlock = resp
+                    .promptFeedback?.blockReason;
+                if (promptBlock)
+                    blockReasons.push(promptBlock);
+                for (const cand of candidates) {
+                    const finish = cand.finishReason;
+                    if (finish && finish !== "STOP" && finish !== "MAX_TOKENS") {
+                        blockReasons.push(finish);
+                    }
+                }
+                // 2026-09-30: gemini-3.1-flash-image (Nano Banana 2) refuses some
+                // requests with finishReason "STOP" and NO promptFeedback block — it
+                // just answers with a TEXT part instead of an image. Verified by
+                // replaying prod job 9NyH60DhQD5wZiS6UenP (an edit asking to undress
+                // a person in an uploaded photo): candidates[0] = one text part, in
+                // the user's language ("Saya tidak bisa mengubah gambar ... karena
+                // adanya pelanggaran kebijakan terkait konten seksual"),
+                // finishReason STOP, no promptFeedback. Neither block signal above
+                // fires, so this used to fall through to the generic "no image
+                // bytes" Error and page Slack on every refusal. Harvest the model's
+                // text as the reason. It is logged (warn) for triage but never shown
+                // to the user — it is model-language-specific free text.
+                if (!gotImageThisResponse) {
+                    const declineText = candidates
+                        .flatMap((cand) => cand.content?.parts ?? [])
+                        .map((part) => part.text)
+                        .filter((text) => Boolean(text && text.trim()))
+                        .join(" ")
+                        .trim();
+                    if (declineText)
+                        textDeclines.push(declineText);
                 }
             }
         }
@@ -763,8 +1001,20 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
                 });
                 throw new errors_1.UserFacingError("Your prompt was flagged by Google's safety filters. Please rephrase and try again.", errors_1.USER_FACING_ERROR_CODES.CONTENT_POLICY_VIOLATION);
             }
-            // No block reason at all — genuinely unexpected; keep it loud so a real
-            // platform/SDK regression isn't muted by the branch above.
+            if (textDeclines.length) {
+                logger_1.logger.warn("Google image generation declined with text instead of an image", {
+                    modelKey: params.modelKey,
+                    modelId,
+                    declines: textDeclines,
+                });
+                // A text-only STOP from an image model is a refusal (policy), same
+                // outcome as the safety-filter branch above, so same code: the
+                // frontend already maps it to "flagged by the model's safety filters".
+                throw new errors_1.UserFacingError("Your prompt was flagged by Google's safety filters. Please rephrase and try again.", errors_1.USER_FACING_ERROR_CODES.CONTENT_POLICY_VIOLATION);
+            }
+            // No block reason and no text at all — genuinely unexpected; keep it
+            // loud so a real platform/SDK regression isn't muted by the branches
+            // above.
             throw new Error("Google image generation returned no image bytes");
         }
         const ts = Date.now();
@@ -805,8 +1055,14 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
         // Image-gen per-image cost keyed by output size (nano-banana-pro). Falls
         // back to `cost.fixed` if `imageSize` isn't supplied by the caller.
         if (cost?.perImageSize) {
-            const key = imageSize ?? "2K";
-            const perImage = cost.perImageSize[key] ?? cost.fixed ?? 0;
+            // No size → nothing is sent and the model renders its default (1K), which
+            // `cost.fixed` prices. "auto_2K" is normalized to "2K" exactly as
+            // _generateImage does, so we bill the size actually requested.
+            // REMOVED FOR v2 — kept for reference: defaulted to 2K, overbilling
+            // size-less requests on models whose 1K and 2K prices differ.
+            // const key = imageSize ?? "2K";
+            const key = imageSize === "auto_2K" ? "2K" : imageSize;
+            const perImage = (key !== undefined ? cost.perImageSize[key] : undefined) ?? cost.fixed ?? 0;
             return (0, helpers_1.getCreditsFromCost)(perImage * Math.max(1, numImages), applyFloor, creditFloor);
         }
         // Image-gen flat per-image cost (Imagen / Nano Banana).

package/lib/services/aiGen/providers/google/googleKeyPool.d.ts

@@ -39,6 +39,12 @@ declare class GoogleKeyPool {
     get primaryClient(): GoogleGenAI;
     /** Resolve a tagged task's key id back to its client (undefined if unknown). */
     clientById(id: string | undefined): GoogleGenAI | undefined;
+    /**
+     * Raw API key for a tagged task's key id, for REST paths the pinned SDK
+     * doesn't wrap (the Interactions API behind Gemini Omni). Untagged/unknown
+     * ids resolve to the primary key, which is where legacy tasks were issued.
+     */
+    apiKeyById(id: string | undefined): string;
     /**
      * Pick the key that should serve a new submission. Walks keys in priority
      * order and returns the first whose per-key minute + day budgets still have

package/lib/services/aiGen/providers/google/googleKeyPool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"googleKeyPool.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/google/googleKeyPool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C,OAAO,EACL,iBAAiB,EAKlB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;;;;;;GAgBG;AAEH,UAAU,QAAQ;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,WAAW,CAAC;IACpB,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;CACd;AAiDD,cAAM,aAAa;IACjB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAa;;IA4BrC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,8EAA8E;IAC9E,IAAI,MAAM,IAAI,MAAM,EAAE,CAErB;IAUD,OAAO,CAAC,WAAW;IAInB,kFAAkF;IAC5E,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBjF,qFAAqF;YACvE,WAAW;IAiBzB,mDAAmD;IACnD,IAAI,aAAa,IAAI,WAAW,CAE/B;IAED,gFAAgF;IAChF,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS;IAK3D;;;;;;;;OAQG;IACG,aAAa,CACjB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GACjB,OAAO,CAAC,QAAQ,CAAC;IA4DpB,8EAA8E;YAChE,OAAO;CAUtB;AAID,sCAAsC;AACtC,wBAAgB,gBAAgB,IAAI,aAAa,CAGhD;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAC7B,YAAY,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"googleKeyPool.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/google/googleKeyPool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C,OAAO,EACL,iBAAiB,EAKlB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;;;;;;GAgBG;AAEH,UAAU,QAAQ;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,WAAW,CAAC;IACpB,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;CACd;AAiDD,cAAM,aAAa;IACjB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAa;;IA4BrC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,8EAA8E;IAC9E,IAAI,MAAM,IAAI,MAAM,EAAE,CAErB;IAUD,OAAO,CAAC,WAAW;IAInB,kFAAkF;IAC5E,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBjF,qFAAqF;YACvE,WAAW;IAiBzB,mDAAmD;IACnD,IAAI,aAAa,IAAI,WAAW,CAE/B;IAED,gFAAgF;IAChF,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS;IAK3D;;;;OAIG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM;IAI1C;;;;;;;;OAQG;IACG,aAAa,CACjB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GACjB,OAAO,CAAC,QAAQ,CAAC;IA4DpB,8EAA8E;YAChE,OAAO;CAUtB;AAID,sCAAsC;AACtC,wBAAgB,gBAAgB,IAAI,aAAa,CAGhD;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAC7B,YAAY,EAAE,aAAa,EAAE,CAAC"}

package/lib/services/aiGen/providers/google/googleKeyPool.js

@@ -141,6 +141,14 @@ class GoogleKeyPool {
             return undefined;
         return this.entries.find((e) => e.id === id)?.client;
     }
+    /**
+     * Raw API key for a tagged task's key id, for REST paths the pinned SDK
+     * doesn't wrap (the Interactions API behind Gemini Omni). Untagged/unknown
+     * ids resolve to the primary key, which is where legacy tasks were issued.
+     */
+    apiKeyById(id) {
+        return (id && this.entries.find((e) => e.id === id)?.apiKey) || this.entries[0].apiKey;
+    }
     /**
      * Pick the key that should serve a new submission. Walks keys in priority
      * order and returns the first whose per-key minute + day budgets still have