vidspotai-shared 1.0.116 → 1.0.117

package/lib/services/translation/translation.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"translation.service.d.ts","sourceRoot":"","sources":["../../../src/services/translation/translation.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGlE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,eAAO,MAAM,kBAAkB,uBAAuB,CAAC;AAqGvD;;;;GAIG;AACH,iBAAe,SAAS,CACtB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,cAAc,EACpB,EAAE,GAAE,cAAkC,EACtC,OAAO,GAAE,IAAI,GAAG,IAAW,GAC1B,OAAO,CAAC,MAAM,CAAC,CAsCjB;AAiDD;;;;;;;;;;;;;;GAcG;AACH,iBAAe,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CA8ChE;AAOD,eAAO,MAAM,kBAAkB;;;CAG9B,CAAC;AAGF,qDAAqD;AACrD,eAAO,MAAM,qBAAqB,kBAAY,CAAC;AAC/C,0DAA0D;AAC1D,eAAO,MAAM,UAAU,uBAAiB,CAAC"}
+{"version":3,"file":"translation.service.d.ts","sourceRoot":"","sources":["../../../src/services/translation/translation.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGlE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,eAAO,MAAM,kBAAkB,uBAAuB,CAAC;AAwIvD;;;;GAIG;AACH,iBAAe,SAAS,CACtB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,cAAc,EACpB,EAAE,GAAE,cAAkC,EACtC,OAAO,GAAE,IAAI,GAAG,IAAW,GAC1B,OAAO,CAAC,MAAM,CAAC,CAsCjB;AAuDD;;;;;;;;;;;;;;GAcG;AACH,iBAAe,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CA8ChE;AAOD,eAAO,MAAM,kBAAkB;;;CAG9B,CAAC;AAGF,qDAAqD;AACrD,eAAO,MAAM,qBAAqB,kBAAY,CAAC;AAC/C,0DAA0D;AAC1D,eAAO,MAAM,UAAU,uBAAiB,CAAC"}

package/lib/services/translation/translation.service.js

@@ -78,9 +78,18 @@ const PRIMARY_MAX_ATTEMPTS = 2;
 // two layers compounded into an unbounded stall — a Vietnamese request was
 // measured at 48s in prod (2026-07-26): ~12s burning both primary attempts,
 // then ~36s waiting on a slow generateText that nothing was bounding. Cap the
-// fallback so the worst case is primary (~12.2s) + fallback (15s) ≈ 27s and the
-// caller gets a definite answer instead of holding the request open.
-const FALLBACK_TIMEOUT_MS = 15000;
+// fallback so the worst case is primary (~12.2s) + fallback (~16s) ≈ 28s and
+// the caller gets a definite answer instead of holding the request open.
+//
+// 2026-09-22: a single un-retried 15s shot then ALSO started losing — both
+// primary AND fallback failed in prod for `id`→`en` (Slack: "translation
+// failed on BOTH primary and LLM fallback"), at ~27.2s total, matching this
+// budget almost exactly. One bad connection with zero recovery chance was
+// enough to take the whole fallback down. Split the same total budget into
+// two shorter attempts so a transient hiccup (dropped connection, slow TLS
+// handshake) gets a second, fresh try instead of being fatal.
+const FALLBACK_ATTEMPT_TIMEOUT_MS = 8000;
+const FALLBACK_MAX_ATTEMPTS = 2;
 // gpt-4o-mini: cheap (~$0.15/1M in, $0.60/1M out → fractions of a cent per
 // prompt), reliable, and independent of the Google video quota. Swap here if a
 // cheaper effective model becomes available.
@@ -104,12 +113,27 @@ async function callPrimaryTranslate(text, from, to, version) {
     }
     return translated;
 }
