vidspotai-shared 1.0.82-dev.0 → 1.0.83

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

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGoogleApiKeys = parseGoogleApiKeys;
+exports.parseGoogleApiKeyTiers = parseGoogleApiKeyTiers;
+exports.googleApiKeyCount = googleApiKeyCount;
+exports.scaleLimitForTier = scaleLimitForTier;
+exports.googleAggregateFactor = googleAggregateFactor;
+exports.googleKeyId = googleKeyId;
+exports.encodeVeoTask = encodeVeoTask;
+exports.decodeVeoTask = decodeVeoTask;
+/**
+ * Per-Veo-model rate ladder, expressed as a factor of the Tier-2 baseline that
+ * the model configs encode. Verified against Google's Veo quota
+ * (predict_long_running_requests_per_model): RPM 2/4/10 and RPD 10/50/500 for
+ * Tier 1/2/3. Only Veo configures per-key min/day caps today, so these factors
+ * only materially affect Veo; models with no caps (factor × 0 = 0) are
+ * unaffected.
+ */
+const TIER_FACTORS = {
+    1: { rpm: 2 / 4, rpd: 10 / 50 }, // 0.5×, 0.2×
+    2: { rpm: 1, rpd: 1 },
+    3: { rpm: 10 / 4, rpd: 500 / 50 }, // 2.5×, 10×
+};
+function tierFactor(tier) {
+    return TIER_FACTORS[tier] ?? TIER_FACTORS[2];
+}
+/** Parse the configured keys in priority order, de-duped, empties removed. */
+function parseGoogleApiKeys() {
+    const multi = (process.env.GOOGLE_API_KEYS ?? "").trim();
+    const raw = multi || (process.env.GOOGLE_API_KEY ?? "").trim();
+    const seen = new Set();
+    const keys = [];
+    for (const part of raw.split(",")) {
+        const k = part.trim();
+        if (k && !seen.has(k)) {
+            seen.add(k);
+            keys.push(k);
+        }
+    }
+    return keys;
+}
+/** Tier per key (aligned to parseGoogleApiKeys order); defaults to 2. */
+function parseGoogleApiKeyTiers() {
+    const keys = parseGoogleApiKeys();
+    const raw = (process.env.GOOGLE_API_KEY_TIERS ?? "").trim();
+    const parsed = raw
+        ? raw.split(",").map((s) => Number(s.trim()))
+        : [];
+    return keys.map((_, i) => {
+        const t = parsed[i];
+        return t === 1 || t === 2 || t === 3 ? t : 2;
+    });
+}
+/** Number of configured Google keys (>= 1 so callers can multiply safely). */
+function googleApiKeyCount() {
+    return Math.max(1, parseGoogleApiKeys().length);
+}
+/** Per-key rate cap for a given Tier-2 baseline and tier. */
+function scaleLimitForTier(baseline, tier, kind) {
+    if (!baseline)
+        return 0;
+    return Math.max(1, Math.round(baseline * tierFactor(tier)[kind]));
+}
+/**
+ * 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).
+ */
+function googleAggregateFactor(kind) {
+    const tiers = parseGoogleApiKeyTiers();
+    if (tiers.length <= 1)
+        return 1; // legacy single key → baseline unchanged
+    return tiers.reduce((sum, t) => sum + tierFactor(t)[kind], 0);
+}
+/** Stable id for the key at a given priority index. */
+function googleKeyId(index) {
+    return `k${index}`;
+}
+const TASK_TAG_RE = /^gk:([a-z0-9]+)::([\s\S]+)$/;
+/**
+ * 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.
+ */
+function encodeVeoTask(keyId, operationName, poolSize) {
+    return poolSize > 1 ? `gk:${keyId}::${operationName}` : operationName;
+}
+/** Reverse of encodeVeoTask. `keyId` is undefined for legacy/un-tagged tasks. */
+function decodeVeoTask(task) {
+    const m = TASK_TAG_RE.exec(task);
+    if (m)
+        return { keyId: m[1], operationName: m[2] };
+    return { operationName: task };
+}

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

