@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/handlers/rerank.js

@@ -1,223 +0,0 @@
-/**
- * Rerank Handler
- *
- * Handles /v1/rerank requests following the Cohere rerank API format.
- * Routes to the appropriate provider based on the model prefix or lookup.
- * Converted from OmniRoute TypeScript.
- */
-
-const CORS_HEADERS = {
-  "Access-Control-Allow-Origin": "*",
-  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
-  "Access-Control-Allow-Headers": "Content-Type, Authorization",
-};
-
-import { errorResponse } from "../utils/error.js";
-import { RERANK_PROVIDERS, parseRerankModel, getRerankProvider } from "../config/rerankRegistry.js";
-
-// ── Inline stubs for @/ imports ──────────────────────────────────────
-function attachOmniRouteMetaHeaders(headers, meta) {
-  if (meta.provider) headers.set("X-Provider", meta.provider);
-  if (meta.model) headers.set("X-Model", meta.model);
-  if (meta.latencyMs != null) headers.set("X-Latency-Ms", String(meta.latencyMs));
-}
-
-function generateRequestId() {
-  return crypto.randomUUID();
-}
-
-async function calculateModalCost(_type, _provider, _model, _opts) {
-  return 0;
-}
-
-async function saveCallLog(_entry) {
-  // noop stub — wire up to actual logging when available
-}
-
-// ── Helpers ──────────────────────────────────────────────────────────
-
-/**
- * Build authorization header for a rerank provider
- */
-function buildAuthHeader(providerConfig, token) {
-  if (providerConfig.authHeader === "bearer") {
-    return { Authorization: `Bearer ${token}` };
-  }
-  return {};
-}
-
-/**
- * Transform request body for provider-specific formats (e.g. NVIDIA ranking API)
- */
-export function transformRequestForProvider(providerConfig, body) {
-  if (providerConfig.format === "nvidia") {
-    return {
-      model: body.model,
-      query: { text: body.query },
-      passages: (body.documents || []).map((doc) => ({
-        text: typeof doc === "string" ? doc : doc.text || "",
-      })),
-      top_n: body.top_n,
-    };
-  }
-  // DeepInfra inference API: the model goes in the URL path (handled by the caller), the body
-  // carries {queries:[query], documents:[strings]} and the response is a positional {scores:[…]}.
-  if (providerConfig.format === "deepinfra") {
-    return {
-      queries: [body.query],
-      documents: (body.documents || []).map((doc) =>
-        typeof doc === "string" ? doc : doc.text || ""
-      ),
-    };
-  }
-  // Default: Cohere-compatible format (used by Together, Fireworks, Cohere, SiliconFlow)
-  return body;
-}
-
-/**
- * Transform response from provider-specific formats back to Cohere format
- */
-export function transformResponseFromProvider(providerConfig, data, options = {}) {
-  if (providerConfig.format === "nvidia") {
-    return {
-      id: data.id != null ? String(data.id) : `rerank-${Date.now()}`,
-      results: (data.rankings || []).map((r) => ({
-        index: r.index,
-        relevance_score: r.logit || r.score || 0,
-        document: { text: r.text || "" },
-      })),
-      meta: {
-        api_version: { version: "2" },
-        billed_units: { search_units: 1 },
-      },
-    };
-  }
-  // DeepInfra returns {scores:[…]} — one float per document, in document order. Map to Cohere's
-  // results[] (index + relevance_score + optional document), sorted by score desc, honoring top_n.
-  if (providerConfig.format === "deepinfra") {
-    const documents = Array.isArray(options.documents) ? options.documents : [];
-    const returnDocuments = options.return_documents !== false;
-    const scored = (Array.isArray(data.scores) ? data.scores : []).map((score, index) => {
-      const doc = documents[index];
-      const text = typeof doc === "string" ? doc : doc?.text || "";
-      return {
-        index,
-        relevance_score: typeof score === "number" ? score : 0,
-        ...(returnDocuments ? { document: { text } } : {}),
-      };
-    });
-    scored.sort((a, b) => b.relevance_score - a.relevance_score);
-    const topN = typeof options.top_n === "number" && options.top_n > 0 ? options.top_n : undefined;
-    return {
-      id: `rerank-${Date.now()}`,
-      results: topN ? scored.slice(0, topN) : scored,
-      meta: {
-        api_version: { version: "2" },
-        billed_units: { search_units: 1 },
-      },
-    };
-  }
-  return data;
-}
-
-/**
- * Handle a rerank request
- */
-export async function handleRerank({
-  model,
-  query,
-  documents,
-  top_n,
-  return_documents,
-  credentials,
-}) {
-  const startTime = Date.now();
-  if (!model) return errorResponse(400, "model is required");
-  if (!query) return errorResponse(400, "query is required");
-  if (!documents || !Array.isArray(documents) || documents.length === 0) {
-    return errorResponse(400, "documents must be a non-empty array");
-  }
-
-  const { provider: providerId, model: modelId } = parseRerankModel(model);
-  const providerConfig = providerId ? getRerankProvider(providerId) : null;
-
-  if (!providerConfig) {
-    const availableProviders = Object.keys(RERANK_PROVIDERS).join(", ");
-    return errorResponse(
-      400,
-      `No rerank provider found for model "${model}". Available: ${availableProviders}`
-    );
-  }
-
-  const token = credentials?.apiKey || credentials?.accessToken;
-  if (!token) {
-    return errorResponse(401, `No credentials for rerank provider: ${providerId}`);
-  }
-
-  const requestBody = transformRequestForProvider(providerConfig, {
-    model: modelId,
-    query,
-    documents,
-    top_n: top_n || documents.length,
-    return_documents: return_documents !== false,
-  });
-
-  // DeepInfra puts the model in the URL path (POST /v1/inference/<model>); all others use a fixed
-  // rerank endpoint with the model in the body.
-  const rerankUrl =
-    providerConfig.format === "deepinfra"
-      ? `${providerConfig.baseUrl}/${modelId}`
-      : providerConfig.baseUrl;
-
-  try {
-    const res = await fetch(rerankUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...buildAuthHeader(providerConfig, token),
-      },
-      body: JSON.stringify(requestBody),
-    });
-
-    if (!res.ok) {
-      const errData = await res.json().catch(() => ({}));
-      return errorResponse(
-        res.status,
-        errData.message || errData.error?.message || `Provider returned HTTP ${res.status}`
-      );
-    }
-
-    const data = await res.json();
-    const result = transformResponseFromProvider(providerConfig, data, {
-      documents,
-      top_n: top_n || documents.length,
-      return_documents,
-    });
-
-    const searchUnits = Number(result?.meta?.billed_units?.search_units) || 0;
-    const costUsd = await calculateModalCost("rerank", providerId, modelId, { searchUnits });
-
-    saveCallLog({
-      method: "POST",
-      path: "/v1/rerank",
-      status: 200,
-      model: `${providerId}/${modelId}`,
-      provider: providerId,
-      duration: Date.now() - startTime,
-      tokens: { prompt_tokens: 0, completion_tokens: 0 },
-      responseBody: { results_count: Array.isArray(result?.results) ? result.results.length : 0 },
-    }).catch(() => {});
-
-    const headers = new Headers({ ...CORS_HEADERS, "Content-Type": "application/json" });
-    attachOmniRouteMetaHeaders(headers, {
-      provider: providerId,
-      model: modelId,
-      costUsd,
-      latencyMs: Date.now() - startTime,
-      requestId: generateRequestId(),
-    });
-    return new Response(JSON.stringify(result), { status: 200, headers });
-  } catch (err) {
-    return errorResponse(500, `Rerank request failed: ${err.message}`);
-  }
-}

