vidspotai-shared 1.0.82-dev.0 → 1.0.83

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

@@ -15,182 +15,93 @@ 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
-// the request never reached the server, or the server hung up mid-flight.
-// Retrying these is safe (idempotent at the API layer for our use cases) and usually succeeds.
-const TRANSIENT_NETWORK_CODES = new Set([
-    "ECONNRESET",
-    "ECONNREFUSED",
-    "ETIMEDOUT",
-    "ENOTFOUND",
-    "EAI_AGAIN",
-    "EPIPE",
-    "UND_ERR_SOCKET",
-    "UND_ERR_CONNECT_TIMEOUT",
-    "UND_ERR_HEADERS_TIMEOUT",
-    "UND_ERR_BODY_TIMEOUT",
-]);
-// Pick a Veo-compatible image MIME type. Veo accepts image/jpeg, image/png,
-// image/webp. We prefer the upstream Content-Type header (Firebase Storage
-// returns the type set at upload), then fall back to URL extension, then to
-// image/jpeg as a reasonable last resort for phone-camera uploads.
-const VEO_SUPPORTED_IMAGE_MIMES = new Set([
-    "image/jpeg",
-    "image/png",
-    "image/webp",
-]);
-function pickImageMimeType(contentType, url) {
-    const normalized = contentType.split(";")[0]?.trim().toLowerCase();
-    if (normalized && VEO_SUPPORTED_IMAGE_MIMES.has(normalized)) {
-        return normalized;
-    }
-    // Map common but non-canonical types
-    if (normalized === "image/jpg")
-        return "image/jpeg";
-    // Extension fallback. Strip query string first (Firebase URLs have ?alt=media).
-    const pathOnly = url.split("?")[0]?.toLowerCase() ?? "";
-    if (pathOnly.endsWith(".png"))
-        return "image/png";
-    if (pathOnly.endsWith(".webp"))
-        return "image/webp";
-    if (pathOnly.endsWith(".jpg") || pathOnly.endsWith(".jpeg"))
-        return "image/jpeg";
-    // Phone uploads default to JPEG far more often than PNG, so it's a safer
-    // last-resort than the previous hardcoded "image/png".
-    return "image/jpeg";
-}
-function isTransientFetchError(err) {
-    if (!err)
-        return false;
-    // undici wraps low-level errors as `TypeError: fetch failed` with the real
-    // reason on `err.cause`. Treat that exact shape as transient.
-    if (err.message === "fetch failed")
-        return true;
-    const code = err.code ?? err.cause?.code;
-    return !!code && TRANSIENT_NETWORK_CODES.has(code);
-}
+const googleErrors_1 = require("./googleErrors");
+const googleFetch_1 = require("./googleFetch");
+const googleMusic_1 = require("./googleMusic");
+const googleApiKeys_1 = require("./googleApiKeys");
+const googleKeyPool_1 = require("./googleKeyPool");
 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.
