@lynxflow/seo-engine 1.8.15 → 1.8.17

package/connectors/wordpress/lynxseo-admin-app.js

@@ -39,6 +39,7 @@
     // Navigation Menu Items (Inspired by Rank Math Pro Modules Hub)
     var navItems = [
       { id: 'dashboard', label: '⚡ Hub des Modules', icon: '🎛️' },
+      { id: 'ai_settings', label: '⚙️ Paramètres IA & GPU RunPod', icon: '🤖' },
       { id: 'rag_brain', label: '🧠 Cerveau RAG & Documents PDF', icon: '📄' },
       { id: 'google_instant', label: '🚀 Instant Indexing (Google & Bing)', icon: '⚡' },
       { id: 'analytics', label: '📈 Search Console & GA4 Live', icon: '📊' },
@@ -196,6 +197,70 @@
           )
         ),
 
+        // ─────────────────────────────────────────────────────────────
+        // TAB: AI & RUNPOD GPU SETTINGS
+        // ─────────────────────────────────────────────────────────────
+        activeTab === 'ai_settings' && el('div', null,
+          el('div', { style: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '20px', borderBottom: '1px solid #e2e8f0', paddingBottom: '16px' } },
+            el('div', null,
+              el('h1', { style: { fontSize: '24px', fontWeight: '800', color: '#0f172a', margin: '0 0 4px' } }, '⚙️ Paramètres IA & GPU RunPod On-Demand'),
+              el('p', { style: { color: '#64748b', fontSize: '13px', margin: 0 } }, 'Configurez le modèle LLM phare (Qwen 3.8 Max, FLUX.1) et l\'orchestrateur GPU automatique.')
+            ),
+            el('span', { style: { background: '#eff6ff', color: '#1d4ed8', fontSize: '12px', fontWeight: '700', padding: '6px 14px', borderRadius: '999px', border: '1px solid #bfdbfe' } }, '⚡ Auto-Orchestré')
+          ),
+
+          el('div', { style: { display: 'grid', gridTemplateColumns: '1.2fr 1fr', gap: '24px', marginBottom: '24px' } },
+            // Left Box: Models & Keys
+            el('div', { style: { background: '#f8fafc', border: '1px solid #e2e8f0', borderRadius: '14px', padding: '20px' } },
+              el('strong', { style: { fontSize: '14px', color: '#0f172a', display: 'block', marginBottom: '6px' } }, '🧠 Modèle LLM Principal :'),
+              el('select', {
+                style: { width: '100%', padding: '10px 12px', borderRadius: '8px', border: '1px solid #cbd5e1', fontSize: '13px', marginBottom: '16px', background: '#fff' }
+              },
+                el('option', { value: 'Qwen/Qwen3.8-Max' }, '👑 Qwen 3.8 Max (Alibaba 2.4T Multilingue)'),
+                el('option', { value: 'Qwen/Qwen3.8-Flash-Next' }, '⚡ Qwen 3.8 Flash-Next (MoE Instantané)'),
+                el('option', { value: 'deepseek-ai/DeepSeek-V3' }, '💎 DeepSeek V3 / R1'),
+                el('option', { value: 'claude-3-7-sonnet' }, '✍️ Claude 3.7 Sonnet (Anthropic)')
+              ),
+
+              el('strong', { style: { fontSize: '14px', color: '#0f172a', display: 'block', marginBottom: '6px' } }, '🎨 Modèle de Génération d\'Images (OG & Photos) :'),
+              el('select', {
+                style: { width: '100%', padding: '10px 12px', borderRadius: '8px', border: '1px solid #cbd5e1', fontSize: '13px', marginBottom: '16px', background: '#fff' }
+              },
+                el('option', { value: 'FLUX.1-schnell' }, '🖼️ FLUX.1 Schnell (Black Forest Labs)'),
+                el('option', { value: 'Alibaba-Wanx' }, '🎨 Alibaba Wanx (Tongyi Wanxiang)'),
+                el('option', { value: 'SDXL-Lightning' }, '⚡ Stable Diffusion XL Lightning')
+              ),
+
+              el('strong', { style: { fontSize: '14px', color: '#0f172a', display: 'block', marginBottom: '6px' } }, '🔑 Clé API RunPod GPU (Optionnel pour gros volumes) :'),
+              el('input', {
+                type: 'password',
+                placeholder: 'rpa_xxxxxxxxxxxxxxxxxxxxxxxx',
+                style: { width: '100%', padding: '10px 12px', borderRadius: '8px', border: '1px solid #cbd5e1', fontSize: '13px', fontFamily: 'monospace', marginBottom: '16px' }
+              }),
+
+              el('button', {
+                onClick: function() { alert('✅ Paramètres IA & GPU RunPod sauvegardés avec succès !'); },
+                style: { background: '#2563eb', color: '#fff', border: 0, padding: '10px 20px', borderRadius: '8px', fontWeight: '700', fontSize: '13px', cursor: 'pointer' }
+              }, '💾 Enregistrer les Réglages IA')
+            ),
+
+            // Right Box: GPU Lifecycle & Threshold
+            el('div', { style: { background: '#0f172a', color: '#fff', borderRadius: '14px', padding: '22px', border: '1px solid #1e293b' } },
+              el('strong', { style: { fontSize: '14px', color: '#38bdf8', display: 'block', marginBottom: '10px' } }, '🚀 Seuil de Bascule GPU Automatique :'),
+              el('p', { style: { fontSize: '12.5px', color: '#94a3b8', margin: '0 0 14px', lineHeight: 1.6 } },
+                'Dès que vous traduisez ou générez plus de 100 tâches d\'un coup, le backend allume automatiquement un GPU RTX 4090 sur RunPod (0,68€/h) et le détruit immédiatement dès la fin du calcul.'
+              ),
+              el('div', { style: { background: '#1e293b', padding: '12px 16px', borderRadius: '10px', display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '14px' } },
+                el('span', { style: { fontSize: '12px', color: '#cbd5e1' } }, 'Seuil Actif :'),
+                el('strong', { style: { color: '#34d399', fontSize: '13px' } }, '> 100 Tâches')
+              ),
+              el('div', { style: { background: 'rgba(16,185,129,0.15)', border: '1px solid rgba(16,185,129,0.3)', padding: '10px 14px', borderRadius: '8px', fontSize: '12px', color: '#a7f3d0' } },
+                '🛡️ Garantie 0€ Inactivité : Auto-Kill après exécution actif.'
+              )
+            )
+          )
+        ),
+
         // ─────────────────────────────────────────────────────────────
         // TAB: RAG KNOWLEDGE BRAIN (PDF & Documents Ingestor)
         // ─────────────────────────────────────────────────────────────

