@fudrouter/fsrouter 0.6.61 → 0.6.63

package/open-sse/executors/lmarena.js

@@ -0,0 +1,395 @@
+import { BaseExecutor } from "./base.ts";
+import { sanitizeErrorMessage } from "../utils/error.js";
+const LMARENA_API_BASE = "https://arena.ai";
+const LMARENA_STREAM_URL = `${LMARENA_API_BASE}/nextjs-api/stream`;
+const LMARENA_USER_AGENT = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36";
+const LMARENA_AUTH_COOKIE = "arena-auth-prod-v1";
+function parseCookieBlob(blob) {
+  const pairs = [];
+  for (const part of blob.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq < 0) continue;
+    const name = part.slice(0, eq).trim();
+    if (!name) continue;
+    const value = part.slice(eq + 1).trim();
+    pairs.push({ name, value });
+  }
+  return pairs;
+}
+function reconstructLMArenaCookie(rawCookie) {
+  if (!rawCookie || !rawCookie.trim()) return rawCookie;
+  const pairs = parseCookieBlob(rawCookie);
+  const existing = pairs.find((p) => p.name === LMARENA_AUTH_COOKIE);
+  if (existing && existing.value) return rawCookie;
+  const chunkPrefix = `${LMARENA_AUTH_COOKIE}.`;
+  const chunks = /* @__PURE__ */ new Map();
+  for (const { name, value } of pairs) {
+    if (!name.startsWith(chunkPrefix)) continue;
+    const idxRaw = name.slice(chunkPrefix.length);
+    if (!/^\d+$/.test(idxRaw)) continue;
+    chunks.set(Number(idxRaw), value);
+  }
+  const joinedParts = [];
+  for (let i = 0; chunks.has(i); i++) {
+    joinedParts.push(chunks.get(i) ?? "");
+  }
+  const joined = joinedParts.join("");
+  if (!joined) return rawCookie;
+  const preserved = pairs.filter(
+    (p) => p.name !== LMARENA_AUTH_COOKIE && !p.name.startsWith(chunkPrefix)
+  );
+  const rebuilt = [
+    `${LMARENA_AUTH_COOKIE}=${joined}`,
+    ...preserved.map((p) => `${p.name}=${p.value}`)
+  ];
+  return rebuilt.join("; ");
+}
+function readLMArenaCookie(credentials) {
+  if (!credentials || typeof credentials !== "object") return "";
+  const c = credentials;
+  const direct = typeof c.cookie === "string" ? c.cookie : "";
+  if (direct.trim()) return reconstructLMArenaCookie(direct);
+  const apiKey = typeof c.apiKey === "string" ? c.apiKey : "";
+  if (apiKey.trim()) return reconstructLMArenaCookie(apiKey);
+  const psd = c.providerSpecificData;
+  if (psd && typeof psd === "object") {
+    const nested = psd.cookie;
+    if (typeof nested === "string" && nested.trim()) return reconstructLMArenaCookie(nested);
+  }
+  return "";
+}
+function parseArenaSSE(line) {
+  if (line.startsWith("a0:")) {
+    try {
+      const content = JSON.parse(line.substring(3));
+      return { type: "text", content: typeof content === "string" ? content : content.text || "" };
+    } catch {
+      return null;
+    }
+  } else if (line.startsWith("ag:")) {
+    try {
+      const content = JSON.parse(line.substring(3));
+      return {
+        type: "thinking",
+        content: typeof content === "string" ? content : content.thinking || ""
+      };
+    } catch {
+      return null;
+    }
+  } else if (line.startsWith("a3:") || line.startsWith("ae:")) {
+    try {
+      const content = JSON.parse(line.substring(3));
+      return {
+        type: "error",
+        content: typeof content === "string" ? content : content.error || JSON.stringify(content)
+      };
+    } catch {
+      return { type: "error", content: line.substring(3) };
+    }
+  } else if (line.startsWith("ad:")) {
+    return { type: "done" };
+  } else if (line.startsWith("a2:")) {
+    return { type: "heartbeat" };
+  }
+  return null;
+}
+class LMArenaExecutor extends BaseExecutor {
+  constructor(providerConfig = {}) {
+    super("lmarena", { format: "openai", ...providerConfig });
+  }
+  buildUrl(_model, _credentials) {
+    return LMARENA_STREAM_URL;
+  }
+  buildHeaders(_model, credentials, _body) {
+    const cookie = readLMArenaCookie(credentials);
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "text/event-stream",
+      "User-Agent": LMARENA_USER_AGENT,
+      Origin: LMARENA_API_BASE,
+      Referer: `${LMARENA_API_BASE}/`
+    };
+    if (cookie) {
+      headers.Cookie = cookie;
+    }
+    return headers;
+  }
+  transformRequest(body, model) {
+    const openaiBody = body;
+    const messages = openaiBody.messages;
+    return {
+      messages: messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      })),
+      model,
+      stream: openaiBody.stream || false
+    };
+  }
+  async execute(input) {
+    const { model, body, stream, credentials, signal, log } = input;
+    const url = this.buildUrl(model, credentials);
+    const headers = this.buildHeaders(model, credentials, body);
+    const transformedBody = this.transformRequest(body, model);
+    const cookie = readLMArenaCookie(credentials);
+    if (!cookie) {
+      return {
+        response: new Response(
+          JSON.stringify({
+            error: {
+              message: "LMArena requires a session cookie. Please provide cookie in credentials.",
+              type: "authentication_error",
+              code: "missing_cookie"
+            }
+          }),
+          { status: 401, headers: { "Content-Type": "application/json" } }
+        ),
+        url,
+        headers,
+        transformedBody
+      };
+    }
+    log?.info?.("LMArenaExecutor", `Executing request for model: ${model}`);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(transformedBody),
+        signal
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        let errorMessage = `LMArena API error: ${response.status}`;
+        try {
+          const errorJson = JSON.parse(errorText);
+          errorMessage = errorJson.error?.message || errorJson.message || errorMessage;
+        } catch {
+          errorMessage = errorText || errorMessage;
+        }
+        return {
+          response: new Response(
+            JSON.stringify({
+              error: {
+                message: sanitizeErrorMessage(errorMessage),
+                type: "api_error",
+                code: String(response.status)
+              }
+            }),
+            { status: response.status, headers: { "Content-Type": "application/json" } }
+          ),
+          url,
+          headers,
+          transformedBody
+        };
+      }
+      const upstreamResponse = stream ? await this.handleStreamingResponse(response, model, log) : await this.handleNonStreamingResponse(response, model, log);
+      return { response: upstreamResponse, url, headers, transformedBody };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      log?.error?.("LMArenaExecutor", `Request failed: ${message}`);
+      return {
+        response: new Response(
+          JSON.stringify({
+            error: {
+              message: sanitizeErrorMessage(message),
+              type: "network_error",
+              code: "request_failed"
+            }
+          }),
+          { status: 502, headers: { "Content-Type": "application/json" } }
+        ),
+        url,
+        headers,
+        transformedBody
+      };
+    }
+  }
+  async handleStreamingResponse(response, model, log) {
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body for streaming");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let fullText = "";
+    let fullThinking = "";
+    const stream = new ReadableStream({
+      async start(controller) {
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.trim()) continue;
+              const sseLine = line.startsWith("data: ") ? line.substring(6) : line;
+              const event = parseArenaSSE(sseLine);
+              if (!event) continue;
+              if (event.type === "text" && event.content) {
+                fullText += event.content;
+                const chunk = {
+                  id: `chatcmpl-${Date.now()}`,
+                  object: "chat.completion.chunk",
+                  created: Math.floor(Date.now() / 1e3),
+                  model,
+                  choices: [
+                    {
+                      index: 0,
+                      delta: { content: event.content },
+                      finish_reason: null
+                    }
+                  ]
+                };
+                controller.enqueue(`data: ${JSON.stringify(chunk)}
+
+`);
+              } else if (event.type === "thinking" && event.content) {
+                fullThinking += event.content;
+              } else if (event.type === "error") {
+                const errorChunk = {
+                  id: `chatcmpl-${Date.now()}`,
+                  object: "chat.completion.chunk",
+                  created: Math.floor(Date.now() / 1e3),
+                  model,
+                  choices: [
+                    {
+                      index: 0,
+                      delta: {},
+                      finish_reason: "stop"
+                    }
+                  ],
+                  error: { message: event.content }
+                };
+                controller.enqueue(`data: ${JSON.stringify(errorChunk)}
+
+`);
+                controller.close();
+                return;
+              } else if (event.type === "done") {
+                const finalChunk2 = {
+                  id: `chatcmpl-${Date.now()}`,
+                  object: "chat.completion.chunk",
+                  created: Math.floor(Date.now() / 1e3),
+                  model,
+                  choices: [
+                    {
+                      index: 0,
+                      delta: {},
+                      finish_reason: "stop"
+                    }
+                  ]
+                };
+                controller.enqueue(`data: ${JSON.stringify(finalChunk2)}
+
+`);
+                controller.enqueue("data: [DONE]\n\n");
+                controller.close();
+                return;
+              }
+            }
+          }
+          const finalChunk = {
+            id: `chatcmpl-${Date.now()}`,
+            object: "chat.completion.chunk",
+            created: Math.floor(Date.now() / 1e3),
+            model,
+            choices: [
+              {
+                index: 0,
+                delta: {},
+                finish_reason: "stop"
+              }
+            ]
+          };
+          controller.enqueue(`data: ${JSON.stringify(finalChunk)}
+
+`);
+          controller.enqueue("data: [DONE]\n\n");
+          controller.close();
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          log?.error?.("LMArenaExecutor", `Streaming error: ${message}`);
+          controller.error(error);
+        }
+      }
+    });
+    return new Response(stream, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  }
+  async handleNonStreamingResponse(response, model, log) {
+    const text = await response.text();
+    const lines = text.split("\n");
+    let fullText = "";
+    let fullThinking = "";
+    let error = null;
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      const sseLine = line.startsWith("data: ") ? line.substring(6) : line;
+      const event = parseArenaSSE(sseLine);
+      if (!event) continue;
+      if (event.type === "text" && event.content) {
+        fullText += event.content;
+      } else if (event.type === "thinking" && event.content) {
+        fullThinking += event.content;
+      } else if (event.type === "error") {
+        error = event.content || "Unknown error";
+        break;
+      } else if (event.type === "done") {
+        break;
+      }
+    }
+    if (error) {
+      return new Response(
+        JSON.stringify({
+          error: {
+            message: sanitizeErrorMessage(error),
+            type: "api_error",
+            code: "lmarena_error"
+          }
+        }),
+        {
+          status: 502,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    const result = {
+      id: `chatcmpl-${Date.now()}`,
+      object: "chat.completion",
+      created: Math.floor(Date.now() / 1e3),
+      model,
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: "assistant",
+            content: fullText
+          },
+          finish_reason: "stop"
+        }
+      ],
+      usage: {
+        prompt_tokens: 0,
+        completion_tokens: 0,
+        total_tokens: 0
+      }
+    };
+    return new Response(JSON.stringify(result), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+}
+export {
+  LMArenaExecutor,
+  parseArenaSSE,
+  reconstructLMArenaCookie
+};

