@fudrouter/fsrouter 0.6.58 → 0.6.60

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

@@ -1,87 +0,0 @@
-// 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

@@ -1,59 +0,0 @@
-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

@@ -1,30 +0,0 @@
-// 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

@@ -1,70 +0,0 @@
-// 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

@@ -1,93 +0,0 @@
-/**
- * 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

@@ -1,119 +0,0 @@
-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

@@ -1,22 +0,0 @@
-// 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;
-}