@fudrouter/fsrouter 0.6.64 → 0.6.65

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

@@ -0,0 +1,87 @@
+// Local device TTS — macOS `say` + Windows SAPI + ffmpeg
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const execFileAsync = promisify(execFile);
+
+let _voicesCache = null;
+
+async function fetchVoicesMac() {
+  const { stdout } = await execFileAsync("say", ["-v", "?"]);
+  const voices = [];
+  for (const line of stdout.split("\n")) {
+    const m = line.match(/^([^\s].*?)\s{2,}([a-z]{2}_[A-Z]{2})/);
+    if (!m) continue;
+    const name = m[1].trim();
+    const locale = m[2].trim();
+    const lang = locale.split("_")[0];
+    const country = locale.split("_")[1];
+    voices.push({ id: name, name, locale, lang, country, gender: "" });
+  }
+  return voices;
+}
+
+async function fetchVoicesWin() {
+  const script = [
+    "Add-Type -AssemblyName System.Speech;",
+    "$s = New-Object System.Speech.Synthesis.SpeechSynthesizer;",
+    "$s.GetInstalledVoices() | ForEach-Object { $v = $_.VoiceInfo;",
+    "[PSCustomObject]@{ Name=$v.Name; Culture=$v.Culture.Name; Gender=$v.Gender } }",
+    "| ConvertTo-Json -Compress",
+  ].join(" ");
+  const { stdout } = await execFileAsync(
+    "powershell.exe",
+    ["-NoProfile", "-NonInteractive", "-WindowStyle", "Hidden", "-Command", script],
+    { windowsHide: true }
+  );
+  const raw = JSON.parse(stdout.trim() || "[]");
+  const list = Array.isArray(raw) ? raw : [raw];
+  return list.map((v) => {
+    const culture = v.Culture || "en-US";
+    const [lang, country = ""] = culture.split("-");
+    const genderMap = { 1: "Male", 2: "Female", Male: "Male", Female: "Female" };
+    return {
+      id: v.Name, name: v.Name,
+      locale: culture.replace("-", "_"),
+      lang, country,
+      gender: genderMap[v.Gender] || "",
+    };
+  });
+}
+
+export async function fetchLocalDeviceVoices() {
+  if (_voicesCache) return _voicesCache;
+  try {
+    const voices = process.platform === "win32" ? await fetchVoicesWin() : await fetchVoicesMac();
+    _voicesCache = voices;
+    return voices;
+  } catch {
+    return [];
+  }
+}
+
+async function synthesizeMacOrWin(text, voiceId) {
+  const dir = await mkdtemp(join(tmpdir(), "tts-"));
+  const aiffPath = join(dir, "out.aiff");
+  const mp3Path = join(dir, "out.mp3");
+  try {
+    const args = voiceId ? ["-v", voiceId, "-o", aiffPath, text] : ["-o", aiffPath, text];
+    await execFileAsync("say", args);
+    await execFileAsync("ffmpeg", ["-y", "-i", aiffPath, "-codec:a", "libmp3lame", "-qscale:a", "4", mp3Path]);
+    const buf = await readFile(mp3Path);
+    return buf.toString("base64");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+export default {
+  noAuth: true,
+  async synthesize(text, model) {
+    const base64 = await synthesizeMacOrWin(text, model);
+    return { base64, format: "mp3" };
+  },
+};

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

@@ -0,0 +1,59 @@
+import { Buffer } from "node:buffer";
+
+function hexToBase64(audioHex) {
+  const clean = typeof audioHex === "string" ? audioHex.trim() : "";
+  if (!clean) throw new Error("MiniMax TTS returned no audio");
+  if (clean.length % 2 !== 0 || !/^[0-9a-f]+$/i.test(clean)) {
+    throw new Error("MiniMax TTS returned invalid audio");
+  }
+  return Buffer.from(clean, "hex").toString("base64");
+}
+
+// MiniMax T2A HTTP: returns hex-encoded audio in non-streaming mode.
+export default async function minimaxTts({ baseUrl, apiKey, text, modelId, voiceId }) {
+  const res = await fetch(baseUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "Authorization": `Bearer ${apiKey}` },
+    body: JSON.stringify({
+      model: modelId || "speech-2.8-hd",
+      text,
+      stream: false,
+      language_boost: "auto",
+      output_format: "hex",
+      voice_setting: {
+        voice_id: voiceId || "English_expressive_narrator",
+        speed: 1,
+        vol: 1,
+        pitch: 0,
+      },
+      audio_setting: {
+        sample_rate: 32000,
+        bitrate: 128000,
+        format: "mp3",
+        channel: 1,
+      },
+    }),
+  });
+
+  const rawText = await res.text();
+  let data = {};
+  if (rawText) {
+    try { data = JSON.parse(rawText); } catch { data = {}; }
+  }
+
+  const baseResp = data.base_resp || data.baseResp || {};
+  const statusCode = Number(baseResp.status_code ?? baseResp.statusCode ?? 0);
+  const statusMessage = baseResp.status_msg || baseResp.statusMsg || data.message || "";
+
+  if (!res.ok) {
+    throw new Error(statusMessage || rawText || `MiniMax TTS error (${res.status})`);
+  }
+  if (statusCode !== 0) {
+    throw new Error(statusMessage || "MiniMax TTS upstream error");
+  }
+
+  return {
+    base64: hexToBase64(data.data?.audio),
+    format: data.extra_info?.audio_format || data.extraInfo?.audioFormat || "mp3",
+  };
+}

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