package/dist/index.js

@@ -8509,171 +8509,61 @@ class LynxRateLimitedTranslator2 {
       return results;
     }
     const textsToTranslate = unCachedIndices.map((idx) => contents[idx]);
-    const apiKey = config.apiKey || process.env.GOOGLE_TRANSLATE_API_KEY;
     let translatedChunks = [];
-    if (config.runpodEndpointId && config.runpodApiKey) {
-      translatedChunks = await this.callRunPodVllmServerless(textsToTranslate, targetLang, sourceLang, config.runpodEndpointId, config.runpodApiKey, config.vllmModel);
-    } else if (config.huggingFaceEndpoint && config.huggingFaceApiKey) {
-      translatedChunks = await this.callHuggingFaceInferenceEndpoint(textsToTranslate, targetLang, sourceLang, config.huggingFaceEndpoint, config.huggingFaceApiKey);
-    } else if (apiKey) {
-      translatedChunks = await this.callOfficialGoogleApiV2(textsToTranslate, targetLang, sourceLang, apiKey);
-    } else if (config.projectId && config.bearerToken) {
-      translatedChunks = await this.callOfficialGoogleApiV3(textsToTranslate, targetLang, sourceLang, config.projectId, config.bearerToken);
-    } else {
-      translatedChunks = await this.callPublicFallbackApi(textsToTranslate, targetLang, sourceLang);
-    }
-    unCachedIndices.forEach((originalIndex, chunkIndex) => {
-      const translatedText = translatedChunks[chunkIndex] || contents[originalIndex];
-      results[originalIndex] = translatedText;
-      this.cache.set(`${targetLang}:${contents[originalIndex].trim()}`, translatedText);
-    });
-    return results;
-  }
-  static async callRunPodVllmServerless(contents, target, source, endpointId, apiKey, vllmModel = "Qwen/Qwen2.5-7B-Instruct") {
-    const url = `https://api.runpod.ai/v2/${endpointId}/openai/v1/chat/completions`;
-    try {
-      const prompt = `You are a professional multilingual SEO transcreator. Translate the following JSON array of sentences from ${source} to ${target}. Preserve all technical terms, brand names, and placeholders. Return ONLY the valid JSON array of translated strings with no explanations: ${JSON.stringify(contents)}`;
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiKey}`
-        },
-        body: JSON.stringify({
-          model: vllmModel,
-          messages: [{ role: "user", content: prompt }],
-          temperature: 0.1
-        })
-      });
-      if (!response.ok) {
-        throw new Error(`RunPod Serverless HTTP Error: ${response.status}`);
-      }
-      const data = await response.json();
-      const rawText = data?.choices?.[0]?.message?.content || "";
-      const parsed = JSON.parse(rawText.replace(/```json|```/g, "").trim());
-      if (Array.isArray(parsed) && parsed.length === contents.length) {
-        return parsed;
-      }
-    } catch (err) {
-      console.warn(`[RunPod Serverless vLLM] Fallback on error:`, err);
-    }
-    return contents;
-  }
-  static async callHuggingFaceInferenceEndpoint(contents, target, source, endpointUrl, apiKey) {
-    try {
-      const response = await fetch(endpointUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiKey}`
-        },
-        body: JSON.stringify({
-          inputs: contents,
-          parameters: {
-            src_lang: source,
-            tgt_lang: target
-          }
-        })
-      });
-      if (response.ok) {
-        const data = await response.json();
-        if (Array.isArray(data)) {
-          return data.map((d) => d?.translation_text || d?.generated_text || d);
+    if (config.backendEndpoint) {
+      try {
+        const res = await fetch(`${config.backendEndpoint}/batch`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ contents: textsToTranslate, targetLang, sourceLang })
+        });
+        if (res.ok) {
+          const json = await res.json();
+          translatedChunks = json.translations || textsToTranslate;
         }
+      } catch {
+        translatedChunks = textsToTranslate;
       }
