wyxrouter 0.4.71

package/open-sse/handlers/search/normalizers.js

@@ -0,0 +1,223 @@
+/**
+ * Search Response Normalizers
+ *
+ * Ported from OmniRoute open-sse/handlers/search.ts.
+ * Each normalizer maps a provider-specific response into the unified SearchResult shape.
+ */
+
+/** Build a unified SearchResult object. */
+function makeResult(providerId, item, idx, now) {
+  const url = item.url || "";
+  return {
+    title: item.title || "",
+    url,
+    display_url: url ? url.replace(/^https?:\/\/(www\.)?/, "").split("?")[0] : undefined,
+    snippet: item.snippet || "",
+    position: idx + 1,
+    score: typeof item.score === "number" ? Math.min(1, Math.max(0, item.score)) : null,
+    published_at: item.published_at || null,
+    favicon_url: item.favicon_url || null,
+    content: item.full_text
+      ? { format: item.text_format || "text", text: item.full_text, length: item.full_text.length }
+      : null,
+    metadata: {
+      author: item.author || null,
+      language: null,
+      source_type: item.source_type || null,
+      image_url: item.image_url || null,
+    },
+    citation: { provider: providerId, retrieved_at: now, rank: idx + 1 },
+    provider_raw: null,
+  };
+}
+
+function normalizeSerper(data, _query, searchType) {
+  const now = new Date().toISOString();
+  const items = searchType === "news" ? data.news : data.organic;
+  if (!Array.isArray(items)) return { results: [], totalResults: null };
+  const results = items.map((item, idx) =>
+    makeResult("serper", { title: item.title, url: item.link, snippet: item.snippet || item.description, published_at: item.date }, idx, now)
+  );
+  const total = data.searchParameters?.totalResults;
+  return { results, totalResults: typeof total === "number" ? total : null };
+}
+
+function normalizeBrave(data, _query, searchType) {
+  const now = new Date().toISOString();
+  const container = searchType === "news" ? data.news || data : data.web;
+  const items = container?.results;
+  if (!Array.isArray(items)) return { results: [], totalResults: null };
+  const results = items.map((item, idx) =>
+    makeResult("brave-search", {
+      title: item.title,
+      url: item.url,
+      snippet: item.description,
+      published_at: item.page_age || item.age,
+      favicon_url: item.meta_url?.favicon || item.favicon,
+    }, idx, now)
+  );
+  return { results, totalResults: container?.totalCount ?? null };
+}
+
+function normalizePerplexity(data, _query, _searchType) {
+  const now = new Date().toISOString();
+  const items = data.results;
+  if (!Array.isArray(items)) return { results: [], totalResults: null };
+  const results = items.map((item, idx) =>
+    makeResult("perplexity", { title: item.title, url: item.url, snippet: item.snippet, published_at: item.date || item.last_updated }, idx, now)
+  );
+  return { results, totalResults: results.length };
+}
+
+function normalizeExa(data, _query, _searchType) {
+  const now = new Date().toISOString();
+  const items = data.results;
+  if (!Array.isArray(items)) return { results: [], totalResults: null };
+  const results = items.map((item, idx) =>
+    makeResult("exa", {
+      title: item.title,
+      url: item.url,
+      snippet: item.highlights?.[0] || item.text?.slice(0, 300) || "",
+      score: item.score,
+      published_at: item.publishedDate,
+      favicon_url: item.favicon,
+      author: item.author,
+      image_url: item.image,
+      full_text: item.text,
+      text_format: "text",
+    }, idx, now)
+  );
+  return { results, totalResults: results.length };
+}
+
+function normalizeTavily(data, _query, _searchType) {
+  const now = new Date().toISOString();
+  const items = data.results;
+  if (!Array.isArray(items)) return { results: [], totalResults: null };
+  const results = items.map((item, idx) =>
+    makeResult("tavily", {
+      title: item.title,
+      url: item.url,
+      snippet: item.content || "",
+      score: item.score,
+      published_at: item.published_date,
+      full_text: item.raw_content,
+      text_format: "text",
+    }, idx, now)
+  );
+  return { results, totalResults: results.length };
+}
+
+function normalizeGooglePse(data, _query, _searchType) {
+  const now = new Date().toISOString();
+  const items = Array.isArray(data.items) ? data.items : [];
+  const results = items.map((item, idx) =>
+    makeResult("google-pse", {
+      title: item.title,
+      url: item.link,
+      snippet: item.snippet,
+      image_url: item.pagemap?.cse_image?.[0]?.src || item.pagemap?.cse_thumbnail?.[0]?.src || item.pagemap?.metatags?.[0]?.["og:image"],
+    }, idx, now)
+  );
+  const raw = data.searchInformation?.totalResults ?? data.queries?.request?.[0]?.totalResults ?? null;
+  const total = typeof raw === "string" ? Number(raw) : raw;
+  return { results, totalResults: Number.isFinite(total) ? total : null };
+}
+
+function normalizeLinkup(data, _query, _searchType) {
+  const now = new Date().toISOString();
+  const items = Array.isArray(data.results) ? data.results : [];
+  const results = items.map((item, idx) =>
+    makeResult("linkup", {
+      title: item.name || item.title,
+      url: item.url,
+      snippet: item.content || item.snippet || "",
+      source_type: item.type || "web",
+      image_url: item.image_url || item.imageUrl || null,
+      full_text: item.content,
+      text_format: "text",
+    }, idx, now)
+  );
+  return { results, totalResults: results.length };
+}
+
+function normalizeSearchApi(data, _query, _searchType) {
+  const now = new Date().toISOString();
+  const items = Array.isArray(data.organic_results) ? data.organic_results : Array.isArray(data.top_stories) ? data.top_stories : [];
+  const results = items.map((item, idx) =>
+    makeResult("searchapi", {
+      title: item.title,
+      url: item.link,
+      snippet: item.snippet || item.description || "",
+      published_at: item.date || item.published_at,
+      favicon_url: item.favicon,
+      author: item.source || null,
+      image_url: item.thumbnail || null,
+    }, idx, now)
+  );
+  const raw = data.search_information?.total_results;
+  const total = typeof raw === "number" ? raw : typeof raw === "string" ? Number(raw) : null;
+  return { results, totalResults: Number.isFinite(total) ? total : results.length };
+}
+
+function normalizeYouCom(data, _query, searchType) {
+  const now = new Date().toISOString();
+  const container = data?.results && typeof data.results === "object" ? data.results : undefined;
+  const section = searchType === "news" ? container?.news || [] : container?.web || [];
+  const items = Array.isArray(section) ? section : [];
+  const results = items.map((item, idx) => {
+    const firstSnippet = Array.isArray(item.snippets) ? item.snippets.find((v) => typeof v === "string") : null;
+    const livecrawlText = typeof item.markdown === "string" ? item.markdown : typeof item.html === "string" ? item.html : undefined;
+    const livecrawlFormat = typeof item.markdown === "string" ? "markdown" : "html";
+    return makeResult("youcom", {
+      title: item.title,
+      url: item.url,
+      snippet: typeof firstSnippet === "string" ? firstSnippet : typeof item.description === "string" ? item.description : "",
+      published_at: item.page_age,
+      favicon_url: item.favicon_url,
+      image_url: item.thumbnail_url,
+      source_type: searchType,
+      full_text: livecrawlText,
+      text_format: livecrawlText ? livecrawlFormat : undefined,
+    }, idx, now);
+  });
+  return { results, totalResults: results.length };
+}
+
+function normalizeSearxng(data, _query, _searchType) {
+  const now = new Date().toISOString();
+  const items = Array.isArray(data.results) ? data.results : [];
+  const results = items.map((item, idx) =>
+    makeResult("searxng", {
+      title: item.title,
+      url: item.url,
+      snippet: item.content || item.snippet || "",
+      published_at: item.publishedDate || item.published_date || null,
+      source_type: Array.isArray(item.engines) ? item.engines.join(", ") : item.engine || item.category || null,
+      image_url: item.thumbnail || item.img_src || null,
+    }, idx, now)
+  );
+  return { results, totalResults: results.length };
+}
+
+const NORMALIZERS = {
+  "serper": normalizeSerper,
+  "brave-search": normalizeBrave,
+  "perplexity": normalizePerplexity,
+  "exa": normalizeExa,
+  "tavily": normalizeTavily,
+  "google-pse": normalizeGooglePse,
+  "linkup": normalizeLinkup,
+  "searchapi": normalizeSearchApi,
+  "youcom": normalizeYouCom,
+  "searxng": normalizeSearxng,
+};
+
+/**
+ * Dispatch to the appropriate normalizer based on providerId.
+ * @returns {{results: Array, totalResults: number|null}}
+ */
+export function normalizeSearchResponse(providerId, data, query, searchType) {
+  const fn = NORMALIZERS[providerId];
+  return fn ? fn(data, query, searchType) : { results: [], totalResults: null };
+}

