vidspotai-shared 1.0.70 → 1.0.71-dev.1

package/lib/services/aiGen/providers/elevenlabs/elevenlabs.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseAiGenProviderService } from "../baseAiGenProvider.service";
+import { CreditUsageParams, SfxGenerationParams, SfxGenerationResult } from "../types";
+/**
+ * ElevenLabs aiGen provider — currently only sound-effects.
+ * (TTS lives in the separate `services/tts/` subsystem.)
+ */
+export declare class ElevenLabsAiGenService extends BaseAiGenProviderService {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor();
+    /**
+     * ElevenLabs Sound Effects. Sync — POST /v1/sound-generation returns mp3 binary.
+     * Body: { text, duration_seconds?, prompt_influence?, loop? }
+     */
+    generateSoundEffects(params: SfxGenerationParams): Promise<SfxGenerationResult>;
+    getCreditUsed({ modelKey, duration, multiClip }: CreditUsageParams): number;
+}
+//# sourceMappingURL=elevenlabs.service.d.ts.map

package/lib/services/aiGen/providers/elevenlabs/elevenlabs.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elevenlabs.service.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/elevenlabs/elevenlabs.service.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,UAAU,CAAC;AAGlB;;;GAGG;AACH,qBAAa,sBAAuB,SAAQ,wBAAwB;IAClE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAE1D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;;IAWhC;;;OAGG;IACG,oBAAoB,CACxB,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,mBAAmB,CAAC;IA0D/B,aAAa,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAiB,EAAE,EAAE,iBAAiB,GAAG,MAAM;CAkBpF"}

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

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElevenLabsAiGenService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const aiModels_1 = require("../../../../globals/aiModels");
+const firebase_1 = require("../../../../libs/firebase");
+const baseAiGenProvider_service_1 = require("../baseAiGenProvider.service");
+const helpers_1 = require("../../../../utils/helpers");
+/**
+ * ElevenLabs aiGen provider — currently only sound-effects.
+ * (TTS lives in the separate `services/tts/` subsystem.)
+ */
+class ElevenLabsAiGenService extends baseAiGenProvider_service_1.BaseAiGenProviderService {
+    constructor() {
+        super();
+        this.baseUrl = "https://api.elevenlabs.io/v1";
+        const raw = process.env.ELEVENLABS_API_KEY?.trim();
+        if (!raw) {
+            throw new Error("Missing ELEVENLABS_API_KEY in environment variables");
+        }
+        this.apiKey = raw;
+    }
+    /**
+     * ElevenLabs Sound Effects. Sync — POST /v1/sound-generation returns mp3 binary.
+     * Body: { text, duration_seconds?, prompt_influence?, loop? }
+     */
+    async generateSoundEffects(params) {
+        const body = {
+            text: params.prompt,
+            ...(params.durationSec !== undefined
+                ? { duration_seconds: params.durationSec }
+                : {}),
+            ...(params.promptInfluence !== undefined
+                ? { prompt_influence: params.promptInfluence }
+                : {}),
+            ...(params.loop !== undefined ? { loop: params.loop } : {}),
+        };
+        try {
+            const resp = await axios_1.default.post(`${this.baseUrl}/sound-generation`, body, {
+                headers: {
+                    "xi-api-key": this.apiKey,
+                    "Content-Type": "application/json",
+                    Accept: "audio/mpeg",
+                },
+                responseType: "arraybuffer",
+                timeout: 120000,
+            });
+            const buffer = Buffer.from(resp.data);
+            const path = `sfx/elevenlabs/${params.outputFilename}.mp3`;
+            const file = (0, firebase_1.getBucket)().file(path);
+            await file.save(buffer, { contentType: "audio/mpeg" });
+            const [signed] = await file.getSignedUrl({
+                action: "read",
+                expires: "03-09-2491",
+            });
+            return {
+                audioUrl: signed,
+                mimeType: "audio/mpeg",
+                extension: "mp3",
+                durationSec: params.durationSec,
+            };
+        }
+        catch (err) {
+            if (err.response?.data) {
+                let detail = "";
+                try {
+                    const bodyStr = Buffer.from(err.response.data).toString("utf8");
+                    const parsed = JSON.parse(bodyStr);
+                    detail = parsed?.detail?.message ?? parsed?.detail ?? bodyStr;
+                }
+                catch {
+                    detail = Buffer.from(err.response.data).toString("utf8");
+                }
+                const wrapped = new Error(`ElevenLabs SFX ${err.response.status}: ${detail} [promptLen=${params.prompt?.length ?? 0}]`);
+                wrapped.cause = err;
+                throw wrapped;
+            }
+            throw err;
+        }
+    }
+    getCreditUsed({ modelKey, duration, multiClip = false }) {
+        const modelConfig = aiModels_1.aiModelConfigs[modelKey];
+        const isSfx = modelConfig?.type?.some((t) => t === "sound-effects");
+        if (isSfx && modelConfig?.cost) {
+            const perSecond = modelConfig.cost.perSecond;
+            const fixed = modelConfig.cost.fixed;
+            // Prefer per-second when caller knows the requested duration; otherwise
+            // fall back to the worst-case fixed ceiling so we never under-charge.
+            const cost = typeof duration === "number" && typeof perSecond === "number"
+                ? perSecond * duration
+                : fixed;
+            if (typeof cost === "number") {
+                return (0, helpers_1.getCreditsFromCost)(cost, !multiClip);
+            }
+        }
+        return (0, helpers_1.getCreditsFromCost)(0.08, !multiClip);
+    }
+}
+exports.ElevenLabsAiGenService = ElevenLabsAiGenService;