- * Returns null when the error is not a known user-facing case (re-throw as-is).
- */
-function classifyGoogleApiError(err) {
-    const raw = err?.message ?? "";
-    try {
-        const parsed = JSON.parse(raw);
-        const inner = parsed.error ?? parsed;
-        const httpCode = inner.code;
-        const status = inner.status;
-        const msg = inner.message ?? raw;
-        if (status === "RESOURCE_EXHAUSTED" || httpCode === 429) {
-            return new errors_1.UserFacingError(msg, errors_1.USER_FACING_ERROR_CODES.VIDEO_PROVIDER_RATE_LIMITED);
-        }
-        // gRPC code 14 = UNAVAILABLE; Veo surfaces "high demand" failures with this.
-        if (httpCode === 14 || /high demand/i.test(msg)) {
-            return new errors_1.UserFacingError(msg, errors_1.USER_FACING_ERROR_CODES.VIDEO_PROVIDER_HIGH_DEMAND);
-        }
-        // INVALID_ARGUMENT 400 — narrow match: only the specific "use case is
-        // currently not supported" string, which Veo returns when our request
-        // structure doesn't match the chosen model variant's capabilities.
-        // The pre-call guards above (duration=8 for lastFrame/refs) should
-        // prevent the known cases; if we still hit this it's a NEW combo we
-        // haven't profiled — surface as CAPABILITY_MISMATCH so the user gets a
-        // useful message, AND keep the raw provider text in the error so the
-        // next entry in PROD_FIX_LOG can identify which combo broke. Generic
-        // 400s (other INVALID_ARGUMENT variants) still surface as `error` so
-        // a real platform bug isn't muted.
-        if ((status === "INVALID_ARGUMENT" || httpCode === 400) &&
-            /use case is currently not supported/i.test(msg)) {
-            return new errors_1.UserFacingError(msg, errors_1.USER_FACING_ERROR_CODES.CAPABILITY_MISMATCH);
-        }
-        // Imagen + Nano-Banana surface Responsible-AI filter rejections as
-        // INVALID_ARGUMENT 400 with the literal text "filtered out because they
-        // violated Google's Responsible AI practices" (and a recommendation to
-        // rephrase). This is user content moderation, not a system bug — show the
-        // user the rephrase hint and skip the Slack page. Also matches the Veo
-        // RAI message ("violated Google's content policies") for the same reason.
-        if ((status === "INVALID_ARGUMENT" || httpCode === 400) &&
-            /(filtered out because they violated|violated Google's (?:Responsible AI|content) (?:practices|policies))/i.test(msg)) {
-            return 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);
-        }
-        // Generic INVALID_ARGUMENT 400 on a provided string field. Veo echoes the
-        // offending value back ("The string value `<prompt>` ...") and the only
-        // large free-text field we send is the prompt, so attribute this to the
-        // prompt: it's either over the model's length limit or otherwise rejected
-        // by the validator. Either way it's user input, not a platform bug —
-        // surface a typed, actionable, non-retryable error (logged warn, no Slack
-        // page) instead of leaking the echoed prompt into the error channel.
-        if ((status === "INVALID_ARGUMENT" || httpCode === 400) &&
-            /string value/i.test(msg)) {
-            const tooLong = /(exceed|too long|maximum length|length limit|\blimit\b)/i.test(msg);
-            return tooLong
-                ? new errors_1.UserFacingError("Your prompt is too long for this model. Please shorten it and try again.", errors_1.USER_FACING_ERROR_CODES.PROMPT_TOO_LONG)
-                : new errors_1.UserFacingError("Your prompt was rejected by the model. Please simplify or rephrase it and try again.", errors_1.USER_FACING_ERROR_CODES.PROMPT_INVALID);
-        }
-        // gRPC code 13 = INTERNAL. Veo returns this for transient backend failures
-        // ("Video generation failed due to an internal server issue. Please try
-        // again in a few minutes."). It is NOT our bug and NOT moderation — a
-        // Google-side flake. Surface as a transient PROVIDER_UNAVAILABLE so the
-        // user gets a "try again" message and it logs warn (Loki) instead of
-        // paging Slack as a platform error. (Egregiously-blocked content that Veo
-        // masks as code 13 also lands here; we can't distinguish it from a real
-        // internal flake, and "try again" is an acceptable fallback message.)
-        if (httpCode === 13 ||
-            status === "INTERNAL" ||
-            /internal (server|error)/i.test(msg)) {
-            return new errors_1.UserFacingError("Google's video service had a temporary problem. Please try again in a few minutes.", errors_1.USER_FACING_ERROR_CODES.PROVIDER_UNAVAILABLE);
-        }
-    }
-    catch {
-        // Not JSON — fall through to non-JSON checks.
-    }
-    if (/timeout/i.test(raw) || err?.code === "ECONNABORTED") {
-        return new errors_1.UserFacingError(raw, errors_1.USER_FACING_ERROR_CODES.VIDEO_PROVIDER_TIMEOUT);
-    }
-    return null;
-}
 class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService {
     constructor() {
         super();
         this.ai = new genai_1.GoogleGenAI({ apiKey: process.env.GOOGLE_API_KEY });
+        this.keyPool = (0, googleKeyPool_1.getGoogleKeyPool)();
+    }
+    /**
+     * Plain text generation via Gemini (`@google/genai` generateContent) for the
+     * aiGen text factory (LLM_NATIVE_MIGRATION_PLAN Phase 6). Accepts the same
+     * `input` shape as OpenaiService.generateText — a bare prompt string or an
+     * OpenAI-style message array (role + string content). System messages fold
+     * into Gemini's `systemInstruction`; assistant turns map to the "model" role.
+     * `options.responseFormat` of type json_object/json_schema flips on Gemini's
+     * native JSON mode (responseMimeType) so callers asking OpenAI for JSON get
+     * the same contract here.
+     */
+    async generateText(params) {
+        const { input, modelKey, options } = params;
+        const model = aiModels_1.aiModelConfigs[modelKey];
+        const modelId = model?.modelId || "gemini-2.5-flash";
+        const { systemInstruction, contents } = this.encodeTextInput(input);
+        const wantsJson = options?.responseFormat?.type === "json_object" ||
+            options?.responseFormat?.type === "json_schema";
+        const temperature = model?.fields?.temperature?.default
+            ? options?.temperature ?? model.fields.temperature.default
+            : undefined;
+        const maxOutputTokens = model?.fields?.maxOutputTokens?.default
+            ? options?.maxOutputTokens ?? model.fields.maxOutputTokens.default
+            : undefined;
+        const resp = await this.withTransientRetry("generateText", () => this.ai.models.generateContent({
+            model: modelId,
+            contents,
+            config: {
+                ...(systemInstruction ? { systemInstruction } : {}),
+                ...(typeof temperature === "number" ? { temperature } : {}),
+                ...(typeof maxOutputTokens === "number" ? { maxOutputTokens } : {}),
+                ...(wantsJson ? { responseMimeType: "application/json" } : {}),
+            },
+        }));
+        const text = resp.text?.trim() || "No response";
+        return { text };
+    }
+    /**
+     * Map an OpenAI-style `input` (string | {role, content}[]) onto Gemini's
+     * shape: merged systemInstruction + Content[] (assistant→"model"). Array
+     * `content` (vision parts) is flattened to its text segments — the text
+     * factory is text-only; image inputs go through the agent GeminiLlmCaller.
+     */
+    encodeTextInput(input) {
+        if (typeof input === "string") {
+            return { contents: [{ role: "user", parts: [{ text: input }] }] };
+        }
+        const messages = Array.isArray(input)
+            ? input
+            : [];
+        let systemInstruction;
+        const contents = [];
+        for (const m of messages) {
+            const text = typeof m.content === "string"
+                ? m.content
+                : Array.isArray(m.content)
+                    ? m.content
+                        .map((p) => p?.text ?? "")
+                        .join("")
+                    : String(m.content ?? "");
+            if (m.role === "system") {
+                systemInstruction = systemInstruction
+                    ? `${systemInstruction}\n\n${text}`
+                    : text;
+                continue;
+            }
+            const role = m.role === "assistant" ? "model" : "user";
+            contents.push({ role, parts: [{ text }] });
+        }
+        return { systemInstruction, contents };
     }
     /**
      * Retries `fn` on transient network errors (undici "fetch failed", ECONNRESET, ETIMEDOUT,
@@ -205,12 +116,12 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
             }
             catch (err) {
                 lastErr = err;
-                const transient = isTransientFetchError(err);
+                const transient = (0, googleFetch_1.isTransientFetchError)(err);
                 if (!transient || attempt === GoogleService.MAX_RETRY_ATTEMPTS) {
                     // Convert known provider errors (quota, high-demand, timeout) into a
                     // typed UserFacingError so the scene processor stores a translatable
                     // code instead of the raw provider JSON.
-                    const userFacing = classifyGoogleApiError(err);
+                    const userFacing = (0, googleErrors_1.classifyGoogleApiError)(err);
                     if (userFacing)
                         throw userFacing;
                     throw err;
@@ -256,9 +167,35 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
                 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 } : {}),
+                // REMOVED for the Gemini Developer API backend — kept for reference.
+                // `seed` is NOT supported by Veo on the Gemini API (Mldev): this client
+                // is `new GoogleGenAI({ apiKey })`, whose SDK transformer
+                // (generateVideosConfigToMldev) throws *client-side*
+                // "seed parameter is not supported in Gemini API" before any request is
+                // sent — so it can never reach Google and was failing every job that
+                // carried a seed. Like `generateAudio`, it is a Vertex-AI-only field.
+                // Restore this line if/when this client switches to Vertex (vertexai:true).
+                // ...(params.seed !== undefined ? { seed: params.seed } : {}),
+                // personGeneration on the Gemini API Veo backend: "allow_all" is the
+                // ONLY supported value for Veo 3.x (and it is also the default).
+                // "allow_adult" and "dont_allow" are Veo-2-only legacy values — sending
+                // either returns 400 "<value> for personGeneration is currently not
+                // supported", which is NOT matched by classifyGoogleApiError and so
+                // leaks to logger.error → Slack while failing the job. Since allow_all
+                // is the default, forward the param only when it's explicitly allow_all
+                // (a no-op that documents intent); drop any other requested value
+                // rather than hard-fail. Restoring allow_adult/dont_allow would require
+                // a Veo-2 model or an allowlisted Vertex project.
+                ...(params.personGeneration === "allow_all"
+                    ? { personGeneration: "allow_all" }
+                    : {}),
+                // negativePrompt support is MODEL-SPECIFIC on the Gemini API: veo-3.1 and
+                // veo-3.1-fast accept it, veo-3.1-lite returns 400 "negativePrompt isn't
+                // supported by this model". Gate on the model config declaring the field
+                // (negative_prompt) so we never forward it to a model that rejects it.
+                ...(params.negativePrompt && (0, helpers_2.modelDeclaresField)(params.modelKey, "negative_prompt")
+                    ? { negativePrompt: params.negativePrompt }
+                    : {}),
                 // REMOVED for the Gemini Developer API backend — kept for reference.
                 // `generateAudio` is a Vertex-AI-only config field. This client is
                 // constructed with `new GoogleGenAI({ apiKey })` (the Mldev / Gemini
@@ -278,11 +215,11 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
             request.video = { uri: params.inputVideoUrl };
         }
         else if (params.inputImageUrl) {
-            request.image = await this.withTransientRetry("input-image fetch", () => fetchAsImage(params.inputImageUrl));
+            request.image = await this.withTransientRetry("input-image fetch", () => (0, googleFetch_1.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));
+            request.config.lastFrame = await this.withTransientRetry("last-frame fetch", () => (0, googleFetch_1.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.
@@ -292,23 +229,36 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
             }
             else {
                 const refs = params.referenceImageUrls.slice(0, 3);
-                const fetched = await Promise.all(refs.map((url) => this.withTransientRetry("reference-image fetch", () => fetchAsImage(url))));
+                const fetched = await Promise.all(refs.map((url) => this.withTransientRetry("reference-image fetch", () => (0, googleFetch_1.fetchAsImage)(url))));
                 request.config.referenceImages = fetched.map((image) => ({
                     image,
                     referenceType: genai_1.VideoGenerationReferenceType.ASSET,
                 }));
             }
         }
-        const operation = await this.withTransientRetry("generateVideos", () => this.ai.models.generateVideos(request));
+        // Route this submit to a key with budget (priority order). The per-key
+        // caps are the single-key Tier-2 numbers in the model config; the
+        // model-level limiter already gated the aggregate (per-key × key count).
+        const keyEntry = await this.keyPool.pickForSubmit(modelId, modelConfig.requestPerMin ?? 0, modelConfig.requestPerDay ?? 0);
+        const operation = await this.withTransientRetry("generateVideos", () => keyEntry.client.models.generateVideos(request));
         if (!operation || !operation.name) {
             throw new Error("Failed to initiate video generation task");
         }
-        return { task: operation.name, status: types_1.EVideoSceneStatus.TRIGGERED };
+        // Tag the task with the issuing key so poll + download re-select the same
+        // (project-scoped) client. Single-key pool → bare name (legacy format).
+        return {
+            task: (0, googleApiKeys_1.encodeVeoTask)(keyEntry.id, operation.name, this.keyPool.size),
+            status: types_1.EVideoSceneStatus.TRIGGERED,
+        };
     }
     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;
         const operation = new genai_1.GenerateVideosOperation();
-        operation.name = task;
-        const result = await this.withTransientRetry("getVideosOperation", () => this.ai.operations.getVideosOperation({ operation }));
+        operation.name = operationName;
+        const result = await this.withTransientRetry("getVideosOperation", () => client.operations.getVideosOperation({ operation }));
         if (result.done) {
             if (result.error) {
                 // A long-running operation can finish with an error (e.g. gRPC 13
@@ -316,7 +266,7 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
                 // as thrown API errors so transient INTERNAL and invalid-prompt
                 // failures get a typed `{code, message}` (which sceneMonitor demotes to
                 // warn) instead of leaking raw gRPC JSON that pages Slack as a bug.
-                const classified = classifyGoogleApiError({
+                const classified = (0, googleErrors_1.classifyGoogleApiError)({
                     message: JSON.stringify(result.error),
                 });
                 return {
@@ -396,7 +346,7 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
             // Responsible AI practices") become UserFacingError(CONTENT_POLICY_VIOLATION)
             // instead of leaking as raw provider JSON into the worker's Slack
             // error channel.
-            const userFacing = classifyGoogleApiError(err);
+            const userFacing = (0, googleErrors_1.classifyGoogleApiError)(err);
             if (userFacing)
                 throw userFacing;
             throw err;
@@ -455,7 +405,7 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
                 ...(params.inputImageUrls ?? []),
             ];
             for (const url of refs) {
-                const ref = await fetchAsImage(url);
+                const ref = await (0, googleFetch_1.fetchAsImage)(url);
                 parts.push({ inlineData: { mimeType: ref.mimeType, data: ref.imageBytes } });
             }
             const resp = await this.ai.models.generateContent({
@@ -506,64 +456,13 @@ class GoogleService extends baseAiGenProvider_service_1.BaseAiGenProviderService
      *
      * Required env: GCP_PROJECT_ID. Optional: GCP_LOCATION (default us-central1).
      */
+    /**
+     * Lyria 2 (Vertex AI) — delegates to the standalone generateGoogleMusic
+     * (Vertex predict endpoint via ADC, not the GoogleGenAI client). See
+     * ./googleMusic.
+     */
     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",
-        };
+        return (0, googleMusic_1.generateGoogleMusic)(params);
     }
     getCreditUsed({ modelKey, duration = 8, resolution = "720p", multiClip = false, numImages = 1, imageSize }) {
         const modelConfig = aiModels_1.aiModelConfigs[modelKey];

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

@@ -0,0 +1,71 @@
+/**
+ * Pure (SDK-free, Redis-free) helpers for the Google AI Studio API key pool.
+ *
+ * ── DECISION RECORD (2026-06-15) ────────────────────────────────────────────
+ * Problem: Veo on a single Gemini Developer API key is quota-starved — Tier 2
+ * is ~4 req/min and ~50/day per Veo model — which serialized bursts of jobs
+ * into a multi-hour queue (~370 min observed avg latency).
+ *
+ * Chosen fix (today): a multi-key pool over TWO Google AI Studio keys that live
+ * in SEPARATE GCP projects / billing accounts, so their quotas are independent
+ * and ADD UP. Keys are used in PRIORITY order:
+ *   - key[0] = the NEW key (vidspotai project), currently **Tier 1** (2/min,
+ *     10/day per Veo model). Used FIRST, deliberately, to drive usage and
+ *     promote its billing account up the tier ladder.
+ *   - key[1] = the CURRENT key, **Tier 2** (4/min, 50/day). Used once key[0]
+ *     is out of per-minute / per-day budget.
+ * Aggregate Veo budget = T1 + T2 = 6/min, 60/day. When BOTH are exhausted, the
+ * job-start capacity selector (videoJobProcessor) spills to another provider.
+ *
+ * When key[1]'s account is billed it moves to Tier 3; bump its tier in
+ * GOOGLE_API_KEY_TIERS then (no code change — the ladder below handles it).
+ *
+ * Vertex AI (DEFERRED, on record for the future): Veo is also available via
+ * Vertex, where quota is **per-project** and the current billing account is
+ * Tier-2-per-project — so we could create multiple projects under one account
+ * to scale further. We are NOT doing Vertex now: the two AI-Studio keys across
+ * two billing accounts already cover our needed headroom, and the Vertex path
+ * needs a different output flow (GCS `gs://` URIs rather than the Files API)
+ * that we'd rather build + test deliberately when the extra capacity is needed.
+ *
+ * ── CONFIG ──────────────────────────────────────────────────────────────────
+ *   GOOGLE_API_KEYS       — comma-separated keys in PRIORITY order. Falls back
+ *                           to the single legacy GOOGLE_API_KEY when unset.
+ *   GOOGLE_API_KEY_TIERS  — comma-separated tier numbers (1/2/3) aligned to
+ *                           GOOGLE_API_KEYS. Missing/extra entries default to 2.
+ *   GOOGLE_API_KEY        — legacy single key; also the client used to poll
+ *                           tasks submitted before the pool existed (un-tagged).
+ *
+ * Per-key budget is derived from the model config's Tier-2 baseline
+ * (requestPerMin / requestPerDay) scaled by each key's tier (see TIER_FACTORS);
+ * the pool gives us the SUM across keys.
+ */
+/** Parse the configured keys in priority order, de-duped, empties removed. */
+export declare function parseGoogleApiKeys(): string[];
+/** Tier per key (aligned to parseGoogleApiKeys order); defaults to 2. */
+export declare function parseGoogleApiKeyTiers(): number[];
+/** Number of configured Google keys (>= 1 so callers can multiply safely). */
+export declare function googleApiKeyCount(): number;
+/** Per-key rate cap for a given Tier-2 baseline and tier. */
+export declare function scaleLimitForTier(baseline: number | undefined, tier: number, kind: "rpm" | "rpd"): number;
+/**
+ * Aggregate multiplier across all configured keys, for scaling a Google
+ * model's Tier-2 baseline into the pool-wide budget. Returns 1 for a single
+ * default key (legacy behavior unchanged).
+ */
+export declare function googleAggregateFactor(kind: "rpm" | "rpd"): number;
+/** Stable id for the key at a given priority index. */
+export declare function googleKeyId(index: number): string;
+/**
+ * Tag a Veo operation name with the id of the key that created it, so polling
+ * + download can re-select the same project-scoped client. With a single key
+ * we return the bare operation name (no tag) — byte-for-byte the legacy format,
+ * so nothing changes until a real pool is configured.
+ */
+export declare function encodeVeoTask(keyId: string, operationName: string, poolSize: number): string;
+/** Reverse of encodeVeoTask. `keyId` is undefined for legacy/un-tagged tasks. */
+export declare function decodeVeoTask(task: string): {
+    keyId?: string;
+    operationName: string;
+};
+//# sourceMappingURL=googleApiKeys.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"googleApiKeys.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/google/googleApiKeys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAoBH,8EAA8E;AAC9E,wBAAgB,kBAAkB,IAAI,MAAM,EAAE,CAa7C;AAED,yEAAyE;AACzE,wBAAgB,sBAAsB,IAAI,MAAM,EAAE,CAUjD;AAED,8EAA8E;AAC9E,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED,6DAA6D;AAC7D,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,KAAK,GAAG,KAAK,GAClB,MAAM,CAGR;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAIjE;AAED,uDAAuD;AACvD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEjD;AAID;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE5F;AAED,iFAAiF;AACjF,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAIrF"}