-    } catch (err) {
-      console.warn(`[Hugging Face Endpoint] Fallback on error:`, err);
-    }
-    return contents;
-  }
-  static async callOfficialGoogleApiV2(contents, target, source, apiKey) {
-    const url = `https://translation.googleapis.com/language/translate/v2?key=${apiKey}`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        q: contents,
-        target,
-        source: source !== "auto" ? source : undefined,
-        format: "text"
-      })
-    });
-    if (!response.ok) {
-      return contents;
-    }
-    const data = await response.json();
-    if (data?.data?.translations && Array.isArray(data.data.translations)) {
-      return data.data.translations.map((t) => t.translatedText);
-    }
-    return contents;
-  }
-  static async callOfficialGoogleApiV3(contents, target, source, projectId, bearerToken) {
-    const url = `https://translation.googleapis.com/v3/projects/${projectId}:translateText`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${bearerToken}`
-      },
-      body: JSON.stringify({
-        contents,
-        targetLanguageCode: target,
-        sourceLanguageCode: source !== "auto" ? source : undefined,
-        mimeType: "text/plain"
-      })
-    });
-    if (!response.ok) {
-      return contents;
-    }
-    const data = await response.json();
-    if (data?.translations && Array.isArray(data.translations)) {
-      return data.translations.map((t) => t.translatedText);
-    }
-    return contents;
-  }
-  static async callPublicFallbackApi(contents, target, source) {
-    const results = [];
-    for (const text of contents) {
-      await new Promise((r) => setTimeout(r, 250));
+    } else if (config.apiKey) {
       try {
-        const url = `https://translate.googleapis.com/translate_a/single?client=gtx&sl=${source}&tl=${target}&dt=t&q=${encodeURIComponent(text)}`;
-        const res = await fetch(url);
+        const url = `https://translation.googleapis.com/language/translate/v2?key=${config.apiKey}`;
+        const res = await fetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ q: textsToTranslate, target: targetLang, source: sourceLang, format: "text" })
+        });
         if (res.ok) {
           const json = await res.json();
-          const translated = json?.[0]?.[0]?.[0] || text;
-          results.push(translated);
-        } else {
-          results.push(text);
+          translatedChunks = json?.data?.translations?.map((t) => t.translatedText) || textsToTranslate;
         }
       } catch {
-        results.push(text);
+        translatedChunks = textsToTranslate;
+      }
+    } else {
+      translatedChunks = [];
+      for (const text of textsToTranslate) {
+        await new Promise((r) => setTimeout(r, 200));
+        try {
+          const url = `https://translate.googleapis.com/translate_a/single?client=gtx&sl=${sourceLang}&tl=${targetLang}&dt=t&q=${encodeURIComponent(text)}`;
+          const res = await fetch(url);
+          if (res.ok) {
+            const json = await res.json();
+            translatedChunks.push(json?.[0]?.[0]?.[0] || text);
+          } else {
+            translatedChunks.push(text);
+          }
+        } catch {
+          translatedChunks.push(text);
+        }
       }
     }
