@amir83nasr/10router 0.1.14 → 0.1.16

package/open-sse/handlers/chatCore/sseToJsonHandler.js

@@ -10,7 +10,12 @@ import {
   saveUsageStats,
   formatDoneLine,
 } from "./requestDetail.js";
-import { ROLE, RESPONSES_ITEM } from "../../translator/schema/index.js";
+import { ROLE, RESPONSES_ITEM, CLAUDE_BLOCK } from "../../translator/schema/index.js";
+import {
+  chatCompletionToClaudeMessage,
+  claudeMessageToChatCompletion,
+  parseClaudeSSEToMessage,
+} from "./claudeMessageBody.js";
 
 // Responses-API providers (e.g. codex) may emit SSE without content-type + use Responses output shape
 const isResponsesProvider = (p) => PROVIDERS[p]?.format === FORMATS.OPENAI_RESPONSES;
@@ -227,10 +232,15 @@ export async function handleForcedSSEToJson({
   log,
 }) {
   const contentType = providerResponse.headers.get("content-type") || "";
+  // Responses-API providers (codex) are known to stream without a content type;
+  // for every other provider an absent header means the body is not a stream we
+  // may consume here — returning null leaves it intact for the JSON handler.
   const isSSE =
     contentType.includes("text/event-stream") ||
     (contentType === "" && isResponsesProvider(provider));
-  if (!isSSE) return null; // not handled here
+  // Not an aggregated stream — the caller falls back to the JSON handler. The
+  // pending counter must stay untouched here: this handler did not serve it.
+  if (!isSSE) return null;
 
   trackDone();
 
@@ -251,6 +261,15 @@ export async function handleForcedSSEToJson({
   if (isCodexResponsesApi) {
     try {
       const jsonResponse = await convertResponsesStreamToJson(providerResponse.body);
+      // A `response.failed` event is the upstream's own failure signal; an empty
+      // "successful" body would hide it from the client.
+      if (jsonResponse.status === "failed") {
+        appendLog({ status: `FAILED ${HTTP_STATUS.BAD_GATEWAY}` });
+        return createErrorResult(
+          HTTP_STATUS.BAD_GATEWAY,
+          "Upstream Responses stream reported failure",
+        );
+      }
       if (onRequestSuccess) await onRequestSuccess();
 
       const usage = jsonResponse.usage || {};
@@ -345,7 +364,36 @@ export async function handleForcedSSEToJson({
       }));
       const hasToolCalls = toolCalls.length > 0;
 
-      if (sourceFormat === FORMATS.ANTIGRAVITY || sourceFormat === FORMATS.GEMINI) {
+      if (sourceFormat === FORMATS.CLAUDE) {
+        // The client speaks Anthropic Messages: reuse the same conversion a
+        // chat-native upstream gets, so both forced-stream upstream dialects
+        // produce one identical Claude body.
+        finalResp = chatCompletionToClaudeMessage({
+          id: jsonResponse.id,
+          created: jsonResponse.created_at,
+          model: jsonResponse.model || model,
+          choices: [
+            {
+              index: 0,
+              message: {
+                role: ROLE.ASSISTANT,
+                content: textContent,
+                ...(hasToolCalls ? { tool_calls: toolCalls } : {}),
+              },
+              finish_reason: hasToolCalls
+                ? "tool_calls"
+                : jsonResponse.status === "completed" || jsonResponse.status === "done"
+                  ? "stop"
+                  : jsonResponse.status || "stop",
+            },
+          ],
+          usage: {
+            prompt_tokens: inTokens,
+            completion_tokens: outTokens,
+            ...cacheDetails,
+          },
+        });
+      } else if (sourceFormat === FORMATS.ANTIGRAVITY || sourceFormat === FORMATS.GEMINI) {
         finalResp = {
           response: {
             candidates: [
@@ -406,6 +454,94 @@ export async function handleForcedSSEToJson({
   // Standard Chat Completions SSE path
   try {
     const sseText = await providerResponse.text();
+
+    // A provider that speaks Claude on the wire (opencode's `union-alpha`, any
+    // anthropic-compatible endpoint) streams Anthropic events, which the chat
+    // aggregator cannot fold — it would produce an empty message. Aggregate in
+    // the format the upstream actually used.
+    //
+    // `targetFormat` is what we asked for, not proof of what came back: some
+    // providers answer their Claude transport in OpenAI dialect. The aggregator
+    // returns null when no Anthropic event was seen, and the standard chat path
+    // below then handles the body it really is.
+    const isClaudeUpstream =
+      targetFormat === FORMATS.CLAUDE || /"type"\s*:\s*"message_start"/.test(sseText);
+    const claudeMessage = isClaudeUpstream ? parseClaudeSSEToMessage(sseText, model) : null;
+    if (claudeMessage) {
+      const message = claudeMessage;
+      if (message.error) {
+        const upstreamCode = String(message.error.code || "");
+        const status =
+          message.error.type === "invalid_request_error" ||
+          upstreamCode === "context_length_exceeded" ||
+          upstreamCode === "bad_request"
+            ? HTTP_STATUS.BAD_REQUEST
+            : HTTP_STATUS.BAD_GATEWAY;
+        return createErrorResult(status, message.error.message || "Upstream SSE stream failed");
+      }
+
+      if (onRequestSuccess) await onRequestSuccess();
+
+      const usage = message.usage || {};
+      appendLog({ tokens: usage, status: "200 OK" });
+      saveUsageStats({
+        provider,
+        model,
+        tokens: usage,
+        connectionId,
+        apiKey,
+        endpoint: clientRawRequest?.endpoint,
+        silent: true,
+      });
+      if (log?.line)
+        log.line(
+          reqTag,
+          "DONE",
+          formatDoneLine({ usage, latency: { total: Date.now() - requestStartTime } }),
+        );
+
+      const totalLatency = Date.now() - requestStartTime;
+      const textBlocks = (message.content || []).filter((b) => b.type === CLAUDE_BLOCK.TEXT);
+      const thinkingBlocks = (message.content || []).filter(
+        (b) => b.type === CLAUDE_BLOCK.THINKING,
+      );
+      saveRequestDetail(
+        buildRequestDetail(
+          {
+            ...ctx,
+            latency: { ttft: totalLatency, total: totalLatency },
+            tokens: {
+              prompt_tokens: usage.input_tokens || 0,
+              completion_tokens: usage.output_tokens || 0,
+            },
+            response: {
+              content: textBlocks.map((b) => b.text || "").join("") || null,
+              thinking: thinkingBlocks.map((b) => b.thinking || "").join("") || null,
+              finish_reason: message.stop_reason || "unknown",
+            },
+            status: "success",
+          },
+          { endpoint: clientRawRequest?.endpoint || null },
+        ),
+      ).catch(() => {});
+
+      // Claude → chat conversion only when the client asked for chat; a Claude
+      // client (or any other) receives the aggregated message unchanged.
+      const finalBody =
+        sourceFormat === FORMATS.CLAUDE
+          ? message
+          : sourceFormat === FORMATS.OPENAI
+            ? claudeMessageToChatCompletion(message)
+            : message;
+
+      return {
+        success: true,
+        response: new Response(JSON.stringify(restoreToolNames(finalBody, toolNameMap)), {
+          headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
+        }),
+      };
+    }
+
     const parsed = parseSSEToOpenAIResponse(sseText, model);
     if (!parsed)
       return createErrorResult(
@@ -491,10 +627,17 @@ export async function handleForcedSSEToJson({
     // lost on the non-streaming return path. Inlined (not imported from
     // nonStreamingHandler.js) to avoid a circular import: nonStreamingHandler
     // already imports parseSSEToOpenAIResponse from this module.
+    // A Claude-format client gets an Anthropic `message`, never a raw
+    // `chat.completion`. Every non-streaming /v1/messages request lands here
+    // when the provider forces streaming (opencode, codex, zed, openai), and
+    // Claude Code reads `message.content[]` — an OpenAI body throws a TypeError
+    // inside the client, which auto mode reports as "classifier unavailable".
     const finalBody =
       sourceFormat === FORMATS.OPENAI_RESPONSES
         ? chatCompletionToResponses(parsed, customToolNames)
-        : parsed;
+        : sourceFormat === FORMATS.CLAUDE
+          ? chatCompletionToClaudeMessage(parsed)
+          : parsed;
 
     return {
       success: true,

package/open-sse/handlers/chatCore.js

@@ -177,10 +177,24 @@ export async function handleChatCore({
     }
   }
 
+  // Client preference (what the response must look like) is independent of the
+  // transport a provider needs. `stream` below is the upstream flag; the
+  // client-facing decision is `clientWantsJson` further down.
+  const acceptHeader = clientRawRequest?.headers?.accept || "";
+  const clientPrefersJson = acceptHeader.includes("application/json");
+  const clientPrefersSSE = acceptHeader.includes("text/event-stream");
   const clientRequestedStreaming =
     body.stream === true || sourceFormat === FORMATS.ANTIGRAVITY || sourceFormat === FORMATS.GEMINI;
   const providerRequiresStreaming = PROVIDERS[provider]?.forceStream === true;
-  let stream = providerRequiresStreaming ? true : body.stream !== false;
+  // Anthropic Messages defaults to a JSON body when `stream` is omitted; OpenAI
+  // chat callers have historically been served SSE in that case here. An
+  // explicit Accept: text/event-stream still opts a Claude client into SSE.
+  const sourceDefaultsToJson = sourceFormat === FORMATS.CLAUDE && !clientPrefersSSE;
+  let stream = providerRequiresStreaming
+    ? true
+    : body.stream === undefined
+      ? !sourceDefaultsToJson
+      : body.stream !== false;
 
   // Image generation models require non-streaming (Google v1internal:generateContent)
   const modelType = getModelType(alias, model);
@@ -197,9 +211,8 @@ export async function handleChatCore({
 
   // Check client Accept header preference for non-streaming requests
   // This fixes AI SDK compatibility where clients send Accept: application/json
-  const acceptHeader = clientRawRequest?.headers?.accept || "";
-  const clientPrefersJson = acceptHeader.includes("application/json");
-  const clientPrefersSSE = acceptHeader.includes("text/event-stream");
+  // (`acceptHeader`, `clientPrefersJson` and `clientPrefersSSE` are resolved
+  // with the stream negotiation above so both decisions share one reading.)
   if (
     clientPrefersJson &&
     !clientPrefersSSE &&
@@ -293,6 +306,21 @@ export async function handleChatCore({
     stripContinuityFields(translatedBody);
   }
 
+  // Reasoning depth is a model capability, so a model that cannot reason silently
+  // loses the client's effort selection inside applyThinking. Report that drop
+  // once per request: without it an ignored effort looks like a provider quirk.
+  const requestedThinking = extractThinking(body);
+  if (requestedThinking && requestedThinking.mode !== "none") {
+    const thinkingCaps = getCapabilitiesForModel(provider, stripThinkingSuffix(upstreamModel));
+    if (!thinkingCaps.reasoning) {
+      const requested = log?.fmtThink?.(requestedThinking) || requestedThinking.mode;
+      log?.warn?.(
+        "THINKING",
+        `${provider}/${model} cannot reason — requested ${requested} omitted`,
+      );
+    }
+  }
+
   // Dedupe duplicate built-in tools when equivalent MCP tools are present (Claude clients only).
   if (clientTool === "claude" && Array.isArray(translatedBody.tools)) {
     const { tools: deduped, stripped } = dedupeTools(translatedBody.tools);
@@ -687,9 +715,20 @@ export async function handleChatCore({
     appendRequestLog({ model, provider, connectionId, ...extra }).catch(() => {});
   const trackDone = () => trackPendingRequest(model, provider, connectionId, false);
 
-  // Provider forced streaming but client wants JSON
-  if (!clientRequestedStreaming && providerRequiresStreaming) {
-    const result = await handleForcedSSEToJson({
+  // The client did not ask for SSE: either the provider only streams, or the
+  // request was negotiated as JSON. Aggregating the upstream stream is tried
+  // first; it declines a non-SSE body so a provider that ignored `stream` — or
+  // one that answered JSON on a forced-stream endpoint — still reaches the
+  // ordinary non-streaming handler instead of being written as an SSE response.
+  const clientWantsJson =
+    !stream ||
+    (providerRequiresStreaming && !clientRequestedStreaming && !clientPrefersSSE) ||
+    // Source-format contract: an Anthropic Messages client that did not ask to
+    // stream keeps a JSON body even if its provider forces streaming upstream.
+    (sourceFormat === FORMATS.CLAUDE && body.stream !== true && !clientPrefersSSE);
+
+  if (clientWantsJson) {
+    const forcedResult = await handleForcedSSEToJson({
       ...sharedCtx,
       providerResponse,
       sourceFormat,
@@ -699,14 +738,11 @@ export async function handleChatCore({
       trackDone,
       appendLog,
     });
-    if (result) {
+    if (forcedResult) {
       streamController.handleComplete();
-      return result;
+      return forcedResult;
     }
-  }
 
-  // True non-streaming response
-  if (!stream) {
     const result = await handleNonStreamingResponse({
       ...sharedCtx,
       providerResponse,

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

@@ -15,7 +15,6 @@ const OPENAI_COMPAT_PROVIDERS = [
   "github",
   "nvidia",
   "jina-ai",
-  "vercel-ai-gateway",
 ];
 
 const ADAPTERS = {

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

@@ -4,7 +4,6 @@ import gemini from "./gemini.js";
 import codex from "./codex.js";
 import sdwebui from "./sdwebui.js";
 import comfyui from "./comfyui.js";
-import huggingface from "./huggingface.js";
 import nanobanana from "./nanobanana.js";
 import falAi from "./falAi.js";
 import stabilityAi from "./stabilityAi.js";
@@ -14,16 +13,13 @@ import antigravity from "./antigravity.js";
 
 const ADAPTERS = {
   openai: createOpenAIAdapter("openai"),
-  minimax: createOpenAIAdapter("minimax"),
   openrouter: createOpenAIAdapter("openrouter"),
   recraft: createOpenAIAdapter("recraft"),
-  "vercel-ai-gateway": createOpenAIAdapter("vercel-ai-gateway"),
   xai: createOpenAIAdapter("xai"),
   gemini,
   codex,
   sdwebui,
   comfyui,
-  huggingface,
   nanobanana,
   antigravity,
   "fal-ai": falAi,

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

@@ -1,4 +1,4 @@
-// OpenAI-compatible adapter (used by openai, minimax, openrouter, recraft)
+// OpenAI-compatible adapter (used by openai, openrouter, recraft)
 import { PROVIDER_MEDIA } from "../../providers/index.js";
 
 const imageCfg = (id) => PROVIDER_MEDIA[id]?.imageConfig || {};

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

@@ -347,33 +347,6 @@ function buildSearxngRequest(config, params) {
   };
 }
 
-function buildXquikRequest(config, params) {
-  const apiKey = params.token;
-  if (!apiKey) throw new Error("Xquik requires an API key");
-
-  const queryType = getProviderSetting(params, "queryType");
-  if (queryType && !["Latest", "Top"].includes(queryType)) {
-    throw new Error("Xquik queryType must be Latest or Top");
-  }
-
-  const qp = new URLSearchParams({
-    q: params.query,
-    limit: String(params.maxResults),
-  });
-  const cursor = getProviderSetting(params, "cursor");
-  if (cursor) qp.set("cursor", cursor);
-  if (queryType) qp.set("queryType", queryType);
-  if (params.language) qp.set("language", params.language);
-
-  return {
-    url: `${resolveBaseUrl(config, params)}?${qp}`,
-    init: {
-      method: "GET",
-      headers: { Accept: "application/json", "x-api-key": apiKey },
-    },
-  };
-}
-
 // ── Ollama Cloud web_search ──────────────────────────────────────────────
 // POST https://ollama.com/api/web_search { query, max_results }
 // Response: { results: [{ title, url, content, published_at? }] }
@@ -435,7 +408,6 @@ const BUILDERS = {
   searchapi: buildSearchApiRequest,
   youcom: buildYouComRequest,
   searxng: buildSearxngRequest,
-  xquik: buildXquikRequest,
   "ollama-search": buildOllamaSearchRequest,
   glm: buildGlmSearchRequest,
 };

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

@@ -1,7 +1,7 @@
 /**
  * Wrap chat-completions endpoints (with built-in web search) into the unified
  * /v1/search response format. Supports gemini, antigravity, openai, xai,
- * minimax, perplexity.
+ * perplexity.
  */
 import { PROVIDER_MEDIA } from "../../providers/index.js";
 import { ANTIGRAVITY_IDE_USER_AGENT } from "../../providers/shared.js";
@@ -253,62 +253,6 @@ const CHAT_SEARCH_CONFIG = {
     },
   },
 
-  minimax: {
-    endpoint: () => searchEndpoint("minimax"),
-    buildBody: (query, model) => ({
-      model,
-      messages: [{ role: "user", content: query }],
-      tools: [{ type: "web_search" }],
-    }),
-    buildHeaders: (token) => ({
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`,
-    }),
-    extractAnswer: (data) => {
-      const msg = data?.choices?.[0]?.message || {};
-      const text = msg.content || "";
-      const citations = [];
-      const direct = Array.isArray(data?.web_search_results) ? data.web_search_results : [];
-      for (const it of direct) {
-        const url = it?.url || it?.link;
-        if (url) {
-          citations.push({
-            url,
-            title: it.title || "",
-            snippet: it.snippet || it.summary || "",
-          });
-        }
-      }
-      if (!citations.length) {
-        const calls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
-        for (const call of calls) {
-          const argStr = call?.function?.arguments;
-          if (!argStr) continue;
-          let parsed;
-          try {
-            parsed = typeof argStr === "string" ? JSON.parse(argStr) : argStr;
-          } catch {
-            continue;
-          }
-          const items = parsed?.results || parsed?.search_results || [];
-          if (Array.isArray(items)) {
-            for (const it of items) {
-              const url = it?.url || it?.link;
-              if (!url) continue;
-              citations.push({
-                url,
-                title: it.title || "",
-                snippet: it.snippet || "",
-              });
-            }
-          }
-        }
-      }
-      const tokens = data?.usage?.total_tokens || 0;
-      return { text, citations, tokens };
-    },
-  },
-
   perplexity: {
     endpoint: () => searchEndpoint("perplexity"),
     buildBody: (query, model) => ({

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

@@ -281,54 +281,6 @@ function normalizeSearxng(data, _query, _searchType) {
   return { results, totalResults: results.length };
 }
 
-function normalizeXquik(data, _query, _searchType) {
-  const now = new Date().toISOString();
-  const items = Array.isArray(data.tweets) ? data.tweets : [];
-  const results = items.map((item, idx) => {
-    const username = typeof item?.author?.username === "string" ? item.author.username : "";
-    const authorName = typeof item?.author?.name === "string" ? item.author.name : "";
-    const tweetId = typeof item?.id === "string" ? item.id : String(item?.id || "");
-    const url =
-      username && tweetId
-        ? `https://x.com/${encodeURIComponent(username)}/status/${encodeURIComponent(tweetId)}`
-        : tweetId
-          ? `https://x.com/i/web/status/${encodeURIComponent(tweetId)}`
-          : "";
-    const author = username ? `@${username}` : authorName || null;
-    const title = author ? `${author} on X` : "X post";
-    const imageUrl = Array.isArray(item?.media)
-      ? item.media.find((media) => typeof media?.mediaUrl === "string")?.mediaUrl
-      : null;
-
-    return makeResult(
-      "xquik",
-      {
-        title,
-        url,
-        snippet: typeof item?.text === "string" ? item.text : "",
-        published_at: typeof item?.createdAt === "string" ? item.createdAt : null,
-        author,
-        image_url: imageUrl || null,
-        source_type: "x_post",
-        full_text: typeof item?.text === "string" ? item.text : undefined,
-        text_format: "text",
-      },
-      idx,
-      now,
-    );
-  });
-  const nextCursor =
-    typeof data.next_cursor === "string" && data.next_cursor ? data.next_cursor : null;
-  return {
-    results,
-    totalResults: null,
-    pagination: {
-      has_more: data.has_next_page === true,
-      next_cursor: nextCursor,
-    },
-  };
-}
-
 function normalizeOllamaSearch(data, _query, _searchType) {
   const now = new Date().toISOString();
   const items = Array.isArray(data?.results) ? data.results : Array.isArray(data) ? data : [];
@@ -399,7 +351,6 @@ const NORMALIZERS = {
   searchapi: normalizeSearchApi,
   youcom: normalizeYouCom,
   searxng: normalizeSearxng,
-  xquik: normalizeXquik,
   "ollama-search": normalizeOllamaSearch,
   glm: normalizeGlmSearch,
 };

package/open-sse/handlers/sttCore.js

@@ -159,21 +159,6 @@ async function transcribeGemini(cfg, file, model, token, formData) {
 }
 
 // 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();
@@ -249,8 +234,6 @@ export async function handleSttCore({ provider, model, formData, credentials, st
         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:

package/open-sse/handlers/ttsCore.js

@@ -74,7 +74,7 @@ export async function handleTtsCore({
       return createTtsResponse(result.base64, result.format, responseFormat);
     }
 
-    // Generic config-driven (hyperbolic, deepgram, nvidia, huggingface, inworld, cartesia, playht, coqui, tortoise, qwen, ...)
+    // Generic config-driven (hyperbolic, deepgram, nvidia, inworld, cartesia, playht, coqui, tortoise, qwen, ...)
     const result = await synthesizeViaConfig(provider, input.trim(), model, credentials);
     if (result) return createTtsResponse(result.base64, result.format, responseFormat);
 

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

@@ -1,7 +1,6 @@
 // Generic config-driven TTS handlers — dispatched by ttsConfig.format.
 // Each handler accepts { baseUrl, apiKey, text, modelId, voiceId } and returns { base64, format }.
 import { responseToBase64, throwUpstreamError } from "./_base.js";
-import minimaxTts from "./minimax.js";
 
 // Hyperbolic: POST { text } → { audio: base64 }
 async function hyperbolic({ baseUrl, apiKey, text }) {
@@ -39,37 +38,6 @@ async function nvidia({ baseUrl, apiKey, text, modelId, voiceId }) {
   return responseToBase64(res, "wav");
 }
 
-// HuggingFace: POST {baseUrl}/{modelId} { inputs: text } → binary
-async function huggingface({ baseUrl, apiKey, text, modelId }) {
-  if (!modelId || modelId.includes("..")) throw new Error("Invalid HuggingFace model ID");
-  const res = await fetch(`${baseUrl}/${modelId}`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
-    body: JSON.stringify({ inputs: text }),
-  });
-  if (!res.ok) await throwUpstreamError(res);
-  return responseToBase64(res, "wav");
-}
-
-// Fish Audio: model travels in an HTTP header, the voice is a reference_id, returns binary
-async function fishAudio({ baseUrl, apiKey, text, modelId, voiceId }) {
-  const res = await fetch(baseUrl, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`,
-      model: modelId || "s2.1-pro-free",
-    },
-    body: JSON.stringify({
-      text,
-      format: "mp3",
-      ...(voiceId ? { reference_id: voiceId } : {}),
-    }),
-  });
-  if (!res.ok) await throwUpstreamError(res);
-  return responseToBase64(res, "mp3");
-}
-
 // Inworld: Basic auth, JSON { audioContent }
 async function inworld({ baseUrl, apiKey, text, modelId, voiceId }) {
   const res = await fetch(baseUrl, {
@@ -179,13 +147,10 @@ export const FORMAT_HANDLERS = {
   hyperbolic,
   deepgram,
   "nvidia-tts": nvidia,
-  "huggingface-tts": huggingface,
   inworld,
   cartesia,
   playht,
   coqui,
   tortoise,
   openai: openaiCompat,
-  "minimax-tts": minimaxTts,
-  "fish-audio": fishAudio,
 };