-/**
- * FALLBACK: translate via a cheap LLM. Lazy-imports the provider factory so this
- * module stays light (utils/helpers re-exports it) and to avoid an import cycle
- * with the aiGen layer.
- */
-async function callLlmTranslate(text, from, to) {
+/** Races `promise` against a timeout; the loser is abandoned (no AbortSignal
+ * on this path), but the caller is unblocked — which is the point. */
+async function withTimeout(promise, ms, label) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+/** One un-retried LLM translate attempt. Lazy-imports the provider factory so
+ * this module stays light (utils/helpers re-exports it) and to avoid an
+ * import cycle with the aiGen layer. */
+async function callLlmTranslateOnce(text, from, to) {
     const { getAiGenProviderService } = await Promise.resolve().then(() => __importStar(require("../aiGen/aiGenFactory.service")));
     const service = getAiGenProviderService(FALLBACK_MODEL);
     const target = languageLabel(to);
@@ -117,25 +141,13 @@ async function callLlmTranslate(text, from, to) {
         `Preserve meaning, tone, names, numbers, hashtags, emojis and line breaks. ` +
         `Output ONLY the translated text — no quotes, no language labels, no commentary. ` +
         `If the text is already in ${target}, return it unchanged.`;
-    // Bounded: generateText itself takes no timeout, so race it. The loser is
-    // abandoned rather than cancelled (there is no AbortSignal on this path), but
-    // the caller is unblocked — which is the point.
-    let timer;
-    const { text: out } = await Promise.race([
-        service.generateText({
-            input: [
-                { role: "system", content: system },
-                { role: "user", content: text },
-            ],
-            modelKey: FALLBACK_MODEL,
-            options: { temperature: 0 },
-        }),
-        new Promise((_, reject) => {
-            timer = setTimeout(() => reject(new Error(`LLM fallback timed out after ${FALLBACK_TIMEOUT_MS}ms`)), FALLBACK_TIMEOUT_MS);
-        }),
-    ]).finally(() => {
-        if (timer)
-            clearTimeout(timer);
+    const { text: out } = await service.generateText({
+        input: [
+            { role: "system", content: system },
+            { role: "user", content: text },
+        ],
+        modelKey: FALLBACK_MODEL,
+        options: { temperature: 0 },
     });
     const trimmed = (out ?? "").trim();
     if (!trimmed || trimmed === "No response") {
@@ -143,6 +155,20 @@ async function callLlmTranslate(text, from, to) {
     }
     return trimmed;
 }
+/** FALLBACK: translate via a cheap LLM, with a real retry — see the
+ * FALLBACK_ATTEMPT_TIMEOUT_MS comment above for why one shot wasn't enough. */
+async function callLlmTranslate(text, from, to) {
+    let lastErr;
+    for (let attempt = 1; attempt <= FALLBACK_MAX_ATTEMPTS; attempt++) {
+        try {
+            return await withTimeout(callLlmTranslateOnce(text, from, to), FALLBACK_ATTEMPT_TIMEOUT_MS, "LLM fallback");
+        }
+        catch (err) {
+            lastErr = err;
+        }
+    }
+    throw lastErr;
+}
 /**
  * Translate `text` from → to (default English). Primary CF first (with a couple
  * of quick retries), then a cheap LLM. Throws Error(TRANSLATION_FAILED) only if
@@ -188,40 +214,23 @@ async function translate(text, from, to = types_1.ELANGUAGE_CODE.en, version = "
         throw e;
     }
 }
-/**
- * FALLBACK: detect via the same cheap LLM `translate` falls back to. Returns
- * the bare ISO 639-1 code. Throws if the reply doesn't look like a code.
- */
-async function callLlmDetect(text) {
+/** One un-retried LLM detect attempt. */
+async function callLlmDetectOnce(text) {
     const { getAiGenProviderService } = await Promise.resolve().then(() => __importStar(require("../aiGen/aiGenFactory.service")));
     const service = getAiGenProviderService(FALLBACK_MODEL);
     const system = "You are a language identification engine. Reply with ONLY the ISO 639-1 " +
         "code of the language the user's text is written in — two lowercase " +
         'letters, nothing else (e.g. "es", "ja", "ar"). Use "zh-cn" or "zh-tw" ' +
         "for Chinese. No punctuation, no explanation.";
-    // Bounded the same way as callLlmTranslate (see comment above it): this is
-    // called synchronously from POST /v1/video/generate before the BullMQ
-    // enqueue, so an unbounded generateText here stalls the HTTP request all
-    // the way to the Cloud Run 300s ceiling instead of failing over to the
-    // "default to en" path below.
-    let timer;
-    const { text: out } = await Promise.race([
-        service.generateText({
-            // Only the opening slice matters for identification, and capping it
-            // keeps this cheap when a long-form brief triggers the fallback.
-            input: [
-                { role: "system", content: system },
-                { role: "user", content: text.slice(0, 1000) },
-            ],
-            modelKey: FALLBACK_MODEL,
-            options: { temperature: 0 },
-        }),
-        new Promise((_, reject) => {
-            timer = setTimeout(() => reject(new Error(`LLM detect timed out after ${FALLBACK_TIMEOUT_MS}ms`)), FALLBACK_TIMEOUT_MS);
-        }),
-    ]).finally(() => {
-        if (timer)
-            clearTimeout(timer);
+    const { text: out } = await service.generateText({
+        // Only the opening slice matters for identification, and capping it
+        // keeps this cheap when a long-form brief triggers the fallback.
+        input: [
+            { role: "system", content: system },
+            { role: "user", content: text.slice(0, 1000) },
+        ],
+        modelKey: FALLBACK_MODEL,
+        options: { temperature: 0 },
     });
     const code = (out ?? "").trim().toLowerCase().replace(/[^a-z-]/g, "");
     if (!/^[a-z]{2}(-[a-z]{2})?$/.test(code)) {
@@ -229,6 +238,27 @@ async function callLlmDetect(text) {
     }
     return code;
 }
+/**
+ * FALLBACK: detect via the same cheap LLM `translate` falls back to, with the
+ * same retry treatment as callLlmTranslate. Returns the bare ISO 639-1 code.
+ *
+ * This is called synchronously from POST /v1/video/generate before the
+ * BullMQ enqueue, so an unbounded generateText here stalls the HTTP request
+ * all the way to the Cloud Run 300s ceiling instead of failing over to the
+ * "default to en" path below — hence the same per-attempt bound as translate.
+ */
+async function callLlmDetect(text) {
+    let lastErr;
+    for (let attempt = 1; attempt <= FALLBACK_MAX_ATTEMPTS; attempt++) {
+        try {
+            return await withTimeout(callLlmDetectOnce(text), FALLBACK_ATTEMPT_TIMEOUT_MS, "LLM detect");
+        }
+        catch (err) {
+            lastErr = err;
+        }
+    }
+    throw lastErr;
+}
 /**
  * Detect the language of `text`. Primary CF → cheap LLM → fail OPEN to English.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vidspotai-shared",
-  "version": "1.0.116",
+  "version": "1.0.117",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "exports": {