@fudrouter/fsrouter 0.6.64 → 0.6.65

package/open-sse/handlers/rerank.js

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

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

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