@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/executors/lmarena.js

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

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