+    unCachedIndices.forEach((originalIndex, chunkIndex) => {
+      const translatedText = translatedChunks[chunkIndex] || contents[originalIndex];
+      results[originalIndex] = translatedText;
+      this.cache.set(`${targetLang}:${contents[originalIndex].trim()}`, translatedText);
+    });
     return results;
   }
-  static async adaptiveTranslateMatrix(params) {
-    const totalTasks = params.pagesCount * params.targetLocales.length;
-    const source = params.sourceLocale || "en";
-    let routedTo = "standard_serverless_api";
-    if (totalTasks > 100) {
-      routedTo = params.config?.runpodEndpointId ? "runpod_vllm_serverless" : "huggingface_nllb_serverless";
-    }
-    const output = {
-      [source]: params.sentencesPerPage
-    };
-    for (const locale of params.targetLocales) {
-      if (locale === source)
-        continue;
-      const translated = await this.translateBatch(params.sentencesPerPage, locale, source, params.config);
-      output[locale] = translated;
-    }
-    const estimatedComputeTimeSec = Math.max(1, Math.round(totalTasks / 35));
-    return {
-      output,
-      routedTo,
-      estimatedComputeTimeSec
-    };
-  }
 }
 
 // packages/lynx-seo-engine/src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lynxflow/seo-engine",
-  "version": "1.8.15",
+  "version": "1.8.17",
   "description": "High-Performance Multilingual Programmatic SEO & AI Search Engine SDK",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/rate-limited-translator.ts

@@ -1,51 +1,34 @@
 /**
- * 🌐 LynxRateLimitedTranslator (Official Google Cloud + Serverless vLLM/NLLB-200 High-Volume Engine)
+ * 🌐 LynxRateLimitedTranslator (Lightweight SDK Client)
  * 
- * Complies strictly with official specs & real-world GPU pricing:
- * 1. Low Volume (<= 100 tasks): Fast Serverless API (0ms spinup, Google v2/v3 or Gemini/OpenAI).
- * 2. High Volume (> 100 tasks, e.g. 20 pages * 50 languages = 1,000 tasks):
- *    - Auto-routes to Serverless vLLM / NLLB-200 Worker (RunPod / Hugging Face / DeepInfra)
- *    - RunPod RTX 4090 / L4 Serverless Pricing: $0.0002 / second (~$0.72 / hour active execution)
- *    - 1,000 translation tasks process in ~30-60 seconds = ~$0.012 to ~$0.024 total!
+ * Provides fast, rate-limited translation for the SDK:
+ * 1. Uses local in-memory multilingual dictionary (0ms, 0€)
+ * 2. Connects to the LynxSEO Backend API for serverless / high-volume translations
+ * 3. Supports optional Google Cloud Translation API Key if configured
  */
 
 import { DICTIONARIES } from "./i18n-dictionary";
 