@@ -0,0 +1,13 @@
+import { UserFacingError } from "../../../../utils/errors";
+/**
+ * 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).
+ *
+ * Used both for thrown SDK errors (generateText/Image/Video) and for
+ * long-running-operation `result.error` payloads (checkVideoStatus), so a
+ * gRPC-13 INTERNAL flake or a RAI/prompt rejection becomes a typed, log-warn
+ * error instead of raw provider JSON that pages Slack as a platform bug.
+ */
+export declare function classifyGoogleApiError(err: any): UserFacingError | null;
+//# sourceMappingURL=googleErrors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"googleErrors.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/google/googleErrors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAA2B,MAAM,0BAA0B,CAAC;AAEpF;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,GAAG,GAAG,eAAe,GAAG,IAAI,CAmHvE"}

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyGoogleApiError = classifyGoogleApiError;
+const errors_1 = require("../../../../utils/errors");
+/**
+ * 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).
+ *
+ * Used both for thrown SDK errors (generateText/Image/Video) and for
+ * long-running-operation `result.error` payloads (checkVideoStatus), so a
+ * gRPC-13 INTERNAL flake or a RAI/prompt rejection becomes a typed, log-warn
+ * error instead of raw provider JSON that pages Slack as a platform bug.
+ */
+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);
+        }
+        // HTTP 503 / status UNAVAILABLE — Google's video backend is temporarily
+        // overloaded or down ("The service is currently unavailable."). Same class
+        // as code 13 INTERNAL above: a transient provider outage, not our bug and
+        // not moderation. Without this branch it fell through to `return null` and
+        // got re-thrown as a raw ApiError → logged at `error` (paging Slack) with
+        // the raw provider JSON as the scene's errorMessage. Surface it as
+        // PROVIDER_UNAVAILABLE so the user gets a "try again" message and it logs
+        // warn (Loki) instead.
+        if (httpCode === 503 ||
+            status === "UNAVAILABLE" ||
+            /service is currently unavailable|temporarily unavailable/i.test(msg)) {
+            return new errors_1.UserFacingError("Google's video service is temporarily unavailable. 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;
+}

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

@@ -0,0 +1,8 @@
+export declare function pickImageMimeType(contentType: string, url: string): string;
+export declare function isTransientFetchError(err: any): boolean;
+export declare function inferImageMime(url: string): string;
+export declare function fetchAsImage(url: string): Promise<{
+    mimeType: string;
+    imageBytes: string;
+}>;
+//# sourceMappingURL=googleFetch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"googleFetch.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/google/googleFetch.ts"],"names":[],"mappings":"AAkCA,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAiB1E;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAOvD;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKlD;AAED,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAyBjG"}

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickImageMimeType = pickImageMimeType;
+exports.isTransientFetchError = isTransientFetchError;
+exports.inferImageMime = inferImageMime;
+exports.fetchAsImage = fetchAsImage;
+const errors_1 = require("../../../../utils/errors");
+/**
+ * Network + image helpers for the Google provider: transient-error detection
+ * (for withTransientRetry) and downloading an input image as Veo-compatible
+ * base64 with a correct MIME type. Pure / I/O helpers, no class state.
+ */
+// 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);
+}
+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"),
+    };
+}

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

