@fudrouter/fsrouter 0.6.64 → 0.6.66

package/open-sse/handlers/sseParser.js

@@ -0,0 +1,469 @@
+import { appendToolCallArgumentDelta } from "../utils/toolCallArguments.js";
+import { sanitizeErrorMessage } from "../utils/error.js";
+
+/**
+ * Extract a provider error message from a buffered SSE stream that carries an
+ * error-only chunk (`data: {"error":...}`) and no content chunks.
+ */
+export function extractSSEErrorMessage(rawSSE) {
+  const lines = String(rawSSE || "").split("\n");
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("data:")) continue;
+    const payload = trimmed.slice(5).trim();
+    if (!payload || payload === "[DONE]") continue;
+
+    let parsed;
+    try {
+      parsed = JSON.parse(payload);
+    } catch {
+      continue;
+    }
+
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+    const record = parsed;
+
+    if (Array.isArray(record.choices)) continue;
+
+    const err = record.error;
+    if (err == null) continue;
+
+    let message = "";
+    if (typeof err === "string") {
+      message = err;
+    } else if (typeof err === "object" && !Array.isArray(err)) {
+      const errRecord = err;
+      if (typeof errRecord.message === "string") {
+        message = errRecord.message;
+      } else {
+        message = JSON.stringify(err);
+      }
+    } else {
+      message = String(err);
+    }
+
+    const sanitized = sanitizeErrorMessage(message);
+    if (sanitized) return sanitized;
+  }
+
+  return null;
+}
+
+/**
+ * Convert OpenAI-style SSE chunks into a single non-streaming JSON response.
+ * Used as a fallback when upstream returns text/event-stream for stream=false.
+ */
+function readSSEEvents(rawSSE) {
+  const lines = String(rawSSE || "").split("\n");
+  const events = [];
+  let currentEvent = "";
+  let currentData = [];
+
+  const flush = () => {
+    if (currentData.length === 0) {
+      currentEvent = "";
+      return;
+    }
+
+    const payload = currentData.join("\n").trim();
+    currentData = [];
+    if (!payload || payload === "[DONE]") {
+      currentEvent = "";
+      return;
+    }
+
+    try {
+      const data = JSON.parse(payload);
+      if (
+        currentEvent &&
+        data &&
+        typeof data === "object" &&
+        !Array.isArray(data) &&
+        typeof data.type !== "string"
+      ) {
+        data.type = currentEvent;
+      }
+      events.push({
+        event: currentEvent || undefined,
+        data,
+      });
+    } catch {
+      // Ignore malformed SSE events and continue best-effort parsing.
+    }
+
+    currentEvent = "";
+  };
+
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/\r$/, "");
+    if (line.trim() === "") {
+      flush();
+      continue;
+    }
+
+    if (line.startsWith("event:")) {
+      if (currentData.length > 0) flush();
+      currentEvent = line.slice(6).trim();
+      continue;
+    }
+
+    if (line.startsWith("data:")) {
+      const dataLine = line.slice(5).trimStart();
+      if (dataLine.trim() === "[DONE]") {
+        flush();
+        currentEvent = "";
+        continue;
+      }
+      currentData.push(dataLine);
+    }
+  }
+
+  flush();
+  return events;
+}
+
+function toRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+function toString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+
+function toNumber(value, fallback = 0) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+  }
+  return fallback;
+}
+
+export function parseSSEToOpenAIResponse(rawSSE, fallbackModel) {
+  const lines = String(rawSSE || "").split("\n");
+  const chunks = [];
+  let sawChoices = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("data:")) continue;
+    const payload = trimmed.slice(5).trim();
+    if (!payload || payload === "[DONE]") continue;
+    try {
+      const parsed = JSON.parse(payload);
+      if (Array.isArray(parsed?.choices)) {
+        sawChoices = true;
+      }
+      chunks.push(parsed);
+    } catch {
+      // Ignore malformed SSE lines and continue best-effort parsing.
+    }
+  }
+
+  if (chunks.length === 0 || !sawChoices) return null;
+
+  const first = chunks[0];
+  const contentParts = [];
+  const reasoningParts = [];
+
+  const accumulatedToolCalls = new Map();
+  let unknownToolCallSeq = 0;
+  let finishReason = "stop";
+  let usage = null;
+
+  const getToolCallKey = (toolCall) => {
+    if (Number.isInteger(toolCall?.index)) return `idx:${toolCall.index}`;
+    if (toolCall?.id != null) return `id:${String(toolCall.id)}`;
+    unknownToolCallSeq += 1;
+    return `seq:${unknownToolCallSeq}`;
+  };
+
+  for (const chunk of chunks) {
+    const choice = chunk?.choices?.[0];
+    const delta = choice?.delta || {};
+
+    if (typeof delta.content === "string" && delta.content.length > 0) {
+      contentParts.push(delta.content);
+    }
+    if (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0) {
+      reasoningParts.push(delta.reasoning_content);
+    }
+    if (
+      typeof delta.reasoning === "string" &&
+      delta.reasoning.length > 0 &&
+      !delta.reasoning_content
+    ) {
+      reasoningParts.push(delta.reasoning);
+    }
+
+    // T18: Accumulate tool calls correctly across streamed chunks
+    if (delta.tool_calls) {
+      for (const tc of delta.tool_calls) {
+        const key = getToolCallKey(tc);
+        const existing = accumulatedToolCalls.get(key);
+        const deltaArgs = typeof tc?.function?.arguments === "string" ? tc.function.arguments : "";
+
+        if (!existing) {
+          accumulatedToolCalls.set(key, {
+            id: tc?.id != null ? String(tc.id) : null,
+            index: Number.isInteger(tc?.index) ? tc.index : accumulatedToolCalls.size,
+            type: tc?.type || "function",
+            function: {
+              name: tc?.function?.name || "unknown",
+              arguments: deltaArgs,
+            },
+          });
+        } else {
+          existing.id = existing.id || (tc?.id != null ? String(tc.id) : null);
+          if (!Number.isInteger(existing.index) && Number.isInteger(tc?.index)) {
+            existing.index = tc.index;
+          }
+          if (tc?.function?.name && !existing.function?.name) {
+            existing.function = existing.function || {};
+            existing.function.name = tc.function.name;
+          }
+          existing.function = existing.function || {};
+          existing.function.arguments = appendToolCallArgumentDelta(
+            existing.function.arguments,
+            deltaArgs
+          );
+          accumulatedToolCalls.set(key, existing);
+        }
+      }
+    }
+
+    if (choice?.finish_reason) {
+      finishReason = choice.finish_reason;
+    }
+    if (chunk?.usage && typeof chunk.usage === "object") {
+      usage = chunk.usage;
+    }
+  }
+
+  const joinedContent = contentParts.length > 0 ? contentParts.join("").trim() : "";
+  const joinedReasoning = reasoningParts.length > 0 ? reasoningParts.join("").trim() : null;
+  const message = {
+    role: "assistant",
+    content: joinedContent,
+  };
+  if (joinedReasoning) {
+    message.reasoning_content = joinedReasoning;
+  }
+
+  const finalToolCalls = [...accumulatedToolCalls.values()].filter(Boolean).sort((a, b) => {
+    const ai = Number.isInteger(a?.index) ? a.index : 0;
+    const bi = Number.isInteger(b?.index) ? b.index : 0;
+    return ai - bi;
+  });
+  if (finalToolCalls.length > 0) {
+    finishReason = "tool_calls";
+    message.tool_calls = finalToolCalls;
+  }
+
+  const result = {
+    id: first.id != null ? String(first.id) : `chatcmpl-${Date.now()}`,
+    object: "chat.completion",
+    created: first.created || Math.floor(Date.now() / 1000),
+    model: first.model || fallbackModel || "unknown",
+    choices: [
+      {
+        index: 0,
+        message,
+        finish_reason: finishReason,
+      },
+    ],
+  };
+
+  if (usage) {
+    result.usage = usage;
+  }
+
+  return result;
+}
+
+/**
+ * Convert Claude-style SSE events into a single non-streaming message object.
+ * Used when Claude-compatible upstreams stream even for stream=false.
+ */
+export function parseSSEToClaudeResponse(rawSSE, fallbackModel) {
+  const payloads = readSSEEvents(rawSSE)
+    .map((event) => toRecord(event.data))
+    .filter((payload) => Object.keys(payload).length > 0);
+
+  if (payloads.length === 0) return null;
+
+  const blocks = new Map();
+  const usage = {};
+  let messageId = "";
+  let model = fallbackModel || "claude";
+  let role = "assistant";
+  let stopReason = "end_turn";
+  let stopSequence = null;
+  let sawClaudeEvent = false;
+
+  const mergeUsage = (incoming) => {
+    const usageRecord = toRecord(incoming);
+    for (const [key, value] of Object.entries(usageRecord)) {
+      if (typeof value === "number" && Number.isFinite(value)) {
+        usage[key] = value;
+      } else if (value && typeof value === "object" && !Array.isArray(value)) {
+        usage[key] = { ...toRecord(usage[key]), ...toRecord(value) };
+      } else if (typeof value === "string" && value.trim().length > 0) {
+        usage[key] = value;
+      }
+    }
+  };
+
+  const tryParseJson = (raw) => {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  };
+
+  for (const payload of payloads) {
+    const eventType = toString(payload.type);
+    if (eventType === "message_start") {
+      sawClaudeEvent = true;
+      const message = toRecord(payload.message);
+      messageId = toString(message.id, messageId || `msg_${Date.now()}`);
+      model = toString(message.model, model);
+      role = toString(message.role, role);
+      mergeUsage(message.usage);
+      continue;
+    }
+
+    if (eventType === "content_block_start") {
+      sawClaudeEvent = true;
+      const index = toNumber(payload.index, blocks.size);
+      const contentBlock = toRecord(payload.content_block);
+      const blockType = toString(contentBlock.type);
+
+      if (blockType === "thinking") {
+        blocks.set(index, {
+          type: "thinking",
+          index,
+          thinking: toString(contentBlock.thinking),
+          signature: toString(contentBlock.signature) || undefined,
+        });
+      } else if (blockType === "tool_use") {
+        blocks.set(index, {
+          type: "tool_use",
+          index,
+          id: toString(contentBlock.id, `toolu_${Date.now()}_${index}`),
+          name: toString(contentBlock.name),
+          input: contentBlock.input ?? {},
+          inputJson: "",
+        });
+      } else {
+        blocks.set(index, {
+          type: "text",
+          index,
+          text: toString(contentBlock.text),
+        });
+      }
+      continue;
+    }
+
+    if (eventType === "content_block_delta") {
+      sawClaudeEvent = true;
+      const index = toNumber(payload.index, 0);
+      const delta = toRecord(payload.delta);
+      const deltaType = toString(delta.type);
+      const existing = blocks.get(index);
+
+      if (deltaType === "input_json_delta") {
+        const toolUse =
+          existing && existing.type === "tool_use"
+            ? existing
+            : {
+                type: "tool_use",
+                index,
+                id: `toolu_${Date.now()}_${index}`,
+                name: "",
+                input: {},
+                inputJson: "",
+              };
+        toolUse.inputJson += toString(delta.partial_json);
+        blocks.set(index, toolUse);
+        continue;
+      }
+
+      const isThinkingDelta = deltaType === "thinking_delta" || typeof delta.thinking === "string";
+      const isSignatureDelta =
+        deltaType === "signature_delta" || typeof delta.signature === "string";
+      if (isThinkingDelta || isSignatureDelta) {
+        const thinking =
+          existing && existing.type === "thinking"
+            ? existing
+            : { type: "thinking", index, thinking: "", signature: undefined };
+        if (isThinkingDelta) thinking.thinking += toString(delta.thinking);
+        const signature = toString(delta.signature);
+        if (signature) thinking.signature = `${thinking.signature || ""}${signature}`;
+        blocks.set(index, thinking);
+        continue;
+      }
+
+      const textBlock =
+        existing && existing.type === "text"
+          ? existing
+          : {
+              type: "text",
+              index,
+              text: "",
+            };
+      textBlock.text += toString(delta.text);
+      blocks.set(index, textBlock);
+      continue;
+    }
+
+    if (eventType === "message_delta") {
+      sawClaudeEvent = true;
+      const delta = toRecord(payload.delta);
+      stopReason = toString(delta.stop_reason, stopReason);
+      stopSequence =
+        typeof delta.stop_sequence === "string" ? String(delta.stop_sequence) : stopSequence;
+      mergeUsage(payload.usage);
+      continue;
+    }
+
+    mergeUsage(payload.usage);
+  }
+
+  if (!sawClaudeEvent) return null;
+
+  const content = [];
+  for (const block of [...blocks.values()].sort((a, b) => a.index - b.index)) {
+    if (block.type === "text") {
+      if (block.text) content.push({ type: "text", text: block.text });
+      continue;
+    }
+    if (block.type === "thinking") {
+      const hasSignature = typeof block.signature === "string" && block.signature.length > 0;
+      if (block.thinking || hasSignature) {
+        content.push({
+          type: "thinking",
+          thinking: block.thinking || "",
+          ...(hasSignature ? { signature: block.signature } : {}),
+        });
+      }
+      continue;
+    }
+
+    const input = block.inputJson.trim().length > 0 ? tryParseJson(block.inputJson) : block.input;
+    content.push({ type: "tool_use", id: block.id, name: block.name, input });
+  }
+
+  return {
+    id: messageId || `msg_${Date.now()}`,
+    type: "message",
+    role,
+    model,
+    content,
+    stop_reason: stopReason,
+    ...(stopSequence ? { stop_sequence: stopSequence } : {}),
+    ...(Object.keys(usage).length > 0 ? { usage } : {}),
+  };
+}

package/open-sse/handlers/sttCore.js

@@ -0,0 +1,193 @@
+import { Buffer } from "node:buffer";
+import { createErrorResult } from "../utils/error.js";
+import { HTTP_STATUS } from "../config/runtimeConfig.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, sttConfig }) {
+  const file = formData.get("file");
+  if (!file) return createErrorResult(HTTP_STATUS.BAD_REQUEST, "Missing required field: file");
+
+  const cfg = 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");
+  }
+}