zevairouter 1.0.36 → 1.0.38

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

@@ -0,0 +1,156 @@
+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 || "https://api.xiaomimimo.com/api/free-ai/openai/chat";
+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: free chat endpoint returns 403 unless a system message contains this.
+export const MIMO_SYSTEM_MARKER =
+  "You are MiMoCode, an interactive CLI tool that helps users with software engineering tasks.";
+
+let cachedJwt = null;
+let jwtExpiresAt = 0;
+
+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;
+}
+
+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;
+}
+
+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);
+
+    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 default MimoFreeExecutor;

package/open-sse/handlers/chatCore.js

@@ -22,6 +22,7 @@ import { injectCaveman } from "../rtk/caveman.js";
 import { injectPonytail } from "../rtk/ponytail.js";
 import { injectContextFiles } from "../context/injectContext.js";
 import { compressMessages, formatRtkLog } from "../rtk/index.js";
+import { applyThinkingFromModelAndSettings, stripThinkingSuffix } from "../utils/thinkingSuffix.js";
 
 /**
  * Core chat handler - shared between SSE and Worker
@@ -31,38 +32,28 @@ import { compressMessages, formatRtkLog } from "../rtk/index.js";
  * @param {string} options.sourceFormatOverride - Override detected source format (e.g. "openai-responses")
  */
 export async function handleChatCore({ body, modelInfo, credentials, log, onCredentialsRefreshed, onRequestSuccess, onDisconnect, clientRawRequest, connectionId, userAgent, apiKey, ccFilterNaming, rtkEnabled, cavemanEnabled, cavemanLevel, contextInjectionEnabled, ponytailEnabled, ponytailLevel, sourceFormatOverride, providerThinking }) {
-  const { provider, model } = modelInfo;
+  const { provider } = modelInfo;
   const requestStartTime = Date.now();
 
   const sourceFormat = sourceFormatOverride || detectFormat(body);
 
   // Check for bypass patterns (warmup, skip, cc naming)
-  const bypassResponse = handleBypassRequest(body, model, userAgent, ccFilterNaming);
+  const bypassResponse = handleBypassRequest(body, modelInfo.model, userAgent, ccFilterNaming);
   if (bypassResponse) return bypassResponse;
 
+  // model(high) suffix + per-provider thinking settings → reasoning_effort / thinking
+  const thinkingApplied = applyThinkingFromModelAndSettings(modelInfo.model, body, providerThinking);
+  body = thinkingApplied.body;
+  const model = thinkingApplied.cleanModel;
+  if (thinkingApplied.applied) {
+    log?.debug?.("THINKING", `Applied thinking mode=${thinkingApplied.applied} (model=${modelInfo.model})`);
+  }
+
   const alias = PROVIDER_ID_TO_ALIAS[provider] || provider;
   const modelTargetFormat = getModelTargetFormat(alias, model);
   const targetFormat = modelTargetFormat || getTargetFormat(provider);
   const stripList = getModelStrip(alias, model);
-  const upstreamModel = getModelUpstreamId(alias, model);
-
-  // Inject provider-level thinking config override (only if client hasn't set)
-  // on/off → extended type (body.thinking), none/low/medium/high → effort type (body.reasoning_effort)
-  if (providerThinking?.mode && providerThinking.mode !== "auto") {
-    const mode = providerThinking.mode;
-    if (mode === "on" && !body.thinking) {
-      console.log("Injecting provider-level thinking config override: on");
-      body = { ...body, thinking: { type: "enabled", budget_tokens: 10000 } };
-    } else if (mode === "off") {
-      body = { ...body, thinking: { type: "disabled" } };
-      delete body.reasoning_effort;
-      if (body.reasoning && typeof body.reasoning === "object") {
-        body.reasoning = { ...body.reasoning, effort: "none" };
-      }
-    } else if (!body.reasoning_effort) {
-      body = { ...body, reasoning_effort: mode };
-    }
-  }
+  const upstreamModel = stripThinkingSuffix(getModelUpstreamId(alias, model));
 
   const clientRequestedStreaming = body.stream === true || sourceFormat === FORMATS.ANTIGRAVITY || sourceFormat === FORMATS.GEMINI || sourceFormat === FORMATS.GEMINI_CLI;
   const providerRequiresStreaming = provider === "openai" || provider === "codex" || provider === "commandcode";

package/open-sse/services/kimchiModels.js

@@ -0,0 +1,176 @@
+import { createHash } from "crypto";
+
+import { proxyAwareFetch } from "../utils/proxyFetch.js";
+
+export const KIMCHI_API = "https://llm.kimchi.dev";
+export const KIMCHI_USER_AGENT = "kimchi/0.1.40";
+
+const FETCH_TIMEOUT_MS = 20_000;
+const CACHE_TTL_MS = 5 * 60 * 1000;
+const RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504]);
+
+/** @type {Map<string, { expiresAt: number, models: object[], rawModels: object[] }>} */
+const catalogCache = new Map();
+/** @type {Map<string, object>} */
+const metadataByModelId = new Map();
+
+function normalizeKimchiEndpoint(endpoint) {
+  const raw = typeof endpoint === "string" ? endpoint.trim() : "";
+  return (raw || KIMCHI_API).replace(/\/+$/, "");
+}
+
+export function buildKimchiModelsUrl(endpoint) {
+  return `${normalizeKimchiEndpoint(endpoint)}/v1/models/metadata?include_in_cli=true`;
+}
+
+function readToken(credentials) {
+  return (
+    credentials?.accessToken
+    || credentials?.apiKey
+    || credentials?.providerSpecificData?.apiKey
+    || null
+  );
+}
+
+function cacheKey(credentials, endpoint) {
+  const psd = credentials?.providerSpecificData || {};
+  const seed = psd.userId || psd.username || credentials?.refreshToken || readToken(credentials) || "anonymous";
+  return createHash("sha256")
+    .update(`kimchi:${normalizeKimchiEndpoint(endpoint)}:${seed}`)
+    .digest("hex");
+}
+
+function toModelKind(inputModalities) {
+  return Array.isArray(inputModalities) && inputModalities.includes("image")
+    ? "imageToText"
+    : "llm";
+}
+
+export function normalizeKimchiModel(item) {
+  if (!item || typeof item !== "object") return null;
+  const id = item.slug || item.id || item.model || item.name;
+  if (typeof id !== "string" || id.trim() === "") return null;
+
+  const inputModalities = Array.isArray(item.input_modalities)
+    ? item.input_modalities.filter((value) => value === "text" || value === "image")
+    : [];
+  const limits = item.limits && typeof item.limits === "object" ? item.limits : {};
+  const contextLength = Number(limits.context_window || item.contextLength || item.context_length) || undefined;
+  const maxOutputTokens = Number(limits.max_output_tokens || item.maxOutputTokens || item.max_output_tokens) || undefined;
+  const upstreamProvider = typeof item.provider === "string" ? item.provider : "";
+  const reasoning = item.reasoning === true;
+  const kind = toModelKind(inputModalities);
+
+  const model = {
+    ...item,
+    id: id.trim(),
+    name: String(item.display_name || item.displayName || item.name || id).trim(),
+    provider: upstreamProvider,
+    upstreamProvider,
+    reasoning,
+    inputModalities,
+    kind,
+    type: kind,
+    capabilities: {
+      vision: inputModalities.includes("image"),
+      reasoning,
+      ...(contextLength ? { contextWindow: contextLength } : {}),
+      ...(maxOutputTokens ? { maxOutput: maxOutputTokens } : {}),
+      ...(upstreamProvider ? { upstreamProvider } : {}),
+    },
+    ...(contextLength ? { contextLength } : {}),
+    ...(maxOutputTokens ? { maxOutputTokens } : {}),
+  };
+
+  if (upstreamProvider === "anthropic") {
+    model.compat = { supportsReasoningEffort: false, cacheControlFormat: "anthropic" };
+  }
+
+  return model;
+}
+
+function rememberModels(models) {
+  for (const model of models || []) {
+    if (!model?.id) continue;
+    metadataByModelId.set(model.id, model);
+    metadataByModelId.set(model.id.toLowerCase(), model);
+  }
+}
+
+export function getCachedKimchiModelMetadata(modelId) {
+  if (typeof modelId !== "string" || modelId.trim() === "") return null;
+  const raw = modelId.includes("/") ? modelId.split("/").pop() : modelId;
+  return metadataByModelId.get(raw) || metadataByModelId.get(raw.toLowerCase()) || null;
+}
+
+async function fetchKimchiCatalogRaw(token, endpoint, options = {}) {
+  const url = buildKimchiModelsUrl(endpoint);
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(new Error("Kimchi models fetch timeout")), FETCH_TIMEOUT_MS);
+  const signal = options.signal
+    ? AbortSignal.any([options.signal, controller.signal])
+    : controller.signal;
+
+  try {
+    const response = await proxyAwareFetch(url, {
+      method: "GET",
+      headers: {
+        "Accept": "application/json",
+        "Authorization": `Bearer ${token}`,
+        "User-Agent": KIMCHI_USER_AGENT,
+      },
+      cache: "no-store",
+      signal,
+    }, options.proxyOptions || null);
+
+    if (!response.ok) {
+      const error = new Error(`Kimchi models ${response.status}: ${response.statusText}`);
+      error.status = response.status;
+      error.retryable = RETRYABLE_STATUSES.has(response.status);
+      throw error;
+    }
+
+    const data = await response.json();
+    return Array.isArray(data?.models) ? data.models : [];
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export async function resolveKimchiModels(credentials, options = {}) {
+  const token = readToken(credentials);
+  if (!token) return null;
+
+  const endpoint = credentials?.providerSpecificData?.kimchiEndpoint || options.endpoint || KIMCHI_API;
+  const key = cacheKey(credentials, endpoint);
+  const now = Date.now();
+  if (!options.forceRefresh) {
+    const cached = catalogCache.get(key);
+    if (cached && cached.expiresAt > now) return cached;
+  }
+
+  let rawModels;
+  try {
+    rawModels = await fetchKimchiCatalogRaw(token, endpoint, options);
+  } catch (error) {
+    options.log?.warn?.("KIMCHI_MODELS", error.message);
+    return null;
+  }
+
+  const models = rawModels.map(normalizeKimchiModel).filter(Boolean);
+  if (models.length === 0) return null;
+
+  rememberModels(models);
+  const entry = {
+    expiresAt: Date.now() + CACHE_TTL_MS,
+    models,
+    rawModels,
+  };
+  catalogCache.set(key, entry);
+  return entry;
+}
+
+export function clearKimchiCatalog() {
+  catalogCache.clear();
+  metadataByModelId.clear();
+}

package/open-sse/services/model.js

@@ -81,6 +81,11 @@ const ALIAS_TO_PROVIDER_ID = {
   "xiaomi-mimo": "xiaomi-mimo",
   xmtp: "xiaomi-tokenplan",
   "xiaomi-tokenplan": "xiaomi-tokenplan",
+  mmf: "mimo-free",
+  "mimo-free": "mimo-free",
+  venice: "venice",
+  fl: "featherless",
+  featherless: "featherless",
   cf: "cloudflare-ai",
   "cloudflare-ai": "cloudflare-ai",
   // Image/video providers

package/open-sse/services/tokenRefresh.js

@@ -705,6 +705,7 @@ async function _getAccessTokenInternal(provider, credentials, log) {
       );
 
     case "xai":
+    case "grok-cli":
       return await refreshXaiToken(credentials.refreshToken, log);
 
     case "vertex":
@@ -756,6 +757,7 @@ export async function refreshTokenByProvider(provider, credentials, log) {
         log
       );
     case "xai":
+    case "grok-cli":
       return refreshXaiToken(credentials.refreshToken, log);
     case "vertex":
     case "vertex-partner": {