@@ -0,0 +1,52 @@
+import { GoogleGenAI } from "@google/genai";
+import { googleApiKeyCount } from "./googleApiKeys";
+/**
+ * Google AI Studio multi-key pool.
+ *
+ * Each configured key is a separate GCP project / billing account with its own
+ * Tier-2 quota, so N keys give us N× the per-model daily + per-minute budget.
+ * The model-level rate limiter (DistributedRateLimiter) enforces the AGGREGATE
+ * (per-key config × key count — see getAiGenModelRateLimiter); this pool decides
+ * WHICH key serves each individual submit, in priority order, so we drain the
+ * first key's budget before leaning on the next.
+ *
+ * Veo operations are project-scoped — a task submitted with key K can only be
+ * polled / downloaded with key K — so submit tags the task with its key id
+ * (encodeVeoTask) and the poll path re-selects the client via clientById().
+ *
+ * Single-key / unconfigured pool: behaves exactly like the legacy single
+ * `GoogleGenAI({ apiKey })` client (no tagging, no Redis routing).
+ */
+interface KeyEntry {
+    id: string;
+    apiKey: string;
+    client: GoogleGenAI;
+    /** Gemini API tier (1/2/3) of this key's billing account. */
+    tier: number;
+}
+declare class GoogleKeyPool {
+    private readonly entries;
+    constructor();
+    get size(): number;
+    /** The highest-priority key's client (index 0). */
+    get primaryClient(): GoogleGenAI;
+    /** Resolve a tagged task's key id back to its client (undefined if unknown). */
+    clientById(id: string | undefined): GoogleGenAI | undefined;
+    /**
+     * 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
+     * headroom, consuming a slot on it. The caps are the model's Tier-2 baseline
+     * (baselineMin / baselineDay) scaled to each key's own tier — so a Tier-1
+     * key gets a smaller share than a Tier-2 one. Falls back to the primary key
+     * if Redis is down or all are at cap (the aggregate model-level gate should
+     * have prevented the latter).
+     */
+    pickForSubmit(modelId: string, baselineMin: number, baselineDay: number): Promise<KeyEntry>;
+    /** Best-effort increment of a key's per-day + per-minute routing counters. */
+    private consume;
+}
+/** Lazily-built process-wide pool. */
+export declare function getGoogleKeyPool(): GoogleKeyPool;
+export { googleApiKeyCount };
+export type { GoogleKeyPool };
+//# sourceMappingURL=googleKeyPool.d.ts.map

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

