@fudrouter/fsrouter 0.6.58 → 0.6.60

package/open-sse/handlers/sseParser.js

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

@@ -1,193 +0,0 @@
-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");
-  }
-}