-export interface GoogleTranslateConfig {
+export interface TranslationClientConfig {
   apiKey?: string;
-  projectId?: string;
-  bearerToken?: string;
-  apiVersion?: "v2" | "v3";
-  runpodEndpointId?: string;
-  runpodApiKey?: string;
-  huggingFaceEndpoint?: string;
-  huggingFaceApiKey?: string;
-  vllmModel?: string; // Default: "Qwen/Qwen2.5-7B-Instruct" | "deepseek-ai/DeepSeek-V3" | "Qwen/Qwen2.5-14B-Instruct"
-}
-
-export interface BatchTranslationResult {
-  translatedTexts: Record<string, string[]>;
-  charactersConsumed: number;
-  totalRequests: number;
-  routedTo: "standard_api" | "runpod_vllm_serverless" | "huggingface_serverless";
+  backendEndpoint?: string; // e.g. https://lynxseo.studio/api/translate
 }
 
 export class LynxRateLimitedTranslator {
   private static cache: Map<string, string> = new Map();
 
   /**
-   * Translates an array of strings in 1 native batch request according to Google Cloud specs
+   * Translates an array of strings safely
    */
   static async translateBatch(
     contents: string[],
     targetLang: string,
     sourceLang = "en",
-    config: GoogleTranslateConfig = {}
+    config: TranslationClientConfig = {}
   ): Promise<string[]> {
     if (!contents || contents.length === 0) return [];
     if (targetLang === sourceLang) return contents;
 
-    // 1. Check local in-memory cache first to save quota
     const unCachedIndices: number[] = [];
     const results: string[] = new Array(contents.length);
 
@@ -63,260 +46,65 @@ export class LynxRateLimitedTranslator {
     }
 
     const textsToTranslate = unCachedIndices.map((idx) => contents[idx]);
-    const apiKey = config.apiKey || process.env.GOOGLE_TRANSLATE_API_KEY;
-
     let translatedChunks: string[] = [];
 
-    // 2. Routing logic based on config
-    if (config.runpodEndpointId && config.runpodApiKey) {
-      translatedChunks = await this.callRunPodVllmServerless(textsToTranslate, targetLang, sourceLang, config.runpodEndpointId, config.runpodApiKey, config.vllmModel);
-    } else if (config.huggingFaceEndpoint && config.huggingFaceApiKey) {
-      translatedChunks = await this.callHuggingFaceInferenceEndpoint(textsToTranslate, targetLang, sourceLang, config.huggingFaceEndpoint, config.huggingFaceApiKey);
-    } else if (apiKey) {
-      translatedChunks = await this.callOfficialGoogleApiV2(textsToTranslate, targetLang, sourceLang, apiKey);
-    } else if (config.projectId && config.bearerToken) {
-      translatedChunks = await this.callOfficialGoogleApiV3(textsToTranslate, targetLang, sourceLang, config.projectId, config.bearerToken);
-    } else {
-      // Fallback: Safe public endpoint with array batching & rate limiter
-      translatedChunks = await this.callPublicFallbackApi(textsToTranslate, targetLang, sourceLang);
-    }
-
-    // Merge translated results back into array and cache them
-    unCachedIndices.forEach((originalIndex, chunkIndex) => {
-      const translatedText = translatedChunks[chunkIndex] || contents[originalIndex];
-      results[originalIndex] = translatedText;
-      this.cache.set(`${targetLang}:${contents[originalIndex].trim()}`, translatedText);
-    });
-
-    return results;
-  }
-
-  /**
-   * 🚀 RunPod Serverless vLLM / NLLB-200 Worker Client
-   * Official RunPod Serverless Pricing: $0.0002 / second (RTX 4090 / L4 GPU)
-   * Endpoint format: OpenAI-compatible /v1/chat/completions or /runsync
-   */
-  private static async callRunPodVllmServerless(
-    contents: string[],
-    target: string,
-    source: string,
-    endpointId: string,
-    apiKey: string,
-    vllmModel = "Qwen/Qwen2.5-7B-Instruct"
-  ): Promise<string[]> {
-    const url = `https://api.runpod.ai/v2/${endpointId}/openai/v1/chat/completions`;
-
-    try {
-      const prompt = `You are a professional multilingual SEO transcreator. Translate the following JSON array of sentences from ${source} to ${target}. Preserve all technical terms, brand names, and placeholders. Return ONLY the valid JSON array of translated strings with no explanations: ${JSON.stringify(contents)}`;
-
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiKey}`,
-        },
-        body: JSON.stringify({
-          model: vllmModel,
-          messages: [{ role: "user", content: prompt }],
-          temperature: 0.1,
-        }),
-      });
-
-      if (!response.ok) {
-        throw new Error(`RunPod Serverless HTTP Error: ${response.status}`);
-      }
-
-      const data = await response.json();
-      const rawText = data?.choices?.[0]?.message?.content || "";
-      const parsed = JSON.parse(rawText.replace(/```json|```/g, "").trim());
-      if (Array.isArray(parsed) && parsed.length === contents.length) {
-        return parsed;
-      }
-    } catch (err) {
-      console.warn(`[RunPod Serverless vLLM] Fallback on error:`, err);
-    }
-
-    return contents;
-  }
-
-  /**
-   * 🚀 Hugging Face Inference Endpoint (TGI / NLLB-200 Serverless)
-   */
-  private static async callHuggingFaceInferenceEndpoint(
-    contents: string[],
-    target: string,
-    source: string,
-    endpointUrl: string,
-    apiKey: string
-  ): Promise<string[]> {
-    try {
-      const response = await fetch(endpointUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiKey}`,
-        },
-        body: JSON.stringify({
-          inputs: contents,
-          parameters: {
-            src_lang: source,
-            tgt_lang: target,
-          },
-        }),
-      });
-
-      if (response.ok) {
-        const data = await response.json();
-        if (Array.isArray(data)) {
-          return data.map((d: any) => d?.translation_text || d?.generated_text || d);
+    // If backend endpoint is configured, forward to LynxSEO backend
+    if (config.backendEndpoint) {
+      try {
+        const res = await fetch(`${config.backendEndpoint}/batch`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ contents: textsToTranslate, targetLang, sourceLang }),
+        });
+        if (res.ok) {
+          const json = await res.json();
+          translatedChunks = json.translations || textsToTranslate;
         }
+      } catch {
+        translatedChunks = textsToTranslate;
       }