package/open-sse/executors/mimo-free.js

@@ -0,0 +1,167 @@
+import { BaseExecutor } from "./base.js";
+import { PROVIDERS } from "../config/providers.js";
+import { proxyAwareFetch } from "../utils/proxyFetch.js";
+import { createHash } from "crypto";
+import os from "os";
+
+const BOOTSTRAP_URL = "https://api.xiaomimimo.com/api/free-ai/bootstrap";
+const CHAT_URL = PROVIDERS["mimo-free"].baseUrl;
+const SESSION_AFFINITY_PREFIX = "ses_";
+const SESSION_ID_LENGTH = 24;
+const JWT_FALLBACK_TTL_SEC = 3000;
+const JWT_EXPIRY_BUFFER_MS = 300000;
+const SESSION_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
+
+// Anti-abuse gate: upstream rejects requests without a Chrome-like User-Agent with 403 "Illegal access"
+const USER_AGENTS = [
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+  "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+];
+
+// Anti-abuse gate marker: the free chat endpoint returns 403 "Illegal access"
+// unless a system message contains this exact MiMoCode signature substring.
+export const MIMO_SYSTEM_MARKER =
+  "You are MiMoCode, an interactive CLI tool that helps users with software engineering tasks.";
+
+// In-memory JWT cache (per-process, survives across requests but not restarts)
+let cachedJwt = null;
+let jwtExpiresAt = 0;
+
+// Device fingerprint reused as the bootstrap "client" — stable per machine
+function generateFingerprint() {
+  let username = "unknown-user";
+  try {
+    username = os.userInfo().username;
+  } catch {
+    // ignore
+  }
+  const cpu = (os.cpus()[0]?.model || "unknown-cpu").trim();
+  const seed = `${os.hostname()}|${os.platform()}|${os.arch()}|${cpu}|${username}`;
+  return createHash("sha256").update(seed).digest("hex");
+}
+
+function generateSessionId() {
+  let id = SESSION_AFFINITY_PREFIX;
+  for (let i = 0; i < SESSION_ID_LENGTH; i++) {
+    id += SESSION_CHARS[Math.floor(Math.random() * SESSION_CHARS.length)];
+  }
+  return id;
+}
+
+// Derive expiry from the JWT exp claim; fall back to a fixed TTL when unparseable
+function parseJwtExp(jwt) {
+  try {
+    const payload = JSON.parse(Buffer.from(jwt.split(".")[1], "base64").toString());
+    if (payload.exp) return payload.exp * 1000;
+  } catch {
+    // ignore
+  }
+  return Date.now() + JWT_FALLBACK_TTL_SEC * 1000;
+}
+
+// Ensure the body carries the anti-abuse marker in a system message (idempotent)
+function injectSystemMarker(body) {
+  const messages = body?.messages;
+  if (!Array.isArray(messages)) return body;
+  const hasMarker = messages.some(
+    (m) => m?.role === "system" && typeof m.content === "string" && m.content.includes(MIMO_SYSTEM_MARKER)
+  );
+  if (hasMarker) return body;
+  return { ...body, messages: [{ role: "system", content: MIMO_SYSTEM_MARKER }, ...messages] };
+}
+
+function resetJwtCache() {
+  cachedJwt = null;
+  jwtExpiresAt = 0;
+}
+
+async function bootstrapJwt(proxyOptions = null) {
+  if (cachedJwt && Date.now() < jwtExpiresAt - JWT_EXPIRY_BUFFER_MS) {
+    return cachedJwt;
+  }
+
+  const response = await proxyAwareFetch(BOOTSTRAP_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)],
+    },
+    body: JSON.stringify({ client: generateFingerprint() }),
+  }, proxyOptions);
+
+  if (!response.ok) {
+    throw new Error(`MiMo bootstrap failed: ${response.status}`);
+  }
+
+  const data = await response.json();
+  if (!data.jwt) {
+    throw new Error("MiMo bootstrap returned no JWT");
+  }
+
+  cachedJwt = data.jwt;
+  jwtExpiresAt = parseJwtExp(data.jwt);
+  return cachedJwt;
+}
+
+export class MimoFreeExecutor extends BaseExecutor {
+  constructor() {
+    super("mimo-free", PROVIDERS["mimo-free"]);
+    this.sessionId = generateSessionId();
+  }
+
+  buildUrl() {
+    return CHAT_URL;
+  }
+
+  buildHeaders(credentials, stream = true) {
+    return {
+      "Content-Type": "application/json",
+      "X-Mimo-Source": "mimocode-cli-free",
+      "User-Agent": USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)],
+      "x-session-affinity": this.sessionId,
+      "Accept": stream ? "text/event-stream" : "application/json",
+    };
+  }
+
+  transformRequest(model, body) {
+    return injectSystemMarker(body);
+  }
+
+  async execute({ model, body, stream, credentials, signal, log, proxyOptions = null }) {
+    let jwt;
+    try {
+      jwt = await bootstrapJwt(proxyOptions);
+    } catch (error) {
+      log?.error?.("AUTH", `MiMo bootstrap failed: ${error.message}`);
+      throw error;
+    }
+
+    const url = this.buildUrl();
+    const transformedBody = this.transformRequest(model, body);
+    const headers = { ...this.buildHeaders(credentials, stream), "Authorization": `Bearer ${jwt}` };
+    const bodyStr = JSON.stringify(transformedBody);
+    log?.debug?.("FETCH", `MIMO-FREE → ${url} | body=${bodyStr.length}B`);
+
+    const response = await proxyAwareFetch(url, { method: "POST", headers, body: bodyStr, signal }, proxyOptions);
+
+    // On auth failure, invalidate cache and retry once with a fresh JWT
+    if (response.status === 401 || response.status === 403) {
+      log?.debug?.("AUTH", `MiMo auth failed (${response.status}), re-bootstrapping...`);
+      resetJwtCache();
+      jwt = await bootstrapJwt(proxyOptions);
+      headers["Authorization"] = `Bearer ${jwt}`;
+      const retryResponse = await proxyAwareFetch(url, { method: "POST", headers, body: bodyStr, signal }, proxyOptions);
+      return { response: retryResponse, url, headers, transformedBody };
+    }
+
+    return { response, url, headers, transformedBody };
+  }
+}
+
+export const __test__ = {
+  generateFingerprint, generateSessionId, bootstrapJwt, resetJwtCache, parseJwtExp,
+  injectSystemMarker, MIMO_SYSTEM_MARKER, BOOTSTRAP_URL, CHAT_URL, SESSION_AFFINITY_PREFIX,
+};
+
+export default MimoFreeExecutor;