@@ -0,0 +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;AAcD,cAAM,aAAa;IACjB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAa;;IA4BrC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,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,GAClB,OAAO,CAAC,QAAQ,CAAC;IA2CpB,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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.googleApiKeyCount = void 0;
+exports.getGoogleKeyPool = getGoogleKeyPool;
+const genai_1 = require("@google/genai");
+const logger_1 = require("../../../../utils/logger");
+const redis_service_1 = require("../../../redis.service");
+const googleApiKeys_1 = require("./googleApiKeys");
+Object.defineProperty(exports, "googleApiKeyCount", { enumerable: true, get: function () { return googleApiKeys_1.googleApiKeyCount; } });
+function utcDateKey() {
+    return new Date().toISOString().slice(0, 10);
+}
+function secsUntilMidnight() {
+    const now = new Date();
+    const midnight = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1));
+    return Math.ceil((midnight.getTime() - now.getTime()) / 1000);
+}
+class GoogleKeyPool {
+    constructor() {
+        const keys = (0, googleApiKeys_1.parseGoogleApiKeys)();
+        const tiers = (0, googleApiKeys_1.parseGoogleApiKeyTiers)();
+        this.entries = keys.map((apiKey, i) => ({
+            id: (0, googleApiKeys_1.googleKeyId)(i),
+            apiKey,
+            client: new genai_1.GoogleGenAI({ apiKey }),
+            tier: tiers[i] ?? 2,
+        }));
+        if (!this.entries.length) {
+            // Mirror the legacy constructor: a bang-asserted GOOGLE_API_KEY. Building
+            // a client with undefined defers the failure to first call, same as before.
+            this.entries.push({
+                id: (0, googleApiKeys_1.googleKeyId)(0),
+                apiKey: process.env.GOOGLE_API_KEY ?? "",
+                client: new genai_1.GoogleGenAI({ apiKey: process.env.GOOGLE_API_KEY }),
+                tier: 2,
+            });
+        }
+        if (this.entries.length > 1) {
+            logger_1.logger.info("googleKeyPool: multi-key pool active", {
+                keys: this.entries.map((e) => ({ id: e.id, tier: e.tier })),
+            });
+        }
+    }
+    get size() {
+        return this.entries.length;
+    }
+    /** The highest-priority key's client (index 0). */
+    get primaryClient() {
+        return this.entries[0].client;
+    }
+    /** Resolve a tagged task's key id back to its client (undefined if unknown). */
+    clientById(id) {
+        if (!id)
+            return undefined;
+        return this.entries.find((e) => e.id === id)?.client;
+    }
+    /**
+     * 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
+     * headroom, consuming a slot on it. The caps are the model's Tier-2 baseline
+     * (baselineMin / baselineDay) scaled to each key's own tier — so a Tier-1
+     * key gets a smaller share than a Tier-2 one. Falls back to the primary key
+     * if Redis is down or all are at cap (the aggregate model-level gate should
+     * have prevented the latter).
+     */
+    async pickForSubmit(modelId, baselineMin, baselineDay) {
+        if (this.entries.length === 1)
+            return this.entries[0];
+        const client = redis_service_1.redis.getClient();
+        if (!client)
+            return this.entries[0];
+        const date = utcDateKey();
+        for (const entry of this.entries) {
+            try {
+                const perKeyMinLimit = (0, googleApiKeys_1.scaleLimitForTier)(baselineMin, entry.tier, "rpm");
+                const perKeyDayLimit = (0, googleApiKeys_1.scaleLimitForTier)(baselineDay, entry.tier, "rpd");
+                const dayKey = `gkpool:${entry.id}:${modelId}:day:${date}`;
+                const minKey = `gkpool:${entry.id}:${modelId}:min`;
+                const [dayRaw, minRaw] = await Promise.all([
+                    client.get(dayKey),
+                    client.get(minKey),
+                ]);
+                const dayUsed = dayRaw ? Number(dayRaw) : 0;
+                const minUsed = minRaw ? Number(minRaw) : 0;
+                const dayOk = perKeyDayLimit <= 0 || dayUsed < perKeyDayLimit;
+                const minOk = perKeyMinLimit <= 0 || minUsed < perKeyMinLimit;
+                if (dayOk && minOk) {
+                    await this.consume(entry, modelId, date);
+                    return entry;
+                }
+            }
+            catch (err) {
+                logger_1.logger.warn("googleKeyPool: routing read failed, trying next key", {
+                    keyId: entry.id,
+                    err: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        // All at cap / errored — use the primary and let Google's own 429 + the
+        // provider-fallback chain handle it.
+        logger_1.logger.warn("googleKeyPool: no key with headroom — using primary", {
+            modelId,
+            poolSize: this.entries.length,
+        });
+        await this.consume(this.entries[0], modelId, date).catch(() => undefined);
+        return this.entries[0];
+    }
+    /** Best-effort increment of a key's per-day + per-minute routing counters. */
+    async consume(entry, modelId, date) {
+        const client = redis_service_1.redis.getClient();
+        if (!client)
+            return;
+        const dayKey = `gkpool:${entry.id}:${modelId}:day:${date}`;
+        const minKey = `gkpool:${entry.id}:${modelId}:min`;
+        const newDay = await client.incr(dayKey);
+        if (newDay === 1)
+            await client.expire(dayKey, secsUntilMidnight());
+        const newMin = await client.incr(minKey);
+        if (newMin === 1)
+            await client.expire(minKey, 60);
+    }
+}
+let pool = null;
+/** Lazily-built process-wide pool. */
+function getGoogleKeyPool() {
+    if (!pool)
+        pool = new GoogleKeyPool();
+    return pool;
+}

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

@@ -0,0 +1,15 @@
+import { MusicGenerationParams, MusicGenerationResult } from "../types";
+/**
+ * Lyria 2 (Vertex AI) music generation. Standalone — does NOT use the
+ * GoogleGenAI (Gemini Developer API) client; it auths via ADC and hits the
+ * Vertex predict endpoint directly. Extracted from GoogleService so the class
+ * stays focused on the Gemini-SDK paths.
+ *
+ * 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).
+ */
+export declare function generateGoogleMusic(params: MusicGenerationParams): Promise<MusicGenerationResult>;
+//# sourceMappingURL=googleMusic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"googleMusic.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/google/googleMusic.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAExE;;;;;;;;;;;GAWG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC,CAmEhC"}

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGoogleMusic = generateGoogleMusic;
+const google_auth_library_1 = require("google-auth-library");
+const aiModels_1 = require("../../../../globals/aiModels");
+const firebase_1 = require("../../../../libs/firebase");
+/**
+ * Lyria 2 (Vertex AI) music generation. Standalone — does NOT use the
+ * GoogleGenAI (Gemini Developer API) client; it auths via ADC and hits the
+ * Vertex predict endpoint directly. Extracted from GoogleService so the class
+ * stays focused on the Gemini-SDK paths.
+ *
+ * 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 function generateGoogleMusic(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",
+    };
+}