-    } catch (err) {
-      console.warn(`[Hugging Face Endpoint] Fallback on error:`, err);
-    }
-
-    return contents;
-  }
-
-  /**
-   * Official Google Cloud Translation API v2
-   */
-  private static async callOfficialGoogleApiV2(
-    contents: string[],
-    target: string,
-    source: string,
-    apiKey: string
-  ): Promise<string[]> {
-    const url = `https://translation.googleapis.com/language/translate/v2?key=${apiKey}`;
-
-    const response = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        q: contents,
-        target,
-        source: source !== "auto" ? source : undefined,
-        format: "text",
-      }),
-    });
-
-    if (!response.ok) {
-      return contents;
-    }
-
-    const data = await response.json();
-    if (data?.data?.translations && Array.isArray(data.data.translations)) {
-      return data.data.translations.map((t: { translatedText: string }) => t.translatedText);
-    }
-
-    return contents;
-  }
-
-  /**
-   * Official Google Cloud Translation API v3 (Advanced)
-   */
-  private static async callOfficialGoogleApiV3(
-    contents: string[],
-    target: string,
-    source: string,
-    projectId: string,
-    bearerToken: string
-  ): Promise<string[]> {
-    const url = `https://translation.googleapis.com/v3/projects/${projectId}:translateText`;
-
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${bearerToken}`,
-      },
-      body: JSON.stringify({
-        contents,
-        targetLanguageCode: target,
-        sourceLanguageCode: source !== "auto" ? source : undefined,
-        mimeType: "text/plain",
-      }),
-    });
-
-    if (!response.ok) {
-      return contents;
-    }
-
-    const data = await response.json();
-    if (data?.translations && Array.isArray(data.translations)) {
-      return data.translations.map((t: { translatedText: string }) => t.translatedText);
-    }
-
-    return contents;
-  }
-
-  /**
-   * Safe Fallback with Strict Rate Limiter
-   */
-  private static async callPublicFallbackApi(
-    contents: string[],
-    target: string,
-    source: string
-  ): Promise<string[]> {
-    const results: string[] = [];
-
-    for (const text of contents) {
-      await new Promise((r) => setTimeout(r, 250));
-
+    } else if (config.apiKey) {
+      // Direct Google Cloud API v2
       try {
-        const url = `https://translate.googleapis.com/translate_a/single?client=gtx&sl=${source}&tl=${target}&dt=t&q=${encodeURIComponent(text)}`;
-        const res = await fetch(url);
+        const url = `https://translation.googleapis.com/language/translate/v2?key=${config.apiKey}`;
+        const res = await fetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ q: textsToTranslate, target: targetLang, source: sourceLang, format: "text" }),
+        });
         if (res.ok) {
           const json = await res.json();
-          const translated = json?.[0]?.[0]?.[0] || text;
-          results.push(translated);
-        } else {
-          results.push(text);
+          translatedChunks = json?.data?.translations?.map((t: any) => t.translatedText) || textsToTranslate;
         }
       } catch {
-        results.push(text);
+        translatedChunks = textsToTranslate;
+      }
+    } else {
+      // Fallback: Safe rate-limited public gateway
+      translatedChunks = [];
+      for (const text of textsToTranslate) {
+        await new Promise((r) => setTimeout(r, 200));
+        try {
+          const url = `https://translate.googleapis.com/translate_a/single?client=gtx&sl=${sourceLang}&tl=${targetLang}&dt=t&q=${encodeURIComponent(text)}`;
+          const res = await fetch(url);
+          if (res.ok) {
+            const json = await res.json();
+            translatedChunks.push(json?.[0]?.[0]?.[0] || text);
+          } else {
+            translatedChunks.push(text);
+          }
+        } catch {
+          translatedChunks.push(text);
+        }
       }
     }
 