package/open-sse/handlers/responseSanitizer/reasoning.js

@@ -1,144 +0,0 @@
-export const REASONING_TAG_NAMES = ["think", "thinking", "thought", "internal_thought"];
-export const REASONING_TAG_PATTERN = REASONING_TAG_NAMES.join("|");
-// Matches complete <think>/<thinking>/<thought>/<internal_thought> blocks.
-export const THINK_TAG_REGEX = new RegExp(
-  `<(${REASONING_TAG_PATTERN})\\b[^>]*>([\\s\\S]*?)<\\/\\1>`,
-  "gi"
-);
-export const REASONING_CLOSE_TAG_REGEX = new RegExp(`</(${REASONING_TAG_PATTERN})>`, "i");
-export const REASONING_TAG_FRAGMENT_REGEX = new RegExp(
-  `</?(${REASONING_TAG_PATTERN})\\b[^>]*>`,
-  "gi"
-);
-export const CONTENT_OPEN_TAG_REGEX = /<content\b[^>]*>/i;
-// Matches an unclosed reasoning tag at the end of a message. Some providers can
-// emit malformed/open reasoning wrappers (for example "<thought\n...") before a
-// tool call. Treat that tail as reasoning instead of visible assistant text.
-export const UNCLOSED_REASONING_TAG_REGEX = new RegExp(
-  `<(${REASONING_TAG_PATTERN})(?:\\s[^>]*)?(?:>|\\r?\\n)([\\s\\S]*)$`,
-  "i"
-);
-
-// #638, #727: Collapse runs of 2+ consecutive newlines into \n\n
-
-// Tool call responses from thinking models often accumulate excessive newlines
-export const EXCESSIVE_NEWLINES = /\n{2,}/g;
-export function collapseExcessiveNewlines(text) {
-  return text.replace(EXCESSIVE_NEWLINES, "\n\n");
-}
-
-export function cleanReasoningFragment(text) {
-  return text.replace(REASONING_TAG_FRAGMENT_REGEX, "").trim();
-}
-
-export function splitClosingOnlyReasoningPrefix(text) {
-  const closeMatch = text.match(REASONING_CLOSE_TAG_REGEX);
-  if (!closeMatch || closeMatch.index === undefined || closeMatch.index === 0) return null;
-  const closeIndex = closeMatch.index;
-
-  const suffix = text.slice(closeIndex + closeMatch[0].length);
-  if (!CONTENT_OPEN_TAG_REGEX.test(suffix)) return null;
-
-  const thinking = cleanReasoningFragment(text.slice(0, closeIndex));
-  if (!thinking) return null;
-  return { content: suffix.trim(), thinking };
-}
-
-export function movePrefixBeforeContentTagToThinking(
-  cleaned,
-  thinkingParts
-) {
-  const contentMatch = cleaned.match(CONTENT_OPEN_TAG_REGEX);
-  if (!contentMatch || contentMatch.index === undefined || contentMatch.index <= 0) return cleaned;
-  const contentIndex = contentMatch.index;
-
-  const prefix = cleanReasoningFragment(cleaned.slice(0, contentIndex));
-  if (prefix) thinkingParts.unshift(prefix);
-  return cleaned.slice(contentIndex);
-}
-
-/**
- * Extract <think> blocks from text content and return separated parts.
- * @returns {{ content: string, thinking: string | null }}
- */
-export function extractThinkingFromContent(text) {
-  if (!text || typeof text !== "string") {
-    return { content: text || "", thinking: null };
-  }
-
-  const thinkingParts = [];
-  let hasThinkTags = false;
-
-  let cleaned = text.replace(THINK_TAG_REGEX, (_match, _tagName, thinkContent) => {
-    hasThinkTags = true;
-    const trimmed = thinkContent.trim();
-    if (trimmed) {
-      thinkingParts.push(trimmed);
-    }
-    return "";
-  });
-
-  if (!hasThinkTags) {
-    const closingOnly = splitClosingOnlyReasoningPrefix(cleaned);
-    if (closingOnly) {
-      return closingOnly;
-    }
-  }
-
-  const unclosedMatch = cleaned.match(UNCLOSED_REASONING_TAG_REGEX);
-  if (unclosedMatch?.index !== undefined) {
-    hasThinkTags = true;
-    const reasoning = String(unclosedMatch[2] || "").trim();
-    if (reasoning) thinkingParts.push(reasoning);
-    const prefix = cleaned.slice(0, unclosedMatch.index);
-    cleaned = /^(?:\s|§\d+§)*$/.test(prefix) ? "" : prefix;
-  }
-
-  if (!hasThinkTags) {
-    return { content: text, thinking: null };
-  }
-
-  cleaned = movePrefixBeforeContentTagToThinking(cleaned, thinkingParts);
-
-  return {
-    content: cleaned.trim(),
-    thinking: thinkingParts.length > 0 ? thinkingParts.join("\n\n") : null,
-  };
-}
-
-export function normalizeReasoningRouteId(value) {
-  return typeof value === "string" ? value.toLowerCase() : "";
-}
-
-export function isAntigravityReasoningRoute(providerId, modelId) {
-  return (
-    providerId.includes("antigravity") ||
-    providerId === "agy" ||
-    modelId.includes("antigravity/") ||
-    modelId.startsWith("agy/")
-  );
-}
-
-export function isTextualReasoningTagNativeRoute(providerId, modelId) {
-  const routeId = `${providerId}/${modelId}`;
-  return (
-    /deepseek[-_/]?r1\b/.test(routeId) ||
-    /r1[-_/]?distill\b/.test(routeId) ||
-    /(?:^|[/:_-])qwq(?:[/._:-]|$)/.test(routeId) ||
-    // 9router#2231: MiniMax M3 leaks raw <think>...</think> into `content` on its
-    // OpenAI-format provider tiers (trae, huggingchat, bazaarlink, ollama-cloud,
-    // opencode, cline, opencode-zen, codebuddy-cn). The direct minimax/minimax-cn
-    // tiers stay on Anthropic's Messages format (targetFormat: "claude") and
-    // already surface reasoning natively, so they are excluded here.
-    (providerId !== "minimax" && providerId !== "minimax-cn" && /minimax[-_]?m3\b/.test(routeId))
-  );
-}
-
-export function shouldParseTextualReasoningTags(provider, model) {
-  const providerId = normalizeReasoningRouteId(provider);
-  const modelId = normalizeReasoningRouteId(model);
-  return (
-    !isAntigravityReasoningRoute(providerId, modelId) &&
-    isTextualReasoningTagNativeRoute(providerId, modelId)
-  );
-}