package/open-sse/handlers/sttCore.js

@@ -0,0 +1,194 @@
+import { Buffer } from "node:buffer";
+import { createErrorResult } from "../utils/error.js";
+import { HTTP_STATUS } from "../config/runtimeConfig.js";
+import { AI_PROVIDERS } from "../../src/shared/constants/providers.js";
+
+// Build auth headers from sttConfig + token
+function buildAuthHeaders(cfg, token) {
+  if (!token) return {};
+  switch (cfg.authHeader) {
+    case "bearer":     return { "Authorization": `Bearer ${token}` };
+    case "token":      return { "Authorization": `Token ${token}` };
+    case "x-api-key":  return { "x-api-key": token };
+    case "key":        return { "Authorization": `Key ${token}` };
+    default:           return { "Authorization": `Bearer ${token}` };
+  }
+}
+
+// Map browser file MIME / ext → audio MIME for binary formats (deepgram/HF)
+function resolveAudioContentType(file) {
+  const t = (file.type || "").toLowerCase();
+  if (t.startsWith("audio/")) return t;
+  const name = typeof file.name === "string" ? file.name.toLowerCase() : "";
+  const ext = name.includes(".") ? name.split(".").pop() : "";
+  const map = { mp3: "audio/mpeg", mp4: "audio/mp4", m4a: "audio/mp4", wav: "audio/wav", ogg: "audio/ogg", flac: "audio/flac", webm: "audio/webm", aac: "audio/aac", opus: "audio/opus" };
+  return map[ext] || "application/octet-stream";
+}
+
+async function upstreamError(res) {
+  let txt = "";
+  try { txt = await res.text(); } catch {}
+  let msg = txt || `Upstream error (${res.status})`;
+  try { const j = JSON.parse(txt); msg = j?.error?.message || j?.error || j?.message || msg; } catch {}
+  return createErrorResult(res.status, typeof msg === "string" ? msg : JSON.stringify(msg));
+}
+
+// Deepgram: raw binary POST + model query param
+async function transcribeDeepgram(cfg, file, model, token, formData) {
+  const url = new URL(cfg.baseUrl);
+  url.searchParams.set("model", model);
+  url.searchParams.set("smart_format", "true");
+  url.searchParams.set("punctuate", "true");
+  const lang = formData.get("language");
+  if (typeof lang === "string" && lang.trim()) url.searchParams.set("language", lang.trim());
+  else url.searchParams.set("detect_language", "true");
+
+  const buf = await file.arrayBuffer();
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { ...buildAuthHeaders(cfg, token), "Content-Type": resolveAudioContentType(file) },
+    body: buf,
+  });
+  if (!res.ok) return upstreamError(res);
+  const data = await res.json();
+  const text = data.results?.channels?.[0]?.alternatives?.[0]?.transcript ?? "";
+  return jsonResponse({ text });
+}
+
+// AssemblyAI: upload → submit → poll (max 120s)
+async function transcribeAssemblyAI(cfg, file, model, token) {
+  const auth = buildAuthHeaders(cfg, token);
+  const buf = await file.arrayBuffer();
+  const up = await fetch("https://api.assemblyai.com/v2/upload", {
+    method: "POST", headers: { ...auth, "Content-Type": "application/octet-stream" }, body: buf,
+  });
+  if (!up.ok) return upstreamError(up);
+  const { upload_url } = await up.json();
+
+  const sub = await fetch(cfg.baseUrl, {
+    method: "POST",
+    headers: { ...auth, "Content-Type": "application/json" },
+    body: JSON.stringify({ audio_url: upload_url, speech_models: [model], language_detection: true }),
+  });
+  if (!sub.ok) return upstreamError(sub);
+  const { id } = await sub.json();
+
+  const start = Date.now();
+  while (Date.now() - start < 120_000) {
+    await new Promise((r) => setTimeout(r, 2000));
+    const poll = await fetch(`${cfg.baseUrl}/${id}`, { headers: auth });
+    if (!poll.ok) continue;
+    const r = await poll.json();
+    if (r.status === "completed") return jsonResponse({ text: r.text || "" });
+    if (r.status === "error") return createErrorResult(500, r.error || "AssemblyAI failed");
+  }
+  return createErrorResult(504, "AssemblyAI timeout after 120s");
+}
+
+// Nvidia NIM: multipart, normalize response
+async function transcribeNvidia(cfg, file, model, token) {
+  const fd = new FormData();
+  fd.append("file", file, file.name || "audio.wav");
+  fd.append("model", model);
+  const res = await fetch(cfg.baseUrl, { method: "POST", headers: buildAuthHeaders(cfg, token), body: fd });
+  if (!res.ok) return upstreamError(res);
+  const data = await res.json();
+  return jsonResponse({ text: data.text || data.transcript || "" });
+}
+
+// Gemini: generateContent with inline_data audio + transcription prompt
+async function transcribeGemini(cfg, file, model, token, formData) {
+  const buf = await file.arrayBuffer();
+  const b64 = Buffer.from(buf).toString("base64");
+  const mime = resolveAudioContentType(file);
+  const lang = formData.get("language");
+  const userPrompt = formData.get("prompt");
+  let promptText = userPrompt && typeof userPrompt === "string" && userPrompt.trim()
+    ? userPrompt.trim()
+    : "Generate a transcript of the speech. Return only the transcribed text, no commentary.";
+  if (typeof lang === "string" && lang.trim()) promptText += ` Language: ${lang.trim()}.`;
+
+  const url = `${cfg.baseUrl}/${model}:generateContent?key=${token}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      contents: [{ parts: [{ text: promptText }, { inline_data: { mime_type: mime, data: b64 } }] }],
+    }),
+  });
+  if (!res.ok) return upstreamError(res);
+  const data = await res.json();
+  const text = data?.candidates?.[0]?.content?.parts?.map((p) => p.text).filter(Boolean).join("") || "";
+  return jsonResponse({ text });
+}
+
+// HuggingFace: POST raw binary to {baseUrl}/{model_id}
+async function transcribeHuggingFace(cfg, file, model, token) {
+  if (model.includes("..") || model.includes("//")) return createErrorResult(400, "Invalid model ID");
+  const url = `${cfg.baseUrl.replace(/\/+$/, "")}/${model}`;
+  const buf = await file.arrayBuffer();
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { ...buildAuthHeaders(cfg, token), "Content-Type": resolveAudioContentType(file) },
+    body: buf,
+  });
+  if (!res.ok) return upstreamError(res);
+  const data = await res.json();
+  return jsonResponse({ text: data.text || "" });
+}
+
+// Default: OpenAI/Groq/Whisper-compatible multipart
+async function transcribeOpenAICompatible(cfg, file, model, token, formData) {
+  const fd = new FormData();
+  fd.append("file", file, file.name || "audio.wav");
+  fd.append("model", model);
+  for (const k of ["language", "prompt", "response_format", "temperature"]) {
+    const v = formData.get(k);
+    if (v !== null && v !== undefined && v !== "") fd.append(k, v);
+  }
+  const res = await fetch(cfg.baseUrl, { method: "POST", headers: buildAuthHeaders(cfg, token), body: fd });
+  if (!res.ok) return upstreamError(res);
+  const ct = res.headers.get("content-type") || "application/json";
+  const txt = await res.text();
+  return { success: true, response: new Response(txt, { status: 200, headers: { "Content-Type": ct, "Access-Control-Allow-Origin": "*" } }) };
+}
+
+function jsonResponse(obj) {
+  return {
+    success: true,
+    response: new Response(JSON.stringify(obj), {
+      status: 200,
+      headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
+    }),
+  };
+}
+
+/**
+ * STT core handler — dispatch by sttConfig.format.
+ * @returns {Promise<{success, response, status?, error?}>}
+ */
+export async function handleSttCore({ provider, model, formData, credentials }) {
+  const file = formData.get("file");
+  if (!file) return createErrorResult(HTTP_STATUS.BAD_REQUEST, "Missing required field: file");
+
+  const cfg = AI_PROVIDERS[provider]?.sttConfig;
+  if (!cfg) return createErrorResult(HTTP_STATUS.BAD_REQUEST, `Provider '${provider}' does not support STT`);
+
+  const token = cfg.authType === "none" ? null : (credentials?.apiKey || credentials?.accessToken);
+  if (cfg.authType !== "none" && !token) {
+    return createErrorResult(HTTP_STATUS.UNAUTHORIZED, `No credentials for STT provider: ${provider}`);
+  }
+
+  try {
+    switch (cfg.format) {
+      case "deepgram":        return await transcribeDeepgram(cfg, file, model, token, formData);
+      case "assemblyai":      return await transcribeAssemblyAI(cfg, file, model, token);
+      case "nvidia-asr":      return await transcribeNvidia(cfg, file, model, token);
+      case "huggingface-asr": return await transcribeHuggingFace(cfg, file, model, token);
+      case "gemini-stt":      return await transcribeGemini(cfg, file, model, token, formData);
+      default:                return await transcribeOpenAICompatible(cfg, file, model, token, formData);
+    }
+  } catch (err) {
+    return createErrorResult(HTTP_STATUS.BAD_GATEWAY, err.message || "STT request failed");
+  }
+}

package/open-sse/handlers/ttsCore.js

@@ -0,0 +1,74 @@
+import { Buffer } from "node:buffer";
+import { createErrorResult } from "../utils/error.js";
+import { HTTP_STATUS } from "../config/runtimeConfig.js";
+import { getTtsAdapter, synthesizeViaConfig } from "./ttsProviders/index.js";
+
+// Re-export voice fetchers + voices APIs for backward compat with existing routes
+export {
+  VOICE_FETCHERS,
+  fetchEdgeTtsVoices,
+  fetchLocalDeviceVoices,
+  fetchElevenLabsVoices,
+} from "./ttsProviders/index.js";
+
+// ── Response Formatter (DRY) ───────────────────────────────────
+function createTtsResponse(base64Audio, format, responseFormat) {
+  const audioBuffer = Buffer.from(base64Audio, "base64");
+
+  // JSON format: return base64 encoded audio
+  if (responseFormat === "json") {
+    return {
+      success: true,
+      response: new Response(JSON.stringify({ audio: base64Audio, format }), {
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+        },
+      }),
+    };
+  }
+
+  // Binary format (default): return raw audio
+  return {
+    success: true,
+    response: new Response(audioBuffer, {
+      headers: {
+        "Content-Type": `audio/${format}`,
+        "Content-Length": String(audioBuffer.length),
+        "Access-Control-Allow-Origin": "*",
+      },
+    }),
+  };
+}
+
+// ── Core handler ───────────────────────────────────────────────
+/**
+ * Synthesize text to audio. Provider logic lives in `./ttsProviders/{id}.js`
+ * or is dispatched generically via `ttsConfig.format`.
+ *
+ * @returns {Promise<{success, response, status?, error?}>}
+ */
+export async function handleTtsCore({ provider, model, input, credentials, responseFormat = "mp3", language }) {
+  if (!input?.trim()) {
+    return createErrorResult(HTTP_STATUS.BAD_REQUEST, "Missing required field: input");
+  }
+
+  try {
+    // Special-case adapters (google-tts, edge-tts, local-device, elevenlabs, openai, openrouter, gemini)
+    const adapter = getTtsAdapter(provider);
+    if (adapter) {
+      const result = await adapter.synthesize(input.trim(), model, credentials, responseFormat, { language });
+      // Adapter may return a full {success, response} (legacy) or {base64, format}
+      if (result.success !== undefined) return result;
+      return createTtsResponse(result.base64, result.format, responseFormat);
+    }
+
+    // Generic config-driven (hyperbolic, deepgram, nvidia, huggingface, inworld, cartesia, playht, coqui, tortoise, qwen, ...)
+    const result = await synthesizeViaConfig(provider, input.trim(), model, credentials);
+    if (result) return createTtsResponse(result.base64, result.format, responseFormat);
+
+    return createErrorResult(HTTP_STATUS.BAD_REQUEST, `Provider '${provider}' does not support TTS via this route.`);
+  } catch (err) {
+    return createErrorResult(HTTP_STATUS.BAD_GATEWAY, err.message || "TTS synthesis failed");
+  }
+}

package/open-sse/handlers/ttsProviders/_base.js

@@ -0,0 +1,39 @@
+// Shared TTS helpers
+import { Buffer } from "node:buffer";
+
+export const UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36";
+
+// Convert upstream Response (binary audio) to { base64, format }
+export async function responseToBase64(res, defaultFormat = "mp3") {
+  const buf = await res.arrayBuffer();
+  if (buf.byteLength < 100) throw new Error("Upstream returned empty audio");
+  const ctype = res.headers.get("content-type") || "";
+  let format = defaultFormat;
+  if (ctype.includes("wav")) format = "wav";
+  else if (ctype.includes("mpeg") || ctype.includes("mp3")) format = "mp3";
+  else if (ctype.includes("ogg")) format = "ogg";
+  return { base64: Buffer.from(buf).toString("base64"), format };
+}
+
+export async function throwUpstreamError(res) {
+  const text = await res.text().catch(() => "");
+  let msg = `Upstream error (${res.status})`;
+  try {
+    const parsed = JSON.parse(text);
+    msg = parsed?.error?.message || parsed?.message || parsed?.detail?.message || (typeof parsed?.detail === "string" ? parsed.detail : null) || text || msg;
+  } catch { msg = text || msg; }
+  throw new Error(msg);
+}
+
+// Parse `model` string as "modelId/voiceId" — match against known model list (longest prefix wins)
+export function parseModelVoice(model, defaultModel = "", defaultVoice = "", knownModels = []) {
+  if (!model) return { modelId: defaultModel, voiceId: defaultVoice };
+  const known = knownModels.map((m) => m.id || m).filter(Boolean).sort((a, b) => b.length - a.length);
+  for (const id of known) {
+    if (model === id) return { modelId: id, voiceId: defaultVoice };
+    if (model.startsWith(`${id}/`)) return { modelId: id, voiceId: model.slice(id.length + 1) };
+  }
+  const idx = model.lastIndexOf("/");
+  if (idx > 0) return { modelId: model.slice(0, idx), voiceId: model.slice(idx + 1) };
+  return { modelId: defaultModel || model, voiceId: defaultVoice || model };
+}

package/open-sse/handlers/ttsProviders/edgeTts.js

@@ -0,0 +1,89 @@
+// Microsoft Edge / Bing TTS (no auth) — via Bing translator endpoint
+import { Buffer } from "node:buffer";
+import { UA } from "./_base.js";
+
+const REFRESH_MS = 5 * 60 * 1000; // token TTL ~1h, refresh early
+const VOICES_TTL = 24 * 60 * 60 * 1000;
+
+const cache = { token: null, tokenTime: 0 };
+let _voicesCache = null;
+let _voicesCacheTime = 0;
+
+async function getToken() {
+  const now = Date.now();
+  if (cache.token && now - cache.tokenTime < REFRESH_MS) return cache.token;
+  const res = await fetch("https://www.bing.com/translator", {
+    headers: { "User-Agent": UA, "Accept-Language": "vi,en-US;q=0.9,en;q=0.8" },
+  });
+  if (!res.ok) throw new Error(`Bing translator fetch failed: ${res.status}`);
+  const rawCookies = res.headers.getSetCookie?.() || [];
+  const cookie = rawCookies.map((c) => c.split(";")[0]).join("; ");
+  const html = await res.text();
+  const match = html.match(/params_AbusePreventionHelper\s*=\s*\[([^,]+),([^,]+),/);
+  if (!match) throw new Error("Failed to parse Bing token");
+  cache.token = { key: match[1], token: match[2].replace(/"/g, ""), cookie };
+  cache.tokenTime = now;
+  return cache.token;
+}
+
+async function ttsRequest(text, voiceId, token) {
+  const parts = voiceId.split("-");
+  const xmlLang = parts.slice(0, 2).join("-");
+  const gender = voiceId.toLowerCase().includes("male") ? "Male" : "Female";
+  const ssml = `<speak version='1.0' xml:lang='${xmlLang}'><voice xml:lang='${xmlLang}' xml:gender='${gender}' name='${voiceId}'><prosody rate='0.00%'>${text}</prosody></voice></speak>`;
+  const body = new URLSearchParams();
+  body.append("ssml", ssml);
+  body.append("token", token.token);
+  body.append("key", token.key);
+  return fetch("https://www.bing.com/tfettts?isVertical=1&&IG=1&IID=translator.5023&SFX=1", {
+    method: "POST",
+    body: body.toString(),
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      "Accept": "*/*",
+      "Origin": "https://www.bing.com",
+      "Referer": "https://www.bing.com/translator",
+      "User-Agent": UA,
+      ...(token.cookie ? { "Cookie": token.cookie } : {}),
+    },
+  });
+}
+
+export async function fetchEdgeTtsVoices() {
+  const now = Date.now();
+  if (_voicesCache && now - _voicesCacheTime < VOICES_TTL) return _voicesCache;
+  const res = await fetch(
+    "https://speech.platform.bing.com/consumer/speech/synthesize/readaloud/voices/list?trustedclienttoken=6A5AA1D4EAFF4E9FB37E23D68491D6F4",
+    { headers: { "User-Agent": UA } }
+  );
+  if (!res.ok) throw new Error(`Edge TTS voices fetch failed: ${res.status}`);
+  const voices = await res.json();
+  _voicesCache = voices;
+  _voicesCacheTime = now;
+  return voices;
+}
+
+export default {
+  noAuth: true,
+  async synthesize(text, model) {
+    const voiceId = model || "vi-VN-HoaiMyNeural";
+    let token = await getToken();
+    let res = await ttsRequest(text, voiceId, token);
+
+    // 429/403: invalidate cache and retry once
+    if (res.status === 429 || res.status === 403) {
+      cache.token = null;
+      cache.tokenTime = 0;
+      token = await getToken();
+      res = await ttsRequest(text, voiceId, token);
+    }
+
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Bing TTS failed: ${res.status}${body ? " - " + body : ""}`);
+    }
+    const buf = await res.arrayBuffer();
+    if (buf.byteLength < 1024) throw new Error("Bing TTS returned empty audio");
+    return { base64: Buffer.from(buf).toString("base64"), format: "mp3" };
+  },
+};