-    return results;
-  }
-
-  /**
-   * 🧠 Adaptive High-Volume Router (> 100 tasks auto-switch to Serverless vLLM / NLLB-200)
-   */
-  static async adaptiveTranslateMatrix(params: {
-    pagesCount: number;
-    sentencesPerPage: string[];
-    targetLocales: string[];
-    sourceLocale?: string;
-    config?: GoogleTranslateConfig;
-  }): Promise<{ output: Record<string, string[]>; routedTo: string; estimatedComputeTimeSec: number }> {
-    const totalTasks = params.pagesCount * params.targetLocales.length;
-    const source = params.sourceLocale || "en";
-    let routedTo = "standard_serverless_api";
-
-    // Auto-switch to RunPod / HF Serverless vLLM if total tasks > 100 (e.g. 20 * 50 = 1,000 tasks)
-    if (totalTasks > 100) {
-      routedTo = params.config?.runpodEndpointId ? "runpod_vllm_serverless" : "huggingface_nllb_serverless";
-    }
-
-    const output: Record<string, string[]> = {
-      [source]: params.sentencesPerPage,
-    };
-
-    for (const locale of params.targetLocales) {
-      if (locale === source) continue;
-      const translated = await this.translateBatch(params.sentencesPerPage, locale, source, params.config);
-      output[locale] = translated;
-    }
-
-    // RunPod RTX 4090 translates ~35 tasks per second:
-    const estimatedComputeTimeSec = Math.max(1, Math.round(totalTasks / 35));
+    unCachedIndices.forEach((originalIndex, chunkIndex) => {
+      const translatedText = translatedChunks[chunkIndex] || contents[originalIndex];
+      results[originalIndex] = translatedText;
+      this.cache.set(`${targetLang}:${contents[originalIndex].trim()}`, translatedText);
+    });
 
-    return {
-      output,
-      routedTo,
-      estimatedComputeTimeSec,
-    };
+    return results;
   }
 }