package/open-sse/handlers/responsesHandler.js

@@ -1,99 +0,0 @@
-/**
- * Responses API Handler for Workers
- * Converts Chat Completions to Codex Responses API format
- */
-
-import { handleChatCore } from "./chatCore.js";
-import { convertResponsesApiFormat } from "../translator/formats/responsesApi.js";
-import { createResponsesApiTransformStream } from "../transformer/responsesTransformer.js";
-import { convertResponsesStreamToJson } from "../transformer/streamToJsonConverter.js";
-import { SSE_HEADERS_CORS } from "../utils/sseConstants.js";
-
-/**
- * Handle /v1/responses request
- * @param {object} options
- * @param {object} options.body - Request body (Responses API format)
- * @param {object} options.modelInfo - { provider, model }
- * @param {object} options.credentials - Provider credentials
- * @param {object} options.log - Logger instance (optional)
- * @param {function} options.onCredentialsRefreshed - Callback when credentials are refreshed
- * @param {function} options.onRequestSuccess - Callback when request succeeds
- * @param {function} options.onDisconnect - Callback when client disconnects
- * @param {string} options.connectionId - Connection ID for usage tracking
- * @returns {Promise<{success: boolean, response?: Response, status?: number, error?: string}>}
- */
-export async function handleResponsesCore({ body, modelInfo, credentials, log, onCredentialsRefreshed, onRequestSuccess, onDisconnect, connectionId }) {
-  // Convert Responses API format to Chat Completions format
-  const convertedBody = convertResponsesApiFormat(body);
-
-  // Preserve client's stream preference (matches OpenClaw behavior)
-  // Default to false if omitted: Boolean(undefined) = false
-  const clientRequestedStreaming = convertedBody.stream === true;
-  if (convertedBody.stream === undefined) {
-    convertedBody.stream = false;
-  }
-
-  // Call chat core handler — force sourceFormat so streaming path knows this is a Responses API client
-  const result = await handleChatCore({
-    body: convertedBody,
-    modelInfo,
-    credentials,
-    log,
-    onCredentialsRefreshed,
-    onRequestSuccess,
-    onDisconnect,
-    connectionId,
-    sourceFormatOverride: "openai-responses"
-  });
-
-  if (!result.success || !result.response) {
-    return result;
-  }
-
-  const response = result.response;
-  const contentType = response.headers.get("Content-Type") || "";
-
-  // Case 1: Client wants non-streaming, but got SSE (provider forced it, e.g., Codex)
-  if (!clientRequestedStreaming && contentType.includes("text/event-stream")) {
-    try {
-      const jsonResponse = await convertResponsesStreamToJson(response.body);
-
-      return {
-        success: true,
-        response: new Response(JSON.stringify(jsonResponse), {
-          status: 200,
-          headers: {
-            "Content-Type": "application/json",
-            "Cache-Control": "no-cache",
-            "Access-Control-Allow-Origin": "*"
-          }
-        })
-      };
-    } catch (error) {
-      console.error("[Responses API] Stream-to-JSON conversion failed:", error);
-      return {
-        success: false,
-        status: 500,
-        error: "Failed to convert streaming response to JSON"
-      };
-    }
-  }
-
-  // Case 2: Client wants streaming, got SSE - transform it
-  if (clientRequestedStreaming && contentType.includes("text/event-stream")) {
-    const transformStream = createResponsesApiTransformStream(null);
-    const transformedBody = response.body.pipeThrough(transformStream);
-
-    return {
-      success: true,
-      response: new Response(transformedBody, {
-        status: 200,
-        headers: { ...SSE_HEADERS_CORS }
-      })
-    };
-  }
-
-  // Case 3: Non-SSE response (error or non-streaming from provider) - return as-is
-  return result;
-}
-