package/lib/services/aiGen/providers/fal/falImage.service.d.ts

@@ -0,0 +1,15 @@
+/**
+ * fal.ai image-generation provider — DISABLED.
+ *
+ * The provider class was written but never wired into `imageServicesMap`
+ * (no enum entry, no factory registration). Disabled here to make the
+ * orphan status explicit. Re-enable steps:
+ *   1. Add EImageGenModels entries for fal-flux-{schnell,1.1-pro,1.1-pro-ultra}
+ *   2. Register FalImageProviderService in imageServicesMap (aiGenFactory.service.ts)
+ *   3. Restore the implementation from the comment block below + re-enable
+ *      `packages/shared/src/services/agent/tools/generateImage.tool.ts`.
+ */
+export declare class FalImageProviderService {
+    constructor();
+}
+//# sourceMappingURL=falImage.service.d.ts.map

package/lib/services/aiGen/providers/fal/falImage.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"falImage.service.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/fal/falImage.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,qBAAa,uBAAuB;;CAMnC"}

package/lib/services/aiGen/providers/fal/falImage.service.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * fal.ai image-generation provider — DISABLED.
+ *
+ * The provider class was written but never wired into `imageServicesMap`
+ * (no enum entry, no factory registration). Disabled here to make the
+ * orphan status explicit. Re-enable steps:
+ *   1. Add EImageGenModels entries for fal-flux-{schnell,1.1-pro,1.1-pro-ultra}
+ *   2. Register FalImageProviderService in imageServicesMap (aiGenFactory.service.ts)
+ *   3. Restore the implementation from the comment block below + re-enable
+ *      `packages/shared/src/services/agent/tools/generateImage.tool.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FalImageProviderService = void 0;
+class FalImageProviderService {
+    constructor() {
+        throw new Error("FalImageProviderService is disabled. See falImage.service.ts header for re-enable steps.");
+    }
+}
+exports.FalImageProviderService = FalImageProviderService;
+/*
+// --- Original implementation preserved for re-enable. ---
+import axios from "axios";
+import { BaseAiGenProviderService } from "../baseAiGenProvider.service";
+import {
+  CreditUsageParams,
+  ImageGenerationParams,
+  ImageGenerationResult,
+} from "../types";
+
+const FAL_MODEL_ENDPOINTS: Record<string, string> = {
+  "fal-flux-1.1-pro": "https://fal.run/fal-ai/flux-pro/v1.1",
+  "fal-flux-1.1-pro-ultra": "https://fal.run/fal-ai/flux-pro/v1.1-ultra",
+  "fal-flux-schnell": "https://fal.run/fal-ai/flux/schnell",
+};
+
+interface FalImagePayload {
+  prompt: string;
+  image_size?: string | { width: number; height: number };
+  num_inference_steps?: number;
+  enable_safety_checker?: boolean;
+  seed?: number;
+}
+
+interface FalImageResponse {
+  images: Array<{ url: string; width?: number; height?: number }>;
+  seed?: number;
+  request_id?: string;
+}
+
+export class FalImageProviderService extends BaseAiGenProviderService {
+  private readonly apiKey: string | undefined = process.env.FAL_API_KEY;
+
+  async generateImage(
+    params: ImageGenerationParams
+  ): Promise<ImageGenerationResult> {
+    if (!this.apiKey) {
+      throw new Error(
+        "FAL_API_KEY not set — fal image provider cannot generate"
+      );
+    }
+
+    const endpoint = FAL_MODEL_ENDPOINTS[params.modelKey];
+    if (!endpoint) {
+      throw new Error(`Unknown fal model key: ${params.modelKey}`);
+    }
+
+    const payload: FalImagePayload = {
+      prompt: params.prompt,
+      image_size: this.mapAspectToImageSize(
+        params.dimensions,
+        params.aspectRatio
+      ),
+    };
+
+    const headers: Record<string, string> = {
+      Authorization: `Key ${this.apiKey}`,
+      "Content-Type": "application/json",
+    };
+    if (params.idempotencyKey) {
+      headers["X-Fal-Idempotency-Key"] = params.idempotencyKey;
+    }
+
+    const { data } = await axios.post<FalImageResponse>(endpoint, payload, {
+      headers,
+      timeout: 60_000,
+    });
+
+    const first = data.images?.[0];
+    if (!first?.url) {
+      throw new Error("fal returned no image");
+    }
+
+    return {
+      imageUrl: first.url,
+      width: first.width,
+      height: first.height,
+      providerRequestId: data.request_id,
+    };
+  }
+
+  getCreditUsed(params: CreditUsageParams): number {
+    const key = params.modelKey as unknown as string;
+    switch (key) {
+      case "fal-flux-1.1-pro-ultra":
+        return 6;
+      case "fal-flux-1.1-pro":
+        return 4;
+      case "fal-flux-schnell":
+        return 1;
+      default:
+        return 4;
+    }
+  }
+
+  private mapAspectToImageSize(
+    dimensions: string | undefined,
+    aspectRatio: string | undefined
+  ): FalImagePayload["image_size"] {
+    if (dimensions) {
+      const parts = dimensions.split("x").map((n) => parseInt(n, 10));
+      const w = parts[0];
+      const h = parts[1];
+      if (Number.isFinite(w) && Number.isFinite(h)) {
+        return { width: w!, height: h! };
+      }
+    }
+    switch (aspectRatio) {
+      case "9:16":
+        return "portrait_16_9";
+      case "16:9":
+        return "landscape_16_9";
+      case "4:5":
+        return "portrait_4_3";
+      case "1:1":
+      default:
+        return "square_hd";
+    }
+  }
+}
+*/

package/lib/services/aiGen/providers/fal/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./falImage.service";
+//# sourceMappingURL=index.d.ts.map

package/lib/services/aiGen/providers/fal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/fal/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/lib/services/aiGen/providers/fal/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./falImage.service"), exports);

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

@@ -1,5 +1,5 @@
 import { BaseAiGenProviderService } from "../baseAiGenProvider.service";
-import { CreditUsageParams, VideoGenerationParams, VideoGenerationResult, VideoStatusParams, VideoStatusResult } from "../types";
+import { CreditUsageParams, ImageGenerationParams, ImageGenerationResult, MusicGenerationParams, MusicGenerationResult, VideoGenerationParams, VideoGenerationResult, VideoStatusParams, VideoStatusResult } from "../types";
 export declare class GoogleService extends BaseAiGenProviderService {
     private ai;
     private static readonly MAX_RETRY_ATTEMPTS;
@@ -12,6 +12,15 @@ export declare class GoogleService extends BaseAiGenProviderService {
     private withTransientRetry;
     generateVideo(params: VideoGenerationParams): Promise<VideoGenerationResult>;
     checkVideoStatus({ task, outputFilename, outputFilePath, }: VideoStatusParams): Promise<VideoStatusResult>;
-    getCreditUsed({ modelKey, duration, resolution, multiClip }: CreditUsageParams): number;
+    generateImage(params: ImageGenerationParams): Promise<ImageGenerationResult>;
+    /**
+     * Lyria 2 (Vertex AI). Sync — POST {region}-aiplatform.googleapis.com/.../lyria-002:predict
+     * returns base64-encoded WAV audio inline. Auth via ADC on the function service
+     * account (or GOOGLE_APPLICATION_CREDENTIALS locally).
+     *
+     * Required env: GCP_PROJECT_ID. Optional: GCP_LOCATION (default us-central1).
+     */
+    generateMusic(params: MusicGenerationParams): Promise<MusicGenerationResult>;
+    getCreditUsed({ modelKey, duration, resolution, multiClip, numImages, imageSize }: CreditUsageParams): number;
 }
 //# sourceMappingURL=google.service.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"google.service.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/google/google.service.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,UAAU,CAAC;AA2FlB,qBAAa,aAAc,SAAQ,wBAAwB;IACzD,OAAO,CAAC,EAAE,CAAc;IACxB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAK;;IAO/C;;;;OAIG;YACW,kBAAkB;IA+B1B,aAAa,CACjB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IAqE3B,gBAAgB,CAAC,EACrB,IAAI,EACJ,cAAc,EACd,cAAyB,GAC1B,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAuFjD,aAAa,CAAC,EAAE,QAAQ,EAAE,QAAY,EAAE,UAAmB,EAAE,SAAiB,EAAE,EAAE,iBAAiB,GAAG,MAAM;CAiB7G"}
+{"version":3,"file":"google.service.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/google/google.service.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAoIlB,qBAAa,aAAc,SAAQ,wBAAwB;IACzD,OAAO,CAAC,EAAE,CAAc;IACxB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAK;;IAO/C;;;;OAIG;YACW,kBAAkB;IA+B1B,aAAa,CACjB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IA2E3B,gBAAgB,CAAC,EACrB,IAAI,EACJ,cAAc,EACd,cAAyB,GAC1B,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IA0F3C,aAAa,CACjB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IAsGjC;;;;;;OAMG;IACG,aAAa,CACjB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IAqEjC,aAAa,CAAC,EAAE,QAAQ,EAAE,QAAY,EAAE,UAAmB,EAAE,SAAiB,EAAE,SAAa,EAAE,SAAS,EAAE,EAAE,iBAAiB,GAAG,MAAM;CA8BvI"}

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

@@ -15,6 +15,7 @@ const logger_1 = require("../../../../utils/logger");
 const errors_1 = require("../../../../utils/errors");
 const helpers_2 = require("../../helpers");
 const baseAiGenProvider_service_1 = require("../baseAiGenProvider.service");
+const google_auth_library_1 = require("google-auth-library");
 const fs_1 = require("fs");
 const promises_2 = require("stream/promises");
 // Codes from undici / Node net layer that indicate a transient network failure
@@ -71,6 +72,41 @@ function isTransientFetchError(err) {
     const code = err.code ?? err.cause?.code;
     return !!code && TRANSIENT_NETWORK_CODES.has(code);
 }
+const VEO_3_1_MODELS = new Set([
+    aiModels_1.EVideoGenModels.GOOGLE_VEO_3_1,
+    aiModels_1.EVideoGenModels.GOOGLE_VEO_3_1_FAST,
+    aiModels_1.EVideoGenModels.GOOGLE_VEO_3_1_LITE,
+]);
+function inferImageMime(url) {
+    const lower = (url.split("?")[0] ?? url).toLowerCase();
+    if (lower.endsWith(".jpg") || lower.endsWith(".jpeg"))
+        return "image/jpeg";
+    if (lower.endsWith(".webp"))
+        return "image/webp";
+    return "image/png";
+}
+async function fetchAsImage(url) {
+    const resp = await fetch(url);
+    // fetch() does NOT throw on 4xx/5xx — surface the HTTP error so we don't
+    // encode an HTML error page as image bytes (Veo silently rejects them).
+    if (!resp.ok) {
+        throw new errors_1.UserFacingError(`Input image could not be downloaded (HTTP ${resp.status}). The image URL may have expired or been deleted.`);
+    }
+    const buf = Buffer.from(await resp.arrayBuffer());
+    // 0-byte body slips through resp.ok if the upstream wrote an empty file.
+    // Veo treats empty bytes as content-filtered (no error, no video).
+    if (buf.length === 0) {
+        throw new errors_1.UserFacingError("Input image is empty (0 bytes). Please re-upload the image.");
+    }
+    // Prefer Content-Type from the response (authoritative — set by Firebase
+    // Storage upload metadata) over URL-extension inference. Hardcoded
+    // image/png caused Veo to reject JPEG bytes labelled PNG with no detail.
+    const respContentType = resp.headers.get("content-type") ?? "";
+    return {
+        mimeType: pickImageMimeType(respContentType, url),
+        imageBytes: buf.toString("base64"),
+    };
+}
 /**
  * Maps `@google/genai` `ApiError` failures (whose message is a JSON string)
  * to a `UserFacingError` with a stable code the frontend can translate.
@@ -146,42 +182,46 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
         (0, helpers_2.validateParams)(params);
         const modelConfig = aiModels_1.aiModelConfigs[params.modelKey];
         const modelId = modelConfig.modelId;
+        const isVeo3_1 = VEO_3_1_MODELS.has(params.modelKey);
         const request = {
             model: modelId,
             prompt: params.prompt,
-            // image:
             config: {
                 aspectRatio: params.aspectRatio,
                 resolution: params.resolution,
                 durationSeconds: params.duration,
+                ...(params.seed !== undefined ? { seed: params.seed } : {}),
+                ...(params.personGeneration ? { personGeneration: params.personGeneration } : {}),
+                ...(params.negativePrompt ? { negativePrompt: params.negativePrompt } : {}),
+                ...(params.audio !== undefined ? { generateAudio: params.audio } : {}),
+                ...(params.promptOptimizer !== undefined ? { enhancePrompt: params.promptOptimizer } : {}),
             },
         };
-        if (params.inputImageUrl) {
-            const imgResp = await this.withTransientRetry("input-image fetch", () => fetch(params.inputImageUrl));
-            // BUG #3 fix: fetch() does NOT throw on 4xx/5xx — it returns a Response
-            // with the error body. Without this check we'd encode an HTML error page
-            // as if it were image bytes, and Veo would silently reject it.
-            if (!imgResp.ok) {
-                throw new errors_1.UserFacingError(`Input image could not be downloaded (HTTP ${imgResp.status}). The image URL may have expired or been deleted.`);
+        // Video extension takes precedence over image (mutually exclusive in Veo API).
+        if (params.inputVideoUrl) {
+            request.video = { uri: params.inputVideoUrl };
+        }
+        else if (params.inputImageUrl) {
+            request.image = await this.withTransientRetry("input-image fetch", () => fetchAsImage(params.inputImageUrl));
+        }
+        // Last-frame image for first-last-frame interpolation. Mutually exclusive with referenceImages.
+        if (params.lastFrameImageUrl) {
+            request.config.lastFrame = await this.withTransientRetry("last-frame fetch", () => fetchAsImage(params.lastFrameImageUrl));
+        }
+        // Reference images (Veo 3.1 only — up to 3 asset images for character/scene consistency).
+        // When references are provided the API requires durationSeconds=8 and forbids image/video/lastFrame.
+        if (params.referenceImageUrls?.length) {
+            if (!isVeo3_1) {
+                logger_1.logger.warn(`Google Veo: referenceImages provided but model ${params.modelKey} does not support them — ignoring.`);
             }
-            const imgBuffer = Buffer.from(await imgResp.arrayBuffer());
-            // BUG #2 fix: a 0-byte body slips through fetch().ok if the upstream
-            // wrote an empty file. Veo treats empty bytes as content-filtered (no
-            // error, no video). Surface the real cause to the user.
-            if (imgBuffer.length === 0) {
-                throw new errors_1.UserFacingError("Input image is empty (0 bytes). Please re-upload the image.");
+            else {
+                const refs = params.referenceImageUrls.slice(0, 3);
+                const fetched = await Promise.all(refs.map((url) => this.withTransientRetry("reference-image fetch", () => fetchAsImage(url))));
+                request.config.referenceImages = fetched.map((image) => ({
+                    image,
+                    referenceType: genai_1.VideoGenerationReferenceType.ASSET,
+                }));
             }
-            // BUG #1 fix: previously hardcoded "image/png" regardless of the actual
-            // upload type. Veo rejects JPEG bytes labeled as PNG, with no error
-            // detail. Prefer the Content-Type from the response (authoritative —
-            // Firebase Storage sets it from upload metadata), fall back to URL
-            // extension, then default to JPEG (modern phone-camera default).
-            const respContentType = imgResp.headers.get("content-type") ?? "";
-            const mimeType = pickImageMimeType(respContentType, params.inputImageUrl);
-            request.image = {
-                mimeType,
-                imageBytes: imgBuffer.toString("base64"),
-            };
         }
         const operation = await this.withTransientRetry("generateVideos", () => this.ai.models.generateVideos(request));
         if (!operation || !operation.name) {
@@ -245,8 +285,11 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
                 .then(() => {
                 // console.log("Local file deleted:", localPath);
             })
-                .catch(() => {
-                console.warn("Failed to delete local file:", localPath);
+                .catch((err) => {
+                logger_1.logger.warn("google: local file cleanup failed", {
+                    localPath,
+                    err: err?.stack ?? err?.message ?? String(err),
+                });
             });
             return {
                 videoUrl: signedUrl,
@@ -255,10 +298,184 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
         }
         return { status: types_1.EVideoSceneStatus.PENDING };
     }
-    getCreditUsed({ modelKey, duration = 8, resolution = "720p", multiClip = false }) {
+    async generateImage(params) {
+        const modelConfig = aiModels_1.aiModelConfigs[params.modelKey];
+        const modelId = modelConfig?.modelId;
+        if (!modelId)
+            throw new Error(`Unknown image modelKey: ${params.modelKey}`);
+        const isImagen = modelId.startsWith("imagen-");
+        const isNanoBanana = modelId.startsWith("gemini-") && modelId.includes("image");
+        const allBytes = [];
+        if (isImagen) {
+            const resp = await this.ai.models.generateImages({
+                model: modelId,
+                prompt: params.prompt,
+                config: {
+                    numberOfImages: params.numImages ?? 1,
+                    ...(params.aspectRatio ? { aspectRatio: params.aspectRatio } : {}),
+                    ...(params.personGeneration
+                        ? { personGeneration: params.personGeneration }
+                        : {}),
+                    ...(params.negativePrompt ? { negativePrompt: params.negativePrompt } : {}),
+                    ...(params.outputFormat ? { outputMimeType: `image/${params.outputFormat}` } : {}),
+                },
+            });
+            for (const gen of resp.generatedImages ?? []) {
+                const b64 = gen.image?.imageBytes;
+                if (!b64)
+                    continue;
+                allBytes.push({
+                    bytes: Buffer.from(b64, "base64"),
+                    mime: gen.image?.mimeType ?? "image/png",
+                });
+            }
+        }
+        else if (isNanoBanana) {
+            // Nano Banana (Gemini image-gen via generateContent) has no structured
+            // aspectRatio knob — Imagen does, this path doesn't. Without the hint
+            // in the prompt it defaults to landscape, so a 9:16 project ended up
+            // with horizontal images that didn't cover the vertical canvas.
+            // 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). `
+                : "";
+            const parts = [{ text: `${aspectHint}${params.prompt}` }];
+            const refs = [
+                ...(params.inputImageUrl ? [params.inputImageUrl] : []),
+                ...(params.inputImageUrls ?? []),
+            ];
+            for (const url of refs) {
+                const ref = await fetchAsImage(url);
+                parts.push({ inlineData: { mimeType: ref.mimeType, data: ref.imageBytes } });
+            }
+            const resp = await 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",
+                        });
+                    }
+                }
+            }
+        }
+        else {
+            throw new Error(`Unsupported Google image modelId: ${modelId}`);
+        }
+        if (!allBytes.length) {
+            throw new Error("Google image generation returned no image bytes");
+        }
+        const bucket = (0, firebase_1.getBucket)();
+        const ts = Date.now();
+        const urls = [];
+        for (let i = 0; i < allBytes.length; i++) {
+            const item = allBytes[i];
+            const { bytes, mime } = item;
+            const ext = (mime.split("/")[1] ?? "png").toLowerCase();
+            const path = `images/google/${ts}-${Math.random().toString(36).slice(2, 8)}-${i}.${ext}`;
+            const file = bucket.file(path);
+            await file.save(bytes, { contentType: mime });
+            const [signed] = await file.getSignedUrl({ action: "read", expires: "03-09-2491" });
+            urls.push(signed);
+        }
+        return {
+            imageUrl: urls[0],
+            imageUrls: urls.length > 1 ? urls : undefined,
+        };
+    }
+    /**
+     * Lyria 2 (Vertex AI). Sync — POST {region}-aiplatform.googleapis.com/.../lyria-002:predict
+     * returns base64-encoded WAV audio inline. Auth via ADC on the function service
+     * account (or GOOGLE_APPLICATION_CREDENTIALS locally).
+     *
+     * Required env: GCP_PROJECT_ID. Optional: GCP_LOCATION (default us-central1).
+     */
+    async generateMusic(params) {
+        const modelConfig = aiModels_1.aiModelConfigs[params.modelKey];
+        const modelId = modelConfig?.modelId ?? "lyria-002";
+        const projectId = process.env.GCP_PROJECT_ID;
+        if (!projectId) {
+            throw new Error("Missing GCP_PROJECT_ID env var (required for Vertex Lyria)");
+        }
+        const location = process.env.GCP_LOCATION ?? "us-central1";
+        const auth = new google_auth_library_1.GoogleAuth({
+            scopes: ["https://www.googleapis.com/auth/cloud-platform"],
+        });
+        const client = await auth.getClient();
+        const tokenRes = await client.getAccessToken();
+        const token = tokenRes?.token;
+        if (!token)
+            throw new Error("Failed to obtain GCP access token for Vertex Lyria");
+        const url = `https://${location}-aiplatform.googleapis.com/v1/projects/${projectId}` +
+            `/locations/${location}/publishers/google/models/${modelId}:predict`;
+        const instance = { prompt: params.prompt };
+        const parameters = {
+            sample_count: 1,
+        };
+        if (params.negativePrompt) {
+            instance.negative_prompt = params.negativePrompt;
+        }
+        if (params.seed !== undefined) {
+            parameters.seed = params.seed;
+        }
+        const resp = await fetch(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ instances: [instance], parameters }),
+        });
+        if (!resp.ok) {
+            const errText = await resp.text();
+            throw new Error(`Vertex Lyria failed (${resp.status}): ${errText}`);
+        }
+        const data = await resp.json();
+        const audioB64 = data?.predictions?.[0]?.bytesBase64Encoded;
+        if (!audioB64) {
+            throw new Error("Vertex Lyria returned no audio data");
+        }
+        const buffer = Buffer.from(audioB64, "base64");
+        const path = `music/lyria/${params.outputFilename}.wav`;
+        const file = (0, firebase_1.getBucket)().file(path);
+        await file.save(buffer, { contentType: "audio/wav" });
+        const [signed] = await file.getSignedUrl({
+            action: "read",
+            expires: "03-09-2491",
+        });
+        return {
+            audioUrl: signed,
+            mimeType: "audio/wav",
+            extension: "wav",
+        };
+    }
+    getCreditUsed({ modelKey, duration = 8, resolution = "720p", multiClip = false, numImages = 1, imageSize }) {
         const modelConfig = aiModels_1.aiModelConfigs[modelKey];
         const cost = modelConfig.cost;
         const applyFloor = !multiClip;
+        // 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;
+            return (0, helpers_1.getCreditsFromCost)(perImage * Math.max(1, numImages), applyFloor);
+        }
+        // Image-gen flat per-image cost (Imagen / Nano Banana).
+        if (cost?.fixed !== undefined) {
+            return (0, helpers_1.getCreditsFromCost)(cost.fixed * Math.max(1, numImages), applyFloor);
+        }
         if (cost?.perResolution) {
             const ratePerSecond = cost.perResolution[resolution] ?? cost.perResolution["720p"];
             return (0, helpers_1.getCreditsFromCost)(ratePerSecond * duration, applyFloor);