package/open-sse/handlers/ttsProviders/elevenlabs.js

@@ -0,0 +1,48 @@
+// ElevenLabs TTS — voice id with optional model_id prefix
+import { Buffer } from "node:buffer";
+
+const VOICES_TTL = 24 * 60 * 60 * 1000;
+const _voicesCache = new Map(); // by API key
+
+export async function fetchElevenLabsVoices(apiKey) {
+  if (!apiKey) throw new Error("ElevenLabs API key required");
+  const now = Date.now();
+  const cached = _voicesCache.get(apiKey);
+  if (cached && now - cached.time < VOICES_TTL) return cached.voices;
+
+  const res = await fetch("https://api.elevenlabs.io/v1/voices", {
+    headers: { "xi-api-key": apiKey, "Content-Type": "application/json" },
+  });
+  if (!res.ok) throw new Error(`ElevenLabs voices fetch failed: ${res.status}`);
+  const data = await res.json();
+  // Normalize: derive lang from labels for grouping
+  const voices = (data.voices || []).map((v) => ({ ...v, lang: v.labels?.language || "en" }));
+  _voicesCache.set(apiKey, { voices, time: now });
+  return voices;
+}
+
+export default {
+  async synthesize(text, model, credentials) {
+    if (!credentials?.apiKey) throw new Error("ElevenLabs API key required");
+    let modelId = "eleven_flash_v2_5";
+    let voiceId = model;
+    if (model && model.includes("/")) [modelId, voiceId] = model.split("/");
+
+    const res = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`, {
+      method: "POST",
+      headers: { "xi-api-key": credentials.apiKey, "Content-Type": "application/json" },
+      body: JSON.stringify({
+        text,
+        model_id: modelId,
+        voice_settings: { stability: 0.5, similarity_boost: 0.75 },
+      }),
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err?.detail?.message || `ElevenLabs TTS failed: ${res.status}`);
+    }
+    const buf = await res.arrayBuffer();
+    if (buf.byteLength < 1024) throw new Error("ElevenLabs TTS returned empty audio");
+    return { base64: Buffer.from(buf).toString("base64"), format: "mp3" };
+  },
+};