@@ -0,0 +1,30 @@
+// OpenAI TTS — model format: "tts-model/voice"
+import { Buffer } from "node:buffer";
+
+export default {
+  async synthesize(text, model, credentials) {
+    if (!credentials?.apiKey) throw new Error("No OpenAI API key configured");
+
+    let ttsModel = "gpt-4o-mini-tts";
+    let voice = "alloy";
+    if (model && model.includes("/")) {
+      const parts = model.split("/");
+      if (parts.length === 2) [ttsModel, voice] = parts;
+    } else if (model) {
+      voice = model;
+    }
+
+    const baseUrl = (credentials.baseUrl || "https://api.openai.com").replace(/\/+$/, "");
+    const res = await fetch(`${baseUrl}/v1/audio/speech`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "Authorization": `Bearer ${credentials.apiKey}` },
+      body: JSON.stringify({ model: ttsModel, voice, input: text }),
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err?.error?.message || `OpenAI TTS failed: ${res.status}`);
+    }
+    const buf = await res.arrayBuffer();
+    return { base64: Buffer.from(buf).toString("base64"), format: "mp3" };
+  },
+};

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

@@ -0,0 +1,70 @@
+// OpenRouter TTS — via chat completions + audio modality (SSE stream)
+export default {
+  async synthesize(text, model, credentials) {
+    if (!credentials?.apiKey) throw new Error("No OpenRouter API key configured");
+
+    // model format: "tts-model/voice" e.g. "openai/gpt-4o-mini-tts/alloy"
+    let ttsModel = "openai/gpt-4o-mini-tts";
+    let voice = "alloy";
+    if (model && model.includes("/")) {
+      const lastSlash = model.lastIndexOf("/");
+      const maybVoice = model.slice(lastSlash + 1);
+      const maybeModel = model.slice(0, lastSlash);
+      if (maybeModel.includes("/")) {
+        ttsModel = maybeModel;
+        voice = maybVoice;
+      } else {
+        voice = model;
+      }
+    } else if (model) {
+      voice = model;
+    }
+
+    const res = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${credentials.apiKey}`,
+        "HTTP-Referer": "https://endpoint-proxy.local",
+        "X-Title": "Endpoint Proxy",
+      },
+      body: JSON.stringify({
+        model: ttsModel,
+        modalities: ["text", "audio"],
+        audio: { voice, format: "wav" },
+        stream: true,
+        messages: [{ role: "user", content: text }],
+      }),
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err?.error?.message || `OpenRouter TTS failed: ${res.status}`);
+    }
+
+    // Parse SSE stream, accumulate base64 audio chunks
+    const chunks = [];
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop();
+      for (const line of lines) {
+        if (!line.startsWith("data: ") || line === "data: [DONE]") continue;
+        try {
+          const json = JSON.parse(line.slice(6));
+          const audioData = json.choices?.[0]?.delta?.audio?.data;
+          if (audioData) chunks.push(audioData);
+        } catch {}
+      }
+    }
+
+    if (chunks.length === 0) throw new Error("OpenRouter TTS returned no audio data");
+    return { base64: chunks.join(""), format: "wav" };
+  },
+};

package/open-sse/handlers/usageExtractor.js

@@ -0,0 +1,93 @@
+/**
+ * Extract usage from non-streaming response body
+ * Handles different provider response formats
+ */
+export function extractUsageFromResponse(responseBody, provider) {
+  if (!responseBody || typeof responseBody !== "object") return null;
+  const providerId = typeof provider === "string" ? provider.toLowerCase() : "";
+  const isClaudeProvider =
+    providerId === "claude" ||
+    providerId === "anthropic" ||
+    providerId.startsWith("anthropic-compatible");
+
+  // OpenAI format (has prompt_tokens / completion_tokens)
+  if (
+    responseBody.usage &&
+    typeof responseBody.usage === "object" &&
+    responseBody.usage.prompt_tokens !== undefined
+  ) {
+    return {
+      prompt_tokens: responseBody.usage.prompt_tokens || 0,
+      completion_tokens: responseBody.usage.completion_tokens || 0,
+      // DeepSeek native API uses flat prompt_cache_hit_tokens (NOT
+      // prompt_tokens_details.cached_tokens). Fall back to it so V4 cache
+      // gets surfaced into kanban call_logs alongside the OpenAI/Claude paths.
+      cached_tokens:
+        responseBody.usage.prompt_tokens_details?.cached_tokens ??
+        responseBody.usage.input_tokens_details?.cached_tokens ??
+        responseBody.usage.prompt_cache_hit_tokens ??
+        responseBody.usage.cached_tokens,
+      reasoning_tokens:
+        responseBody.usage.completion_tokens_details?.reasoning_tokens ??
+        responseBody.usage.output_tokens_details?.reasoning_tokens ??
+        responseBody.usage.reasoning_tokens,
+    };
+  }
+
+  // Claude format
+  if (
+    isClaudeProvider &&
+    responseBody.usage &&
+    typeof responseBody.usage === "object" &&
+    (responseBody.usage.input_tokens !== undefined ||
+      responseBody.usage.output_tokens !== undefined)
+  ) {
+    const inputTokens = responseBody.usage.input_tokens || 0;
+    const cacheRead = responseBody.usage.cache_read_input_tokens || 0;
+    const cacheCreation = responseBody.usage.cache_creation_input_tokens || 0;
+
+    // Total prompt tokens = input + cache_read + cache_creation (per Claude API docs)
+    const promptTokens = inputTokens + cacheRead + cacheCreation;
+
+    return {
+      prompt_tokens: promptTokens,
+      completion_tokens: responseBody.usage.output_tokens || 0,
+      cache_read_input_tokens: cacheRead,
+      cache_creation_input_tokens: cacheCreation,
+    };
+  }
+
+  // OpenAI Responses API format (input_tokens / output_tokens)
+  const responsesUsage = responseBody.response?.usage || responseBody.usage;
+  if (
+    responsesUsage &&
+    typeof responsesUsage === "object" &&
+    (responsesUsage.input_tokens !== undefined || responsesUsage.output_tokens !== undefined)
+  ) {
+    return {
+      prompt_tokens: responsesUsage.input_tokens || 0,
+      completion_tokens: responsesUsage.output_tokens || 0,
+      cache_read_input_tokens: responsesUsage.cache_read_input_tokens,
+      cached_tokens:
+        responsesUsage.input_tokens_details?.cached_tokens ??
+        responsesUsage.prompt_tokens_details?.cached_tokens ??
+        responsesUsage.cache_read_input_tokens,
+      cache_creation_input_tokens: responsesUsage.cache_creation_input_tokens,
+      reasoning_tokens:
+        responsesUsage.output_tokens_details?.reasoning_tokens ??
+        responsesUsage.completion_tokens_details?.reasoning_tokens ??
+        responsesUsage.reasoning_tokens,
+    };
+  }
+
+  // Gemini format
+  if (responseBody.usageMetadata && typeof responseBody.usageMetadata === "object") {
+    return {
+      prompt_tokens: responseBody.usageMetadata.promptTokenCount || 0,
+      completion_tokens: responseBody.usageMetadata.candidatesTokenCount || 0,
+      reasoning_tokens: responseBody.usageMetadata.thoughtsTokenCount,
+    };
+  }
+
+  return null;
+}

package/open-sse/handlers/videoGenerationCore.js

@@ -0,0 +1,119 @@
+import { createErrorResult } from "../utils/error.js";
+import { HTTP_STATUS } from "../config/runtimeConfig.js";
+import { getVideoAdapter } from "./videoProviders/index.js";
+
+/**
+ * Core video generation handler — orchestrator only.
+ * Provider-specific logic lives in `./videoProviders/{id}.js`.
+ *
+ * Each adapter exports a `generate(credentials, prompt, body, log)` method
+ * that returns `{ urls: string[], genId: string }`.
+ *
+ * @param {object} options
+ * @param {object} options.body  - Request body { model, prompt, size, duration, ... }
+ * @param {object} options.modelInfo - { provider, model }
+ * @param {object} options.credentials - Provider credentials
+ * @param {object} [options.log] - Logger
+ * @param {function} [options.onRequestSuccess]
+ * @returns {Promise<{ success: boolean, response: Response, status?: number, error?: string }>}
+ */
+export async function handleVideoGenerationCore({
+  body,
+  modelInfo,
+  credentials,
+  log,
+  onRequestSuccess,
+  onRequestFailure,
+}) {
+  const { provider, model } = modelInfo;
+
+  if (!body.prompt) {
+    return createErrorResult(HTTP_STATUS.BAD_REQUEST, "Missing required field: prompt");
+  }
+
+  const adapter = getVideoAdapter(provider);
+  if (!adapter) {
+    return createErrorResult(
+      HTTP_STATUS.BAD_REQUEST,
+      `Provider '${provider}' does not support video generation`
+    );
+  }
+
+  log?.debug?.("VIDEO", `${provider.toUpperCase()} | ${model} | prompt="${(body.prompt || "").slice(0, 50)}..."`);
+
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      // Send a single space immediately to force Cloudflare to flush headers
+      try {
+        controller.enqueue(encoder.encode(" "));
+      } catch (e) {
+        log?.debug?.("VIDEO", `Stream start enqueue error: ${e.message}`);
+      }
+
+      const interval = setInterval(() => {
+        try {
+          controller.enqueue(encoder.encode(" "));
+        } catch (e) {
+          clearInterval(interval);
+        }
+      }, 15000);
+
+      try {
+        const result = await adapter.generate(credentials, body.prompt, { ...body, model }, log);
+        clearInterval(interval);
+
+        if (onRequestSuccess) await onRequestSuccess();
+
+        const created = Math.floor(Date.now() / 1000);
+        const urls = result?.urls || [];
+        const responseBody = {
+          created,
+          data: urls.map((url) => ({ url })),
+          model,
+          provider,
+        };
+
+        controller.enqueue(encoder.encode(JSON.stringify(responseBody)));
+        controller.close();
+      } catch (error) {
+        clearInterval(interval);
+        const msg = error?.message || `${provider} video generation failed`;
+        log?.debug?.("VIDEO", `Error: ${msg}`);
+
+        if (onRequestFailure) {
+          try {
+            await onRequestFailure(error);
+          } catch (failErr) {
+            log?.debug?.("VIDEO", `onRequestFailure callback error: ${failErr.message}`);
+          }
+        }
+        
+        const errorBody = {
+          error: {
+            message: msg,
+            type: "api_error",
+            code: "bad_gateway",
+          }
+        };
+        try {
+          controller.enqueue(encoder.encode(JSON.stringify(errorBody)));
+        } catch (e) {}
+        controller.close();
+      }
+    }
+  });
+
+  return {
+    success: true,
+    response: new Response(stream, {
+      headers: {
+        "Content-Type": "application/json",
+        "X-Accel-Buffering": "no",
+        "Cache-Control": "no-cache, no-transform",
+        "Connection": "keep-alive",
+        "Access-Control-Allow-Origin": "*",
+      },
+    }),
+  };
+}

package/open-sse/handlers/videoProviders/index.js

@@ -0,0 +1,22 @@
+// Video provider adapter registry
+// Add new video providers here following the same pattern as imageProviders/index.js
+import leonardoVideo from "./leonardo.js";
+import weavyVideo from "./weavy.js";
+
+const ADAPTERS = {
+  leonardo: leonardoVideo,
+  weavy: weavyVideo,
+};
+
+/**
+ * Get the video adapter for a given provider ID.
+ * @param {string} provider
+ * @returns {object|null} adapter with a `generate(credentials, prompt, body, log)` method
+ */
+export function getVideoAdapter(provider) {
+  return ADAPTERS[provider] || null;
+}
+
+export function isVideoProvider(provider) {
+  return provider in ADAPTERS;
+}