From f260a1817b9a3bb693408e298c56443f97823f80 Mon Sep 17 00:00:00 2001
From: B1nh M1nh <43268322+b1nhm1nh@users.noreply.github.com>
Date: Sun, 2 Aug 2026 09:34:27 +0700
Subject: [PATCH 01/42] feat: Ollama Cloud quota tracker + proactive background
 OAuth refresh

Ollama: replace informational stub with real quota tracker hitting ollama.com/api/usage (session 5h + weekly 7d, 0..1 ratio) and /api/me plan label; bind handler to apiKey + add features.usageApikey so apikey connections work.

Token refresh: add backgroundTokenRefresh scheduler that refreshes OAuth connections within max(provider lead, 30min) of expiry, independent of inbound traffic (10s after boot, then every 5min, unref'd timers, DISABLE_BACKGROUND_TOKEN_REFRESH kill-switch, fail-open per tick/connection). Registered from custom-server.js (listening) and initializeApp.js. checkAndRefreshToken gains opt-in {force} for the scheduler; request path unchanged.
---
 custom-server.js                              |  41 +++-
 open-sse/providers/registry/ollama.js         |   1 +
 open-sse/services/usage.js                    |   2 +-
 open-sse/services/usage/misc.js               |  91 ++++++--
 .../usage/components/ProviderLimits/utils.js  |  16 ++
 src/shared/services/initializeApp.js          |   6 +
 src/sse/services/backgroundTokenRefresh.js    | 195 +++++++++++++++++
 src/sse/services/tokenRefresh.js              |   8 +-
 tests/unit/background-token-refresh.test.js   | 203 ++++++++++++++++++
 tests/unit/ollama-usage.test.js               | 165 ++++++++++++++
 10 files changed, 710 insertions(+), 18 deletions(-)
 create mode 100644 src/sse/services/backgroundTokenRefresh.js
 create mode 100644 tests/unit/background-token-refresh.test.js
 create mode 100644 tests/unit/ollama-usage.test.js

diff --git a/custom-server.js b/custom-server.js
index 6e39683f..f21d4366 100644
--- a/custom-server.js
+++ b/custom-server.js
@@ -1,7 +1,42 @@
 const http = require("http");
+const path = require("path");
+const { pathToFileURL } = require("url");
 
 const origCreate = http.createServer.bind(http);
 
+let backgroundRefreshStarted = false;
+
+function startBackgroundTokenRefreshFromCustomServer() {
+  if (backgroundRefreshStarted) return;
+  backgroundRefreshStarted = true;
+  // Prefer source path (repo / standalone that still has src). Fail-open if missing
+  // — initializeApp also starts the same scheduler when the Next app boots.
+  const modPath = path.join(__dirname, "src", "sse", "services", "backgroundTokenRefresh.js");
+  import(pathToFileURL(modPath).href)
+    .then((m) => {
+      try {
+        m.startBackgroundTokenRefresh();
+      } catch (e) {
+        console.error("[BackgroundTokenRefresh] start failed:", e && e.message ? e.message : e);
+      }
+      const stop = () => {
+        try {
+          m.stopBackgroundTokenRefresh();
+        } catch {
+          /* ignore */
+        }
+      };
+      process.once("SIGINT", stop);
+      process.once("SIGTERM", stop);
+    })
+    .catch((e) => {
+      // Expected in published CLI standalone (src/ not on disk). App bootstrap covers it.
+      if (process.env.DEBUG_BACKGROUND_TOKEN_REFRESH) {
+        console.error("[BackgroundTokenRefresh] import failed:", e && e.message ? e.message : e);
+      }
+    });
+}
+
 // Wrap Next standalone HTTP server: derive client IP from the TCP socket
 // (unspoofable) and strip client-supplied forwarding headers so downstream
 // rate-limiting keys on the real peer address instead of attacker-controlled XFF.
@@ -26,7 +61,11 @@ http.createServer = (...args) => {
     if (viaProxy) req.headers["x-9r-via-proxy"] = "1";
     return handler(req, res);
   };
-  return origCreate(...rest, wrapped);
+  const server = origCreate(...rest, wrapped);
+  server.once("listening", () => {
+    startBackgroundTokenRefreshFromCustomServer();
+  });
+  return server;
 };
 
 require("./server.js");
diff --git a/open-sse/providers/registry/ollama.js b/open-sse/providers/registry/ollama.js
index 69923aa1..1e938c58 100644
--- a/open-sse/providers/registry/ollama.js
+++ b/open-sse/providers/registry/ollama.js
@@ -32,5 +32,6 @@ export default {
   serviceKinds: ["llm"],
   features: {
     usage: true,
+    usageApikey: true,
   },
 };
diff --git a/open-sse/services/usage.js b/open-sse/services/usage.js
index 65819e72..d1c361b9 100644
--- a/open-sse/services/usage.js
+++ b/open-sse/services/usage.js
@@ -39,7 +39,7 @@ const USAGE_HANDLERS = {
   qoder: (c) => getQoderUsage(c.accessToken, c.proxyOptions),
   qwen: (c) => getQwenUsage(c.accessToken, c.providerSpecificData),
   iflow: (c) => getIflowUsage(c.accessToken),
-  ollama: (c) => getOllamaUsage(c.accessToken),
+  ollama: (c) => getOllamaUsage(c.apiKey, c.providerSpecificData, c.proxyOptions),
   glm: (c) => getGlmUsage(c.apiKey, c.provider, c.proxyOptions),
   "glm-cn": (c) => getGlmUsage(c.apiKey, c.provider, c.proxyOptions),
   minimax: (c) => getMiniMaxUsage(c.apiKey, c.provider, c.proxyOptions),
diff --git a/open-sse/services/usage/misc.js b/open-sse/services/usage/misc.js
index 6ce012fa..6a4323c8 100644
--- a/open-sse/services/usage/misc.js
+++ b/open-sse/services/usage/misc.js
@@ -46,23 +46,86 @@ export async function getIflowUsage(accessToken) {
 
 /**
  * Ollama Cloud Usage
- * Ollama Cloud uses an API key from ollama.com/settings/keys
- * and has no public usage API — free tier has light usage limits (resets every 5h & 7d).
- * This returns an informational message with the plan details.
+ * GET https://ollama.com/api/usage — session (5h) + weekly (7d) `usage` is a 0..1
+ *   ratio (1.0 = limit reached, e.g. weekly 100% used). No reset timestamp exposed.
+ * POST https://ollama.com/api/me — plan label (fail-open).
+ * Auth: Authorization: Bearer <apiKey>
  */
-export async function getOllamaUsage(accessToken, providerSpecificData) {
+export async function getOllamaUsage(apiKey, providerSpecificData, proxyOptions = null) {
+  if (!apiKey) {
+    return { message: "Ollama Cloud API key not available." };
+  }
+
   try {
-    // Ollama Cloud does not expose a public quota/usage API.
-    // The provider is configured as noAuth with a notice explaining limits.
-    // We return a graceful message so the UI shows a friendly state instead of an error.
-    const plan = providerSpecificData?.plan || "Free";
-    return {
-      plan,
-      message: "Ollama Cloud uses a free tier with light usage limits (resets every 5h & 7d). For detailed usage tracking, visit ollama.com/settings/keys.",
-      quotas: [],
-    };
+    const response = await proxyAwareFetch("https://ollama.com/api/usage", {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json",
+      },
+    }, proxyOptions);
+
+    if (response.status === 401 || response.status === 403) {
+      return { message: "Ollama Cloud API key invalid or expired." };
+    }
+
+    if (!response.ok) {
+      return { message: `Ollama Cloud usage API error (${response.status}).` };
+    }
+
+    let data;
+    try {
+      data = await response.json();
+    } catch {
+      return { message: "Ollama Cloud usage response was not JSON." };
+    }
+
+    // Best-effort plan label from /api/me
+    const me = await proxyAwareFetch("https://ollama.com/api/me", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json",
+        "Content-Length": "0",
+      },
+    }, proxyOptions).then((r) => (r.ok ? r.json() : null)).catch(() => null);
+
+    const planRaw = typeof me?.Plan === "string" ? me.Plan : "";
+    const plan = planRaw
+      ? planRaw.charAt(0).toUpperCase() + planRaw.slice(1).toLowerCase()
+      : "Ollama Cloud";
+
+    const limits = data?.limits && typeof data.limits === "object" ? data.limits : {};
+
+    // Ollama `usage` is a 0..1 ratio (1.0 = limit reached). Convert to a 0..100
+    // bar. Do NOT set absolute `remaining` — QuotaTable reads remainingPercentage.
+    function ratioQuota(usageRatio, resetAt = null) {
+      const ratio = Math.max(0, Math.min(1, Number(usageRatio) || 0));
+      const usedPct = Math.round(ratio * 100);
+      return { used: usedPct, total: 100, remainingPercentage: 100 - usedPct, resetAt, unlimited: false };
+    }
+
+    const sessionRaw = limits.session?.usage;
+    const weeklyRaw = limits.weekly?.usage;
+    const sessionNum = Number(sessionRaw);
+    const weeklyNum = Number(weeklyRaw);
+    const hasSession = sessionRaw !== undefined && sessionRaw !== null && !Number.isNaN(sessionNum);
+    const hasWeekly = weeklyRaw !== undefined && weeklyRaw !== null && !Number.isNaN(weeklyNum);
+
+    if (!hasSession && !hasWeekly) {
+      return {
+        plan,
+        message: "Ollama Cloud connected. No usage limits reported.",
+        quotas: {},
+      };
+    }
+
+    const quotas = {};
+    if (hasSession) quotas["Session (5h)"] = ratioQuota(sessionNum);
+    if (hasWeekly) quotas["Weekly (7d)"] = ratioQuota(weeklyNum);
+
+    return { plan, quotas };
   } catch (error) {
-    return { message: "Unable to fetch Ollama Cloud usage." };
+    return { message: `Ollama Cloud error: ${error.message}` };
   }
 }
 
diff --git a/src/app/(dashboard)/dashboard/usage/components/ProviderLimits/utils.js b/src/app/(dashboard)/dashboard/usage/components/ProviderLimits/utils.js
index b3a61c19..9f185b83 100644
--- a/src/app/(dashboard)/dashboard/usage/components/ProviderLimits/utils.js
+++ b/src/app/(dashboard)/dashboard/usage/components/ProviderLimits/utils.js
@@ -522,6 +522,22 @@ export function parseQuotaData(provider, data) {
         }
         break;
 
+      case "ollama":
+        // Session (5h) / Weekly (7d) usage % from ollama.com/api/usage.
+        // remainingPercentage only — no absolute remaining (UI treats remaining as %).
+        if (data.quotas) {
+          Object.entries(data.quotas).forEach(([name, quota]) => {
+            normalizedQuotas.push({
+              name,
+              used: quota.used || 0,
+              total: quota.total || 0,
+              resetAt: quota.resetAt || null,
+              remainingPercentage: quota.remainingPercentage,
+            });
+          });
+        }
+        break;
+
       default:
         // Generic fallback for unknown providers
         if (data.quotas) {
diff --git a/src/shared/services/initializeApp.js b/src/shared/services/initializeApp.js
index 536b6676..5b27f774 100644
--- a/src/shared/services/initializeApp.js
+++ b/src/shared/services/initializeApp.js
@@ -112,6 +112,12 @@ async function runHeavyStartup() {
       .then(({ startQuotaAutoPing }) => startQuotaAutoPing())
       .catch((e) => console.log("[AutoPing] scheduler start failed:", e.message));
   }
+
+  // Proactive OAuth token refresh (e.g. grok-cli ~6h TTL). Module is idempotent
+  // and also started from custom-server.js when that entry is used.
+  import("@/sse/services/backgroundTokenRefresh.js")
+    .then(({ startBackgroundTokenRefresh }) => startBackgroundTokenRefresh())
+    .catch((e) => console.log("[BackgroundTokenRefresh] scheduler start failed:", e.message));
 }
 
 function hasQuotaAutoPingEnabled(settings) {
diff --git a/src/sse/services/backgroundTokenRefresh.js b/src/sse/services/backgroundTokenRefresh.js
new file mode 100644
index 00000000..b10a86ba
--- /dev/null
+++ b/src/sse/services/backgroundTokenRefresh.js
@@ -0,0 +1,195 @@
+// Background proactive OAuth token refresh — independent of inbound requests.
+// Fail-open everywhere: tick errors and per-connection failures never kill the interval.
+
+import * as log from "../utils/logger.js";
+import { getRefreshLeadMs } from "open-sse/services/tokenRefresh.js";
+import { getCredentialExpiryMs } from "open-sse/services/oauthCredentialManager.js";
+
+/** Refresh when expiry is within 30 minutes (or the provider on-request lead, whichever larger). */
+export const BACKGROUND_REFRESH_LEAD_MS = 30 * 60 * 1000;
+const DEFAULT_INTERVAL_MS = 5 * 60 * 1000;
+const INITIAL_DELAY_MS = 10 * 1000;
+
+let started = false;
+let intervalHandle = null;
+let initialTimeoutHandle = null;
+let tickRunning = false;
+
+function isTruthyEnv(value) {
+  if (value == null || value === "") return false;
+  const v = String(value).trim().toLowerCase();
+  return v === "1" || v === "true" || v === "yes" || v === "on";
+}
+
+function isNonServerRuntime() {
+  if (typeof window !== "undefined") return true;
+  const phase = process.env.NEXT_PHASE || "";
+  if (
+    phase === "phase-production-build" ||
+    phase === "phase-export" ||
+    phase === "phase-static"
+  ) {
+    return true;
+  }
+  // Next.js build / static generation markers
+  if (process.env.NEXT_RUNTIME === "edge") return true;
+  return false;
+}
+
+/**
+ * Pure selection: OAuth connections with a refreshToken whose access token
+ * expires within max(provider on-request lead, BACKGROUND_REFRESH_LEAD_MS).
+ *
+ * @param {Array<object>} connections
+ * @param {number} [nowMs]
+ * @returns {Array<object>}
+ */
+export function selectConnectionsNeedingRefresh(connections, nowMs = Date.now()) {
+  if (!Array.isArray(connections) || connections.length === 0) return [];
+
+  const out = [];
+  for (const conn of connections) {
+    if (!conn) continue;
+
+    const authType = String(conn.authType || "").toLowerCase().replace(/_/g, "");
+    if (authType !== "oauth") continue;
+    if (!conn.refreshToken) continue;
+
+    const expiresAtMs = getCredentialExpiryMs(conn);
+    if (expiresAtMs === null) continue;
+
+    const providerLead = getRefreshLeadMs(conn.provider);
+    const leadMs = Math.max(
+      Number.isFinite(providerLead) ? providerLead : 0,
+      BACKGROUND_REFRESH_LEAD_MS
+    );
+
+    if (expiresAtMs - nowMs < leadMs) {
+      out.push(conn);
+    }
+  }
+  return out;
+}
+
+async function loadActiveConnections() {
+  // Dynamic import avoids circular load with db / app graph at module eval time.
+  const { getProviderConnections } = await import("../../lib/db/repos/connectionsRepo.js");
+  return getProviderConnections({ isActive: true });
+}
+
+async function refreshOne(connection) {
+  const { checkAndRefreshToken } = await import("./tokenRefresh.js");
+  return checkAndRefreshToken(connection.provider, connection, { force: true });
+}
+
+/**
+ * One scheduler tick. Fail-open at top level and per connection.
+ * @param {{ loadConnections?: Function, refreshConnection?: Function }} [deps]
+ */
+export async function runBackgroundTokenRefreshTick(deps = {}) {
+  if (tickRunning) {
+    log.debug("BG_TOKEN_REFRESH", "Tick already running, skip");
+    return;
+  }
+  tickRunning = true;
+  try {
+    const load = deps.loadConnections || loadActiveConnections;
+    const refresh = deps.refreshConnection || refreshOne;
+
+    const connections = await load();
+    const due = selectConnectionsNeedingRefresh(connections, Date.now());
+
+    if (due.length === 0) {
+      log.debug("BG_TOKEN_REFRESH", "No connections due for refresh", {
+        active: Array.isArray(connections) ? connections.length : 0,
+      });
+      return;
+    }
+
+    log.info("BG_TOKEN_REFRESH", "Refreshing due OAuth connections", {
+      due: due.length,
+      ids: due.map((c) => c.id).filter(Boolean),
+    });
+
+    await Promise.allSettled(
+      due.map(async (conn) => {
+        try {
+          await refresh(conn);
+          log.info("BG_TOKEN_REFRESH", "Connection refresh finished", {
+            id: conn.id,
+            provider: conn.provider,
+          });
+        } catch (err) {
+          log.warn("BG_TOKEN_REFRESH", "Connection refresh failed (swallowed)", {
+            id: conn?.id,
+            provider: conn?.provider,
+            error: err?.message ?? String(err),
+          });
+        }
+      })
+    );
+  } catch (err) {
+    log.warn("BG_TOKEN_REFRESH", "Tick failed (swallowed)", {
+      error: err?.message ?? String(err),
+    });
+  } finally {
+    tickRunning = false;
+  }
+}
+
+/**
+ * Start the background interval. Safe to call multiple times (no-op if already started).
+ * @param {{ intervalMs?: number }} [opts]
+ * @returns {boolean} true if started this call
+ */
+export function startBackgroundTokenRefresh({ intervalMs } = {}) {
+  if (started) return false;
+  if (isTruthyEnv(process.env.DISABLE_BACKGROUND_TOKEN_REFRESH)) {
+    log.info("BG_TOKEN_REFRESH", "Disabled via DISABLE_BACKGROUND_TOKEN_REFRESH");
+    return false;
+  }
+  if (isNonServerRuntime()) {
+    log.debug("BG_TOKEN_REFRESH", "Skip start outside long-running server runtime");
+    return false;
+  }
+
+  started = true;
+  const period = Number.isFinite(intervalMs) && intervalMs > 0 ? intervalMs : DEFAULT_INTERVAL_MS;
+
+  const safeTick = () => {
+    runBackgroundTokenRefreshTick().catch((err) => {
+      log.warn("BG_TOKEN_REFRESH", "Unhandled tick rejection (swallowed)", {
+        error: err?.message ?? String(err),
+      });
+    });
+  };
+
+  // First pass soon after boot so idle connections don't wait a full interval.
+  initialTimeoutHandle = setTimeout(safeTick, INITIAL_DELAY_MS);
+  if (initialTimeoutHandle.unref) initialTimeoutHandle.unref();
+
+  intervalHandle = setInterval(safeTick, period);
+  if (intervalHandle.unref) intervalHandle.unref();
+
+  log.info("BG_TOKEN_REFRESH", "Scheduler started", {
+    intervalMs: period,
+    initialDelayMs: INITIAL_DELAY_MS,
+    leadMs: BACKGROUND_REFRESH_LEAD_MS,
+  });
+  return true;
+}
+
+export function stopBackgroundTokenRefresh() {
+  if (initialTimeoutHandle) {
+    clearTimeout(initialTimeoutHandle);
+    initialTimeoutHandle = null;
+  }
+  if (intervalHandle) {
+    clearInterval(intervalHandle);
+    intervalHandle = null;
+  }
+  if (started) {
+    started = false;
+    log.info("BG_TOKEN_REFRESH", "Scheduler stopped");
+  }
+}
diff --git a/src/sse/services/tokenRefresh.js b/src/sse/services/tokenRefresh.js
index d6fe288e..4e75a8ad 100644
--- a/src/sse/services/tokenRefresh.js
+++ b/src/sse/services/tokenRefresh.js
@@ -216,16 +216,20 @@ export async function updateProviderCredentials(connectionId, newCredentials) {
  *
  * @param {string} provider
  * @param {object} credentials
+ * @param {{ force?: boolean }} [options]  force=true skips the on-request lead check
+ *   (used by background scheduler which applies a larger lead). Request path omits this.
  * @returns {Promise<object>} updated credentials object
  */
-export async function checkAndRefreshToken(provider, credentials) {
+export async function checkAndRefreshToken(provider, credentials, options = {}) {
   let creds = { ...credentials };
   if (!creds.connectionId && creds.id) {
     creds.connectionId = creds.id;
   }
 
+  const force = options?.force === true;
+
   // ── 1. Regular access-token expiry ────────────────────────────────────────
-  if (_shouldRefreshCredentials(provider, creds)) {
+  if (force || _shouldRefreshCredentials(provider, creds)) {
     const expiresAt = creds.expiresAt ? new Date(creds.expiresAt).getTime() : null;
     const remaining = expiresAt ? expiresAt - Date.now() : null;
     const refreshLead = _getRefreshLeadMs(provider);
diff --git a/tests/unit/background-token-refresh.test.js b/tests/unit/background-token-refresh.test.js
new file mode 100644
index 00000000..62507545
--- /dev/null
+++ b/tests/unit/background-token-refresh.test.js
@@ -0,0 +1,203 @@
+/**
+ * Background OAuth token-refresh scheduler.
+ *
+ * Covers pure selection (selectConnectionsNeedingRefresh) and a fake tick that
+ * exercises checkAndRefreshToken dispatch + fail-open per connection.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+const NOW = Date.parse("2026-08-01T12:00:00.000Z");
+
+function conn(overrides = {}) {
+  return {
+    id: "c1",
+    provider: "grok-cli",
+    authType: "oauth",
+    refreshToken: "rt-1",
+    expiresAt: new Date(NOW + 10 * 60 * 1000).toISOString(),
+    isActive: true,
+    ...overrides,
+  };
+}
+
+describe("selectConnectionsNeedingRefresh", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(NOW);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.resetModules();
+  });
+
+  it("selects oauth grok-cli connection expiring in 10 minutes", async () => {
+    const { selectConnectionsNeedingRefresh } = await import(
+      "../../src/sse/services/backgroundTokenRefresh.js"
+    );
+    const list = selectConnectionsNeedingRefresh(
+      [conn({ expiresAt: new Date(NOW + 10 * 60 * 1000).toISOString() })],
+      NOW
+    );
+    expect(list).toHaveLength(1);
+    expect(list[0].id).toBe("c1");
+  });
+
+  it("skips connection expiring in 2 hours", async () => {
+    const { selectConnectionsNeedingRefresh } = await import(
+      "../../src/sse/services/backgroundTokenRefresh.js"
+    );
+    const list = selectConnectionsNeedingRefresh(
+      [conn({ expiresAt: new Date(NOW + 2 * 60 * 60 * 1000).toISOString() })],
+      NOW
+    );
+    expect(list).toHaveLength(0);
+  });
+
+  it("never selects apikey connections", async () => {
+    const { selectConnectionsNeedingRefresh } = await import(
+      "../../src/sse/services/backgroundTokenRefresh.js"
+    );
+    const list = selectConnectionsNeedingRefresh(
+      [
+        conn({ authType: "apikey", refreshToken: "rt" }),
+        conn({ id: "c2", authType: "api_key", refreshToken: "rt" }),
+      ],
+      NOW
+    );
+    expect(list).toHaveLength(0);
+  });
+
+  it("skips oauth connection without refreshToken", async () => {
+    const { selectConnectionsNeedingRefresh } = await import(
+      "../../src/sse/services/backgroundTokenRefresh.js"
+    );
+    const list = selectConnectionsNeedingRefresh(
+      [conn({ refreshToken: null }), conn({ id: "c2", refreshToken: undefined })],
+      NOW
+    );
+    expect(list).toHaveLength(0);
+  });
+
+  it("selects already-expired oauth connection", async () => {
+    const { selectConnectionsNeedingRefresh } = await import(
+      "../../src/sse/services/backgroundTokenRefresh.js"
+    );
+    const list = selectConnectionsNeedingRefresh(
+      [conn({ expiresAt: new Date(NOW - 60 * 1000).toISOString() })],
+      NOW
+    );
+    expect(list).toHaveLength(1);
+  });
+});
+
+describe("runBackgroundTokenRefreshTick", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(NOW);
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  it("calls refresh only for due connections and swallows per-connection errors", async () => {
+    const due = conn({
+      id: "due",
+      expiresAt: new Date(NOW + 10 * 60 * 1000).toISOString(),
+    });
+    const notDue = conn({
+      id: "not-due",
+      expiresAt: new Date(NOW + 2 * 60 * 60 * 1000).toISOString(),
+    });
+    const apikey = conn({
+      id: "key",
+      authType: "apikey",
+      expiresAt: new Date(NOW + 60 * 1000).toISOString(),
+    });
+
+    const refreshConnection = vi.fn(async (c) => {
+      if (c.id === "due") throw new Error("boom");
+      return c;
+    });
+    const loadConnections = vi.fn(async () => [due, notDue, apikey]);
+
+    const { runBackgroundTokenRefreshTick } = await import(
+      "../../src/sse/services/backgroundTokenRefresh.js"
+    );
+
+    await expect(
+      runBackgroundTokenRefreshTick({ loadConnections, refreshConnection })
+    ).resolves.toBeUndefined();
+
+    expect(loadConnections).toHaveBeenCalledTimes(1);
+    expect(refreshConnection).toHaveBeenCalledTimes(1);
+    expect(refreshConnection.mock.calls[0][0].id).toBe("due");
+  });
+
+  it("does not call refresh when nothing is due", async () => {
+    const refreshConnection = vi.fn();
+    const loadConnections = vi.fn(async () => [
+      conn({
+        expiresAt: new Date(NOW + 3 * 60 * 60 * 1000).toISOString(),
+      }),
+    ]);
+
+    const { runBackgroundTokenRefreshTick } = await import(
+      "../../src/sse/services/backgroundTokenRefresh.js"
+    );
+
+    await runBackgroundTokenRefreshTick({ loadConnections, refreshConnection });
+
+    expect(refreshConnection).not.toHaveBeenCalled();
+  });
+
+  it("swallows top-level load errors", async () => {
+    const refreshConnection = vi.fn();
+    const loadConnections = vi.fn(async () => {
+      throw new Error("db down");
+    });
+
+    const { runBackgroundTokenRefreshTick } = await import(
+      "../../src/sse/services/backgroundTokenRefresh.js"
+    );
+
+    await expect(
+      runBackgroundTokenRefreshTick({ loadConnections, refreshConnection })
+    ).resolves.toBeUndefined();
+    expect(refreshConnection).not.toHaveBeenCalled();
+  });
+});
+
+describe("start/stop guards", () => {
+  afterEach(async () => {
+    vi.unstubAllEnvs();
+    const mod = await import("../../src/sse/services/backgroundTokenRefresh.js");
+    mod.stopBackgroundTokenRefresh();
+    vi.resetModules();
+  });
+
+  it("honors DISABLE_BACKGROUND_TOKEN_REFRESH kill-switch", async () => {
+    vi.stubEnv("DISABLE_BACKGROUND_TOKEN_REFRESH", "1");
+    const { startBackgroundTokenRefresh, stopBackgroundTokenRefresh } = await import(
+      "../../src/sse/services/backgroundTokenRefresh.js"
+    );
+    expect(startBackgroundTokenRefresh()).toBe(false);
+    stopBackgroundTokenRefresh();
+  });
+
+  it("is idempotent: second start is no-op", async () => {
+    vi.stubEnv("DISABLE_BACKGROUND_TOKEN_REFRESH", "");
+    const { startBackgroundTokenRefresh, stopBackgroundTokenRefresh } = await import(
+      "../../src/sse/services/backgroundTokenRefresh.js"
+    );
+    const first = startBackgroundTokenRefresh({ intervalMs: 60_000 });
+    const second = startBackgroundTokenRefresh({ intervalMs: 60_000 });
+    expect(first).toBe(true);
+    expect(second).toBe(false);
+    stopBackgroundTokenRefresh();
+  });
+});
diff --git a/tests/unit/ollama-usage.test.js b/tests/unit/ollama-usage.test.js
new file mode 100644
index 00000000..fd8587e3
--- /dev/null
+++ b/tests/unit/ollama-usage.test.js
@@ -0,0 +1,165 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("../../open-sse/utils/proxyFetch.js", () => ({
+  proxyAwareFetch: vi.fn(),
+}));
+
+import { proxyAwareFetch } from "../../open-sse/utils/proxyFetch.js";
+import { getUsageForProvider } from "../../open-sse/services/usage.js";
+import {
+  USAGE_SUPPORTED_PROVIDERS,
+  USAGE_APIKEY_PROVIDERS,
+} from "../../src/shared/constants/providers.js";
+import { parseQuotaData } from "../../src/app/(dashboard)/dashboard/usage/components/ProviderLimits/utils.js";
+
+const USAGE_URL = "https://ollama.com/api/usage";
+const ME_URL = "https://ollama.com/api/me";
+
+function jsonResponse(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+const SAMPLE_USAGE = {
+  activity: {
+    cost: "0.00000",
+    period: {
+      type: "last_4_weeks",
+      starting_at: "2026-07-01T00:00:00Z",
+      ending_at: "2026-07-29T00:00:00Z",
+    },
+    models: [],
+  },
+  limits: {
+    session: { usage: 0, models: [] },
+    weekly: {
+      usage: 1,
+      models: [
+        { name: "glm-5.2", request_count: 5967 },
+        { name: "kimi-k2.5", request_count: 2 },
+      ],
+    },
+  },
+};
+
+const SAMPLE_ME = {
+  Plan: "max",
+};
+
+describe("ollama registry usage flags", () => {
+  it("is listed for apikey quota dashboard", () => {
+    expect(USAGE_SUPPORTED_PROVIDERS).toContain("ollama");
+    expect(USAGE_APIKEY_PROVIDERS).toContain("ollama");
+  });
+});
+
+describe("getUsageForProvider(ollama)", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("GETs /api/usage with Bearer apiKey and POSTs /api/me for plan", async () => {
+    proxyAwareFetch
+      .mockResolvedValueOnce(jsonResponse(SAMPLE_USAGE))
+      .mockResolvedValueOnce(jsonResponse(SAMPLE_ME));
+
+    const usage = await getUsageForProvider({
+      provider: "ollama",
+      apiKey: "k",
+      providerSpecificData: {},
+    });
+
+    expect(usage.message).toBeUndefined();
+    expect(usage.plan).toBe("Max");
+    expect(usage.quotas["Session (5h)"]).toMatchObject({
+      used: 0,
+      total: 100,
+      remainingPercentage: 100,
+      unlimited: false,
+    });
+    expect(usage.quotas["Weekly (7d)"]).toMatchObject({
+      used: 100,
+      total: 100,
+      remainingPercentage: 0,
+      unlimited: false,
+    });
+    // Must not set absolute remaining — UI treats remaining as %
+    expect(usage.quotas["Session (5h)"].remaining).toBeUndefined();
+    expect(usage.quotas["Weekly (7d)"].remaining).toBeUndefined();
+
+    expect(proxyAwareFetch).toHaveBeenCalledTimes(2);
+
+    const [usageUrl, usageOpts] = proxyAwareFetch.mock.calls[0];
+    expect(usageUrl).toBe(USAGE_URL);
+    expect(usageOpts.headers.Authorization).toBe("Bearer k");
+    expect(usageOpts.headers.Accept).toBe("application/json");
+
+    const [meUrl, meOpts] = proxyAwareFetch.mock.calls[1];
+    expect(meUrl).toBe(ME_URL);
+    expect(meOpts.method).toBe("POST");
+    expect(meOpts.headers.Authorization).toBe("Bearer k");
+    expect(meOpts.headers["Content-Length"]).toBe("0");
+  });
+
+  it("surfaces invalid key message on 401", async () => {
+    proxyAwareFetch.mockResolvedValueOnce(
+      jsonResponse({ error: "unauthorized" }, 401),
+    );
+
+    const usage = await getUsageForProvider({
+      provider: "ollama",
+      apiKey: "bad",
+    });
+
+    expect(usage.message).toMatch(/invalid/i);
+    expect(proxyAwareFetch).toHaveBeenCalledTimes(1);
+  });
+
+  it("returns message when apiKey missing", async () => {
+    const usage = await getUsageForProvider({
+      provider: "ollama",
+      providerSpecificData: {},
+    });
+
+    expect(usage.message).toMatch(/api key/i);
+    expect(proxyAwareFetch).not.toHaveBeenCalled();
+  });
+});
+
+describe("parseQuotaData(ollama)", () => {
+  it("forwards remainingPercentage for dashboard bars", () => {
+    const rows = parseQuotaData("ollama", {
+      plan: "Max",
+      quotas: {
+        "Session (5h)": {
+          used: 0,
+          total: 100,
+          remainingPercentage: 100,
+          resetAt: null,
+        },
+        "Weekly (7d)": {
+          used: 100,
+          total: 100,
+          remainingPercentage: 0,
+          resetAt: null,
+        },
+      },
+    });
+
+    expect(rows).toHaveLength(2);
+    expect(rows[0]).toMatchObject({
+      name: "Session (5h)",
+      used: 0,
+      total: 100,
+      remainingPercentage: 100,
+    });
+    expect(rows[1]).toMatchObject({
+      name: "Weekly (7d)",
+      used: 100,
+      total: 100,
+      remainingPercentage: 0,
+    });
+  });
+});

From 0e5da70cb1c0cbe4abaa94c1af16f3840df991c6 Mon Sep 17 00:00:00 2001
From: techysy <techysy@gmail.com>
Date: Wed, 5 Aug 2026 10:22:29 +0700
Subject: [PATCH 02/42] fix: freeTier/apikey providers without authModes
 default to apikey in dualAuthTypes

Free-tier and apikey providers (e.g. cloudflare-ai, byteplus, ollama, vertex) whose registry entry omits authModes were treated as oauth-only, hiding their apikey connections on the providers grid card.
---
 src/app/(dashboard)/dashboard/providers/page.js | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/app/(dashboard)/dashboard/providers/page.js b/src/app/(dashboard)/dashboard/providers/page.js
index eab63c7a..b1c23de2 100644
--- a/src/app/(dashboard)/dashboard/providers/page.js
+++ b/src/app/(dashboard)/dashboard/providers/page.js
@@ -283,7 +283,15 @@ export default function ProvidersPage() {
   const dualAuthTypes = (info, key) => {
     if (key === "kiro") return ["oauth", "apikey", "api_key"];
     const modes = info?.authModes;
-    if (!Array.isArray(modes) || !modes.includes("apikey")) return "oauth";
+    // Free-tier and API-key providers default to supporting apikey even when the
+    // registry entry omits authModes (e.g. cloudflare-ai, byteplus, ollama,
+    // vertex) — otherwise their apikey connections are invisible on the grid card.
+    if (!Array.isArray(modes)) {
+      return key in FREE_TIER_PROVIDERS || key in APIKEY_PROVIDERS
+        ? ["oauth", "apikey", "api_key"]
+        : "oauth";
+    }
+    if (!modes.includes("apikey")) return "oauth";
     return ["oauth", "apikey", "api_key"];
   };
 

From 918b3c87a19a118cef06aa0147f1f6a7e988c573 Mon Sep 17 00:00:00 2001
From: lazysaltyfish <7127935+lazysaltyfish@users.noreply.github.com>
Date: Wed, 5 Aug 2026 10:23:39 +0700
Subject: [PATCH 03/42] fix(cli-tools): enable Apply button for dynamic
 OpenAI/Anthropic-compatible providers

getAllAvailableModels() only consulted the static PROVIDER_MODELS catalog,
which has no entry for dynamically-registered compatible providers
(id like openai-compatible-chat-uuid). Fall back to the connection's
own defaultModel/customModels/placeholder, mirroring ModelSelectModal.js.
---
 .../cli-tools/[toolId]/ToolDetailClient.js    | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/src/app/(dashboard)/dashboard/cli-tools/[toolId]/ToolDetailClient.js b/src/app/(dashboard)/dashboard/cli-tools/[toolId]/ToolDetailClient.js
index 2e735647..209a6d33 100644
--- a/src/app/(dashboard)/dashboard/cli-tools/[toolId]/ToolDetailClient.js
+++ b/src/app/(dashboard)/dashboard/cli-tools/[toolId]/ToolDetailClient.js
@@ -81,6 +81,33 @@ export default function ToolDetailClient({ toolId, machineId }) {
           models.push({ value: modelValue, label: `${alias}/${m.id}`, provider: conn.provider, alias, connectionName: conn.name, modelId: m.id });
         }
       });
+
+      // openai/anthropic-compatible providers are registered with a random UUID (e.g.
+      // "openai-compatible-chat-<uuid>") that has no entry in the static PROVIDER_MODELS
+      // catalog, so `getModelsByProviderId` returns []. Routing still works because the
+      // request path uses the connection's own model config, but `hasActiveProviders`
+      // below would flip to false and disable the Apply button. Fall back to the
+      // connection's own models so these providers are usable from CLI tool pages.
+      if (providerModels.length === 0) {
+        const prefix = conn.providerSpecificData?.prefix || alias;
+        const fallbackModels = [];
+        if (conn.defaultModel) fallbackModels.push({ id: conn.defaultModel, name: conn.defaultModel });
+        (conn.providerSpecificData?.customModels || []).forEach(m => {
+          if (m?.id && !fallbackModels.some(f => f.id === m.id)) fallbackModels.push({ id: m.id, name: m.name || m.id });
+        });
+        if (fallbackModels.length === 0 && conn.testStatus === "active") {
+          // Provider is confirmed reachable but exposes no model info anywhere;
+          // still let the user apply so they aren't stuck on a permanently disabled button.
+          fallbackModels.push({ id: "model-id", name: `${prefix}/model-id` });
+        }
+        fallbackModels.forEach(m => {
+          const modelValue = `${prefix}/${m.id}`;
+          if (!seenModels.has(modelValue)) {
+            seenModels.add(modelValue);
+            models.push({ value: modelValue, label: `${prefix}/${m.id}`, provider: conn.provider, alias: prefix, connectionName: conn.name, modelId: m.id });
+          }
+        });
+      }
     });
     return models;
   };

From ae4f76c433c945143abd7aa8542414e859dd4f67 Mon Sep 17 00:00:00 2001
From: DaDecky <mdikiisra98@gmail.com>
Date: Wed, 5 Aug 2026 10:26:57 +0700
Subject: [PATCH 04/42] fix(auth): redirect active sessions from /login

/api/auth/status did not expose whether the auth cookie corresponds to a
valid dashboard session, so /login could only detect "auth disabled"
(requireLogin === false) and not "already logged in". Add authenticated
to the status response and redirect from /login when it's true.
---
 src/app/api/auth/status/route.js |  2 +
 src/app/login/page.js            |  2 +-
 tests/unit/auth-status.test.js   | 69 ++++++++++++++++++++++++++++++++
 3 files changed, 72 insertions(+), 1 deletion(-)
 create mode 100644 tests/unit/auth-status.test.js

diff --git a/src/app/api/auth/status/route.js b/src/app/api/auth/status/route.js
index 32cc503b..ebef5766 100644
--- a/src/app/api/auth/status/route.js
+++ b/src/app/api/auth/status/route.js
@@ -24,6 +24,7 @@ export async function GET() {
       hasPassword: !!settings.password,
       displayName,
       loginMethod,
+      authenticated: !!session,
       oidcName: oidcName || null,
       oidcEmail: oidcEmail || null,
       oidcLogin: !!session?.oidc,
@@ -37,6 +38,7 @@ export async function GET() {
       hasPassword: false,
       displayName: "Password user",
       loginMethod: "Password",
+      authenticated: false,
       oidcName: null,
       oidcEmail: null,
       oidcLogin: false,
diff --git a/src/app/login/page.js b/src/app/login/page.js
index 8e50a191..86c7b7d4 100644
--- a/src/app/login/page.js
+++ b/src/app/login/page.js
@@ -37,7 +37,7 @@ export default function LoginPage() {
 
         if (res.ok) {
           const data = await res.json();
-          if (data.requireLogin === false) {
+          if (data.authenticated === true || data.requireLogin === false) {
             window.location.assign("/dashboard");
             return;
           }
diff --git a/tests/unit/auth-status.test.js b/tests/unit/auth-status.test.js
new file mode 100644
index 00000000..e384bb72
--- /dev/null
+++ b/tests/unit/auth-status.test.js
@@ -0,0 +1,69 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  json: vi.fn((body, init) => ({
+    status: init?.status || 200,
+    body,
+  })),
+  cookies: vi.fn(),
+  getSettings: vi.fn(),
+  isOidcConfigured: vi.fn(),
+  getDashboardAuthSession: vi.fn(),
+}));
+
+vi.mock("next/server", () => ({
+  NextResponse: { json: mocks.json },
+}));
+
+vi.mock("next/headers", () => ({
+  cookies: mocks.cookies,
+}));
+
+vi.mock("@/lib/localDb", () => ({
+  getSettings: mocks.getSettings,
+}));
+
+vi.mock("@/lib/auth/oidc", () => ({
+  isOidcConfigured: mocks.isOidcConfigured,
+}));
+
+vi.mock("@/lib/auth/dashboardSession", () => ({
+  getDashboardAuthSession: mocks.getDashboardAuthSession,
+}));
+
+const { GET } = await import("../../src/app/api/auth/status/route.js");
+
+describe("GET /api/auth/status", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.getSettings.mockResolvedValue({ requireLogin: true, authMode: "password" });
+    mocks.cookies.mockResolvedValue({ get: vi.fn(() => ({ value: "session-token" })) });
+    mocks.isOidcConfigured.mockReturnValue(false);
+  });
+
+  it("reports an authenticated session when the auth cookie is valid", async () => {
+    mocks.getDashboardAuthSession.mockResolvedValue({ authenticated: true });
+
+    const response = await GET();
+
+    expect(response.body.authenticated).toBe(true);
+    expect(mocks.getDashboardAuthSession).toHaveBeenCalledWith("session-token");
+  });
+
+  it("reports unauthenticated when the auth cookie is invalid", async () => {
+    mocks.getDashboardAuthSession.mockResolvedValue(null);
+
+    const response = await GET();
+
+    expect(response.body.authenticated).toBe(false);
+  });
+
+  it("fails closed when status dependencies throw", async () => {
+    mocks.getSettings.mockRejectedValue(new Error("database unavailable"));
+
+    const response = await GET();
+
+    expect(response.body.authenticated).toBe(false);
+    expect(response.body.requireLogin).toBe(true);
+  });
+});

From 0648e9e420f7392476ca88ddf00c4f59ec3656e3 Mon Sep 17 00:00:00 2001
From: dajinglingpake <1753473884@qq.com>
Date: Wed, 5 Aug 2026 10:31:40 +0700
Subject: [PATCH 05/42] fix(server): support IntelliJ IDEA OpenAI clients over
 HTTP

JetBrains Runtime (JBR 25+) sends an h2c upgrade on OpenAI-compatible requests, which the HTTP/1.1 server would otherwise close. Intercept the upgrade, replay the buffered request through the existing handler, and respond over HTTP/1.1.
---
 custom-server.js                      | 48 +++++++++++++++++++-
 tests/unit/custom-server-h2c.test.cjs | 65 +++++++++++++++++++++++++++
 2 files changed, 112 insertions(+), 1 deletion(-)
 create mode 100644 tests/unit/custom-server-h2c.test.cjs

diff --git a/custom-server.js b/custom-server.js
index f21d4366..cf824ba4 100644
--- a/custom-server.js
+++ b/custom-server.js
@@ -65,7 +65,53 @@ http.createServer = (...args) => {
   server.once("listening", () => {
     startBackgroundTokenRefreshFromCustomServer();
   });
+  const origEmit = server.emit;
+  // JBR 25 sends h2c upgrades that the HTTP/1.1 server would otherwise close.
+  server.emit = function (event, ...eventArgs) {
+    const [req, socket, head] = eventArgs;
+    if (event !== "upgrade" || String(req.headers.upgrade || "").toLowerCase() !== "h2c") {
+      return origEmit.call(this, event, ...eventArgs);
+    }
+
+    const contentLength = Number(req.headers["content-length"] || 0);
+    if (!Number.isSafeInteger(contentLength) || contentLength < 0) {
+      socket.destroy();
+      return true;
+    }
+    const chunks = [head];
+    let received = head.length;
+    const serve = () => {
+      // Replay the upgraded request through the existing HTTP/1.1 handler.
+      const replay = new http.IncomingMessage(socket);
+      Object.assign(replay, { method: req.method, url: req.url, headers: req.headers, complete: true });
+      if (received) replay.push(Buffer.concat(chunks, received).subarray(0, contentLength));
+      replay.push(null);
+      const res = new http.ServerResponse(replay);
+      res.shouldKeepAlive = false;
+      res.assignSocket(socket);
+      res.once("finish", () => socket.end());
+      Promise.resolve().then(() => wrapped(replay, res)).catch((error) => {
+        console.error("Failed to downgrade h2c request", error);
+        socket.destroy();
+      });
+    };
+    if (received >= contentLength) serve();
+    else {
+      socket.on("data", function readBody(chunk) {
+        chunks.push(chunk);
+        received += chunk.length;
+        if (received < contentLength) return;
+        socket.off("data", readBody);
+        serve();
+      });
+      socket.resume();
+    }
+    delete req.headers.upgrade;
+    delete req.headers["http2-settings"];
+    req.headers.connection = "close";
+    return true;
+  };
   return server;
 };
 
-require("./server.js");
+if (require.main === module) require("./server.js");
diff --git a/tests/unit/custom-server-h2c.test.cjs b/tests/unit/custom-server-h2c.test.cjs
new file mode 100644
index 00000000..5a2c1b06
--- /dev/null
+++ b/tests/unit/custom-server-h2c.test.cjs
@@ -0,0 +1,65 @@
+const assert = require("node:assert/strict");
+const http = require("node:http");
+const net = require("node:net");
+const test = require("node:test");
+
+test("serves h2c POST requests as HTTP/1.1", async () => {
+  const originalCreateServer = http.createServer;
+  delete require.cache[require.resolve("../../custom-server.js")];
+  require("../../custom-server.js");
+
+  const server = http.createServer(async (req, res) => {
+    assert.equal(req.url, "/v1/chat/completions");
+    assert.equal(req.headers.upgrade, undefined);
+    assert.equal(req.headers["http2-settings"], undefined);
+    assert.equal(req.headers.connection, "close");
+    const body = [];
+    for await (const chunk of req) body.push(chunk);
+    assert.equal(Buffer.concat(body).toString("utf8"), '{"model":"test","stream":true}');
+    res.setHeader("Content-Type", "text/event-stream");
+    res.end("data: [DONE]\n\n");
+  });
+  server.on("upgrade", (_req, socket) => socket.destroy());
+
+  try {
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(0, "127.0.0.1", resolve);
+    });
+    const port = server.address().port;
+
+    const response = await new Promise((resolve, reject) => {
+      const chunks = [];
+      const socket = net.createConnection({ host: "127.0.0.1", port }, () => {
+        const body = '{"model":"test","stream":true}';
+        socket.write([
+          "POST /v1/chat/completions HTTP/1.1",
+          `Host: 127.0.0.1:${port}`,
+          "Connection: Upgrade, HTTP2-Settings",
+          "Upgrade: h2c",
+          "HTTP2-Settings: AAEAAEAAAAIAAAAAAAMAAAAAAAQBAAAAAAUAAEAAAAYABgAA",
+          `Content-Length: ${Buffer.byteLength(body)}`,
+          "Content-Type: application/json",
+          "",
+          "",
+        ].join("\r\n"));
+        setImmediate(() => socket.write(body));
+      });
+      socket.setTimeout(2_000, () => {
+        socket.destroy();
+        reject(new Error("h2c fallback response timed out"));
+      });
+      socket.on("data", (chunk) => chunks.push(chunk));
+      socket.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+      socket.on("error", reject);
+    });
+
+    assert.match(response, /^HTTP\/1\.1 200 OK\r\n/);
+    assert.match(response, /\r\nContent-Type: text\/event-stream\r\n/i);
+    assert.match(response, /\r\nConnection: close\r\n/i);
+    assert.match(response, /\r\n\r\ndata: \[DONE\]\n\n$/);
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+    http.createServer = originalCreateServer;
+  }
+});

From 786b3013ba683b206976984e4cf402d33138da90 Mon Sep 17 00:00:00 2001
From: DaDecky <mdikiisra98@gmail.com>
Date: Wed, 5 Aug 2026 10:31:34 +0700
Subject: [PATCH 06/42] fix(build): include assets in standalone output

With output: "standalone", next build writes server.js under
.next/standalone but leaves generated static/public assets in the
project root, so starting the standalone server directly (e.g. via PM2)
404s on JS/CSS/font/favicon requests and /login stays stuck loading.
Add a postbuild step that copies .next/static and public into the
standalone directory, skipping the workspace-traced CLI build which
already copies its own assets.
---
 package.json                         |  2 +
 scripts/copy-standalone-assets.mjs   | 36 ++++++++++++++++++
 tests/unit/standalone-assets.test.js | 55 ++++++++++++++++++++++++++++
 3 files changed, 93 insertions(+)
 create mode 100644 scripts/copy-standalone-assets.mjs
 create mode 100644 tests/unit/standalone-assets.test.js

diff --git a/package.json b/package.json
index fbedad57..4f5f8f95 100644
--- a/package.json
+++ b/package.json
@@ -7,6 +7,8 @@
     "dev": "next dev --port 20127",
     "dev:webpack": "next dev --webpack --port 20127",
     "build": "next build --webpack",
+    "postbuild": "node scripts/copy-standalone-assets.mjs",
+    "postbuild:bun": "node scripts/copy-standalone-assets.mjs",
     "start": "next start --port 20127",
     "dev:bun": "bun --bun next dev --webpack --port 20127",
     "build:bun": "bun --bun next build --webpack",
diff --git a/scripts/copy-standalone-assets.mjs b/scripts/copy-standalone-assets.mjs
new file mode 100644
index 00000000..bfaf6e0d
--- /dev/null
+++ b/scripts/copy-standalone-assets.mjs
@@ -0,0 +1,36 @@
+import { cpSync, existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+
+export function copyStandaloneAssets({ projectRoot = process.cwd(), distDir = process.env.NEXT_DIST_DIR || ".next" } = {}) {
+  if (process.env.NEXT_TRACING_ROOT_MODE === "workspace") {
+    console.log("[standalone-assets] Skipping workspace-traced CLI build; CLI packaging handles assets");
+    return;
+  }
+
+  const buildDir = resolve(projectRoot, distDir);
+  const standaloneDir = resolve(buildDir, "standalone");
+
+  if (!existsSync(standaloneDir)) {
+    console.log(`[standalone-assets] No standalone build found at ${standaloneDir}`);
+    return;
+  }
+
+  const staticSource = resolve(buildDir, "static");
+  const staticDestination = resolve(standaloneDir, distDir, "static");
+  if (existsSync(staticSource)) {
+    cpSync(staticSource, staticDestination, { recursive: true, force: true });
+    console.log(`[standalone-assets] Copied static assets to ${staticDestination}`);
+  }
+
+  const publicSource = resolve(projectRoot, "public");
+  const publicDestination = resolve(standaloneDir, "public");
+  if (existsSync(publicSource)) {
+    cpSync(publicSource, publicDestination, { recursive: true, force: true });
+    console.log(`[standalone-assets] Copied public assets to ${publicDestination}`);
+  }
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === resolve(dirname(fileURLToPath(import.meta.url)), "copy-standalone-assets.mjs")) {
+  copyStandaloneAssets();
+}
diff --git a/tests/unit/standalone-assets.test.js b/tests/unit/standalone-assets.test.js
new file mode 100644
index 00000000..94951325
--- /dev/null
+++ b/tests/unit/standalone-assets.test.js
@@ -0,0 +1,55 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { mkdtempSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { copyStandaloneAssets } from "../../scripts/copy-standalone-assets.mjs";
+
+function createBuildFixture(distDir) {
+  const projectRoot = mkdtempSync(join(tmpdir(), "9router-standalone-assets-"));
+  const buildRoot = join(projectRoot, distDir);
+  mkdirSync(join(buildRoot, "standalone"), { recursive: true });
+  mkdirSync(join(buildRoot, "static", "chunks"), { recursive: true });
+  mkdirSync(join(projectRoot, "public"), { recursive: true });
+  writeFileSync(join(buildRoot, "static", "chunks", "app.js"), "static asset");
+  writeFileSync(join(projectRoot, "public", "favicon.svg"), "public asset");
+  return projectRoot;
+}
+
+describe("standalone build assets", () => {
+  it("copies static and public assets into the default standalone layout", () => {
+    const projectRoot = createBuildFixture(".next");
+
+    copyStandaloneAssets({ projectRoot, distDir: ".next" });
+
+    expect(readFileSync(join(projectRoot, ".next", "standalone", ".next", "static", "chunks", "app.js"), "utf8"))
+      .toBe("static asset");
+    expect(readFileSync(join(projectRoot, ".next", "standalone", "public", "favicon.svg"), "utf8"))
+      .toBe("public asset");
+  });
+
+  it("uses a custom Next dist directory", () => {
+    const projectRoot = createBuildFixture(".next-cli-build");
+
+    copyStandaloneAssets({ projectRoot, distDir: ".next-cli-build" });
+
+    expect(readFileSync(join(projectRoot, ".next-cli-build", "standalone", ".next-cli-build", "static", "chunks", "app.js"), "utf8"))
+      .toBe("static asset");
+  });
+
+  it("does not modify workspace-traced CLI builds", () => {
+    const projectRoot = createBuildFixture(".next-cli-build");
+    const previousMode = process.env.NEXT_TRACING_ROOT_MODE;
+    process.env.NEXT_TRACING_ROOT_MODE = "workspace";
+
+    try {
+      copyStandaloneAssets({ projectRoot, distDir: ".next-cli-build" });
+    } finally {
+      if (previousMode === undefined) delete process.env.NEXT_TRACING_ROOT_MODE;
+      else process.env.NEXT_TRACING_ROOT_MODE = previousMode;
+    }
+
+    expect(() => readFileSync(join(projectRoot, ".next-cli-build", "standalone", ".next-cli-build", "static", "chunks", "app.js")))
+      .toThrow();
+  });
+});

From d6df6576c5e0034177b3d9b1c7fc019b2f30b8fc Mon Sep 17 00:00:00 2001
From: Cokky Turnip <cokkyturnip@gmail.com>
Date: Wed, 5 Aug 2026 10:34:17 +0700
Subject: [PATCH 07/42] fix(providers): count apikey connections for ollama
 freeTier provider

ollama's registry entry lacked authModes, so dualAuthTypes on the providers page defaulted to oauth and its apikey connections showed as No connections on the freeTier card.
---
 open-sse/providers/registry/ollama.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/open-sse/providers/registry/ollama.js b/open-sse/providers/registry/ollama.js
index 1e938c58..89fec43c 100644
--- a/open-sse/providers/registry/ollama.js
+++ b/open-sse/providers/registry/ollama.js
@@ -15,6 +15,8 @@ export default {
     },
   },
   category: "freeTier",
+  authType: "apikey",
+  authModes: ["apikey"],
   transport: {
     baseUrl: "https://ollama.com/api/chat",
     validateUrl: "https://ollama.com/api/tags",

From c06cc0845353c3ac38cfb4def5d673779b47ad69 Mon Sep 17 00:00:00 2001
From: Tomauskasz <tomas.bitvinskas@gmail.com>
Date: Wed, 5 Aug 2026 10:38:06 +0700
Subject: [PATCH 08/42] fix(oauth): keep `open` external so xAI/Grok token
 refresh works on Windows

`open` derives its own directory from import.meta.url at module scope.
Webpack replaces that with the build machine's absolute path as a
string literal, so a release built on macOS ships a file:///Users/...
URL that fileURLToPath rejects on Windows (no drive letter), throwing
on import. refreshXaiToken dynamic-imports the xAI OAuth service, which
imports open eagerly, so every Grok token refresh silently failed and
was swallowed by a catch that only logs a warning.

Add open to serverExternalPackages so it keeps its real import.meta.url
at runtime, and bundle it into the CLI package via ensureModuleInBundle
(same guard already used for sql.js) since externalizing it means
webpack no longer traces/copies it automatically.
---
 cli/scripts/build-cli.js                 |  4 +++
 next.config.mjs                          |  9 +++++-
 tests/unit/open-package-external.test.js | 38 ++++++++++++++++++++++++
 3 files changed, 50 insertions(+), 1 deletion(-)
 create mode 100644 tests/unit/open-package-external.test.js

diff --git a/cli/scripts/build-cli.js b/cli/scripts/build-cli.js
index a1b28c5f..3af3120f 100644
--- a/cli/scripts/build-cli.js
+++ b/cli/scripts/build-cli.js
@@ -195,6 +195,10 @@ function ensureModuleInBundle(pkg) {
   console.log(`✅ Bundled ${pkg}`);
 }
 ensureModuleInBundle("sql.js");
+// `open` is external (see serverExternalPackages in next.config.mjs), so it must exist in
+// the bundle's node_modules or every importer throws MODULE_NOT_FOUND at runtime. Output
+// tracing normally copies it; this is the same belt-and-braces guard used for sql.js.
+ensureModuleInBundle("open");
 const betterDir = path.join(cliAppDir, "node_modules", "better-sqlite3");
 if (fs.existsSync(betterDir)) {
   fs.rmSync(betterDir, { recursive: true, force: true });
diff --git a/next.config.mjs b/next.config.mjs
index d017c157..ecd385ca 100644
--- a/next.config.mjs
+++ b/next.config.mjs
@@ -13,7 +13,14 @@ const proxyClientMaxBodySize = process.env.NINEROUTER_PROXY_CLIENT_MAX_BODY_SIZE
 const nextConfig = {
   distDir: process.env.NEXT_DIST_DIR || ".next",
   output: "standalone",
-  serverExternalPackages: ["better-sqlite3", "sql.js", "node:sqlite", "bun:sqlite"],
+  // `open` must stay external. It derives its own directory from `import.meta.url`, and
+  // webpack replaces that with the absolute path of the BUILD machine as a string literal.
+  // A release built on macOS therefore ships `file:///Users/.../open/index.js`, which
+  // `fileURLToPath` rejects on Windows ("File URL path must be absolute" — no drive
+  // letter). That throw happens at module scope, so every consumer of `open` dies on
+  // import — including xAI/Grok token refresh, which loads the OAuth service that imports
+  // it. Keeping it external preserves the real `import.meta.url` at runtime.
+  serverExternalPackages: ["better-sqlite3", "sql.js", "node:sqlite", "bun:sqlite", "open"],
   turbopack: {
     root: tracingRoot
   },
diff --git a/tests/unit/open-package-external.test.js b/tests/unit/open-package-external.test.js
new file mode 100644
index 00000000..de007914
--- /dev/null
+++ b/tests/unit/open-package-external.test.js
@@ -0,0 +1,38 @@
+import { describe, it, expect } from "vitest";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+// Regression guard for the Windows xAI/Grok token refresh failure.
+//
+// `open` computes its own directory from `import.meta.url`. When it is bundled, webpack
+// replaces that with the BUILD machine's absolute path as a string literal, so a release
+// built on macOS ships `fileURLToPath("file:///Users/.../open/index.js")`. On Windows that
+// throws ERR_INVALID_FILE_URL_PATH ("File URL path must be absolute" — no drive letter) at
+// module scope, which kills every importer. `refreshXaiToken` imports the xAI OAuth
+// service, which imports `open`, so no Grok refresh could ever reach auth.x.ai on Windows.
+//
+// Keeping the package external preserves the real `import.meta.url` at runtime.
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+
+describe("open must not be bundled into the server build", () => {
+  const config = readFileSync(path.join(repoRoot, "next.config.mjs"), "utf8");
+
+  it("is declared in serverExternalPackages", () => {
+    const match = config.match(/serverExternalPackages:\s*\[([^\]]*)\]/);
+    expect(match, "serverExternalPackages not found in next.config.mjs").toBeTruthy();
+    const packages = match[1].split(",").map((s) => s.trim().replace(/^["']|["']$/g, ""));
+    expect(packages).toContain("open");
+  });
+
+  it("stays a runtime dependency so the standalone output can resolve it", async () => {
+    const pkg = JSON.parse(readFileSync(path.join(repoRoot, "package.json"), "utf8"));
+    expect(pkg.dependencies?.open).toBeTruthy();
+  });
+
+  it("resolves its own directory from import.meta.url, which is why it must stay external", async () => {
+    const entry = path.join(repoRoot, "node_modules", "open", "index.js");
+    const source = readFileSync(entry, "utf8");
+    expect(source).toMatch(/import\.meta\.url/);
+  });
+});

From 2abe8b855c6e146d557b55c92a37d67df4da8c69 Mon Sep 17 00:00:00 2001
From: Muhammad Usama <55662931+MuhammadUsamaMX@users.noreply.github.com>
Date: Wed, 5 Aug 2026 10:42:30 +0700
Subject: [PATCH 09/42] fix(translator): drop JSON Schema keywords Gemini has
 no field for

Tool schemas carrying uniqueItems, contains, multipleOf,
unevaluatedProperties, unevaluatedItems, or contentSchema get rejected
by the Gemini API with "Unknown name ...: Cannot find field", failing
the whole request. Add them to UNSUPPORTED_SCHEMA_CONSTRAINTS alongside
the existing stripped keywords (minItems, maxItems, format, ...).
---
 open-sse/translator/formats/gemini.js | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/open-sse/translator/formats/gemini.js b/open-sse/translator/formats/gemini.js
index b1d4db34..6393a78b 100644
--- a/open-sse/translator/formats/gemini.js
+++ b/open-sse/translator/formats/gemini.js
@@ -7,7 +7,13 @@ import { OPENAI_BLOCK } from "../schema/index.js";
 export const UNSUPPORTED_SCHEMA_CONSTRAINTS = [
   // Basic constraints (not supported by Gemini API)
   "minLength", "maxLength", "exclusiveMinimum", "exclusiveMaximum",
-  "minItems", "maxItems", "format",
+  "minItems", "maxItems", "format", "multipleOf",
+  // Array keywords the Gemini schema proto has no field for. Agent tool
+  // schemas set these routinely, and one occurrence rejects the whole request
+  // with "Unknown name ...: Cannot find field".
+  "uniqueItems", "contains",
+  // 2020-12 keywords with no Gemini equivalent
+  "unevaluatedProperties", "unevaluatedItems", "contentSchema",
   // Claude rejects these in VALIDATED mode
   "default", "examples",
   // JSON Schema meta keywords

From 41606a37a349795f84fcf6c901b5021115392bc3 Mon Sep 17 00:00:00 2001
From: omar-nahhas <omar@innovativerealities.com>
Date: Wed, 5 Aug 2026 10:44:45 +0700
Subject: [PATCH 10/42] fix(usage): don't lose cached tokens in the
 forced-SSE->JSON path

handleForcedSSEToJson dropped cached prompt tokens in two ways: the
Responses branch summed only input_tokens, which excludes cache_read
and cache_creation on cache-capable upstreams (measured 2012 reported
vs ~5344 actual, 5332 from cache); and the Chat Completions branch
computed usage correctly but it didn't always reach the client (an
Anthropic response with cache_read_input_tokens: 11022 arrived with no
usage field at all). Now folds cache counters into prompt_tokens,
surfaces them via prompt_tokens_details, and re-attaches usage before
serialisation.
---
 .../handlers/chatCore/sseToJsonHandler.js     | 34 ++++++++++++++++---
 1 file changed, 30 insertions(+), 4 deletions(-)

diff --git a/open-sse/handlers/chatCore/sseToJsonHandler.js b/open-sse/handlers/chatCore/sseToJsonHandler.js
index 9638824b..91cff8ac 100644
--- a/open-sse/handlers/chatCore/sseToJsonHandler.js
+++ b/open-sse/handlers/chatCore/sseToJsonHandler.js
@@ -133,13 +133,18 @@ export async function handleForcedSSEToJson({ providerResponse, sourceFormat, pr
       saveUsageStats({ provider, model, tokens: usage, connectionId, apiKey, endpoint: clientRawRequest?.endpoint, silent: true });
       if (log?.line) log.line(reqTag, "📊", formatDoneLine({ usage, latency: { total: Date.now() - requestStartTime } }));
 
+      // Same cache-inclusive total for the recorded detail, so the DB and the
+      // client-facing usage can never disagree.
+      const inTokensForLog = (usage.input_tokens || 0)
+        + (usage.cache_read_input_tokens || usage.cached_tokens || 0)
+        + (usage.cache_creation_input_tokens || 0);
       const { msgItem, textContent } = pickAssistantMessageForChatCompletion(jsonResponse.output);
       const totalLatency = Date.now() - requestStartTime;
 
       saveRequestDetail(buildRequestDetail({
         ...ctx,
         latency: { ttft: totalLatency, total: totalLatency },
-        tokens: { prompt_tokens: usage.input_tokens || 0, completion_tokens: usage.output_tokens || 0 },
+        tokens: { prompt_tokens: inTokensForLog, completion_tokens: usage.output_tokens || 0 },
         response: { content: textContent, thinking: null, finish_reason: jsonResponse.status || "unknown" },
         status: "success"
       }, { endpoint: clientRawRequest?.endpoint || null })).catch(() => {});
@@ -149,9 +154,21 @@ export async function handleForcedSSEToJson({ providerResponse, sourceFormat, pr
         return { success: true, response: new Response(JSON.stringify(jsonResponse), { headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" } }) };
       }
 
-      // Build client-format response
-      const inTokens = usage.input_tokens || 0;
+      // Build client-format response.
+      // input_tokens EXCLUDES cached tokens on cache-capable upstreams, so summing
+      // only input+output under-reports prompt_tokens — measured: 2012 reported
+      // where the real prompt was ~5344 with 5332 served from cache. Fold the cache
+      // counters in, and keep them visible in prompt_tokens_details so a client can
+      // tell a cache hit from a small prompt.
+      const cacheRead = usage.cache_read_input_tokens || usage.cached_tokens || 0;
+      const cacheCreate = usage.cache_creation_input_tokens || 0;
+      const inTokens = (usage.input_tokens || 0) + cacheRead + cacheCreate;
       const outTokens = usage.output_tokens || 0;
+      const cacheDetails = (cacheRead > 0 || cacheCreate > 0)
+        ? { prompt_tokens_details: {
+              ...(cacheRead > 0 ? { cached_tokens: cacheRead } : {}),
+              ...(cacheCreate > 0 ? { cache_creation_tokens: cacheCreate } : {}) } }
+        : {};
       let finalResp;
 
       // Extract tool calls from Responses API output (function_call items)
@@ -186,7 +203,7 @@ export async function handleForcedSSEToJson({ providerResponse, sourceFormat, pr
           created: jsonResponse.created_at || Math.floor(Date.now() / 1000),
           model: jsonResponse.model || model,
           choices: [{ index: 0, message, finish_reason: finishReason }],
-          usage: { prompt_tokens: inTokens, completion_tokens: outTokens, total_tokens: inTokens + outTokens }
+          usage: { prompt_tokens: inTokens, completion_tokens: outTokens, total_tokens: inTokens + outTokens, ...cacheDetails }
         };
       }
 
@@ -229,6 +246,15 @@ export async function handleForcedSSEToJson({ providerResponse, sourceFormat, pr
       status: "success"
     }, { endpoint: clientRawRequest?.endpoint || null })).catch(() => {});
 
+    // Re-attach usage explicitly. This handler already HAS the correct usage — it is
+    // the same object written to the usage DB, and for a cached Claude request that DB
+    // row reads cache_read_input_tokens: 11022 — yet the client was observed receiving
+    // no usage field at all (verified 2026-08-04 with a fingerprinted payload matched
+    // on both sides). Whatever drops it between assembly and serialisation, the client
+    // must not be left unable to account for its own token spend: a caller cannot tell
+    // a 90%-cached request from a cheap one without this.
+    if (usage && Object.keys(usage).length > 0) parsed.usage = usage;
+
     // Strip reasoning_content only when content is non-empty.
     // When content is empty (e.g. thinking models that used all tokens for reasoning),
     // reasoning_content is the only useful output and must be preserved.

From 9138c99391b52392b961b144acc257bfd2cb3956 Mon Sep 17 00:00:00 2001
From: Rafi Mahardika <rafimahardika96@gmail.com>
Date: Wed, 5 Aug 2026 10:51:29 +0700
Subject: [PATCH 11/42] fix(codebuddy): dodge Tencent filter for CN, add usage
 tracking & normalize messages for INT

Neutralize CLI-agent system prompts that trigger CodeBuddy CN's content filter, add usage/quota tracking for codebuddy-intl sharing CN's logic, and normalize codebuddy-intl request messages to the shape it expects.
---
 open-sse/executors/codebuddy-cn.js            | 29 +++++++++++++++++++
 open-sse/executors/codebuddy-intl.js          | 14 +++++++++
 open-sse/providers/registry/codebuddy-intl.js |  4 +++
 open-sse/services/usage.js                    |  3 +-
 open-sse/services/usage/codebuddy-cn.js       | 20 +++++++++----
 5 files changed, 63 insertions(+), 7 deletions(-)

diff --git a/open-sse/executors/codebuddy-cn.js b/open-sse/executors/codebuddy-cn.js
index 5f37d015..76ec52ff 100644
--- a/open-sse/executors/codebuddy-cn.js
+++ b/open-sse/executors/codebuddy-cn.js
@@ -18,6 +18,35 @@ export class CodeBuddyExecutor extends DefaultExecutor {
     const transformed = super.transformRequest(model, body, stream, credentials);
     transformed.stream = true;
 
+    // Tencent's content filter flags CLI agent system prompts ("You are Claude
+    // Code, Anthropic's official CLI...") as prompt injection / sensitive content
+    // and rejects the whole request. Detect agent system prompts (length catch-all
+    // + identity-marker regex) and replace them with a neutral one, while leaving
+    // legitimate user system prompts untouched. content may be a string or typed
+    // blocks ([{type:"text",text}]) depending on the incoming client format, so
+    // flatten before matching and preserve the original shape on replacement.
+    const NEUTRAL_PROMPT = "You are a helpful AI assistant that helps with software engineering tasks.";
+    const AGENT_PATTERN = /you are claude code|claude.?code.+official.+cli|anthropic.+official.+cli|anxthxropic.+official.+cli|you are (?:cursor|windsurf|cline|aider|continue|copilot|cody)|you are an? (?:ai )?(?:coding |code )?agent|cc_entrypoint\s*=\s*(?:cli|vscode|jetbrains|gui)|claude.?code.+issues|give feedback.+claude.?code|you are .{0,30}(?:powerful )?ai agent|orchestration capabilities|OhMyOpenCode|<agent-identity>|<Role>|<Behavior_Instructions>/i;
+    const flatten = (content) =>
+      typeof content === "string"
+        ? content
+        : Array.isArray(content)
+          ? content.map((b) => (b && typeof b.text === "string" ? b.text : "")).join("\n")
+          : "";
+    if (Array.isArray(transformed.messages)) {
+      transformed.messages = transformed.messages.map((message) => {
+        if (!message || message.role !== "system") return message;
+        const text = flatten(message.content);
+        if (!text) return message;
+        if (text.length > 2000 || AGENT_PATTERN.test(text)) {
+          return typeof message.content === "string"
+            ? { ...message, content: NEUTRAL_PROMPT }
+            : { ...message, content: [{ type: "text", text: NEUTRAL_PROMPT }] };
+        }
+        return message;
+      });
+    }
+
     // CodeBuddy only surfaces model reasoning when the request carries the CLI's
     // OpenAI-style params: reasoning_effort + reasoning_summary:"auto". 9router's
     // thinking pipeline sets reasoning_effort only when the client asks, and never
diff --git a/open-sse/executors/codebuddy-intl.js b/open-sse/executors/codebuddy-intl.js
index 06fe4326..bb99ff47 100644
--- a/open-sse/executors/codebuddy-intl.js
+++ b/open-sse/executors/codebuddy-intl.js
@@ -23,6 +23,20 @@ export class CodeBuddyIntlExecutor extends DefaultExecutor {
     } else if (eff) {
       transformed.reasoning_summary = "auto";
     }
+
+    // CodeBuddy rejects plain OpenAI shape (11101 invalid request): needs a
+    // leading system prompt + user content as typed blocks, not a bare string.
+    const source = Array.isArray(transformed.messages) ? transformed.messages : [];
+    transformed.messages = [{ role: "system", content: "You are CodeBuddy Code." }];
+    for (const message of source) {
+      if (!message || typeof message !== "object" || ["system", "developer"].includes(message.role)) continue;
+      if (message.role === "user" && typeof message.content === "string") {
+        transformed.messages.push({ ...message, content: [{ type: "text", text: message.content }] });
+      } else {
+        transformed.messages.push({ ...message });
+      }
+    }
+
     return transformed;
   }
 }
diff --git a/open-sse/providers/registry/codebuddy-intl.js b/open-sse/providers/registry/codebuddy-intl.js
index 7e69836c..eab1ce93 100644
--- a/open-sse/providers/registry/codebuddy-intl.js
+++ b/open-sse/providers/registry/codebuddy-intl.js
@@ -38,6 +38,10 @@ export default {
       header: "Authorization",
       scheme: "bearer",
     },
+    // Intl billing endpoint mirrors CN shape (data.Response.Data.Accounts[]).
+    usage: {
+      url: "https://www.codebuddy.ai/v2/billing/meter/get-user-resource",
+    },
   },
   // Same model lineup exposed by the CN gateway — intl backend is the same catalog.
   models: [
diff --git a/open-sse/services/usage.js b/open-sse/services/usage.js
index d1c361b9..cfcc05da 100644
--- a/open-sse/services/usage.js
+++ b/open-sse/services/usage.js
@@ -10,7 +10,7 @@ import { getCodexUsage, consumeCodexRateLimitResetCredit, getCodexRateLimitReset
 export { consumeCodexRateLimitResetCredit, getCodexRateLimitResetCredits };
 import { getKiroUsage } from "./usage/kiro.js";
 import { getMiniMaxUsage } from "./usage/minimax.js";
-import { getCodeBuddyCnUsage } from "./usage/codebuddy-cn.js";
+import { getCodeBuddyCnUsage, getCodeBuddyIntlUsage } from "./usage/codebuddy-cn.js";
 import { getGrokCliUsage } from "./usage/grok-cli.js";
 import { getKimiUsage } from "./usage/kimi.js";
 import { getDeepseekUsage } from "./usage/deepseek.js";
@@ -46,6 +46,7 @@ const USAGE_HANDLERS = {
   "minimax-cn": (c) => getMiniMaxUsage(c.apiKey, c.provider, c.proxyOptions),
   "vercel-ai-gateway": (c) => getVercelAiGatewayUsage(c.apiKey, c.proxyOptions),
   "codebuddy-cn": (c) => getCodeBuddyCnUsage(c.accessToken, c.apiKey, c.providerSpecificData, c.proxyOptions),
+  "codebuddy-intl": (c) => getCodeBuddyIntlUsage(c.accessToken, c.apiKey, c.providerSpecificData, c.proxyOptions),
   "grok-cli": (c) => getGrokCliUsage(c.accessToken, c.providerSpecificData, c.proxyOptions),
   kimi: (c) => getKimiUsage(c.accessToken, c.apiKey, c.proxyOptions, c.providerSpecificData),
   deepseek: (c) => getDeepseekUsage(c.apiKey, c.proxyOptions),
diff --git a/open-sse/services/usage/codebuddy-cn.js b/open-sse/services/usage/codebuddy-cn.js
index d355c729..e61d56c6 100644
--- a/open-sse/services/usage/codebuddy-cn.js
+++ b/open-sse/services/usage/codebuddy-cn.js
@@ -43,17 +43,17 @@ function refillCadence(acc) {
   return "Monthly";
 }
 
-export async function getCodeBuddyCnUsage(accessToken, apiKey, providerSpecificData, proxyOptions = null) {
+async function getCodeBuddyUsage(providerId, accessToken, apiKey, providerSpecificData, proxyOptions = null) {
   const token = accessToken || apiKey;
   if (!token) {
-    return { message: "CodeBuddy CN credential not available." };
+    return { message: `CodeBuddy (${providerId}) credential not available.` };
   }
 
   try {
-    const response = await proxyAwareFetch(U(PROVIDER_ID).url, {
+    const response = await proxyAwareFetch(U(providerId).url, {
       method: "POST",
       headers: {
-        ...(PROVIDERS[PROVIDER_ID]?.headers || {}),
+        ...(PROVIDERS[providerId]?.headers || {}),
         Authorization: `Bearer ${token}`,
         "Content-Type": "application/json",
         Accept: "application/json",
@@ -129,10 +129,18 @@ export async function getCodeBuddyCnUsage(accessToken, apiKey, providerSpecificD
     });
 
     const basePkg = refills[0] || accounts[0] || {};
-    const plan = basePkg.PackageName || basePkg.SubProductName || "CodeBuddy CN";
+    const plan = basePkg.PackageName || basePkg.SubProductName || "CodeBuddy";
 
     return { plan, quotas };
   } catch (error) {
-    return { message: `CodeBuddy CN error: ${error.message}` };
+    return { message: `CodeBuddy (${providerId}) error: ${error.message}` };
   }
 }
+
+export async function getCodeBuddyCnUsage(accessToken, apiKey, providerSpecificData, proxyOptions = null) {
+  return getCodeBuddyUsage(PROVIDER_ID, accessToken, apiKey, providerSpecificData, proxyOptions);
+}
+
+export async function getCodeBuddyIntlUsage(accessToken, apiKey, providerSpecificData, proxyOptions = null) {
+  return getCodeBuddyUsage("codebuddy-intl", accessToken, apiKey, providerSpecificData, proxyOptions);
+}

From 3292dfc1023366c2c26c3b815ec05f9cca349ca3 Mon Sep 17 00:00:00 2001
From: ryanngit <ryanngit@users.noreply.github.com>
Date: Wed, 5 Aug 2026 10:59:49 +0700
Subject: [PATCH 12/42] fix(github): hold monthly-exhausted accounts until
 reset

Lock GitHub Copilot connections account-wide until 00:00 UTC on the
first of next month when the upstream 402 response indicates the
monthly additional-usage-limit was hit, instead of only cooling down
the requested model for 120s. Other GitHub 402 responses keep the
existing model-scoped cooldown.
---
 src/sse/services/auth.js                     | 20 ++++-
 tests/unit/github-monthly-usage-lock.test.js | 86 ++++++++++++++++++++
 2 files changed, 104 insertions(+), 2 deletions(-)
 create mode 100644 tests/unit/github-monthly-usage-lock.test.js

diff --git a/src/sse/services/auth.js b/src/sse/services/auth.js
index 36fd6c49..feaaa2ab 100644
--- a/src/sse/services/auth.js
+++ b/src/sse/services/auth.js
@@ -8,6 +8,15 @@ import * as log from "../utils/logger.js";
 // Mutex to prevent race conditions during account selection
 let selectionMutex = Promise.resolve();
 
+const GITHUB_MONTHLY_USAGE_LIMIT = "you've reached your additional usage limit for your plan";
+
+function githubMonthlyResetMs(status, errorText, provider) {
+  if (resolveProviderId(provider) !== "github" || Number(status) !== 402) return null;
+  if (!String(errorText || "").toLowerCase().includes(GITHUB_MONTHLY_USAGE_LIMIT)) return null;
+  const now = new Date();
+  return Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1);
+}
+
 /**
  * Get provider credentials from localDb
  * Filters out unavailable accounts and returns the selected account based on strategy
@@ -213,9 +222,16 @@ export async function markAccountUnavailable(connectionId, status, errorText, pr
   const conn = connections.find(c => c.id === connectionId);
   const backoffLevel = conn?.backoffLevel || 0;
 
+  // GitHub premium-request exhaustion is account-wide until the next UTC month.
+  const githubResetAtMs = githubMonthlyResetMs(status, errorText, provider);
+
   // Provider-specific precise cooldown (e.g. codex usage_limit_reached resets_at) overrides backoff
   let shouldFallback, cooldownMs, newBackoffLevel;
-  if (resetsAtMs && resetsAtMs > Date.now()) {
+  if (githubResetAtMs) {
+    shouldFallback = true;
+    cooldownMs = githubResetAtMs - Date.now();
+    newBackoffLevel = 0;
+  } else if (resetsAtMs && resetsAtMs > Date.now()) {
     shouldFallback = true;
     cooldownMs = Math.min(resetsAtMs - Date.now(), MAX_RATE_LIMIT_COOLDOWN_MS);
     newBackoffLevel = 0;
@@ -225,7 +241,7 @@ export async function markAccountUnavailable(connectionId, status, errorText, pr
   if (!shouldFallback) return { shouldFallback: false, cooldownMs: 0 };
 
   const reason = typeof errorText === "string" ? errorText.slice(0, 100) : "Provider error";
-  const lockUpdate = buildModelLockUpdate(model, cooldownMs);
+  const lockUpdate = buildModelLockUpdate(githubResetAtMs ? null : model, cooldownMs);
 
   await updateProviderConnection(connectionId, {
     ...lockUpdate,
diff --git a/tests/unit/github-monthly-usage-lock.test.js b/tests/unit/github-monthly-usage-lock.test.js
new file mode 100644
index 00000000..d7a0d204
--- /dev/null
+++ b/tests/unit/github-monthly-usage-lock.test.js
@@ -0,0 +1,86 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const dbMocks = vi.hoisted(() => ({
+  getProviderConnections: vi.fn(),
+  updateProviderConnection: vi.fn(),
+}));
+
+vi.mock("@/lib/localDb", () => dbMocks);
+vi.mock("@/lib/network/connectionProxy", () => ({
+  pickProxyPoolId: vi.fn(),
+  resolveConnectionProxyConfig: vi.fn(),
+}));
+vi.mock("@/shared/constants/providers.js", () => ({
+  FREE_PROVIDERS: {},
+  resolveProviderId: (provider) => provider,
+}));
+vi.mock("@/sse/utils/logger.js", () => ({ debug: vi.fn(), info: vi.fn(), warn: vi.fn() }));
+
+const { markAccountUnavailable } = await import("../../src/sse/services/auth.js");
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  dbMocks.getProviderConnections.mockResolvedValue([{
+    id: "github-a",
+    provider: "github",
+    name: "github-a",
+    backoffLevel: 4,
+  }]);
+});
+
+describe("GitHub monthly usage exhaustion", () => {
+  it("locks the whole account until the next UTC month", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-08-04T19:30:00.000Z"));
+
+    try {
+      await markAccountUnavailable(
+        "github-a",
+        402,
+        "You've reached your additional usage limit for your plan. Go to GitHub settings for details.",
+        "github",
+        "claude-fable-5",
+      );
+
+      expect(dbMocks.updateProviderConnection).toHaveBeenCalledWith(
+        "github-a",
+        expect.objectContaining({
+          modelLock___all: "2026-09-01T00:00:00.000Z",
+          testStatus: "unavailable",
+          errorCode: 402,
+          backoffLevel: 0,
+        }),
+      );
+      expect(dbMocks.updateProviderConnection.mock.calls[0][1])
+        .not.toHaveProperty("modelLock_claude-fable-5");
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("keeps unrelated GitHub 402 errors model-scoped", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-08-04T19:30:00.000Z"));
+
+    try {
+      await markAccountUnavailable(
+        "github-a",
+        402,
+        "Payment required",
+        "github",
+        "claude-fable-5",
+      );
+
+      expect(dbMocks.updateProviderConnection).toHaveBeenCalledWith(
+        "github-a",
+        expect.objectContaining({
+          "modelLock_claude-fable-5": "2026-08-04T19:32:00.000Z",
+        }),
+      );
+      expect(dbMocks.updateProviderConnection.mock.calls[0][1])
+        .not.toHaveProperty("modelLock___all");
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});

From d433c0b2955ea23efc6c87139c51d4fc5a1ebd39 Mon Sep 17 00:00:00 2001
From: mannnrachman <mannnrachman@users.noreply.github.com>
Date: Wed, 5 Aug 2026 11:16:01 +0700
Subject: [PATCH 13/42] feat(qoder): support PAT (Personal Access Token)
 connections end-to-end
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds pt-... token auth as an alternative to OAuth device flow. A PAT can't
sign COSY requests directly, so it's exchanged for a short-lived job token
(jt-...) plus userId via openapi.qoder.sh, then used for signing.

Also fixes job-token traffic (jt-...) being rejected by api3.qoder.sh with
403 "Login expired" — the official qodercli serves jt- traffic from
api2.qoder.sh instead, so buildUrl/model-list routing now branches on it.

Quota usage and the dashboard add-key modal are updated to resolve PAT
credentials and label the field correctly, and bulk-add now validates
each key so it gets a real testStatus instead of a hardcoded "unknown".
---
 open-sse/executors/qoder.js                   |  15 +-
 open-sse/providers/registry/qoder.js          |   2 +
 open-sse/services/qoderModels.js              | 147 +++++++++++++++++-
 open-sse/services/usage.js                    |   8 +-
 open-sse/shared/qoder/constants.js            |   3 +
 .../providers/[id]/AddApiKeyModal.js          |  29 +++-
 .../dashboard/providers/[id]/page.js          |   1 +
 src/app/api/providers/[id]/models/route.js    |   1 +
 8 files changed, 189 insertions(+), 17 deletions(-)

diff --git a/open-sse/executors/qoder.js b/open-sse/executors/qoder.js
index d062b139..912e9995 100644
--- a/open-sse/executors/qoder.js
+++ b/open-sse/executors/qoder.js
@@ -32,6 +32,8 @@ import { SSE_DONE } from "../utils/sseConstants.js";
 import { FETCH_CONNECT_TIMEOUT_MS } from "../config/runtimeConfig.js";
 import {
   QODER_CHAT_URL_ENCODED,
+  QODER_CHAT_BASE_ALT,
+  QODER_CHAT_SIG_PATH,
   QODER_JOB_TOKEN_EXCHANGE_URL,
   QODER_USERINFO_URL,
   QODER_MODEL_MAP,
@@ -433,7 +435,13 @@ export class QoderExecutor extends BaseExecutor {
     super("qoder", PROVIDERS.qoder);
   }
 
-  buildUrl() {
+  buildUrl(credentials) {
+    // Job-token (jt-...) traffic must hit api2.qoder.sh — api3 rejects jt-
+    // with "Login expired" (403). Device tokens (dt-...) stay on api3.
+    const raw = credentials?.apiKey || credentials?.accessToken;
+    if (typeof raw === "string" && !raw.startsWith("pt-") && (raw.startsWith("jt-") || (credentials?.accessToken || "").startsWith("jt-"))) {
+      return `${QODER_CHAT_BASE_ALT}/algo${QODER_CHAT_SIG_PATH}?FetchKeys=llm_model_result&AgentId=agent_common&Encode=1`;
+    }
     return QODER_CHAT_URL_ENCODED;
   }
 
@@ -443,8 +451,6 @@ export class QoderExecutor extends BaseExecutor {
   //   - COSY headers built from the *encoded* body bytes
   //   - response stream re-wrapped from {statusCodeValue, body} to OpenAI SSE
   async execute({ model, body, stream, credentials, signal, log, proxyOptions = null }) {
-    const url = this.buildUrl();
-
     // PAT (pt-...) → exchange for short-lived job token + resolve userId so
     // downstream COSY signing + catalog fetch work. Device tokens (dt-...) and
     // job tokens (jt-...) skip this and are used directly.
@@ -469,10 +475,11 @@ export class QoderExecutor extends BaseExecutor {
           JSON.stringify({ error: { message: `qoder PAT exchange failed: ${err.message}` } }),
           { status: 401, headers: { "Content-Type": "application/json" } },
         );
-        return { response: fakeResp, url, headers: {}, transformedBody: body };
+        return { response: fakeResp, url: this.buildUrl(credentials), headers: {}, transformedBody: body };
       }
     }
 
+    const url = this.buildUrl(credentials);
     const psd = credentials?.providerSpecificData || {};
     if (!psd.userId) {
       // No user id → no way to sign. Surface a 401 so the dashboard nudges
diff --git a/open-sse/providers/registry/qoder.js b/open-sse/providers/registry/qoder.js
index 2b6c93ed..fe76fd72 100644
--- a/open-sse/providers/registry/qoder.js
+++ b/open-sse/providers/registry/qoder.js
@@ -52,5 +52,7 @@ export default {
   },
   features: {
     usage: true,
+    // PAT (apikey) connections also carry quota usage (via job-token exchange).
+    usageApikey: true,
   },
 };
diff --git a/open-sse/services/qoderModels.js b/open-sse/services/qoderModels.js
index 01e6fb13..930461af 100644
--- a/open-sse/services/qoderModels.js
+++ b/open-sse/services/qoderModels.js
@@ -10,6 +10,12 @@
  *
  * On any error the live cache stays empty and chatExecuteCall surfaces the
  * problem to the user as "model config not yet fetched, retry shortly".
+ *
+ * PAT (Personal Access Token, pt-...) connections: a PAT cannot sign COSY
+ * requests directly, so we exchange it for a short-lived job token (jt-...)
+ * via openapi.qoder.sh/api/v1/jobToken/exchange (plain JSON POST), then use
+ * that job token for signing. Job-token traffic must hit api2.qoder.sh —
+ * api3 rejects jt- with "Login expired" (403).
  */
 
 import { createHash } from "crypto";
@@ -18,11 +24,24 @@ import { proxyAwareFetch } from "../utils/proxyFetch.js";
 import { buildCosyHeaders } from "../shared/qoder/cosy.js";
 import {
   QODER_MODEL_LIST_URL,
+  QODER_CHAT_BASE_ALT,
+  QODER_JOB_TOKEN_EXCHANGE_URL,
+  QODER_USERINFO_URL,
+  QODER_IDE_VERSION,
+  QODER_CLIENT_TYPE,
 } from "../shared/qoder/constants.js";
 
 const FETCH_TIMEOUT_MS = 15_000;
 const CACHE_TTL_MS = 60 * 60 * 1000; // 1h, same as the Kiro catalog
 
+// PAT → job-token cache: a job token is short-lived (24h), so we keep it per
+// PAT and re-exchange once it is within 5 minutes of expiry.
+const PAT_REFRESH_BUFFER_MS = 5 * 60 * 1000;
+const PAT_DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+
+/** @type {Map<string, { accessToken: string, userId: string, expiresAt: number }>} */
+const patJobCache = new Map();
+
 /** @type {Map<string, { expiresAt: number, models: any[], rawConfigs: Map<string, object>, fetched: boolean }>} */
 const catalogCache = new Map();
 
@@ -34,6 +53,109 @@ const catalogCache = new Map();
  */
 const inflight = new Map();
 
+/**
+ * Exchange a Qoder PAT (pt-...) for a short-lived job token (jt-...).
+ * This endpoint is plain JSON POST — NOT COSY-signed.
+ */
+async function exchangeJobToken(pat, proxyOptions = null, signal = null) {
+  const res = await proxyAwareFetch(
+    QODER_JOB_TOKEN_EXCHANGE_URL,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "User-Agent": "qodercli/1.0.0",
+        "Cosy-Version": QODER_IDE_VERSION,
+        "Cosy-ClientType": QODER_CLIENT_TYPE,
+      },
+      body: JSON.stringify({ personal_token: pat }),
+      signal,
+    },
+    proxyOptions,
+  );
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`qoder PAT exchange failed: ${res.status} ${text.slice(0, 200)}`);
+  }
+  const data = await res.json();
+  if (!data.token) throw new Error("qoder PAT exchange returned no job token");
+
+  let expiresAt = Date.now() + PAT_DEFAULT_TTL_MS;
+  if (data.expires_at) {
+    const parsed = Date.parse(data.expires_at);
+    if (!Number.isNaN(parsed)) expiresAt = parsed;
+  } else if (typeof data.expires_in === "number" && data.expires_in > 0) {
+    expiresAt = Date.now() + data.expires_in;
+  }
+  return { jobToken: data.token, jobRefreshToken: data.refresh_token || "", expiresAt };
+}
+
+/**
+ * Resolve the Qoder userId for a job token (needed for COSY signing).
+ * Returns "" on any failure — callers fall back to the stored userId.
+ */
+async function fetchUserIdForJobToken(jobToken, proxyOptions = null, signal = null) {
+  try {
+    const res = await proxyAwareFetch(
+      QODER_USERINFO_URL,
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${jobToken}`,
+          Accept: "application/json",
+          "User-Agent": "qodercli/1.0.0",
+        },
+        signal,
+      },
+      proxyOptions,
+    );
+    if (!res.ok) return "";
+    const data = await res.json().catch(() => ({}));
+    return data.id || data.userId || data.user_id || "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Resolve a PAT to a job-token credential, cached per-PAT.
+ */
+async function resolvePatCredential(pat, proxyOptions = null, signal = null) {
+  const cached = patJobCache.get(pat);
+  if (cached && cached.expiresAt - Date.now() > PAT_REFRESH_BUFFER_MS) return cached;
+
+  const { jobToken, expiresAt } = await exchangeJobToken(pat, proxyOptions, signal);
+  const userId = await fetchUserIdForJobToken(jobToken, proxyOptions, signal);
+  const resolved = { accessToken: jobToken, userId, expiresAt };
+  patJobCache.set(pat, resolved);
+  return resolved;
+}
+
+/**
+ * Resolve connection credentials to COSY-signable form:
+ *   - PAT (pt-...) connections → exchanged to a job token (jt-...) + userId
+ *   - everything else → passed through unchanged
+ */
+export async function resolveQoderCredentials(credentials, proxyOptions = null, signal = null) {
+  const raw = credentials?.apiKey || credentials?.accessToken;
+  if (typeof raw === "string" && raw.startsWith("pt-")) {
+    const resolved = await resolvePatCredential(raw, proxyOptions, signal);
+    return {
+      ...credentials,
+      accessToken: resolved.accessToken,
+      apiKey: undefined,
+      providerSpecificData: {
+        authMethod: "pat",
+        ...(credentials?.providerSpecificData || {}),
+        userId: resolved.userId || credentials?.providerSpecificData?.userId || "",
+        machineId: credentials?.providerSpecificData?.machineId || "",
+      },
+    };
+  }
+  return credentials;
+}
+
 /**
  * Stable cache key per credential (so different login sessions for the same
  * account share an entry).
@@ -68,10 +190,16 @@ async function fetchQoderCatalogRaw(credentials, signal, proxyOptions = null) {
   const creds = cosyCredsFromConnection(credentials);
   if (!creds.userId || !creds.authToken) return null;
 
+  // Job-token traffic is rejected by api3 ("Login expired" 403) — the
+  // official qodercli serves it from api2 instead.
+  const modelListUrl = String(creds.authToken).startsWith("jt-")
+    ? `${QODER_CHAT_BASE_ALT}/algo/api/v2/model/list`
+    : QODER_MODEL_LIST_URL;
+
   const headers = {
     Accept: "application/json",
     "Accept-Encoding": "identity",
-    ...buildCosyHeaders(Buffer.alloc(0), QODER_MODEL_LIST_URL, creds),
+    ...buildCosyHeaders(Buffer.alloc(0), modelListUrl, creds),
   };
 
   const controller = new AbortController();
@@ -92,7 +220,7 @@ async function fetchQoderCatalogRaw(credentials, signal, proxyOptions = null) {
       }
     }
     response = await proxyAwareFetch(
-      QODER_MODEL_LIST_URL,
+      modelListUrl,
       {
         method: "GET",
         headers,
@@ -159,11 +287,16 @@ export async function getQoderModelConfig(credentials, modelKey, options = {}) {
  * one upstream request per credential.
  */
 export async function resolveQoderModels(credentials, options = {}) {
-  if (!credentials?.accessToken) return null;
-  const psd = credentials.providerSpecificData || {};
-  if (!psd.userId) return null;
+  let resolved;
+  try {
+    resolved = await resolveQoderCredentials(credentials, options.proxyOptions, options.signal);
+  } catch (error) {
+    options.log?.warn?.("QODER", `PAT exchange failed: ${error.message}`);
+    return null;
+  }
+  if (!resolved?.accessToken || !(resolved.providerSpecificData || {}).userId) return null;
 
-  const key = cacheKey(credentials);
+  const key = cacheKey(resolved);
   const now = Date.now();
   if (!options.forceRefresh) {
     const cached = catalogCache.get(key);
@@ -180,7 +313,7 @@ export async function resolveQoderModels(credentials, options = {}) {
   }
 
   const fetchPromise = (async () => {
-    const fetched = await fetchQoderCatalogRaw(credentials, options.signal, options.proxyOptions);
+    const fetched = await fetchQoderCatalogRaw(resolved, options.signal, options.proxyOptions);
     if (!fetched) return null;
     const entry = {
       expiresAt: Date.now() + CACHE_TTL_MS,
diff --git a/open-sse/services/usage.js b/open-sse/services/usage.js
index cfcc05da..93bfeca6 100644
--- a/open-sse/services/usage.js
+++ b/open-sse/services/usage.js
@@ -14,6 +14,7 @@ import { getCodeBuddyCnUsage, getCodeBuddyIntlUsage } from "./usage/codebuddy-cn
 import { getGrokCliUsage } from "./usage/grok-cli.js";
 import { getKimiUsage } from "./usage/kimi.js";
 import { getDeepseekUsage } from "./usage/deepseek.js";
+import { resolveQoderCredentials } from "./qoderModels.js";
 import {
   getQwenUsage,
   getIflowUsage,
@@ -36,7 +37,12 @@ const USAGE_HANDLERS = {
   claude: (c) => getClaudeUsage(c.accessToken, c.proxyOptions),
   codex: (c) => getCodexUsage(c.accessToken, c.proxyOptions),
   kiro: (c) => getKiroUsage(c.accessToken, c.providerSpecificData, c.proxyOptions),
-  qoder: (c) => getQoderUsage(c.accessToken, c.proxyOptions),
+  qoder: async (c) => {
+    // PAT (pt-...) connections must be exchanged to a job token before the
+    // quota endpoint accepts them.
+    const resolved = await resolveQoderCredentials(c, c.proxyOptions).catch(() => null);
+    return getQoderUsage(resolved?.accessToken || c.accessToken, c.proxyOptions);
+  },
   qwen: (c) => getQwenUsage(c.accessToken, c.providerSpecificData),
   iflow: (c) => getIflowUsage(c.accessToken),
   ollama: (c) => getOllamaUsage(c.apiKey, c.providerSpecificData, c.proxyOptions),
diff --git a/open-sse/shared/qoder/constants.js b/open-sse/shared/qoder/constants.js
index 184c35d6..e2635f40 100644
--- a/open-sse/shared/qoder/constants.js
+++ b/open-sse/shared/qoder/constants.js
@@ -11,6 +11,9 @@
 export const QODER_OPENAPI_BASE = "https://openapi.qoder.sh";
 export const QODER_CENTER_BASE = "https://center.qoder.sh";
 export const QODER_CHAT_BASE = "https://api3.qoder.sh";
+// Job-token (jt-...) traffic is rejected by api3 with "Login expired" (403);
+// the official qodercli serves it from api2 instead.
+export const QODER_CHAT_BASE_ALT = "https://api2.qoder.sh";
 
 export const QODER_LOGIN_URL = "https://qoder.com/device/selectAccounts";
 
diff --git a/src/app/(dashboard)/dashboard/providers/[id]/AddApiKeyModal.js b/src/app/(dashboard)/dashboard/providers/[id]/AddApiKeyModal.js
index 5d19bd10..e9a628db 100644
--- a/src/app/(dashboard)/dashboard/providers/[id]/AddApiKeyModal.js
+++ b/src/app/(dashboard)/dashboard/providers/[id]/AddApiKeyModal.js
@@ -13,10 +13,10 @@ export default function AddApiKeyModal({ isOpen, provider, providerName, isCompa
   const isOllamaLocal = provider === "ollama-local";
   const isCookie = authType === "cookie";
   const isXaiApiKey = provider === "xai" && !isCookie;
-  const credentialLabel = isCookie ? "Cookie Value" : "API Key";
+  const credentialLabel = isCookie ? "Cookie Value" : provider === "qoder" ? "Personal Access Token (PAT)" : "API Key";
   const credentialPlaceholder = isCookie
     ? (provider === "grok-web" ? "sso=xxxxx... or just the raw value" : "eyJhbGciOi...")
-    : (isXaiApiKey ? "xai-..." : "");
+    : (isXaiApiKey ? "xai-..." : provider === "qoder" ? "pt-..." : "");
 
   const isAzure = provider === "azure";
   const isCloudflareAi = provider === "cloudflare-ai";
@@ -44,7 +44,9 @@ export default function AddApiKeyModal({ isOpen, provider, providerName, isCompa
   const [saving, setSaving] = useState(false);
   const bulkPlaceholder = isCloudflareAi
     ? `name1|sk-key1|acc123456\nname2|sk-key2|def789012\nsk-key-only-auto-named`
-    : BULK_PLACEHOLDER;
+    : provider === "qoder"
+      ? `name1|pt-xxxxx\nname2|pt-yyyyy\npt-only-auto-named`
+      : BULK_PLACEHOLDER;
 
   const [mode, setMode] = useState("single"); // "single" | "bulk"
   const [bulkText, setBulkText] = useState("");
@@ -145,6 +147,21 @@ export default function AddApiKeyModal({ isOpen, provider, providerName, isCompa
     let failed = 0;
     for (const entry of plan) {
       try {
+        // Validate each key before saving so bulk-added connections get a
+        // real status (active/unknown) like single adds, instead of a
+        // hardcoded "unknown" that never flips until a manual test.
+        let isValid = false;
+        try {
+          const vres = await fetch("/api/providers/validate", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ provider, apiKey: entry.apiKey }),
+          });
+          const vdata = await vres.json().catch(() => ({}));
+          isValid = !!vdata.valid;
+        } catch {
+          isValid = false;
+        }
         const res = await fetch("/api/providers", {
           method: "POST",
           headers: { "Content-Type": "application/json" },
@@ -153,7 +170,7 @@ export default function AddApiKeyModal({ isOpen, provider, providerName, isCompa
             apiKey: entry.apiKey,
             name: entry.name,
             priority: 1,
-            testStatus: "unknown",
+            testStatus: isValid ? "active" : "unknown",
             ...(entry.providerSpecificData ? { providerSpecificData: entry.providerSpecificData } : {}),
           }),
         });
@@ -184,7 +201,9 @@ export default function AddApiKeyModal({ isOpen, provider, providerName, isCompa
             <p className="text-xs text-text-muted">
               {isCloudflareAi
                 ? <>One key per line. Format: <code>name|apiKey|accountId</code> or just <code>apiKey</code> (auto-named by index).</>
-                : <>One key per line. Format: <code>name|apiKey</code> or just <code>apiKey</code> (auto-named by index).</>
+                : provider === "qoder"
+                  ? <>One PAT per line. Format: <code>name|pt-...</code> or just <code>pt-...</code> (auto-named by index).</>
+                  : <>One key per line. Format: <code>name|apiKey</code> or just <code>apiKey</code> (auto-named by index).</>
               }
             </p>
             <textarea
diff --git a/src/app/(dashboard)/dashboard/providers/[id]/page.js b/src/app/(dashboard)/dashboard/providers/[id]/page.js
index 72c1423a..8ca07ae4 100644
--- a/src/app/(dashboard)/dashboard/providers/[id]/page.js
+++ b/src/app/(dashboard)/dashboard/providers/[id]/page.js
@@ -161,6 +161,7 @@ export default function ProviderDetailPage() {
   const apiKeyConnectionLabel =
     providerId === "xai" ? "xAI API Key"
     : providerId === "kimi" ? "Kimi API Key"
+    : providerId === "qoder" ? "PAT"
     : "API Key";
   // Resolve suffix "(level)" for a model when a thinking level is picked and the model supports it.
   const resolveThinkingSuffix = (modelId) => {
diff --git a/src/app/api/providers/[id]/models/route.js b/src/app/api/providers/[id]/models/route.js
index 592cd704..018db024 100644
--- a/src/app/api/providers/[id]/models/route.js
+++ b/src/app/api/providers/[id]/models/route.js
@@ -356,6 +356,7 @@ const PROVIDER_MODELS_CONFIG = {
     customResolver: async (connection) => {
       const credentials = {
         accessToken: connection.accessToken,
+        apiKey: connection.apiKey,
         refreshToken: connection.refreshToken,
         email: connection.email,
         displayName: connection.displayName,

From 1eb37db32d7823d4fa045d71109b8cd30564fab9 Mon Sep 17 00:00:00 2001
From: decolua <decoluadt@gmail.com>
Date: Wed, 5 Aug 2026 11:26:22 +0700
Subject: [PATCH 14/42] refactor(qoder): dedupe PAT exchange logic, validate
 PAT keys properly

PAT-to-job-token exchange was duplicated between the executor and the model service, each with its own cache. Consolidate into qoderModels.js and have the executor import it.

Also add a qoder case to the API-key validate route - the generic OpenAI-compat probe cannot validate a PAT (needs job-token exchange + COSY signing first), so bulk-add always reported unknown for qoder keys.
---
 open-sse/executors/qoder.js             | 107 +-----------------------
 open-sse/services/qoderModels.js        |   8 +-
 src/app/api/providers/validate/route.js |  15 ++++
 3 files changed, 24 insertions(+), 106 deletions(-)

diff --git a/open-sse/executors/qoder.js b/open-sse/executors/qoder.js
index 912e9995..f8691ef5 100644
--- a/open-sse/executors/qoder.js
+++ b/open-sse/executors/qoder.js
@@ -34,13 +34,9 @@ import {
   QODER_CHAT_URL_ENCODED,
   QODER_CHAT_BASE_ALT,
   QODER_CHAT_SIG_PATH,
-  QODER_JOB_TOKEN_EXCHANGE_URL,
-  QODER_USERINFO_URL,
   QODER_MODEL_MAP,
-  QODER_IDE_VERSION,
-  QODER_CLIENT_TYPE,
 } from "../shared/qoder/constants.js";
-import { getQoderModelConfig, resolveQoderModels } from "../services/qoderModels.js";
+import { getQoderModelConfig, resolveQoderModels, isQoderPat, resolveQoderCredentials } from "../services/qoderModels.js";
 
 /**
  * Hoist role:"system" messages out of the messages array (Qoder rejects
@@ -344,92 +340,6 @@ function wrapQoderSSE(response, model) {
   });
 }
 
-// ── PAT (Personal Access Token) → job-token exchange ───────────────────────
-// PATs (pt-...) cannot sign COSY requests directly. Exchange them for a
-// short-lived job token (jt-...) via /api/v1/jobToken/exchange (plain JSON,
-// not COSY-signed), then resolve the userId from userinfo. Mirrors the
-// official qodercli flow. Cached per-PAT until near-expiry.
-const PAT_PREFIX = "pt-";
-const PAT_REFRESH_BUFFER_MS = 5 * 60 * 1000;
-const patJobCache = new Map();
-
-export function isQoderPat(token) {
-  return typeof token === "string" && token.startsWith(PAT_PREFIX);
-}
-
-async function exchangeJobToken(pat, proxyOptions = null, signal = null) {
-  const res = await proxyAwareFetch(
-    QODER_JOB_TOKEN_EXCHANGE_URL,
-    {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        "User-Agent": "qodercli/1.0.0",
-        "Cosy-Version": QODER_IDE_VERSION,
-        "Cosy-ClientType": QODER_CLIENT_TYPE,
-      },
-      body: JSON.stringify({ personal_token: pat }),
-      signal,
-    },
-    proxyOptions,
-  );
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    throw new Error(`qoder PAT exchange failed: ${res.status} ${text.slice(0, 200)}`);
-  }
-  const data = await res.json();
-  if (!data.token) throw new Error("qoder PAT exchange returned no job token");
-
-  let expiresAt = Date.now() + 24 * 60 * 60 * 1000;
-  if (data.expires_at) {
-    const parsed = Date.parse(data.expires_at);
-    if (!Number.isNaN(parsed)) expiresAt = parsed;
-  } else if (typeof data.expires_in === "number" && data.expires_in > 0) {
-    expiresAt = Date.now() + data.expires_in;
-  }
-  return { jobToken: data.token, jobRefreshToken: data.refresh_token || "", expiresAt };
-}
-
-async function fetchUserIdForJobToken(jobToken, proxyOptions = null, signal = null) {
-  try {
-    const res = await proxyAwareFetch(
-      QODER_USERINFO_URL,
-      {
-        method: "GET",
-        headers: {
-          Authorization: `Bearer ${jobToken}`,
-          Accept: "application/json",
-          "User-Agent": "qodercli/1.0.0",
-        },
-        signal,
-      },
-      proxyOptions,
-    );
-    if (!res.ok) return "";
-    const info = await res.json().catch(() => ({}));
-    return info.id || info.userId || info.user_id || "";
-  } catch {
-    return "";
-  }
-}
-
-/**
- * Exchange a PAT for a job token + userId, caching until near-expiry so repeat
- * chat requests don't re-exchange. Returns { accessToken, userId }.
- */
-async function resolvePatCredential(pat, proxyOptions = null, signal = null) {
-  const cached = patJobCache.get(pat);
-  if (cached && cached.expiresAt - Date.now() > PAT_REFRESH_BUFFER_MS) {
-    return cached;
-  }
-  const { jobToken, expiresAt } = await exchangeJobToken(pat, proxyOptions, signal);
-  const userId = await fetchUserIdForJobToken(jobToken, proxyOptions, signal);
-  const entry = { accessToken: jobToken, userId, expiresAt };
-  patJobCache.set(pat, entry);
-  return entry;
-}
-
 export class QoderExecutor extends BaseExecutor {
   constructor() {
     super("qoder", PROVIDERS.qoder);
@@ -457,18 +367,7 @@ export class QoderExecutor extends BaseExecutor {
     const rawToken = credentials?.apiKey || credentials?.accessToken;
     if (isQoderPat(rawToken)) {
       try {
-        const resolved = await resolvePatCredential(rawToken, proxyOptions, signal);
-        credentials = {
-          ...credentials,
-          accessToken: resolved.accessToken,
-          apiKey: undefined,
-          providerSpecificData: {
-            authMethod: "pat",
-            ...(credentials?.providerSpecificData || {}),
-            userId: resolved.userId || credentials?.providerSpecificData?.userId || "",
-            machineId: credentials?.providerSpecificData?.machineId || "",
-          },
-        };
+        credentials = await resolveQoderCredentials(credentials, proxyOptions, signal);
       } catch (err) {
         log?.error?.("QODER", `PAT exchange failed: ${err.message}`);
         const fakeResp = new Response(
@@ -597,6 +496,4 @@ export const __test__ = {
   normalizeMessages,
   wrapQoderSSE,
   buildQoderRequestBody,
-  isQoderPat,
-  resolvePatCredential,
 };
diff --git a/open-sse/services/qoderModels.js b/open-sse/services/qoderModels.js
index 930461af..572931e5 100644
--- a/open-sse/services/qoderModels.js
+++ b/open-sse/services/qoderModels.js
@@ -34,11 +34,17 @@ import {
 const FETCH_TIMEOUT_MS = 15_000;
 const CACHE_TTL_MS = 60 * 60 * 1000; // 1h, same as the Kiro catalog
 
+const PAT_PREFIX = "pt-";
+
 // PAT → job-token cache: a job token is short-lived (24h), so we keep it per
 // PAT and re-exchange once it is within 5 minutes of expiry.
 const PAT_REFRESH_BUFFER_MS = 5 * 60 * 1000;
 const PAT_DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
 
+export function isQoderPat(token) {
+  return typeof token === "string" && token.startsWith(PAT_PREFIX);
+}
+
 /** @type {Map<string, { accessToken: string, userId: string, expiresAt: number }>} */
 const patJobCache = new Map();
 
@@ -139,7 +145,7 @@ async function resolvePatCredential(pat, proxyOptions = null, signal = null) {
  */
 export async function resolveQoderCredentials(credentials, proxyOptions = null, signal = null) {
   const raw = credentials?.apiKey || credentials?.accessToken;
-  if (typeof raw === "string" && raw.startsWith("pt-")) {
+  if (isQoderPat(raw)) {
     const resolved = await resolvePatCredential(raw, proxyOptions, signal);
     return {
       ...credentials,
diff --git a/src/app/api/providers/validate/route.js b/src/app/api/providers/validate/route.js
index 0be11b1e..e9f8f400 100644
--- a/src/app/api/providers/validate/route.js
+++ b/src/app/api/providers/validate/route.js
@@ -4,6 +4,7 @@ import { isOpenAICompatibleProvider, isAnthropicCompatibleProvider, isCustomEmbe
 import { getDefaultModel } from "open-sse/config/providerModels.js";
 import { resolveOllamaLocalHost, resolveXiaomiTokenplanBaseUrl, PROVIDERS } from "open-sse/config/providers.js";
 import { openaiToCommandCodeRequest } from "open-sse/translator/request/openai-to-commandcode.js";
+import { resolveQoderCredentials, resolveQoderModels } from "open-sse/services/qoderModels.js";
 import { normalizeProviderId } from "@/lib/providerNormalization";
 
 // Probe a webSearch/webFetch provider using its searchConfig/fetchConfig.
@@ -581,6 +582,20 @@ export async function POST(request) {
           break;
         }
 
+        case "qoder": {
+          // PAT (pt-...) needs the job-token exchange before it can sign
+          // anything — the generic OpenAI-compat probe below can't validate it.
+          try {
+            const resolved = await resolveQoderCredentials({ apiKey, providerSpecificData }, null, AbortSignal.timeout(8000));
+            const result = await resolveQoderModels(resolved, { forceRefresh: true });
+            isValid = !!result?.models?.length;
+          } catch (err) {
+            isValid = false;
+            error = err.message;
+          }
+          break;
+        }
+
         default: {
           // Generic probe for OpenAI-compatible providers (config-driven from PROVIDERS)
           const cfg = PROVIDERS[provider];

From 13ed14568d569f86b7d09e08c5f197a5dba36308 Mon Sep 17 00:00:00 2001
From: decolua <decoluadt@gmail.com>
Date: Wed, 5 Aug 2026 11:32:14 +0700
Subject: [PATCH 15/42] fix(claude): remove global header cache, gate
 anthropic-beta by model

The global claudeHeaderCache singleton overlaid the last-seen Claude Code
client's identity headers onto every subsequent request, leaking one
client's headers (anthropic-beta, user-agent, x-stainless-*, etc.) onto
another client/account sharing the same server. Removed the singleton and
the claudeOverlay hook entirely, falling back to static per-provider
headers. anthropic-beta is now computed per-request from the requested
model, gating heavy-agent flags (advanced-tool-use, effort) to
opus/sonnet only.
---
 open-sse/executors/base.js                  |   2 +-
 open-sse/executors/default.js               |  26 +--
 open-sse/providers/registry/claude.js       |   3 -
 open-sse/providers/shared.js                |  20 ++
 open-sse/utils/claudeHeaderCache.js         |  70 -------
 src/sse/handlers/chat.js                    |   3 -
 tests/unit/claude-header-forwarding.test.js | 206 ++++----------------
 7 files changed, 65 insertions(+), 265 deletions(-)
 delete mode 100644 open-sse/utils/claudeHeaderCache.js

diff --git a/open-sse/executors/base.js b/open-sse/executors/base.js
index 5a3c4467..f1f8139b 100644
--- a/open-sse/executors/base.js
+++ b/open-sse/executors/base.js
@@ -126,7 +126,7 @@ export class BaseExecutor {
     for (let urlIndex = 0; urlIndex < fallbackCount; urlIndex++) {
       const url = this.buildUrl(model, stream, urlIndex, credentials);
       const transformedBody = this.transformRequest(model, body, stream, credentials);
-      const headers = this.buildHeaders(credentials, stream, url);
+      const headers = this.buildHeaders(credentials, stream, url, model);
 
       if (!retryAttemptsByUrl[urlIndex]) retryAttemptsByUrl[urlIndex] = 0;
 
diff --git a/open-sse/executors/default.js b/open-sse/executors/default.js
index 48be8350..cbd1ccce 100644
--- a/open-sse/executors/default.js
+++ b/open-sse/executors/default.js
@@ -1,9 +1,8 @@
 import { BaseExecutor } from "./base.js";
 import { PROVIDERS, PROVIDER_OAUTH } from "../config/providers.js";
-import { ANTHROPIC_API_VERSION, OPENAI_COMPAT_BASE, ANTHROPIC_COMPAT_BASE } from "../providers/shared.js";
+import { ANTHROPIC_API_VERSION, OPENAI_COMPAT_BASE, ANTHROPIC_COMPAT_BASE, selectAnthropicBeta } from "../providers/shared.js";
 import { OAUTH_ENDPOINTS, buildKimiHeaders } from "../config/appConstants.js";
 import { buildClineHeaders } from "../shared/clineAuth.js";
-import { getCachedClaudeHeaders } from "../utils/claudeHeaderCache.js";
 import { proxyAwareFetch } from "../utils/proxyFetch.js";
 import { injectReasoningContent } from "../utils/reasoningContentInjector.js";
 import { stripUnsupportedParams } from "../translator/concerns/paramSupport.js";
@@ -42,21 +41,6 @@ const HEADER_HOOKS = {
   kimiHeaders: (h, c) => Object.assign(h, buildKimiHeaders(c?.providerSpecificData?.deviceId)),
   clineHeaders: (h, c) => Object.assign(h, buildClineHeaders(c.apiKey || c.accessToken)),
   kilocodeOrg: (h, c) => { if (c.providerSpecificData?.orgId) h["X-Kilocode-OrganizationID"] = c.providerSpecificData.orgId; },
-  claudeOverlay: (h) => {
-    const cached = getCachedClaudeHeaders();
-    if (!cached) return;
-    for (const lcKey of Object.keys(cached)) {
-      const titleKey = lcKey.replace(/(^|-)([a-z])/g, (_, sep, ch) => sep + ch.toUpperCase());
-      if (lcKey === "anthropic-beta") {
-        const staticBetaStr = h[titleKey] || h[lcKey] || "";
-        const flags = new Set(staticBetaStr.split(",").map(f => f.trim()).filter(Boolean));
-        for (const f of cached[lcKey].split(",").map(f => f.trim()).filter(Boolean)) flags.add(f);
-        cached[lcKey] = Array.from(flags).join(",");
-      }
-      if (titleKey !== lcKey && h[titleKey] !== undefined) delete h[titleKey];
-    }
-    Object.assign(h, cached);
-  },
 };
 
 // Config-driven OAuth refresh grants — derived from registry oauth.refresh.
@@ -161,14 +145,18 @@ export class DefaultExecutor extends BaseExecutor {
     return BEARER;
   }
 
-  buildHeaders(credentials, stream = true) {
+  buildHeaders(credentials, stream = true, url, model) {
     const rt = credentials?.runtimeTransport;
     const headers = { "Content-Type": "application/json", ...(rt ? rt.headers : this.config.headers) };
     const desc = rt?.auth || AUTH_DESCRIPTORS[this.provider] || this.resolveAuthDescriptor();
-    // Hooks run BEFORE auth so dynamic overlays (claude cached headers) can't clobber the token.
+    // Hooks run BEFORE auth so dynamic overlays can't clobber the token.
     for (const hook of desc.hooks || []) HEADER_HOOKS[hook]?.(headers, credentials);
     applyAuth(headers, desc, credentials);
 
+    if (this.provider === "claude" && model) {
+      headers["Anthropic-Beta"] = selectAnthropicBeta(model);
+    }
+
     // Strip first-party Claude Code identity headers for non-Anthropic anthropic-compatible upstreams
     if (this.provider?.startsWith?.("anthropic-compatible-")) {
       const baseUrl = credentials?.providerSpecificData?.baseUrl || "";
diff --git a/open-sse/providers/registry/claude.js b/open-sse/providers/registry/claude.js
index 8b030e5a..8c47a6b3 100644
--- a/open-sse/providers/registry/claude.js
+++ b/open-sse/providers/registry/claude.js
@@ -49,9 +49,6 @@ export default {
         header: "Authorization",
         scheme: "bearer",
       },
-      hooks: [
-        "claudeOverlay",
-      ],
     },
     usage: {
       oauthUrl: "https://api.anthropic.com/api/oauth/usage",
diff --git a/open-sse/providers/shared.js b/open-sse/providers/shared.js
index 85b256a1..fdd76c40 100644
--- a/open-sse/providers/shared.js
+++ b/open-sse/providers/shared.js
@@ -47,6 +47,26 @@ export const CLAUDE_CLI_SPOOF_HEADERS = {
   "X-Stainless-Timeout": "600"
 };
 
+const ANTHROPIC_BETA_BASE = [
+  "claude-code-20250219",
+  "oauth-2025-04-20",
+  "interleaved-thinking-2025-05-14",
+  "context-management-2025-06-27",
+  "prompt-caching-scope-2026-01-05",
+  "structured-outputs-2025-12-15",
+  "fast-mode-2026-02-01",
+  "redact-thinking-2026-02-12",
+  "token-efficient-tools-2026-03-28",
+];
+const ANTHROPIC_BETA_HEAVY_AGENT = ["advanced-tool-use-2025-11-20", "effort-2025-11-24"];
+
+// Heavy-agent beta flags are gated to opus/sonnet — cheaper models don't need them.
+export function selectAnthropicBeta(model = "") {
+  const flags = [...ANTHROPIC_BETA_BASE];
+  if (/^claude-(opus|sonnet)/.test(model)) flags.push(...ANTHROPIC_BETA_HEAVY_AGENT);
+  return flags.join(",");
+}
+
 // Shared baseUrls
 export const KIMI_CODING_BASE_URL = "https://api.kimi.com/coding/v1/messages";
 
diff --git a/open-sse/utils/claudeHeaderCache.js b/open-sse/utils/claudeHeaderCache.js
deleted file mode 100644
index 11b2eb81..00000000
--- a/open-sse/utils/claudeHeaderCache.js
+++ /dev/null
@@ -1,70 +0,0 @@
-/**
- * Singleton cache for real Claude Code client headers.
- * Captures headers from authentic Claude Code requests and makes them available
- * for forwarding to api.anthropic.com, replacing static hardcoded values.
- */
-
-const CLAUDE_IDENTITY_HEADERS = [
-  "user-agent",
-  "anthropic-beta",
-  "anthropic-version",
-  "anthropic-dangerous-direct-browser-access",
-  "x-app",
-  "x-stainless-helper-method",
-  "x-stainless-retry-count",
-  "x-stainless-runtime-version",
-  "x-stainless-package-version",
-  "x-stainless-runtime",
-  "x-stainless-lang",
-  "x-stainless-arch",
-  "x-stainless-os",
-  "x-stainless-timeout",
-  "x-claude-code-session-id",
-  "package-version",
-  "runtime-version",
-  "os",
-  "arch",
-];
-
-let cachedHeaders = null;
-
-/**
- * Detect if request headers look like a real Claude Code client.
- * @param {object} headers - Lowercase header key/value object
- */
-function isClaudeCodeClient(headers) {
-  const ua = (headers["user-agent"] || "").toLowerCase();
-  const xApp = (headers["x-app"] || "").toLowerCase();
-  return ua.includes("claude-cli") || ua.includes("claude-code") || xApp === "cli";
-}
-
-/**
- * Store Claude Code identity headers if this looks like a real client request.
- * Called at the entry point before any translation/forwarding.
- * @param {object} headers - Lowercase header key/value object (from request.headers.entries())
- */
-export function cacheClaudeHeaders(headers) {
-  if (!headers || typeof headers !== "object") return;
-  if (!isClaudeCodeClient(headers)) return;
-
-  const captured = {};
-  for (const key of CLAUDE_IDENTITY_HEADERS) {
-    if (headers[key] !== undefined && headers[key] !== null) {
-      captured[key] = headers[key];
-    }
-  }
-
-  if (Object.keys(captured).length > 0) {
-    cachedHeaders = captured;
-    console.log(`[ClaudeHeaders] Cached ${Object.keys(captured).length} identity headers from Claude Code client`);
-  }
-}
-
-/**
- * Get the most recently cached Claude Code identity headers.
- * Returns null if no authentic client request has been seen yet (cold start).
- * @returns {object|null}
- */
-export function getCachedClaudeHeaders() {
-  return cachedHeaders;
-}
diff --git a/src/sse/handlers/chat.js b/src/sse/handlers/chat.js
index af2914a4..b44727ab 100644
--- a/src/sse/handlers/chat.js
+++ b/src/sse/handlers/chat.js
@@ -7,7 +7,6 @@ import {
   extractApiKey,
   isValidApiKey,
 } from "../services/auth.js";
-import { cacheClaudeHeaders } from "open-sse/utils/claudeHeaderCache.js";
 import { getSettings } from "@/lib/localDb";
 import { getModelInfo, getComboModels } from "../services/model.js";
 import { handleChatCore } from "open-sse/handlers/chatCore.js";
@@ -46,8 +45,6 @@ export async function handleChat(request, clientRawRequest = null) {
       headers: Object.fromEntries(request.headers.entries())
     };
   }
-  cacheClaudeHeaders(clientRawRequest.headers);
-
   const modelStr = body.model;
 
   // Request summary is emitted as the unified "▶" line in chatCore (has fmt/thinking/account)
diff --git a/tests/unit/claude-header-forwarding.test.js b/tests/unit/claude-header-forwarding.test.js
index acad66a9..52318782 100644
--- a/tests/unit/claude-header-forwarding.test.js
+++ b/tests/unit/claude-header-forwarding.test.js
@@ -1,10 +1,8 @@
 /**
- * Unit tests for Anthropic header caching + forwarding pipeline
+ * Unit tests for Anthropic header forwarding pipeline
  *
  * Tests cover:
- *  - claudeHeaderCache: detection, capture, and retrieval of Claude Code headers
- *  - default.js buildHeaders(): live header overlay for "claude" provider
- *  - default.js buildHeaders(): cold-start fallback when cache is empty
+ *  - default.js buildHeaders(): static provider defaults + model-gated anthropic-beta
  *  - default.js buildHeaders(): anthropic-compatible non-Anthropic host stripping
  *  - default.js buildHeaders(): anthropic-compatible official host keeps headers
  *  - proxyFetch.js: api.anthropic.com routes through anthropicFetch path
@@ -12,109 +10,6 @@
 
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 
-// ─── claudeHeaderCache ────────────────────────────────────────────────────────
-
-describe("claudeHeaderCache", () => {
-  let cacheModule;
-
-  beforeEach(async () => {
-    // Re-import fresh module each time to reset singleton state
-    vi.resetModules();
-    cacheModule = await import("open-sse/utils/claudeHeaderCache.js");
-  });
-
-  it("returns null before any headers are cached (cold start)", () => {
-    expect(cacheModule.getCachedClaudeHeaders()).toBeNull();
-  });
-
-  it("caches headers when user-agent contains 'claude-code'", () => {
-    cacheModule.cacheClaudeHeaders({
-      "user-agent": "claude-code/2.1.63 node/24.3.0",
-      "anthropic-beta": "claude-code-20250219,oauth-2025-04-20",
-      "anthropic-version": "2023-06-01",
-      "x-app": "cli",
-      "x-stainless-os": "MacOS",
-      "x-stainless-arch": "arm64",
-      "x-stainless-lang": "js",
-      "x-stainless-runtime": "node",
-      "x-stainless-runtime-version": "v24.3.0",
-      "x-stainless-package-version": "0.74.0",
-      "x-stainless-helper-method": "stream",
-      "x-stainless-retry-count": "0",
-      "x-stainless-timeout": "600",
-      "anthropic-dangerous-direct-browser-access": "true",
-      // Non-identity header — should NOT be captured
-      "content-type": "application/json",
-    });
-
-    const cached = cacheModule.getCachedClaudeHeaders();
-    expect(cached).not.toBeNull();
-    expect(cached["user-agent"]).toBe("claude-code/2.1.63 node/24.3.0");
-    expect(cached["anthropic-beta"]).toBe("claude-code-20250219,oauth-2025-04-20");
-    expect(cached["x-app"]).toBe("cli");
-    expect(cached["x-stainless-os"]).toBe("MacOS");
-    // Non-identity header must not leak in
-    expect(cached["content-type"]).toBeUndefined();
-  });
-
-  it("caches headers when user-agent contains 'claude-cli'", () => {
-    cacheModule.cacheClaudeHeaders({
-      "user-agent": "claude-cli/1.0.0",
-      "anthropic-version": "2023-06-01",
-    });
-    expect(cacheModule.getCachedClaudeHeaders()).not.toBeNull();
-    expect(cacheModule.getCachedClaudeHeaders()["user-agent"]).toBe("claude-cli/1.0.0");
-  });
-
-  it("caches headers when x-app is 'cli' (regardless of user-agent)", () => {
-    cacheModule.cacheClaudeHeaders({
-      "user-agent": "axios/1.7.0",
-      "x-app": "cli",
-      "anthropic-version": "2023-06-01",
-    });
-    expect(cacheModule.getCachedClaudeHeaders()).not.toBeNull();
-  });
-
-  it("does NOT cache headers for non-Claude clients", () => {
-    cacheModule.cacheClaudeHeaders({
-      "user-agent": "PostmanRuntime/7.43.0",
-      "anthropic-version": "2023-06-01",
-    });
-    expect(cacheModule.getCachedClaudeHeaders()).toBeNull();
-  });
-
-  it("refreshes cache on each matching request", () => {
-    cacheModule.cacheClaudeHeaders({
-      "user-agent": "claude-code/2.0.0",
-      "x-stainless-package-version": "0.70.0",
-    });
-    cacheModule.cacheClaudeHeaders({
-      "user-agent": "claude-code/2.1.63",
-      "x-stainless-package-version": "0.74.0",
-    });
-    const cached = cacheModule.getCachedClaudeHeaders();
-    expect(cached["user-agent"]).toBe("claude-code/2.1.63");
-    expect(cached["x-stainless-package-version"]).toBe("0.74.0");
-  });
-
-  it("ignores calls with null or non-object headers", () => {
-    cacheModule.cacheClaudeHeaders(null);
-    cacheModule.cacheClaudeHeaders(undefined);
-    cacheModule.cacheClaudeHeaders("string");
-    expect(cacheModule.getCachedClaudeHeaders()).toBeNull();
-  });
-
-  it("only stores keys that are actually present in the headers object", () => {
-    cacheModule.cacheClaudeHeaders({
-      "user-agent": "claude-code/2.1.63",
-      // Most stainless headers absent
-    });
-    const cached = cacheModule.getCachedClaudeHeaders();
-    expect(cached["x-stainless-os"]).toBeUndefined();
-    expect(cached["user-agent"]).toBe("claude-code/2.1.63");
-  });
-});
-
 // ─── DefaultExecutor.buildHeaders() ──────────────────────────────────────────
 
 describe("DefaultExecutor.buildHeaders() — claude provider", () => {
@@ -122,55 +17,51 @@ describe("DefaultExecutor.buildHeaders() — claude provider", () => {
 
   beforeEach(async () => {
     vi.resetModules();
-    // Prime the cache with live client headers before importing executor
-    const cache = await import("open-sse/utils/claudeHeaderCache.js");
-    cache.cacheClaudeHeaders({
-      "user-agent": "claude-code/2.1.63 node/24.3.0",
-      "anthropic-beta": "claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14",
-      "anthropic-version": "2023-06-01",
-      "anthropic-dangerous-direct-browser-access": "true",
-      "x-app": "cli",
-      "x-stainless-os": "MacOS",
-      "x-stainless-arch": "arm64",
-      "x-stainless-lang": "js",
-      "x-stainless-runtime": "node",
-      "x-stainless-runtime-version": "v24.3.0",
-      "x-stainless-package-version": "0.74.0",
-      "x-stainless-helper-method": "stream",
-      "x-stainless-retry-count": "0",
-      "x-stainless-timeout": "600",
-    });
     const mod = await import("open-sse/executors/default.js");
     DefaultExecutor = mod.DefaultExecutor || mod.default;
   });
 
-  it("overlays live cached headers over static provider defaults", () => {
+  it("uses static provider defaults when no model is given", () => {
     const executor = new DefaultExecutor("claude");
     const headers = executor.buildHeaders({ apiKey: "sk-test" }, true);
 
-    // Live values should win over static providers.js values
-    expect(headers["user-agent"]).toBe("claude-code/2.1.63 node/24.3.0");
-    // Beta flags are MERGED (static + cached) to preserve required flags like oauth
-    const betaFlags = headers["anthropic-beta"].split(",").map(s => s.trim());
-    expect(betaFlags).toContain("claude-code-20250219");
-    expect(betaFlags).toContain("oauth-2025-04-20");
-    expect(betaFlags).toContain("interleaved-thinking-2025-05-14");
-    expect(headers["x-stainless-package-version"]).toBe("0.74.0");
-    expect(headers["x-stainless-os"]).toBe("MacOS");
+    const hasVersion =
+      headers["Anthropic-Version"] === "2023-06-01" ||
+      headers["anthropic-version"] === "2023-06-01";
+    expect(hasVersion).toBe(true);
   });
 
-  it("removes conflicting Title-Case static keys when cached lowercase keys exist", () => {
+  it("includes heavy-agent beta flags for claude-opus-5", () => {
     const executor = new DefaultExecutor("claude");
-    const headers = executor.buildHeaders({ apiKey: "sk-test" }, true);
+    const headers = executor.buildHeaders({ apiKey: "sk-test" }, true, undefined, "claude-opus-5");
+    const betaFlags = headers["Anthropic-Beta"].split(",").map(s => s.trim());
+    expect(betaFlags).toContain("advanced-tool-use-2025-11-20");
+    expect(betaFlags).toContain("effort-2025-11-24");
+  });
 
-    // Title-Case variants from providers.js must be gone
-    expect(headers["Anthropic-Version"]).toBeUndefined();
-    expect(headers["Anthropic-Beta"]).toBeUndefined();
-    expect(headers["User-Agent"]).toBeUndefined();
-    expect(headers["X-App"]).toBeUndefined();
-    // Lowercase variants must be present
-    expect(headers["anthropic-version"]).toBe("2023-06-01");
-    expect(headers["x-app"]).toBe("cli");
+  it("includes heavy-agent beta flags for claude-sonnet-5", () => {
+    const executor = new DefaultExecutor("claude");
+    const headers = executor.buildHeaders({ apiKey: "sk-test" }, true, undefined, "claude-sonnet-5");
+    const betaFlags = headers["Anthropic-Beta"].split(",").map(s => s.trim());
+    expect(betaFlags).toContain("advanced-tool-use-2025-11-20");
+    expect(betaFlags).toContain("effort-2025-11-24");
+  });
+
+  it("omits heavy-agent beta flags for claude-haiku-4-5-20251001", () => {
+    const executor = new DefaultExecutor("claude");
+    const headers = executor.buildHeaders({ apiKey: "sk-test" }, true, undefined, "claude-haiku-4-5-20251001");
+    const betaFlags = headers["Anthropic-Beta"].split(",").map(s => s.trim());
+    expect(betaFlags).not.toContain("advanced-tool-use-2025-11-20");
+    expect(betaFlags).not.toContain("effort-2025-11-24");
+    expect(betaFlags).toContain("claude-code-20250219");
+  });
+
+  it("omits heavy-agent beta flags for claude-fable-5", () => {
+    const executor = new DefaultExecutor("claude");
+    const headers = executor.buildHeaders({ apiKey: "sk-test" }, true, undefined, "claude-fable-5");
+    const betaFlags = headers["Anthropic-Beta"].split(",").map(s => s.trim());
+    expect(betaFlags).not.toContain("advanced-tool-use-2025-11-20");
+    expect(betaFlags).not.toContain("effort-2025-11-24");
   });
 
   it("sets x-api-key auth when apiKey is provided", () => {
@@ -198,31 +89,8 @@ describe("DefaultExecutor.buildHeaders() — claude provider", () => {
     const headers = executor.buildHeaders({ apiKey: "k" }, false);
     expect(headers["Accept"]).toBeUndefined();
   });
-});
 
-describe("DefaultExecutor.buildHeaders() — claude provider cold start (no cache)", () => {
-  let DefaultExecutor;
-
-  beforeEach(async () => {
-    vi.resetModules();
-    // Do NOT prime cache — simulate cold start
-    const mod = await import("open-sse/executors/default.js");
-    DefaultExecutor = mod.DefaultExecutor || mod.default;
-  });
-
-  it("falls back to static provider headers when cache is empty", () => {
-    const executor = new DefaultExecutor("claude");
-    const headers = executor.buildHeaders({ apiKey: "sk-test" }, true);
-
-    // Static fallback values from providers.js must still be present
-    // They may be Title-Case since no cache to conflict with them
-    const hasVersion =
-      headers["Anthropic-Version"] === "2023-06-01" ||
-      headers["anthropic-version"] === "2023-06-01";
-    expect(hasVersion).toBe(true);
-  });
-
-  it("does not throw when cache returns null", () => {
+  it("does not throw when no model is given", () => {
     const executor = new DefaultExecutor("claude");
     expect(() => executor.buildHeaders({ apiKey: "sk" }, false)).not.toThrow();
   });

From da8691f8663effea4d8bfb4039b22b3fad8e6e39 Mon Sep 17 00:00:00 2001
From: minhnhat166 <minhnhatphan2003@gmail.com>
Date: Wed, 5 Aug 2026 11:29:07 +0700
Subject: [PATCH 16/42] feat(headroom): report effective payload savings

Break out tool schema and tool-history bytes in the size snapshot and
add an effective byte-savings percentage so token-saved logs reflect
the actual outbound payload reduction, not just processed content.
---
 open-sse/rtk/headroom.js    | 13 ++++++++++++-
 tests/unit/headroom.test.js |  9 ++++++++-
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/open-sse/rtk/headroom.js b/open-sse/rtk/headroom.js
index 880195ff..2b15eed2 100644
--- a/open-sse/rtk/headroom.js
+++ b/open-sse/rtk/headroom.js
@@ -25,9 +25,17 @@ function messagePayload(body) {
 
 function captureSizeSnapshot(body) {
   const messages = messagePayload(body);
+  const toolHistory = messages?.filter((message) =>
+    message?.role === "tool"
+    || message?.role === "function"
+    || message?.tool_calls?.length
+    || message?.content?.some?.((part) => part?.type === "tool_use" || part?.type === "tool_result")
+  ) || [];
   return {
     bodyBytes: jsonBytes(body),
     messageBytes: messages ? jsonBytes(messages) : 0,
+    toolSchemaBytes: jsonBytes(body?.tools || []),
+    toolHistoryBytes: jsonBytes(toolHistory),
   };
 }
 
@@ -336,7 +344,10 @@ export function formatHeadroomSizeLog(diagnostics) {
   const before = diagnostics?.before;
   const after = diagnostics?.after;
   if (!before || !after) return "";
-  return `body=${before.bodyBytes}B→${after.bodyBytes}B messages=${before.messageBytes}B→${after.messageBytes}B`;
+  const effective = before.bodyBytes > 0
+    ? (((before.bodyBytes - after.bodyBytes) / before.bodyBytes) * 100).toFixed(1)
+    : "0.0";
+  return `body=${before.bodyBytes}B→${after.bodyBytes}B messages=${before.messageBytes}B→${after.messageBytes}B tools=${before.toolSchemaBytes || 0}B→${after.toolSchemaBytes || 0}B toolHistory=${before.toolHistoryBytes || 0}B→${after.toolHistoryBytes || 0}B effective=${effective}%`;
 }
 
 export function isHeadroomPhantomSavings(stats, diagnostics, minShrinkRatio = 0.05) {
diff --git a/tests/unit/headroom.test.js b/tests/unit/headroom.test.js
index b7c414d0..a5d28112 100644
--- a/tests/unit/headroom.test.js
+++ b/tests/unit/headroom.test.js
@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, afterEach } from "vitest";
-import { compressWithHeadroom, formatHeadroomLog } from "../../open-sse/rtk/headroom.js";
+import { compressWithHeadroom, formatHeadroomLog, formatHeadroomSizeLog } from "../../open-sse/rtk/headroom.js";
 
 afterEach(() => {
   vi.restoreAllMocks();
@@ -209,4 +209,11 @@ describe("formatHeadroomLog", () => {
     expect(formatHeadroomLog({ tokens_before: 100, tokens_after: 25, tokens_saved: 75 }))
       .toBe("reported token delta=75 before=100 after=25 (75.0%)");
   });
+
+  it("reports effective payload, tool-schema, and tool-history sizes", () => {
+    expect(formatHeadroomSizeLog({
+      before: { bodyBytes: 1000, messageBytes: 800, toolSchemaBytes: 100, toolHistoryBytes: 500 },
+      after: { bodyBytes: 900, messageBytes: 700, toolSchemaBytes: 100, toolHistoryBytes: 400 },
+    })).toContain("tools=100B→100B toolHistory=500B→400B effective=10.0%");
+  });
 });

From 651df2f0e2545ee4aa1c30fb4713ff7aa9e18eaa Mon Sep 17 00:00:00 2001
From: Diwak4r <diwak4r.comp@gmail.com>
Date: Wed, 5 Aug 2026 11:35:01 +0700
Subject: [PATCH 17/42] feat(cli-tools): add OpenDesign (manalkaff/opendesign)
 support

Adds a guide-type CLI Tools entry for OpenDesign, the open-sourced
claude.ai/design skills pack. It has no standalone config - it inherits
the host agent's model/provider config - so once the host (Claude Code,
Cursor, Codex, Gemini CLI, OpenCode) points at 9Router, /opendesign
sessions route through automatically.
---
 README.md                        |  26 +++++++++++++++++++++
 public/providers/opendesign.png  | Bin 0 -> 1170 bytes
 src/shared/constants/cliTools.js |  39 +++++++++++++++++++++++++++++++
 3 files changed, 65 insertions(+)
 create mode 100644 public/providers/opendesign.png

diff --git a/README.md b/README.md
index 4458ba78..4e90b9c4 100644
--- a/README.md
+++ b/README.md
@@ -285,6 +285,32 @@ Default URLs:
         <b>Kilo Code</b>
       </td>
     </tr>
+    <tr>
+      <td align="center" width="120">
+        <img src="./public/providers/opendesign.png" width="60" alt="OpenDesign"/><br/>
+        <b>OpenDesign</b>
+      </td>
+      <td align="center" width="120">
+        <img src="./public/providers/jcode.png" width="60" alt="jcode"/><br/>
+        <b>jcode</b>
+      </td>
+      <td align="center" width="120">
+        <img src="./public/providers/grok-cli.png" width="60" alt="Grok Build"/><br/>
+        <b>Grok Build</b>
+      </td>
+      <td align="center" width="120">
+        <img src="./public/providers/devin-cli.png" width="60" alt="Devin CLI"/><br/>
+        <b>Devin CLI</b>
+      </td>
+      <td align="center" width="120">
+        <img src="./public/providers/deepseek-tui.png" width="60" alt="DeepSeek TUI"/><br/>
+        <b>DeepSeek TUI</b>
+      </td>
+      <td align="center" width="120">
+        <img src="./public/providers/qwen.png" width="60" alt="Qwen Code"/><br/>
+        <b>Qwen Code</b>
+      </td>
+    </tr>
   </table>
 </div>
 
diff --git a/public/providers/opendesign.png b/public/providers/opendesign.png
new file mode 100644
index 0000000000000000000000000000000000000000..c68169aa3abc1163189719db7a36d747acc32b78
GIT binary patch
literal 1170
zcmV;D1a13?P)<h;3K|Lk000e1NJLTq004jh004jp1^@s6!#-il000D8Nkl<Zc%1E<
z+fEZv7=>pyeFFgvz6mI2y+zR&BOpRsz(f;`QSor;0X0#H5fwG@+5^h1;sFf2iBdqH
zp=Jh)t(|E*%uM&*|5{(NLkpd0=~{dJ|DJ<#66AW@??RIMN8!fmE|t{2W8Lw!wqF#y
z0o+_|icPmzc0}RrHA18vT;+^6f?E-cu%itryc{E>!frtE&1EOrgmTOkM!pr?4v_?P
zy^zAoHA2l2K=JLR9_^|+WQvh5g6S$r5V{E@vIum>R6CFANn(1%KLvb$d70vi<c^OC
zDoOywmy4ga>;b?ji-b#zehBWCl!A2mpLjMGjcq4fY~Q5%K-^nt_OxdY0FGw>&VD?K
zntMF}vmY0h0C2We0f}96N=!#x*vIZ48I}NWXaI21TmfLi1OSHy0EZ<29QXvd|GmjU
z2HpVZsB`-_U>5=pmYcU9pYPao5Mcs<!zS=As4)ne01r#z-|smJum&JoumpgY0muZH
z35fd{z%l@70P>HN8+%Bj)-0b{Zr1)88#$N&;Lrfzs52cnhk_q1)!*cu?Zh}V%me_3
z1^@?U6%Z!=oxiWw{h7H6Ac>PMcs?V3Abd9vJ;39omWFO;6A%U<!SHNg4Wt(V@d+>+
zF~(<wmw_~I4X*>ix6iW#fR_Q$CE&@o7NhoKB5Ja8U7W#_6zp`@h9e0zA;bVrHO$gU
z0cNn;06IjMW(MmFV3Oz(%%H|CFu*elL=R%Za5ETf0Goxk#R$e3K$7S-m_g+XFu)vu
z=s}EYHiOD_<+T`K?(1$HZ)-H;-Rlj1PnFeVfKr|Vn<1w`bmI(wW`>+*(Tz5MR5RoZ
z61^0aG1ve_URZ2|tf9hNWdPgEkTqO%s|{eP8L}3MUWyvC*Z`%x)L@2;rJ{>8K%>l%
z5g@vF10-RDj4<IL?hPD^Nwl%<b?yI4QiE3ogI^Ua`l3(*UIN@P+7qn|jP}Tle|Ine
zz@Y)aQ6t@JZW4&+)t5b?w>j05ccjAv0EhPmRskUzVG>{@WSoxx#6Oe)h(GCq;G<ko
zD1dw~Pzi9dHy`WkBmiXqQVCZ9pxr-g0u0xP_hF#;hco~II~(XXh5}~!P;XxQXXDvG
z(ok3ez=13Q?il>93=9IszdM)!;G_%6^#Lh>eh<(IaH4Om>?b171|W{3j`#k=%s%45
z1OSHy0EcG-!C?Y`Lj!>0UHNv5D*;Gee{NN2?-9rakfaip0C2nn;E^Ek1bDO9$|3+p
zQFE36aLQ)>(LSCRK;Ugj;%}`2wqZAbMn&yE()WWd5X`&9y=9uS2LLBk%OOM#e%c0#
zJ-|{Riur(vU3In(9AG~nf%#9tsm>k%oSOCiFjK&4-dCCZbtOQp9T0P=N4rqsG7an?
z%%lxHyAQD>7|n-}iJeON4M^kIi8hhMWEz-3lt~%OZ0=`S(859tX&h^u(+KtmUnJ3b
k-hYrs660XuV{(1hAK^#+y(RlX{r~^~07*qoM6N<$g2k%=9{>OV

literal 0
HcmV?d00001

diff --git a/src/shared/constants/cliTools.js b/src/shared/constants/cliTools.js
index 78ce98d0..2933bc5d 100644
--- a/src/shared/constants/cliTools.js
+++ b/src/shared/constants/cliTools.js
@@ -416,6 +416,45 @@ devin auth login
 devin --version`,
     },
   },
+  opendesign: {
+    id: "opendesign",
+    name: "OpenDesign",
+    image: "/providers/opendesign.png",
+    color: "#7C3AED",
+    description: "OpenDesign — claude.ai/design open-sourced! Agent-native design skills pack",
+    docsUrl: "https://github.com/manalkaff/opendesign",
+    configType: "guide",
+    notes: [
+      { type: "info", text: "OpenDesign ships as a plugin/skills pack installed into Claude Code, Cursor, OpenAI Codex, Gemini CLI, or OpenCode. It inherits the host agent's model config, so once your host points at 9Router, /opendesign design sessions route through 9Router automatically — no extra env vars needed." },
+      { type: "info", text: "Invoke with /opendesign <brief>. Covers decks, wireframes, interactive prototypes, design-system extraction, and brand systems, with a verifier subagent that checks output against the brief." },
+    ],
+    guideSteps: [
+      { step: 1, title: "Install the plugin", desc: "Pick your host below and run the matching install command from the matrix." },
+      { step: 2, title: "No config needed", desc: "OpenDesign runs inside your host agent and uses its model config. If the host already routes through 9Router, /opendesign traffic does too." },
+      { step: 3, title: "Start designing", desc: "Invoke OpenDesign from your agent:", value: "/opendesign make a pitch deck for a seed-stage AI company, 10 slides", copyable: true },
+    ],
+    codeBlock: {
+      language: "bash",
+      code: `# Claude Code
+/plugin marketplace add manalkaff/opendesign
+/plugin install opendesign@opendesign
+
+# Cursor
+/add-plugin opendesign
+
+# OpenAI Codex CLI
+/plugins   # search "opendesign" -> Install Plugin
+
+# OpenAI Codex App
+# Plugins sidebar -> OpenDesign (Design section) -> +
+
+# Gemini CLI
+gemini extensions install https://github.com/manalkaff/opendesign
+
+# OpenCode
+# Fetch and follow .opencode/INSTALL.md from the repo`,
+    },
+  },
   // HIDDEN: gemini-cli
   // "gemini-cli": {
   //   id: "gemini-cli",

From 86131b9ca440486aa7604a1f3b5807fe33874b51 Mon Sep 17 00:00:00 2001
From: "seakleang.nhak" <seakleang.nhak@kesspay.io>
Date: Wed, 5 Aug 2026 11:39:07 +0700
Subject: [PATCH 18/42] feat(codex): support GPT-5.6 Max and Ultra overrides

Add "ultra" reasoning level for Codex GPT-5.6 Sol and Terra, and expose
Max for Luna (Luna falls back Ultra to Max since it is not supported
upstream). Scoped to cx/ routes only; Kiro and generic OpenAI routing
unchanged.
---
 ...08-02-gpt-5-6-codex-reasoning-overrides.md | 328 ++++++++++++++++++
 ...pt-5-6-codex-reasoning-overrides-design.md | 122 +++++++
 open-sse/executors/codex.js                   |  13 +-
 open-sse/handlers/chatCore.js                 |  15 +-
 open-sse/providers/thinkingLevels.js          |  11 +-
 .../translator/concerns/thinkingUnified.js    |  17 +-
 tests/translator/thinking-unified.test.js     |  25 ++
 tests/unit/codex-fast-capacity.test.js        |  30 ++
 .../codex-native-passthrough-thinking.test.js | 111 ++++++
 tests/unit/thinking-levels-gpt56-sol.test.js  |  22 +-
 10 files changed, 675 insertions(+), 19 deletions(-)
 create mode 100644 docs/superpowers/plans/2026-08-02-gpt-5-6-codex-reasoning-overrides.md
 create mode 100644 docs/superpowers/specs/2026-08-02-gpt-5-6-codex-reasoning-overrides-design.md
 create mode 100644 tests/unit/codex-native-passthrough-thinking.test.js

diff --git a/docs/superpowers/plans/2026-08-02-gpt-5-6-codex-reasoning-overrides.md b/docs/superpowers/plans/2026-08-02-gpt-5-6-codex-reasoning-overrides.md
new file mode 100644
index 00000000..8ff5a940
--- /dev/null
+++ b/docs/superpowers/plans/2026-08-02-gpt-5-6-codex-reasoning-overrides.md
@@ -0,0 +1,328 @@
+# GPT-5.6 Codex Reasoning Overrides Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Preserve Codex-advertised Max and Ultra overrides for GPT-5.6 Sol and Terra, preserve Max for Luna, and convert Luna Ultra to Max without changing Kiro or generic OpenAI-format behavior.
+
+**Architecture:** Keep the supported reasoning matrix in the existing `getThinkingLevels(provider, model)` resolver and reuse that result in both translation and Codex executor normalization. The dashboard already consumes this resolver, so no UI component change is required. Unsupported top-end levels remain safely normalized, with Luna Ultra selecting Luna's supported Max level.
+
+**Tech Stack:** JavaScript ES modules, Next.js, Vitest, Codex Responses transport.
+
+## Global Constraints
+
+- Apply the new overrides only to the OpenAI Codex provider (`codex`, exposed as `cx/`).
+- Sol and Terra support `max` and `ultra`; Luna supports `max` but not `ultra`.
+- Convert Luna `ultra` requests to `max` in both translated and native passthrough request paths.
+- Preserve existing Kiro and generic OpenAI-compatible normalization.
+- Do not add runtime model-catalog fetching, dependencies, pricing changes, or unrelated refactors.
+- Write each behavior test first and observe the expected failure before changing production code.
+
+---
+
+### Task 1: Provider-scoped GPT-5.6 level matrix
+
+**Files:**
+- Modify: `tests/unit/thinking-levels-gpt56-sol.test.js`
+- Modify: `open-sse/providers/thinkingLevels.js`
+
+**Interfaces:**
+- Consumes: `getThinkingLevels(provider, model)` and existing capability metadata.
+- Produces: `getThinkingLevels(provider, model): string[] | null` with Codex-only GPT-5.6 level overrides.
+
+- [ ] **Step 1: Replace the Sol-only assertions with the complete behavior matrix**
+
+Use literal expected arrays so each model/provider contract is independently checked:
+
+```js
+it.each([
+  ["gpt-5.6-sol", ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"]],
+  ["gpt-5.6-terra", ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"]],
+  ["gpt-5.6-luna", ["none", "minimal", "low", "medium", "high", "xhigh", "max"]],
+  ["gpt-5.6-sol-review", ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"]],
+  ["gpt-5.6-terra-review", ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"]],
+  ["gpt-5.6-luna-review", ["none", "minimal", "low", "medium", "high", "xhigh", "max"]],
+])("returns Codex levels for %s", (model, expected) => {
+  expect(getThinkingLevels("codex", model)).toEqual(expected);
+});
+
+it("does not expose Codex-only GPT-5.6 overrides on Kiro", () => {
+  expect(getThinkingLevels("kiro", "gpt-5.6-sol")).toEqual([
+    "none", "minimal", "low", "medium", "high", "xhigh",
+  ]);
+});
+```
+
+Keep the older Codex-model assertion to protect the existing `gpt-5.3-codex` behavior.
+
+- [ ] **Step 2: Run the level test and verify it fails for the missing matrix/provider scoping**
+
+Run:
+
+```bash
+npx vitest run tests/unit/thinking-levels-gpt56-sol.test.js
+```
+
+Expected: FAIL because Sol lacks Ultra, Terra/Luna lack Max, and Kiro currently inherits Sol Max.
+
+- [ ] **Step 3: Add provider-aware pattern matching and the three Codex model rules**
+
+Update `PATTERN_THINKING` entries to accept an optional `provider` field and match it in `getThinkingLevels`:
+
+```js
+const CODEX_GPT_5_6_LEVELS = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+
+const PATTERN_THINKING = [
+  { provider: "codex", pattern: "*gpt-5.6-sol*", levels: [...CODEX_GPT_5_6_LEVELS, "ultra"] },
+  { provider: "codex", pattern: "*gpt-5.6-terra*", levels: [...CODEX_GPT_5_6_LEVELS, "ultra"] },
+  { provider: "codex", pattern: "*gpt-5.6-luna*", levels: CODEX_GPT_5_6_LEVELS },
+  { pattern: "*codex*", levels: ["low", "medium", "high", "xhigh"] },
+];
+
+const hit = PATTERN_THINKING.find((entry) =>
+  (!entry.provider || entry.provider === provider) && matchPattern(entry.pattern, model)
+);
+```
+
+- [ ] **Step 4: Re-run the level test and verify it passes**
+
+Run:
+
+```bash
+npx vitest run tests/unit/thinking-levels-gpt56-sol.test.js
+```
+
+Expected: 1 test file passed with no failures.
+
+- [ ] **Step 5: Commit the capability matrix**
+
+```bash
+git add open-sse/providers/thinkingLevels.js tests/unit/thinking-levels-gpt56-sol.test.js
+git commit -m "feat(codex): expose GPT-5.6 reasoning overrides"
+```
+
+### Task 2: Model-aware shared thinking translation
+
+**Files:**
+- Modify: `tests/translator/thinking-unified.test.js`
+- Modify: `open-sse/translator/concerns/thinkingUnified.js`
+
+**Interfaces:**
+- Consumes: `getThinkingLevels(provider, cleanModel): string[] | null` from Task 1.
+- Produces: `parseSuffix(model)` support for `ultra` and `applyThinking(...)` output that preserves supported Codex levels.
+
+- [ ] **Step 1: Add failing suffix and translation tests**
+
+Add a literal parser assertion:
+
+```js
+expect(parseSuffix("gpt-5.6-sol(ultra)")).toEqual({
+  cleanModel: "gpt-5.6-sol",
+  override: { mode: "level", level: "ultra" },
+});
+```
+
+Add table-driven Codex assertions using direct request fields:
+
+```js
+it.each([
+  ["gpt-5.6-sol", "max", "max"],
+  ["gpt-5.6-sol", "ultra", "ultra"],
+  ["gpt-5.6-terra", "max", "max"],
+  ["gpt-5.6-terra", "ultra", "ultra"],
+  ["gpt-5.6-luna", "max", "max"],
+  ["gpt-5.6-luna", "ultra", "max"],
+])("normalizes Codex %s effort %s to %s", (model, effort, expected) => {
+  const out = apply("openai-responses", model, { reasoning: { effort } }, "codex");
+  expect(out.reasoning_effort).toBe(expected);
+});
+```
+
+Add a parenthesized override assertion and Kiro isolation assertion:
+
+```js
+expect(apply("openai-responses", "gpt-5.6-sol(ultra)", {}, "codex").reasoning_effort).toBe("ultra");
+expect(apply("openai", "gpt-5.6-sol", { reasoning_effort: "max" }, "kiro").reasoning_effort).toBe("xhigh");
+```
+
+- [ ] **Step 2: Run the translator test and verify it fails for Ultra parsing and preserved Max/Ultra**
+
+Run:
+
+```bash
+npx vitest run tests/translator/thinking-unified.test.js
+```
+
+Expected: FAIL because Ultra suffixes are ignored and OpenAI translation clamps Max to XHigh.
+
+- [ ] **Step 3: Implement supported-level normalization in the shared translator**
+
+Import `getThinkingLevels`. Recognize `ultra` explicitly in `parseSuffix` without adding it to the budget map. Resolve supported levels once in `applyThinking` and pass them to `applyFormat`.
+
+Use this normalization rule for the OpenAI format:
+
+```js
+function normalizeOpenAILevel(level, supportedLevels) {
+  if (level !== "max" && level !== "ultra") return level;
+  if (supportedLevels?.includes(level)) return level;
+  if (level === "ultra" && supportedLevels?.includes("max")) return "max";
+  return "xhigh";
+}
+```
+
+Keep `none`, automatic effort, budget conversion, and every non-OpenAI format unchanged.
+
+- [ ] **Step 4: Re-run the translator and generic OpenAI clamp tests**
+
+Run:
+
+```bash
+npx vitest run tests/translator/thinking-unified.test.js tests/unit/thinking-effort-openai-max-clamp.test.js
+```
+
+Expected: 2 test files passed; generic OpenAI Max still becomes XHigh.
+
+- [ ] **Step 5: Commit shared translation support**
+
+```bash
+git add open-sse/translator/concerns/thinkingUnified.js tests/translator/thinking-unified.test.js
+git commit -m "feat(codex): preserve supported reasoning efforts"
+```
+
+### Task 3: Codex native passthrough normalization
+
+**Files:**
+- Modify: `tests/unit/codex-fast-capacity.test.js`
+- Modify: `open-sse/executors/codex.js`
+
+**Interfaces:**
+- Consumes: `getThinkingLevels("codex", upstreamModel): string[] | null` from Task 1.
+- Produces: `CodexExecutor.transformRequest(...)` payloads with model-supported upstream `reasoning.effort` values.
+
+- [ ] **Step 1: Add failing Codex executor behavior tests**
+
+Add a separate `describe("Codex reasoning normalization", ...)` block with real `transformRequest` calls:
+
+```js
+it.each([
+  ["gpt-5.6-sol", "max", "max"],
+  ["gpt-5.6-sol", "ultra", "ultra"],
+  ["gpt-5.6-terra", "max", "max"],
+  ["gpt-5.6-terra", "ultra", "ultra"],
+  ["gpt-5.6-luna", "max", "max"],
+  ["gpt-5.6-luna", "ultra", "max"],
+])("normalizes %s effort %s to %s", (model, effort, expected) => {
+  const body = new CodexExecutor().transformRequest(model, {
+    model,
+    input: "hi",
+    reasoning: { effort },
+  }, true, {});
+  expect(body.reasoning.effort).toBe(expected);
+});
+
+it("resolves review models before applying the reasoning matrix", () => {
+  const body = new CodexExecutor().transformRequest("gpt-5.6-terra-review", {
+    model: "gpt-5.6-terra-review",
+    input: "hi",
+    reasoning_effort: "ultra",
+  }, true, {});
+  expect(body.model).toBe("gpt-5.6-terra");
+  expect(body.reasoning.effort).toBe("ultra");
+});
+```
+
+Keep the existing GPT-5.5 Max-to-XHigh fast-tier test.
+
+- [ ] **Step 2: Run the executor test and verify supported values fail by being clamped**
+
+Run:
+
+```bash
+npx vitest run tests/unit/codex-fast-capacity.test.js
+```
+
+Expected: FAIL because current normalization maps supported Max to XHigh and does not map Luna Ultra to Max.
+
+- [ ] **Step 3: Make Codex normalization model-aware**
+
+Import `getThinkingLevels` and replace the global Max clamp with:
+
+```js
+function normalizeReasoningEffort(model, value) {
+  const supportedLevels = getThinkingLevels("codex", model);
+  if (supportedLevels?.includes(value)) return value;
+  if (value === "ultra" && supportedLevels?.includes("max")) return "max";
+  if (value === "max" || value === "ultra") return "xhigh";
+  return value;
+}
+```
+
+Call it only after `body.model` has resolved review aliases to their upstream base model. Pass `body.model` for both `reasoning_effort` and existing `reasoning.effort` request shapes.
+
+- [ ] **Step 4: Re-run the executor and focused feature suites**
+
+Run:
+
+```bash
+npx vitest run tests/unit/codex-fast-capacity.test.js tests/unit/thinking-levels-gpt56-sol.test.js tests/translator/thinking-unified.test.js tests/unit/thinking-effort-openai-max-clamp.test.js
+```
+
+Expected: 4 test files passed with no failures.
+
+- [ ] **Step 5: Commit native Codex normalization**
+
+```bash
+git add open-sse/executors/codex.js tests/unit/codex-fast-capacity.test.js
+git commit -m "feat(codex): forward GPT-5.6 max and ultra efforts"
+```
+
+### Task 4: Full verification and pull request
+
+**Files:**
+- Verify all changed production, test, design, and plan files.
+
+**Interfaces:**
+- Consumes: completed Tasks 1-3.
+- Produces: verified branch pushed to `origin` and a pull request targeting `decolua/9router:master`.
+
+- [ ] **Step 1: Run all focused regression tests**
+
+```bash
+npx vitest run tests/unit/thinking-levels-gpt56-sol.test.js tests/translator/thinking-unified.test.js tests/unit/thinking-effort-openai-max-clamp.test.js tests/unit/codex-fast-capacity.test.js
+```
+
+Expected: all selected test files and tests pass.
+
+- [ ] **Step 2: Run the complete unit test suite**
+
+```bash
+npx vitest run tests/unit tests/translator
+```
+
+Expected: all test files pass with zero failed tests.
+
+- [ ] **Step 3: Run the production build**
+
+```bash
+npm run build
+```
+
+Expected: Next.js production build exits with status 0.
+
+- [ ] **Step 4: Verify repository hygiene and requirement coverage**
+
+```bash
+git diff --check upstream/master...HEAD
+git status --short --branch
+git log --oneline upstream/master..HEAD
+```
+
+Expected: no whitespace errors, no uncommitted source changes, and only scoped feature commits.
+
+- [ ] **Step 5: Push the feature branch and open the pull request**
+
+```bash
+git push -u origin codex/gpt-5-6-reasoning-overrides
+gh pr create --repo decolua/9router --base master --head seakleangnhak:codex/gpt-5-6-reasoning-overrides --title "feat(codex): support GPT-5.6 Max and Ultra overrides" --body $'## Summary\n- expose Max and Ultra for Codex GPT-5.6 Sol and Terra\n- expose Max for Codex GPT-5.6 Luna and normalize Luna Ultra to Max\n- keep Kiro and generic OpenAI-compatible reasoning behavior unchanged\n\n## Verification\n- `npx vitest run tests/unit tests/translator`\n- `npm run build`'
+```
+
+The pull request body must summarize the Codex-only support matrix, Luna Ultra-to-Max fallback, Kiro isolation, and fresh test/build evidence.
diff --git a/docs/superpowers/specs/2026-08-02-gpt-5-6-codex-reasoning-overrides-design.md b/docs/superpowers/specs/2026-08-02-gpt-5-6-codex-reasoning-overrides-design.md
new file mode 100644
index 00000000..832fb5ce
--- /dev/null
+++ b/docs/superpowers/specs/2026-08-02-gpt-5-6-codex-reasoning-overrides-design.md
@@ -0,0 +1,122 @@
+# GPT-5.6 Codex Reasoning Overrides Design
+
+## Goal
+
+Expose and preserve the reasoning levels currently advertised by the OpenAI
+Codex model catalog for GPT-5.6 Sol, Terra, and Luna when they are routed
+through the `codex` provider (`cx/`).
+
+The supported override matrix is:
+
+| Model family | Max | Ultra |
+| --- | --- | --- |
+| GPT-5.6 Sol | Yes | Yes |
+| GPT-5.6 Terra | Yes | Yes |
+| GPT-5.6 Luna | Yes | No |
+
+The same matrix applies to 9router's virtual `-review` variants because they
+resolve to the corresponding upstream base model.
+
+## Scope
+
+This change is limited to OpenAI Codex (`cx/`) routes. Kiro (`kr/`) and other
+OpenAI-format providers retain their existing reasoning-level behavior even
+when they expose models with the same GPT-5.6 names.
+
+The change covers the complete local request path:
+
+1. The provider page advertises only the levels supported by each Codex model.
+2. A copied model suffix such as `gpt-5.6-sol(ultra)` is parsed as a reasoning
+   override.
+3. The shared thinking translator preserves a supported Codex override while
+   retaining the existing `xhigh` fallback for unsupported OpenAI levels.
+4. The Codex executor sends supported `max` and `ultra` values unchanged to the
+   upstream Codex Responses endpoint.
+
+## Current Behavior
+
+`gpt-5.6-luna` and the other GPT-5.6 models already exist in the Codex model
+registry. The capability picker has a global Sol-only `max` pattern, which also
+affects providers such as Kiro unintentionally. The shared OpenAI translator
+and Codex executor then convert `max` to `xhigh`, so the advertised override is
+not preserved end to end. `ultra` is not recognized as a model suffix.
+
+## Design
+
+### Provider-scoped level resolution
+
+Extend the existing model-pattern overrides in
+`open-sse/providers/thinkingLevels.js` with an optional provider constraint.
+Add three Codex-only GPT-5.6 patterns in most-specific order:
+
+- Sol: existing levels plus `max` and `ultra`.
+- Terra: existing levels plus `max` and `ultra`.
+- Luna: existing levels plus `max`.
+
+Matching remains wildcard-based so virtual `-review` variants inherit the
+base model's levels. Provider matching prevents these overrides from changing
+Kiro or other providers.
+
+### Shared translation
+
+Teach the suffix parser to recognize `ultra` as a discrete level without
+assigning it a synthetic token budget. When applying the OpenAI wire format,
+reuse the resolved per-provider model levels:
+
+- Preserve `max` or `ultra` when the target provider/model explicitly supports
+  the requested level.
+- Convert `ultra` to `max` for GPT-5.6 Luna, preserving the highest level Luna
+  supports.
+- Convert other unsupported `max` or `ultra` requests to `xhigh`, preserving
+  the existing safe fallback for generic OpenAI-compatible providers.
+- Leave all existing lower levels and `none` handling unchanged.
+
+This keeps one capability source for the dashboard and translation behavior
+instead of duplicating the GPT-5.6 matrix.
+
+### Codex executor
+
+Make Codex reasoning normalization model-aware. After virtual review models
+are resolved to their upstream base model, preserve a requested level when
+the Codex capability resolver lists it. Continue converting unsupported
+`max` or `ultra` values to `xhigh`, except that Luna converts `ultra` to its
+supported `max` level.
+
+Do not add `max` to the executor's legacy hyphen-suffix parser because
+`gpt-5.1-codex-max` is an actual model identifier. Dashboard overrides use the
+existing parenthesized suffix and the shared translator removes that suffix
+before executor dispatch.
+
+## Error and Compatibility Behavior
+
+- `cx/gpt-5.6-luna(ultra)` becomes `max` rather than sending an unsupported
+  level upstream.
+- Non-GPT-5.6 Codex models retain their current supported levels and fallback
+  behavior.
+- Kiro GPT-5.6 routes no longer inherit the Codex Sol-only picker override and
+  continue using Kiro's existing effort normalization.
+- Direct request fields and parenthesized model overrides follow the same
+  model-aware rules.
+
+## Testing
+
+Use test-driven development with focused unit coverage:
+
+1. Level resolver tests for Sol, Terra, Luna, their review variants, an older
+   Codex model, and Kiro isolation.
+2. Shared translator tests proving `max` and `ultra` survive only for supported
+   Codex model/provider combinations, Luna `ultra` becomes `max`, and other
+   unsupported combinations become `xhigh`.
+3. Codex executor tests proving native and translated request shapes preserve
+   supported values after upstream model resolution.
+4. Existing thinking translation and Codex executor suites to guard generic
+   OpenAI clamping and fast-tier behavior.
+5. Project lint/build checks in proportion to the changed JavaScript modules.
+
+## Non-goals
+
+- Runtime fetching or caching of the Codex model catalog.
+- Adding these levels to Kiro or another provider.
+- Changing model pricing, quotas, defaults, or service tiers.
+- Adding Codex Ultra's multi-agent orchestration behavior inside 9router;
+  9router only forwards the catalog-advertised reasoning override.
diff --git a/open-sse/executors/codex.js b/open-sse/executors/codex.js
index 3b04445f..4d9acbd2 100644
--- a/open-sse/executors/codex.js
+++ b/open-sse/executors/codex.js
@@ -8,6 +8,7 @@ import {
 import { normalizeResponsesInput } from "../translator/formats/responsesApi.js";
 import { fetchImageAsBase64 } from "../translator/concerns/image.js";
 import { getModelUpstreamId } from "../config/providerModels.js";
+import { getThinkingLevels } from "../providers/thinkingLevels.js";
 import { DEFAULT_RETRY_CONFIG, HTTP_STATUS, resolveRetryEntry } from "../config/runtimeConfig.js";
 import { dbg } from "../utils/debugLog.js";
 import { resolveSessionId } from "../utils/sessionManager.js";
@@ -124,8 +125,12 @@ function resolveCacheSessionId(body, credentials) {
   });
 }
 
-function normalizeReasoningEffort(value) {
-  return value === "max" ? "xhigh" : value;
+function normalizeReasoningEffort(model, value) {
+  const supportedLevels = getThinkingLevels("codex", model);
+  if (supportedLevels?.includes(value)) return value;
+  if (value === "ultra" && supportedLevels?.includes("max")) return "max";
+  if (value === "max" || value === "ultra") return "xhigh";
+  return value;
 }
 
 function findNestedMessage(value, depth = 0) {
@@ -440,10 +445,10 @@ export class CodexExecutor extends BaseExecutor {
 
     // Priority: explicit reasoning.effort > reasoning_effort param > model suffix > default (medium)
     if (!body.reasoning) {
-      const effort = normalizeReasoningEffort(body.reasoning_effort || modelEffort || 'low');
+      const effort = normalizeReasoningEffort(body.model, body.reasoning_effort || modelEffort || 'low');
       body.reasoning = { effort, summary: "auto" };
     } else {
-      body.reasoning.effort = normalizeReasoningEffort(body.reasoning.effort);
+      body.reasoning.effort = normalizeReasoningEffort(body.model, body.reasoning.effort);
       if (!body.reasoning.summary) body.reasoning.summary = "auto";
     }
     delete body.reasoning_effort;
diff --git a/open-sse/handlers/chatCore.js b/open-sse/handlers/chatCore.js
index 4f91e020..c32b74bb 100644
--- a/open-sse/handlers/chatCore.js
+++ b/open-sse/handlers/chatCore.js
@@ -1,6 +1,6 @@
 import { detectFormat, getTargetFormat, resolveTransport } from "../services/provider.js";
 import { translateRequest } from "../translator/index.js";
-import { stripThinkingSuffix } from "../translator/concerns/thinkingUnified.js";
+import { applyThinking, extractThinking, stripThinkingSuffix } from "../translator/concerns/thinkingUnified.js";
 import { FORMATS } from "../translator/formats.js";
 import { normalizeClaudePassthrough } from "../translator/formats/claude.js";
 import { createStreamController } from "../utils/streamHandler.js";
@@ -28,7 +28,6 @@ import { compressWithPxpipe } from "../rtk/pxpipe.js";
 import { getCapabilitiesForModel } from "../providers/capabilities.js";
 import { stripUnsupportedModalities } from "../translator/concerns/modality.js";
 import { prefetchRemoteImages } from "../translator/concerns/prefetch.js";
-import { extractThinking } from "../translator/concerns/thinkingUnified.js";
 import { resolveSessionId } from "../utils/sessionManager.js";
 
 /**
@@ -137,6 +136,18 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
   if (passthrough) {
     log?.debug?.("PASSTHROUGH", `${clientTool} → ${provider} | native lossless`);
     translatedBody = { ...body, model: stripThinkingSuffix(upstreamModel) };
+    if (provider === "codex") {
+      const suffixThinking = {};
+      applyThinking(sourceFormat, upstreamModel, suffixThinking, provider);
+      if (suffixThinking.reasoning_effort) {
+        const reasoning = translatedBody.reasoning;
+        translatedBody.reasoning = {
+          ...(reasoning && typeof reasoning === "object" && !Array.isArray(reasoning) ? reasoning : {}),
+          effort: suffixThinking.reasoning_effort,
+        };
+        delete translatedBody.reasoning_effort;
+      }
+    }
     // Normalize newer Cowork/CC beta shapes (adaptive thinking, mid-conversation system) the API rejects
     if (clientTool === "claude") normalizeClaudePassthrough(translatedBody, translatedBody.model);
   } else {
diff --git a/open-sse/providers/thinkingLevels.js b/open-sse/providers/thinkingLevels.js
index 7b638700..f42cdd84 100644
--- a/open-sse/providers/thinkingLevels.js
+++ b/open-sse/providers/thinkingLevels.js
@@ -31,10 +31,13 @@ const FORMAT_LEVELS = {
   step: L.base,
 };
 
+const CODEX_GPT_5_6_LEVELS = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+
 // Model-name pattern overrides (glob, first match wins) — more precise than format default.
 const PATTERN_THINKING = [
-  // gpt-5.6-sol accepts max (maps to xhigh on wire); live probe rejected ultra.
-  { pattern: "*gpt-5.6-sol*", levels: ["none", "minimal", "low", "medium", "high", "xhigh", "max"] },
+  { provider: "codex", pattern: "*gpt-5.6-sol*", levels: [...CODEX_GPT_5_6_LEVELS, "ultra"] },
+  { provider: "codex", pattern: "*gpt-5.6-terra*", levels: [...CODEX_GPT_5_6_LEVELS, "ultra"] },
+  { provider: "codex", pattern: "*gpt-5.6-luna*", levels: CODEX_GPT_5_6_LEVELS },
   { pattern: "*codex*", levels: ["low", "medium", "high", "xhigh"] }, // codex cannot disable thinking
 ];
 
@@ -43,7 +46,9 @@ export function getThinkingLevels(provider, model) {
   if (provider === "kiro" && resolveKiroEffortPath(model) === null) return null;
   const caps = getCapabilitiesForModel(provider, model);
   if (!caps.reasoning) return null;
-  const hit = PATTERN_THINKING.find((p) => matchPattern(p.pattern, model));
+  const hit = PATTERN_THINKING.find((entry) =>
+    (!entry.provider || entry.provider === provider) && matchPattern(entry.pattern, model)
+  );
   let levels = hit?.levels || FORMAT_LEVELS[caps.thinkingFormat] || L.base;
   if (caps.thinkingCanDisable === false) levels = levels.filter((l) => l !== "none");
   return levels;
diff --git a/open-sse/translator/concerns/thinkingUnified.js b/open-sse/translator/concerns/thinkingUnified.js
index ee0b86aa..5dbf756b 100644
--- a/open-sse/translator/concerns/thinkingUnified.js
+++ b/open-sse/translator/concerns/thinkingUnified.js
@@ -3,6 +3,7 @@
 // never hardcoded per-model here. See .docs/thinking/plan.md MATRIX VI-A.
 
 import { getCapabilitiesForModel } from "../../providers/capabilities.js";
+import { getThinkingLevels } from "../../providers/thinkingLevels.js";
 import { PROVIDERS } from "../../providers/index.js";
 import { LEVEL_TO_BUDGET, budgetToLevel, effortToBudget, effortToThinkingLevel } from "./thinking.js";
 
@@ -37,6 +38,7 @@ export function parseSuffix(model) {
   const raw = m[2].trim().toLowerCase();
   if (raw === "none" || raw === "off") return { cleanModel, override: { mode: "none" } };
   if (raw === "auto") return { cleanModel, override: { mode: "auto" } };
+  if (raw === "ultra") return { cleanModel, override: { mode: "level", level: raw } };
   if (/^\d+$/.test(raw)) return { cleanModel, override: { mode: "budget", budget: Number(raw) } };
   if (LEVEL_TO_BUDGET[raw] !== undefined) return { cleanModel, override: { mode: "level", level: raw } };
   return { cleanModel, override: null };
@@ -134,6 +136,13 @@ function toLevel(cfg) {
   return null;
 }
 
+function normalizeOpenAILevel(level, supportedLevels) {
+  if (level !== "max" && level !== "ultra") return level;
+  if (supportedLevels?.includes(level)) return level;
+  if (level === "ultra" && supportedLevels?.includes("max")) return "max";
+  return "xhigh";
+}
+
 function toGeminiThinkingLevel(cfg) {
   const raw = cfg.mode === "auto" ? "high" : (toLevel(cfg) || "high");
   return effortToThinkingLevel(raw);
@@ -213,7 +222,7 @@ function stripAll(body) {
 }
 
 // Apply unified thinking config to body in the resolved provider-native format.
-function applyFormat(fmt, body, cfg, caps) {
+function applyFormat(fmt, body, cfg, caps, supportedLevels) {
   const none = cfg.mode === "none";
   const canDisable = caps.thinkingCanDisable !== false;
   // Model cannot disable thinking → clamp "none" to minimal effort instead.
@@ -223,8 +232,7 @@ function applyFormat(fmt, body, cfg, caps) {
     case "openai": {
       if (none && canDisable) { body.reasoning_effort = "none"; break; }
       const level = toLevel(eff);
-      // OpenAI reasoning_effort enum caps at "xhigh" (no "max"); clamp Claude Code's "max".
-      if (level) body.reasoning_effort = level === "max" ? "xhigh" : level;
+      if (level) body.reasoning_effort = normalizeOpenAILevel(level, supportedLevels);
       break;
     }
     case "claude-adaptive": {
@@ -329,7 +337,8 @@ export function applyThinking(targetFormat, model, body, provider = null, intent
   if (!cfg) return body;
 
   const fmt = resolveFormat(targetFormat, cleanModel, provider);
+  const supportedLevels = getThinkingLevels(provider, cleanModel);
   stripAll(body);
-  applyFormat(fmt, body, cfg, caps);
+  applyFormat(fmt, body, cfg, caps, supportedLevels);
   return body;
 }
diff --git a/tests/translator/thinking-unified.test.js b/tests/translator/thinking-unified.test.js
index 7f276d5c..ee48e3bb 100644
--- a/tests/translator/thinking-unified.test.js
+++ b/tests/translator/thinking-unified.test.js
@@ -18,6 +18,12 @@ describe("parseSuffix", () => {
   it("parses level suffix", () => {
     expect(parseSuffix("gpt-5(high)")).toEqual({ cleanModel: "gpt-5", override: { mode: "level", level: "high" } });
   });
+  it("parses ultra suffix", () => {
+    expect(parseSuffix("gpt-5.6-sol(ultra)")).toEqual({
+      cleanModel: "gpt-5.6-sol",
+      override: { mode: "level", level: "ultra" },
+    });
+  });
   it("parses numeric budget suffix", () => {
     expect(parseSuffix("model(8192)")).toEqual({ cleanModel: "model", override: { mode: "budget", budget: 8192 } });
   });
@@ -157,6 +163,25 @@ describe("applyThinking per provider format", () => {
     const out = apply("openai", "gpt-5.3-codex", { reasoning_effort: "xhigh" }, "codex");
     expect(out.reasoning_effort).toBe("xhigh");
   });
+  it.each([
+    ["gpt-5.6-sol", "max", "max"],
+    ["gpt-5.6-sol", "ultra", "ultra"],
+    ["gpt-5.6-terra", "max", "max"],
+    ["gpt-5.6-terra", "ultra", "ultra"],
+    ["gpt-5.6-luna", "max", "max"],
+    ["gpt-5.6-luna", "ultra", "max"],
+  ])("normalizes Codex %s effort %s to %s", (model, effort, expected) => {
+    const out = apply("openai-responses", model, { reasoning: { effort } }, "codex");
+    expect(out.reasoning_effort).toBe(expected);
+  });
+  it("applies a supported Codex Ultra suffix", () => {
+    const out = apply("openai-responses", "gpt-5.6-sol(ultra)", {}, "codex");
+    expect(out.reasoning_effort).toBe("ultra");
+  });
+  it("keeps Codex-only GPT-5.6 levels out of Kiro translation", () => {
+    const out = apply("openai", "gpt-5.6-sol", { reasoning_effort: "max" }, "kiro");
+    expect(out.reasoning_effort).toBe("xhigh");
+  });
 });
 
 describe("extractReasoningText (response shapes)", () => {
diff --git a/tests/unit/codex-fast-capacity.test.js b/tests/unit/codex-fast-capacity.test.js
index aad85284..818831e1 100644
--- a/tests/unit/codex-fast-capacity.test.js
+++ b/tests/unit/codex-fast-capacity.test.js
@@ -69,3 +69,33 @@ describe("Codex fast tier and capacity handling", () => {
     await expect(new Response(peek.replacementBody).text()).resolves.toBe(text);
   });
 });
+
+describe("Codex reasoning normalization", () => {
+  it.each([
+    ["gpt-5.6-sol", "max", "max"],
+    ["gpt-5.6-sol", "ultra", "ultra"],
+    ["gpt-5.6-terra", "max", "max"],
+    ["gpt-5.6-terra", "ultra", "ultra"],
+    ["gpt-5.6-luna", "max", "max"],
+    ["gpt-5.6-luna", "ultra", "max"],
+  ])("normalizes %s effort %s to %s", (model, effort, expected) => {
+    const body = new CodexExecutor().transformRequest(model, {
+      model,
+      input: "hi",
+      reasoning: { effort },
+    }, true, {});
+
+    expect(body.reasoning.effort).toBe(expected);
+  });
+
+  it("resolves review models before applying the reasoning matrix", () => {
+    const body = new CodexExecutor().transformRequest("gpt-5.6-terra-review", {
+      model: "gpt-5.6-terra-review",
+      input: "hi",
+      reasoning_effort: "ultra",
+    }, true, {});
+
+    expect(body.model).toBe("gpt-5.6-terra");
+    expect(body.reasoning.effort).toBe("ultra");
+  });
+});
diff --git a/tests/unit/codex-native-passthrough-thinking.test.js b/tests/unit/codex-native-passthrough-thinking.test.js
new file mode 100644
index 00000000..bba0b630
--- /dev/null
+++ b/tests/unit/codex-native-passthrough-thinking.test.js
@@ -0,0 +1,111 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const { executeMock, forcedSSEToJsonMock } = vi.hoisted(() => ({
+  executeMock: vi.fn(),
+  forcedSSEToJsonMock: vi.fn(),
+}));
+
+vi.mock("../../open-sse/executors/index.js", () => ({
+  getExecutor: () => ({
+    noAuth: true,
+    execute: executeMock,
+  }),
+}));
+
+vi.mock("../../open-sse/utils/requestLogger.js", () => ({
+  createRequestLogger: async () => ({
+    logClientRawRequest: vi.fn(),
+    logRawRequest: vi.fn(),
+    logTargetRequest: vi.fn(),
+    logProviderResponse: vi.fn(),
+    logConvertedResponse: vi.fn(),
+    logError: vi.fn(),
+  }),
+}));
+
+vi.mock("@/lib/usageDb.js", () => ({
+  trackPendingRequest: vi.fn(),
+  appendRequestLog: vi.fn(async () => {}),
+  saveRequestDetail: vi.fn(async () => {}),
+}));
+
+vi.mock("../../open-sse/handlers/chatCore/sseToJsonHandler.js", () => ({
+  handleForcedSSEToJson: forcedSSEToJsonMock,
+}));
+
+const { handleChatCore } = await import("../../open-sse/handlers/chatCore.js");
+
+async function runNativeCodexRequest(model, reasoning) {
+  const body = {
+    model,
+    input: "hello",
+    stream: false,
+    ...(reasoning ? { reasoning } : {}),
+  };
+
+  await handleChatCore({
+    body,
+    modelInfo: { provider: "codex", model },
+    credentials: { accessToken: "test-token", providerSpecificData: {} },
+    log: { debug: vi.fn(), info: vi.fn(), warn: vi.fn() },
+    connectionId: "test-connection",
+    rtkEnabled: false,
+    headroomEnabled: false,
+    cavemanEnabled: false,
+    ponytailEnabled: false,
+    pxpipeEnabled: false,
+    sourceFormatOverride: "openai-responses",
+    clientRawRequest: {
+      endpoint: "/v1/responses",
+      body,
+      headers: {
+        accept: "application/json",
+        "user-agent": "codex-cli/0.144.1",
+      },
+    },
+  });
+
+  return executeMock.mock.calls.at(-1)[0].body;
+}
+
+describe("native Codex passthrough thinking suffixes", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    executeMock.mockResolvedValue({
+      response: new Response("", { status: 200 }),
+      url: "https://chatgpt.com/backend-api/codex/responses",
+      headers: {},
+      transformedBody: null,
+    });
+    forcedSSEToJsonMock.mockResolvedValue({
+      success: true,
+      response: new Response("{}", { status: 200 }),
+    });
+  });
+
+  it("forwards Ultra for Sol", async () => {
+    const body = await runNativeCodexRequest("gpt-5.6-sol(ultra)");
+
+    expect(body.model).toBe("gpt-5.6-sol");
+    expect(body.reasoning).toEqual({ effort: "ultra" });
+  });
+
+  it("converts unsupported Luna Ultra to Max without dropping reasoning metadata", async () => {
+    const body = await runNativeCodexRequest("gpt-5.6-luna(ultra)", {
+      effort: "low",
+      summary: "detailed",
+    });
+
+    expect(body.model).toBe("gpt-5.6-luna");
+    expect(body.reasoning).toEqual({ effort: "max", summary: "detailed" });
+  });
+
+  it("forwards Ultra through a Terra review alias", async () => {
+    const body = await runNativeCodexRequest("gpt-5.6-terra-review(ultra)", {
+      effort: "low",
+    });
+
+    expect(body.model).toBe("gpt-5.6-terra");
+    expect(body.reasoning).toEqual({ effort: "ultra" });
+  });
+});
diff --git a/tests/unit/thinking-levels-gpt56-sol.test.js b/tests/unit/thinking-levels-gpt56-sol.test.js
index 1a5a3ceb..5ff6546c 100644
--- a/tests/unit/thinking-levels-gpt56-sol.test.js
+++ b/tests/unit/thinking-levels-gpt56-sol.test.js
@@ -2,11 +2,21 @@ import { describe, it, expect } from "vitest";
 import { getThinkingLevels } from "../../open-sse/providers/thinkingLevels.js";
 
 describe("getThinkingLevels", () => {
-  it("adds max for gpt-5.6-sol on codex", () => {
-    const levels = getThinkingLevels("codex", "gpt-5.6-sol");
-    expect(levels).toContain("max");
-    expect(levels).toContain("xhigh");
-    expect(levels).not.toContain("ultra");
+  it.each([
+    ["gpt-5.6-sol", ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"]],
+    ["gpt-5.6-terra", ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"]],
+    ["gpt-5.6-luna", ["none", "minimal", "low", "medium", "high", "xhigh", "max"]],
+    ["gpt-5.6-sol-review", ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"]],
+    ["gpt-5.6-terra-review", ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"]],
+    ["gpt-5.6-luna-review", ["none", "minimal", "low", "medium", "high", "xhigh", "max"]],
+  ])("returns Codex levels for %s", (model, expected) => {
+    expect(getThinkingLevels("codex", model)).toEqual(expected);
+  });
+
+  it("does not expose Codex-only GPT-5.6 overrides on Kiro", () => {
+    expect(getThinkingLevels("kiro", "gpt-5.6-sol")).toEqual([
+      "none", "minimal", "low", "medium", "high", "xhigh",
+    ]);
   });
 
   it("does not add max for other codex models", () => {
@@ -14,7 +24,7 @@ describe("getThinkingLevels", () => {
     expect(levels).toEqual(["low", "medium", "high", "xhigh"]);
   });
 
-  it("does not add max for other gpt-5.6 models", () => {
+  it("does not add max for other Codex models", () => {
     const levels = getThinkingLevels("codex", "gpt-5.5");
     expect(levels || []).not.toContain("max");
   });

From 948dd8f89bf4ec34ea7ba283a1fee29256bab99f Mon Sep 17 00:00:00 2001
From: alfep <alfep@users.noreply.github.com>
Date: Wed, 5 Aug 2026 11:40:51 +0700
Subject: [PATCH 19/42] fix(oauth): declare searchParams in register-session
 POST handler

Missing declaration caused a ReferenceError -> 500 HTML response instead
of JSON when clients called POST .../register-session.
---
 src/app/api/oauth/[provider]/[action]/route.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/app/api/oauth/[provider]/[action]/route.js b/src/app/api/oauth/[provider]/[action]/route.js
index f85bbfa1..824cad8b 100644
--- a/src/app/api/oauth/[provider]/[action]/route.js
+++ b/src/app/api/oauth/[provider]/[action]/route.js
@@ -254,6 +254,7 @@ export async function POST(request, { params }) {
     if (action === "register-session") {
       // Register proxy session out of URL query (state) + body (codeVerifier).
       // Zed's codeVerifier encodes the RSA private key — must stay out of URL/logs.
+      const searchParams = new URL(request.url).searchParams;
       const state = searchParams.get("state") || body?.state;
       if (!state) return NextResponse.json({ error: "Missing state" }, { status: 400 });
       let ok = false;

From d0751bcff77ce7a4551e71885847ce4c953b4a28 Mon Sep 17 00:00:00 2001
From: ryanngit <ryanngit@users.noreply.github.com>
Date: Wed, 5 Aug 2026 11:43:13 +0700
Subject: [PATCH 20/42] fix(grok-cli): display public subscription tier

Map the Grok OAuth access-token tier claim to the public plan label
and prefer it over internal /user entitlement names. Fails open to
existing plan detection for opaque or malformed tokens; upstream
remains authoritative for access and quota enforcement.
---
 open-sse/services/usage/grok-cli.js | 19 +++++++++++++++++++
 tests/unit/grok-cli-usage.test.js   | 12 +++++++++---
 2 files changed, 28 insertions(+), 3 deletions(-)

diff --git a/open-sse/services/usage/grok-cli.js b/open-sse/services/usage/grok-cli.js
index 768192ad..67518e1c 100644
--- a/open-sse/services/usage/grok-cli.js
+++ b/open-sse/services/usage/grok-cli.js
@@ -91,6 +91,24 @@ function resolvePlan(user, config) {
   return "Grok Build";
 }
 
+// Display only; upstream remains authoritative for access and quota enforcement.
+function planFromAccessToken(accessToken) {
+  try {
+    const payload = JSON.parse(Buffer.from(accessToken.split(".")[1], "base64url"));
+    return {
+      0: "Free",
+      1: "SuperGrok",
+      2: "X Basic",
+      3: "X Premium",
+      4: "X Premium Plus",
+      5: "SuperGrok Heavy",
+      6: "SuperGrok Lite",
+    }[payload.tier] || "";
+  } catch {
+    return "";
+  }
+}
+
 function makeQuota({ used, total, resetAt, unlimited = false }) {
   const safeTotal = Math.max(0, toFiniteNumber(total, 0));
   const safeUsed = Math.max(0, toFiniteNumber(used, 0));
@@ -371,6 +389,7 @@ export async function getGrokCliUsage(accessToken, providerSpecificData = null,
     }
 
     const parsed = parseGrokCliBilling(billing, user);
+    parsed.plan = planFromAccessToken(accessToken) || parsed.plan;
 
     if (!parsed.quotas || Object.keys(parsed.quotas).length === 0) {
       // Paid SuperGrok often returns cap=0 over REST but exposes the shared
diff --git a/tests/unit/grok-cli-usage.test.js b/tests/unit/grok-cli-usage.test.js
index a0e28a5c..4017ea03 100644
--- a/tests/unit/grok-cli-usage.test.js
+++ b/tests/unit/grok-cli-usage.test.js
@@ -226,6 +226,11 @@ function binaryResponse(buffer, status = 200) {
   });
 }
 
+function accessTokenWithTier(tier) {
+  const payload = Buffer.from(JSON.stringify({ tier })).toString("base64url");
+  return `header.${payload}.signature`;
+}
+
 const EMPTY_GRPC_WEB_FRAME = Buffer.from([0, 0, 0, 0, 0]);
 const GRPC_CREDITS_URL =
   "https://grok.com/grok_api_v2.GrokBuildBilling/GetGrokCreditsConfig";
@@ -311,6 +316,7 @@ describe("getUsageForProvider(grok-cli)", () => {
   });
 
   it("falls back to GetGrokCreditsConfig gRPC when paid sub has no REST numeric quota", async () => {
+    const accessToken = accessTokenWithTier(5);
     const resetSeconds = 1784825940;
     const resetNanos = 867850000;
     const resetAt = new Date(
@@ -329,11 +335,11 @@ describe("getUsageForProvider(grok-cli)", () => {
 
     const usage = await getUsageForProvider({
       provider: "grok-cli",
-      accessToken: "test-token",
+      accessToken,
     });
 
     expect(usage.message).toBeUndefined();
-    expect(usage.plan).toBe("XPremiumPlus");
+    expect(usage.plan).toBe("SuperGrok Heavy");
     expect(usage.quotas["Weekly SuperGrok"]).toMatchObject({
       used: 35,
       total: 100,
@@ -345,7 +351,7 @@ describe("getUsageForProvider(grok-cli)", () => {
     const grpcCall = proxyAwareFetch.mock.calls[2];
     expect(grpcCall[0]).toBe(GRPC_CREDITS_URL);
     expect(grpcCall[1].method).toBe("POST");
-    expect(grpcCall[1].headers.Authorization).toBe("Bearer test-token");
+    expect(grpcCall[1].headers.Authorization).toBe(`Bearer ${accessToken}`);
     expect(grpcCall[1].headers["Content-Type"]).toBe("application/grpc-web+proto");
     expect(grpcCall[1].headers["X-Grpc-Web"]).toBe("1");
     // Empty gRPC-web request frame is required (flag 0 + length 0)

From c570fe33aea001846a3235d69bcea71be0e1ab91 Mon Sep 17 00:00:00 2001
From: MiQieR <122154116+MiQieR@users.noreply.github.com>
Date: Wed, 5 Aug 2026 11:45:27 +0700
Subject: [PATCH 21/42] feat(tts): add Xiaomi MiMo text-to-speech support

Adds mimo-v2.5-tts as a Media Provider TTS through the existing
OpenAI-compatible chat-completions endpoint. Voice is selected via the
top-level audio.voice field, and an optional style/language hint is
threaded through tts.js -> ttsCore.js -> the new adapter.
---
 CHANGELOG.md                                  |   1 +
 open-sse/config/ttsModels.js                  |  23 +++
 open-sse/handlers/ttsCore.js                  |   6 +-
 open-sse/handlers/ttsProviders/index.js       |   2 +
 open-sse/handlers/ttsProviders/xiaomi-mimo.js |  65 ++++++++
 open-sse/providers/registry/xiaomi-mimo.js    |  10 +-
 public/i18n/literals/ar.json                  |   2 +
 public/i18n/literals/bn.json                  |   2 +
 public/i18n/literals/cs.json                  |   2 +
 public/i18n/literals/da.json                  |   2 +
 public/i18n/literals/de.json                  |   2 +
 public/i18n/literals/el.json                  |   2 +
 public/i18n/literals/es.json                  |   2 +
 public/i18n/literals/fa.json                  |   2 +
 public/i18n/literals/fi.json                  |   2 +
 public/i18n/literals/fr.json                  |   2 +
 public/i18n/literals/he.json                  |   2 +
 public/i18n/literals/hi.json                  |   2 +
 public/i18n/literals/hu.json                  |   2 +
 public/i18n/literals/id.json                  |   2 +
 public/i18n/literals/it.json                  |   2 +
 public/i18n/literals/ja.json                  |   2 +
 public/i18n/literals/km.json                  |   2 +
 public/i18n/literals/ko.json                  |   2 +
 public/i18n/literals/nl.json                  |   2 +
 public/i18n/literals/no.json                  |   2 +
 public/i18n/literals/pl.json                  |   2 +
 public/i18n/literals/pt-BR.json               |   4 +-
 public/i18n/literals/pt-PT.json               |   2 +
 public/i18n/literals/ro.json                  |   2 +
 public/i18n/literals/ru.json                  |   2 +
 public/i18n/literals/sv.json                  |   2 +
 public/i18n/literals/th.json                  |   4 +-
 public/i18n/literals/tl.json                  |   2 +
 public/i18n/literals/tr.json                  |   2 +
 public/i18n/literals/uk.json                  |   2 +
 public/i18n/literals/ur.json                  |   2 +
 public/i18n/literals/vi.json                  |   2 +
 public/i18n/literals/zh-CN.json               |   2 +
 public/i18n/literals/zh-TW.json               |   2 +
 .../[kind]/[id]/components/TtsExampleCard.js  |  64 ++++++--
 src/shared/constants/ttsProviders.js          |  12 ++
 src/sse/handlers/tts.js                       |  11 +-
 tests/unit/xiaomi-mimo-tts.test.js            | 150 ++++++++++++++++++
 44 files changed, 396 insertions(+), 20 deletions(-)
 create mode 100644 open-sse/handlers/ttsProviders/xiaomi-mimo.js
 create mode 100644 tests/unit/xiaomi-mimo-tts.test.js

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b970869d..20900a68 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,7 @@
 # v0.5.45 (2026-07-30)
 
 ## Features
+- **TTS**: add Xiaomi MiMo text-to-speech (preset voices 冰糖/茉莉/苏打/白桦/Mia/Chloe/Milo/Dean, style control, language hint dropdown with Auto-detect, i18n for Style label/placeholder)
 - **Providers**: add Poolside (OpenAI-compatible)
 - **Providers**: add api-airforce, baidu, bazaarlink, bluesminds, kilo-gateway, llm7, morph, sambanova, tencent
 - **OAuth**: zed / trae / windsurf providers + harden callback proxies
diff --git a/open-sse/config/ttsModels.js b/open-sse/config/ttsModels.js
index 6925f5f5..0142f6f1 100644
--- a/open-sse/config/ttsModels.js
+++ b/open-sse/config/ttsModels.js
@@ -33,6 +33,21 @@ const GEMINI_VOICES = [
   "Vindemiatrix", "Sadachbia", "Sadaltager", "Sulafat",
 ].map((id) => ({ id, name: id, type: "tts" }));
 
+// Xiaomi MiMo preset voices (from https://mimo.mi.com/docs/zh-CN/quick-start/usage-guide/audio/speech-synthesis-v2.5).
+// Voice id is passed via `audio.voice`; `mimo_default` = default (冰糖 on CN cluster, Mia elsewhere).
+// Voices are language-independent — the spoken language is a separate hint, not bound to the voice.
+const MIMO_VOICES = [
+  { id: "mimo_default", name: "mimo_default" },
+  { id: "冰糖",           name: "冰糖" },
+  { id: "茉莉",           name: "茉莉" },
+  { id: "苏打",           name: "苏打" },
+  { id: "白桦",           name: "白桦" },
+  { id: "Mia",           name: "Mia" },
+  { id: "Chloe",         name: "Chloe" },
+  { id: "Milo",          name: "Milo" },
+  { id: "Dean",          name: "Dean" },
+].map((v) => ({ type: "tts", ...v }));
+
 // ── TTS Config (config-driven, single source of truth) ─────────────────────
 export const TTS_MODELS_CONFIG = {
   openai: {
@@ -107,6 +122,14 @@ export const TTS_MODELS_CONFIG = {
     },
     allVoices: GEMINI_VOICES,
   },
+  "xiaomi-mimo": {
+    models: [
+      { id: "mimo-v2.5-tts", name: "MiMo V2.5 TTS", type: "tts" },
+    ],
+    voices: {
+      "mimo-v2.5-tts": MIMO_VOICES,
+    },
+  },
 };
 
 // ── Helper: get voices for a specific model ────────────────────────────────
diff --git a/open-sse/handlers/ttsCore.js b/open-sse/handlers/ttsCore.js
index b4b69eeb..e074eb96 100644
--- a/open-sse/handlers/ttsCore.js
+++ b/open-sse/handlers/ttsCore.js
@@ -48,16 +48,16 @@ function createTtsResponse(base64Audio, format, responseFormat) {
  *
  * @returns {Promise<{success, response, status?, error?}>}
  */
-export async function handleTtsCore({ provider, model, input, credentials, responseFormat = "mp3", language }) {
+export async function handleTtsCore({ provider, model, input, credentials, responseFormat = "mp3", language, style }) {
   if (!input?.trim()) {
     return createErrorResult(HTTP_STATUS.BAD_REQUEST, "Missing required field: input");
   }
 
   try {
-    // Special-case adapters (google-tts, edge-tts, local-device, elevenlabs, openai, openrouter, gemini)
+    // Special-case adapters (google-tts, edge-tts, local-device, elevenlabs, openai, openrouter, gemini, xiaomi-mimo)
     const adapter = getTtsAdapter(provider);
     if (adapter) {
-      const result = await adapter.synthesize(input.trim(), model, credentials, responseFormat, { language });
+      const result = await adapter.synthesize(input.trim(), model, credentials, responseFormat, { language, style });
       // Adapter may return a full {success, response} (legacy) or {base64, format}
       if (result.success !== undefined) return result;
       return createTtsResponse(result.base64, result.format, responseFormat);
diff --git a/open-sse/handlers/ttsProviders/index.js b/open-sse/handlers/ttsProviders/index.js
index e1bb8b83..80e104d2 100644
--- a/open-sse/handlers/ttsProviders/index.js
+++ b/open-sse/handlers/ttsProviders/index.js
@@ -6,6 +6,7 @@ import elevenlabs, { fetchElevenLabsVoices } from "./elevenlabs.js";
 import openai from "./openai.js";
 import openrouter from "./openrouter.js";
 import gemini, { fetchGeminiVoices } from "./gemini.js";
+import xiaomiMimo from "./xiaomi-mimo.js";
 import { FORMAT_HANDLERS } from "./genericFormats.js";
 import { parseModelVoice } from "./_base.js";
 
@@ -18,6 +19,7 @@ const SPECIAL_ADAPTERS = {
   openai,
   openrouter,
   gemini,
+  "xiaomi-mimo": xiaomiMimo,
 };
 
 export function getTtsAdapter(provider) {
diff --git a/open-sse/handlers/ttsProviders/xiaomi-mimo.js b/open-sse/handlers/ttsProviders/xiaomi-mimo.js
new file mode 100644
index 00000000..46682689
--- /dev/null
+++ b/open-sse/handlers/ttsProviders/xiaomi-mimo.js
@@ -0,0 +1,65 @@
+// Xiaomi MiMo TTS — via OpenAI-compatible chat completions (non-streaming).
+// Docs: https://mimo.mi.com/docs/zh-CN/quick-start/usage-guide/audio/speech-synthesis-v2.5
+// Message contract: target text in `role: assistant` content, style/voice
+// instructions in `role: user` content. Voice is selected via the top-level
+// `audio.voice` field (NOT embedded in the model name).
+import { parseModelVoice } from "./_base.js";
+
+const DEFAULT_MODEL = "mimo-v2.5-tts";
+const DEFAULT_VOICE = "mimo_default";
+
+export default {
+  synthesize(text, model, credentials, responseFormat, { style, language } = {}) {
+    if (!credentials?.apiKey) throw new Error("xiaomi-mimo API key required");
+    return synthesizeMiMo(text, model, credentials.apiKey, style, language);
+  },
+};
+
+export async function synthesizeMiMo(text, model, apiKey, style, language) {
+  const { modelId, voiceId } = parseModelVoice(model, DEFAULT_MODEL, DEFAULT_VOICE, [DEFAULT_MODEL]);
+
+  // Language and style are soft instructions → prepend as a role:user message.
+  // MiMo auto-detects the spoken language of the text; the hint only nudges it
+  // (e.g. "Speak in English.") and is independent of the chosen voice.
+  const instructions = [];
+  if (language) instructions.push(`Speak in ${language}.`);
+  if (style) instructions.push(style);
+
+  const messages = [{ role: "assistant", content: text }];
+  if (instructions.length) messages.unshift({ role: "user", content: instructions.join(" ") });
+
+  const res = await fetch("https://api.xiaomimimo.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model: modelId,
+      stream: false,
+      messages,
+      audio: {
+        format: "wav",
+        voice: voiceId || DEFAULT_VOICE,
+      },
+    }),
+  });
+
+  const rawText = await res.text();
+  let data = {};
+  if (rawText) {
+    try { data = JSON.parse(rawText); } catch { data = {}; }
+  }
+
+  if (!res.ok) {
+    throw new Error(data?.error?.message || rawText || `MiMo TTS error (${res.status})`);
+  }
+
+  const audio = data?.choices?.[0]?.message?.audio?.data;
+  if (!audio) throw new Error(data?.error?.message || "MiMo TTS returned no audio");
+
+  return {
+    base64: audio,
+    format: data?.choices?.[0]?.message?.audio?.format || "wav",
+  };
+}
diff --git a/open-sse/providers/registry/xiaomi-mimo.js b/open-sse/providers/registry/xiaomi-mimo.js
index fcef7af8..49465f43 100644
--- a/open-sse/providers/registry/xiaomi-mimo.js
+++ b/open-sse/providers/registry/xiaomi-mimo.js
@@ -15,10 +15,11 @@ export default {
     textIcon: "XM",
     website: "https://xiaomimimo.com",
     notice: {
-      apiKeyUrl: "https://xiaomimimo.com",
+      apiKeyUrl: "https://platform.xiaomimimo.com/console/api-keys",
     },
   },
   category: "apikey",
+  serviceKinds: ["llm", "tts"],
   transport: {
     baseUrl: "https://api.xiaomimimo.com/v1/chat/completions",
     validateUrl: "https://api.xiaomimimo.com/v1/models",
@@ -42,5 +43,12 @@ export default {
     { id: "mimo-v2.5", name: "MiMo V2.5" },
     { id: "mimo-v2-omni", name: "MiMo V2 Omni" },
     { id: "mimo-v2-flash", name: "MiMo V2 Flash" },
+    { id: "mimo-v2.5-tts", name: "MiMo V2.5 TTS", kind: "tts" },
   ],
+  ttsConfig: {
+    baseUrl: "https://api.xiaomimimo.com/v1/chat/completions",
+    authType: "apikey",
+    authHeader: "bearer",
+    format: "xiaomi-mimo-tts",
+  },
 };
diff --git a/public/i18n/literals/ar.json b/public/i18n/literals/ar.json
index 32b72f8b..f17abcf2 100644
--- a/public/i18n/literals/ar.json
+++ b/public/i18n/literals/ar.json
@@ -12,6 +12,7 @@
   "Logout": "تسجيل الخروج",
   "Login": "تسجيل الدخول",
   "Providers": "الموفرون",
+  "Style": "النمط",
   "Usage": "الإحصائيات",
   "API Key": "مفتاح API",
   "Connected": "متصل",
@@ -176,6 +177,7 @@
   "How it works:": "كيف يعمل:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "طلب Antigravity/Copilot IDE → إعادة توجيه DNS إلى localhost:443 → يعترض وكيل MITM → 9Router → الرد إلى Antigravity/Copilot",
   "No API keys — create one in Keys page": "لا توجد مفاتيح API — قم بإنشاء واحدة في صفحة المفاتيح",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "مثال: صوت دافئ ولطيف، يتحدث ببطء بلهجة بريطانية",
   "sk_9router (default)": "sk_9router (افتراضي)",
   "Server started": "تم بدء الخادم",
   "Failed to start server": "فشل في بدء الخادم",
diff --git a/public/i18n/literals/bn.json b/public/i18n/literals/bn.json
index ef71ddf8..a8ccc168 100644
--- a/public/i18n/literals/bn.json
+++ b/public/i18n/literals/bn.json
@@ -12,6 +12,7 @@
   "Logout": "লগ আউট",
   "Login": "লগ ইন",
   "Providers": "সরবরাহকারী",
+  "Style": "শৈলী",
   "Usage": "ব্যবহারের পরিসংখ্যান",
   "API Key": "API কী",
   "Connected": "সংযুক্ত",
@@ -176,6 +177,7 @@
   "How it works:": "এটি কীভাবে কাজ করে:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Antigravity/Copilot IDE অনুরোধ → DNS কে localhost:443 তে রিডিরেক্ট করুন → MITM প্রক্সি ইন্টারসেপ্ট করে → 9Router → Antigravity/Copilot এ প্রতিক্রিয়া",
   "No API keys — create one in Keys page": "কোন API কী নেই — Keys পৃষ্ঠায় একটি তৈরি করুন",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "যেমন: উষ্ণ, মৃদু কণ্ঠস্বর, ব্রিটিশ উচ্চারণে ধীরে ধীরে কথা বলা",
   "sk_9router (default)": "sk_9router (ডিফল্ট)",
   "Server started": "সার্ভার শুরু হয়েছে",
   "Failed to start server": "সার্ভার শুরু করতে ব্যর্থ",
diff --git a/public/i18n/literals/cs.json b/public/i18n/literals/cs.json
index ed0d991a..d73139cd 100644
--- a/public/i18n/literals/cs.json
+++ b/public/i18n/literals/cs.json
@@ -12,6 +12,7 @@
   "Logout": "Odhlásit se",
   "Login": "Přihlásit se",
   "Providers": "Poskytovatelé",
+  "Style": "Styl",
   "Usage": "Statistika",
   "API Key": "Klíč API",
   "Connected": "Připojeno",
@@ -176,6 +177,7 @@
   "How it works:": "Jak to funguje:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Požadavek Antigravity/Copilot IDE → Přesměrování DNS na localhost:443 → Proxy MITM zachycuje → 9Router → odpověď na Antigravity/Copilot",
   "No API keys — create one in Keys page": "Žádné klíče API — vytvořte jeden na stránce Klíče",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "např.: teplý, jemný hlas, mluvící pomalu s britským přízvukem",
   "sk_9router (default)": "sk_9router (výchozí)",
   "Server started": "Server spuštěn",
   "Failed to start server": "Spuštění serveru se nezdařilo",
diff --git a/public/i18n/literals/da.json b/public/i18n/literals/da.json
index c81bbe79..aca9c53c 100644
--- a/public/i18n/literals/da.json
+++ b/public/i18n/literals/da.json
@@ -12,6 +12,7 @@
   "Logout": "Log ud",
   "Login": "Log ind",
   "Providers": "Udbydere",
+  "Style": "Stil",
   "Usage": "Forbrugsstatistik",
   "API Key": "API-nøgle",
   "Connected": "Forbundet",
@@ -176,6 +177,7 @@
   "How it works:": "Sådan virker det:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Antigravity/Copilot IDE-anmodning → DNS-omdirigering til localhost:443 → MITM-proxy aflytter → 9Router → svar til Antigravity/Copilot",
   "No API keys — create one in Keys page": "Ingen API-nøgler — opret en på Keys-siden",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "fx.: en varm, blød stemme, der taler langsomt med britisk accent",
   "sk_9router (default)": "sk_9router (standard)",
   "Server started": "Server startet",
   "Failed to start server": "Fejl ved start af server",
diff --git a/public/i18n/literals/de.json b/public/i18n/literals/de.json
index 57bf3ef3..1a02fab7 100644
--- a/public/i18n/literals/de.json
+++ b/public/i18n/literals/de.json
@@ -12,6 +12,7 @@
   "Logout": "Abmelden",
   "Login": "Anmelden",
   "Providers": "Anbieter",
+  "Style": "Stil",
   "Usage": "Statistiken",
   "API Key": "API-Schlüssel",
   "Connected": "Verbunden",
@@ -176,6 +177,7 @@
   "How it works:": "So funktioniert es:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Antigravity/Copilot IDE-Anforderung → DNS-Umleitung auf localhost:443 → MITM-Proxy abfangen → 9Router → Antwort auf Antigravity/Copilot",
   "No API keys — create one in Keys page": "Keine API-Schlüssel — erstellen Sie einen auf der Seite Schlüssel",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "z. B.: eine warme, sanfte Stimme, die langsam mit britischem Akzent spricht",
   "sk_9router (default)": "sk_9router (Standard)",
   "Server started": "Server gestartet",
   "Failed to start server": "Server konnte nicht gestartet werden",
diff --git a/public/i18n/literals/el.json b/public/i18n/literals/el.json
index bfbf8888..a220ac81 100644
--- a/public/i18n/literals/el.json
+++ b/public/i18n/literals/el.json
@@ -12,6 +12,7 @@
   "Logout": "Έξοδος",
   "Login": "Σύνδεση",
   "Providers": "Παρόχοι",
+  "Style": "Στυλ",
   "Usage": "Στατιστικά χρήσης",
   "API Key": "Κλειδί API",
   "Connected": "Συνδεδεμένο",
@@ -176,6 +177,7 @@
   "How it works:": "Πώς λειτουργεί:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Αίτημα Antigravity/Copilot IDE → Ανακατεύθυνση DNS στο localhost:443 → Ο διακομιστής μεσολάβησης MITM παρεμβαίνει → 9Router → απάντηση στο Antigravity/Copilot",
   "No API keys — create one in Keys page": "Δεν υπάρχουν κλειδιά API — δημιουργήστε ένα στη σελίδα Keys",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "π.χ.: μια ζεστή, απαλή φωνή, που μιλάει αργά με βρετανική προφορά",
   "sk_9router (default)": "sk_9router (προεπιλεγμένο)",
   "Server started": "Ο διακομιστής ξεκίνησε",
   "Failed to start server": "Αποτυχία εκκίνησης διακομιστή",
diff --git a/public/i18n/literals/es.json b/public/i18n/literals/es.json
index 69d71e8f..a5e10674 100644
--- a/public/i18n/literals/es.json
+++ b/public/i18n/literals/es.json
@@ -12,6 +12,7 @@
   "Logout": "Cerrar sesión",
   "Login": "Iniciar sesión",
   "Providers": "Proveedores",
+  "Style": "Estilo",
   "Usage": "Estadísticas",
   "API Key": "Clave API",
   "Connected": "Conectado",
@@ -176,6 +177,7 @@
   "How it works:": "Cómo funciona:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Solicitud de Antigravity/Copilot IDE → Redireccionamiento DNS a localhost:443 → El proxy MITM intercepta → 9Router → respuesta a Antigravity/Copilot",
   "No API keys — create one in Keys page": "Sin claves API — cree una en la página Claves",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "p. ej.: voz cálida y suave, hablando lentamente con acento británico",
   "sk_9router (default)": "sk_9router (predeterminado)",
   "Server started": "Servidor iniciado",
   "Failed to start server": "Error al iniciar el servidor",
diff --git a/public/i18n/literals/fa.json b/public/i18n/literals/fa.json
index b298fc57..0f28367f 100644
--- a/public/i18n/literals/fa.json
+++ b/public/i18n/literals/fa.json
@@ -1119,6 +1119,7 @@
   "Stop Server": "توقف سرور",
   "Stopped": "متوقف شد",
   "Strict Proxy": "پروکسی سختگیرانه",
+  "Style": "سبک",
   "Subagent Model": "مدل زیرعامل",
   "Sudo Password Required": "رمز عبور sudo الزامی است",
   "Sudo password is required": "رمز عبور sudo الزامی است",
@@ -1312,6 +1313,7 @@
   "disabled": "غیرفعال",
   "dollars per million tokens": "دلار به ازای هر میلیون توکن",
   "e.g. CwhRBWXzGAHq8TQ4Fs17": "مثلاً CwhRBWXzGAHq8TQ4Fs17",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "مثلاً: صدای گرم و ملایم که با لهجه بریتانیایی به‌آرامی صحبت می‌کند",
   "e.g. claude-opus-4-5": "مثلاً claude-opus-4-5",
   "e.g. my-model-id": "مثلاً my-model-id",
   "e.g. tts-1-hd": "مثلاً tts-1-hd",
diff --git a/public/i18n/literals/fi.json b/public/i18n/literals/fi.json
index dc8b116c..4f86b061 100644
--- a/public/i18n/literals/fi.json
+++ b/public/i18n/literals/fi.json
@@ -12,6 +12,7 @@
   "Logout": "Kirjaudu ulos",
   "Login": "Kirjaudu sisään",
   "Providers": "Palveluntarjoajat",
+  "Style": "Tyyli",
   "Usage": "Käyttötilastot",
   "API Key": "API-avain",
   "Connected": "Yhdistetty",
@@ -176,6 +177,7 @@
   "How it works:": "Kuinka se toimii:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Antigravity/Copilot IDE-pyyntö → DNS-uudelleenohjaus localhost:443:iin → MITM-välityspalvelin sieppaa → 9Router → vastaus Antigravity/Copilot:ille",
   "No API keys — create one in Keys page": "Ei API-avaimia — luo yksi Keys-sivulla",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "esim.: lämmin, pehmeä ääni, joka puhuu hitaasti brittiaksentilla",
   "sk_9router (default)": "sk_9router (oletus)",
   "Server started": "Palvelin käynnistetty",
   "Failed to start server": "Palvelimen käynnistäminen epäonnistui",
diff --git a/public/i18n/literals/fr.json b/public/i18n/literals/fr.json
index bbf8854a..55b86581 100644
--- a/public/i18n/literals/fr.json
+++ b/public/i18n/literals/fr.json
@@ -12,6 +12,7 @@
   "Logout": "Déconnexion",
   "Login": "Connexion",
   "Providers": "Fournisseurs",
+  "Style": "Style",
   "Usage": "Statistiques",
   "API Key": "Clé API",
   "Connected": "Connecté",
@@ -176,6 +177,7 @@
   "How it works:": "Comment ça marche :",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Demande Antigravity/Copilot IDE → Redirection DNS vers localhost:443 → Le proxy MITM intercepte → 9Router → réponse à Antigravity/Copilot",
   "No API keys — create one in Keys page": "Aucune clé API — créez-en une dans la page Clés",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "ex. : voix chaleureuse et douce, parlant lentement avec un accent britannique",
   "sk_9router (default)": "sk_9router (par défaut)",
   "Server started": "Serveur démarré",
   "Failed to start server": "Impossible de démarrer le serveur",
diff --git a/public/i18n/literals/he.json b/public/i18n/literals/he.json
index c144d01b..7ed67a5e 100644
--- a/public/i18n/literals/he.json
+++ b/public/i18n/literals/he.json
@@ -12,6 +12,7 @@
   "Logout": "התנתקות",
   "Login": "כניסה",
   "Providers": "ספקים",
+  "Style": "סגנון",
   "Usage": "סטטיסטיקה",
   "API Key": "מפתח API",
   "Connected": "מחובר",
@@ -176,6 +177,7 @@
   "How it works:": "איך זה עובד:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "בקשת Antigravity/Copilot IDE → הפניה DNS ל-localhost:443 → פרוקסי MITM חוטף → 9Router → תגובה ל-Antigravity/Copilot",
   "No API keys — create one in Keys page": "אין מפתחות API — צור אחד בעמוד Keys",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "למשל: קול חם ועדין, מדבר לאט במבטא בריטי",
   "sk_9router (default)": "sk_9router (ברירת מחדל)",
   "Server started": "השרת התחיל",
   "Failed to start server": "הפעלת השרת נכשלה",
diff --git a/public/i18n/literals/hi.json b/public/i18n/literals/hi.json
index 2fc6b338..3f3aeda6 100644
--- a/public/i18n/literals/hi.json
+++ b/public/i18n/literals/hi.json
@@ -12,6 +12,7 @@
   "Logout": "लॉग आउट",
   "Login": "लॉगिन",
   "Providers": "प्रदाता",
+  "Style": "शैली",
   "Usage": "उपयोग के आंकड़े",
   "API Key": "API कुंजी",
   "Connected": "जुड़ा हुआ",
@@ -176,6 +177,7 @@
   "How it works:": "यह कैसे काम करता है:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Antigravity/Copilot IDE अनुरोध → DNS को localhost:443 में पुनर्निर्देशित करें → MITM प्रॉक्सी इंटरसेप्ट करता है → 9Router → Antigravity/Copilot को प्रतिक्रिया",
   "No API keys — create one in Keys page": "कोई API कुंजी नहीं — Keys पृष्ठ में एक बनाएं",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "जैसे: गर्म, कोमल आवाज़, ब्रिटिश लहजे में धीरे-धीरे बोलते हुए",
   "sk_9router (default)": "sk_9router (डिफ़ॉल्ट)",
   "Server started": "सर्वर शुरू किया गया",
   "Failed to start server": "सर्वर शुरू करने में विफल",
diff --git a/public/i18n/literals/hu.json b/public/i18n/literals/hu.json
index 8e339291..927d1135 100644
--- a/public/i18n/literals/hu.json
+++ b/public/i18n/literals/hu.json
@@ -12,6 +12,7 @@
   "Logout": "Kijelentkezés",
   "Login": "Bejelentkezés",
   "Providers": "Szolgáltatók",
+  "Style": "Stílus",
   "Usage": "Használati statisztika",
   "API Key": "API-kulcs",
   "Connected": "Csatlakoztatva",
@@ -176,6 +177,7 @@
   "How it works:": "Hogyan működik:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Antigravity/Copilot IDE kérés → DNS átirányítás a localhost:443-ra → MITM proxy elfogja → 9Router → válasz Antigravity/Copilot-nak",
   "No API keys — create one in Keys page": "Nincsenek API-kulcsok — hozzon létre egyet a Keys oldalon",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "pl.: meleg, lágy hang, lassan beszél brit akcentussal",
   "sk_9router (default)": "sk_9router (alapértelmezett)",
   "Server started": "Szerver elindult",
   "Failed to start server": "Nem sikerült elindítani a szervert",
diff --git a/public/i18n/literals/id.json b/public/i18n/literals/id.json
index 3e5097aa..c60c1397 100644
--- a/public/i18n/literals/id.json
+++ b/public/i18n/literals/id.json
@@ -12,6 +12,7 @@
   "Logout": "Keluar",
   "Login": "Masuk",
   "Providers": "Penyedia",
+  "Style": "Gaya",
   "Usage": "Statistik Penggunaan",
   "API Key": "Kunci API",
   "Connected": "Terhubung",
@@ -176,6 +177,7 @@
   "How it works:": "Cara kerjanya:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Permintaan Antigravity/Copilot IDE → Pengalihan DNS ke localhost:443 → Proxy MITM mengintersep → 9Router → respons ke Antigravity/Copilot",
   "No API keys — create one in Keys page": "Tidak ada kunci API — buat satu di halaman Keys",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "mis.: suara hangat dan lembut, berbicara pelan dengan aksen Inggris",
   "sk_9router (default)": "sk_9router (bawaan)",
   "Server started": "Server dimulai",
   "Failed to start server": "Gagal memulai server",
diff --git a/public/i18n/literals/it.json b/public/i18n/literals/it.json
index 7f684e83..e1619f86 100644
--- a/public/i18n/literals/it.json
+++ b/public/i18n/literals/it.json
@@ -12,6 +12,7 @@
   "Logout": "Esci",
   "Login": "Accedi",
   "Providers": "Provider",
+  "Style": "Stile",
   "Usage": "Statistiche di utilizzo",
   "API Key": "Chiave API",
   "Connected": "Connesso",
@@ -176,6 +177,7 @@
   "How it works:": "Come funziona:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Richiesta Antigravity/Copilot IDE → Reindirizzamento DNS a localhost:443 → Il proxy MITM intercetta → 9Router → Risposta a Antigravity/Copilot",
   "No API keys — create one in Keys page": "Nessuna chiave API — crearne una nella pagina Chiavi",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "es.: voce calda e morbida, che parla lentamente con accento britannico",
   "sk_9router (default)": "sk_9router (predefinito)",
   "Server started": "Server avviato",
   "Failed to start server": "Impossibile avviare il server",
diff --git a/public/i18n/literals/ja.json b/public/i18n/literals/ja.json
index e448c685..bac4f57b 100644
--- a/public/i18n/literals/ja.json
+++ b/public/i18n/literals/ja.json
@@ -12,6 +12,7 @@
   "Logout": "ログアウト",
   "Login": "ログイン",
   "Providers": "プロバイダー",
+  "Style": "スタイル",
   "Usage": "統計",
   "API Key": "APIキー",
   "Connected": "接続済み",
@@ -176,6 +177,7 @@
   "How it works:": "しくみ：",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Antigravity/Copilot IDE リクエスト → localhost:443 への DNS リダイレクト → MITM プロキシが傍受 → 9Router → Antigravity/Copilot への応答",
   "No API keys — create one in Keys page": "APIキーがありません — キーページで1つ作成してください",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "例：温かく穏やかな声で、イギリス英語のアクセントでゆっくり話す",
   "sk_9router (default)": "sk_9router（デフォルト）",
   "Server started": "サーバーが開始されました",
   "Failed to start server": "サーバーの開始に失敗しました",
diff --git a/public/i18n/literals/km.json b/public/i18n/literals/km.json
index cb40c432..bce40e0a 100644
--- a/public/i18n/literals/km.json
+++ b/public/i18n/literals/km.json
@@ -1121,6 +1121,7 @@
   "Stop Server": "បញ្ឈប់ម៉ាស៊ីនមេ",
   "Stopped": "បានបញ្ឈប់",
   "Strict Proxy": "Strict Proxy",
+  "Style": "រចនាបទ",
   "Subagent Model": "ម៉ូដែល Subagent",
   "Sudo Password Required": "ត្រូវការពាក្យសម្ងាត់ Sudo",
   "Sudo password is required": "ត្រូវការពាក្យសម្ងាត់ Sudo",
@@ -1317,6 +1318,7 @@
   "disabled": "បានបិទ",
   "dollars per million tokens": "ដុល្លារក្នុងមួយលាន Tokens",
   "e.g. CwhRBWXzGAHq8TQ4Fs17": "ឧ. CwhRBWXzGAHq8TQ4Fs17",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "ឧទាហរណ៍៖ សំឡេងកក់ក្តៅ និងទន់ភ្លន់ និយាយយឺតៗដោយសង្កត់សំឡេងបែបអង់គ្លេស",
   "e.g. claude-opus-4-5": "ឧ. claude-opus-4-5",
   "e.g. my-model-id": "ឧ. my-model-id",
   "e.g. tts-1-hd": "ឧ. tts-1-hd",
diff --git a/public/i18n/literals/ko.json b/public/i18n/literals/ko.json
index 1edb094e..2ca0fc19 100644
--- a/public/i18n/literals/ko.json
+++ b/public/i18n/literals/ko.json
@@ -12,6 +12,7 @@
   "Logout": "로그아웃",
   "Login": "로그인",
   "Providers": "제공자",
+  "Style": "스타일",
   "Usage": "통계",
   "API Key": "API 키",
   "Connected": "연결됨",
@@ -176,6 +177,7 @@
   "How it works:": "작동 방식:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Antigravity/Copilot IDE 요청 → localhost:443로 DNS 리디렉션 → MITM 프록시가 가로챔 → 9Router → Antigravity/Copilot으로 응답",
   "No API keys — create one in Keys page": "API 키 없음 — 키 페이지에서 만들기",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "예: 따뜻하고 부드러운 목소리로 영국식 억양을 쓰며 천천히 말하기",
   "sk_9router (default)": "sk_9router (기본값)",
   "Server started": "서버 시작됨",
   "Failed to start server": "서버 시작 실패",
diff --git a/public/i18n/literals/nl.json b/public/i18n/literals/nl.json
index 2eab85ba..9fb47cda 100644
--- a/public/i18n/literals/nl.json
+++ b/public/i18n/literals/nl.json
@@ -12,6 +12,7 @@
   "Logout": "Afmelden",
   "Login": "Aanmelden",
   "Providers": "Providers",
+  "Style": "Stijl",
   "Usage": "Statistieken",
   "API Key": "API-sleutel",
   "Connected": "Verbonden",
@@ -176,6 +177,7 @@
   "How it works:": "Hoe het werkt:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Antigravity/Copilot IDE-aanvraag → DNS-omleiding naar localhost:443 → MITM-proxy onderschept → 9Router → antwoord naar Antigravity/Copilot",
   "No API keys — create one in Keys page": "Geen API-sleutels — maak er één aan op de pagina Sleutels",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "bijv.: een warme, zachte stem, die langzaam praat met een Brits accent",
   "sk_9router (default)": "sk_9router (standaard)",
   "Server started": "Server gestart",
   "Failed to start server": "Server starten mislukt",
diff --git a/public/i18n/literals/no.json b/public/i18n/literals/no.json
index e3f52155..50e84505 100644
--- a/public/i18n/literals/no.json
+++ b/public/i18n/literals/no.json
@@ -12,6 +12,7 @@
   "Logout": "Logg ut",
   "Login": "Logg inn",
   "Providers": "Leverandører",
+  "Style": "Stil",
   "Usage": "Bruksstatistikk",
   "API Key": "API-nøkkel",
   "Connected": "Tilkoblet",
@@ -176,6 +177,7 @@
   "How it works:": "Slik fungerer det:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Antigravity/Copilot IDE-forespørsel → DNS-omdirigering til localhost:443 → MITM-proxy avlytt → 9Router → svar til Antigravity/Copilot",
   "No API keys — create one in Keys page": "Ingen API-nøkler — lag en på Keys-siden",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "f.eks.: en varm, myk stemme, som snakker sakte med britisk aksent",
   "sk_9router (default)": "sk_9router (standard)",
   "Server started": "Server startet",
   "Failed to start server": "Klarte ikke å starte server",
diff --git a/public/i18n/literals/pl.json b/public/i18n/literals/pl.json
index f4b62a67..3840be97 100644
--- a/public/i18n/literals/pl.json
+++ b/public/i18n/literals/pl.json
@@ -12,6 +12,7 @@
   "Logout": "Wyloguj się",
   "Login": "Zaloguj się",
   "Providers": "Dostawcy",
+  "Style": "Styl",
   "Usage": "Statystyka",
   "API Key": "Klucz API",
   "Connected": "Połączony",
@@ -176,6 +177,7 @@
   "How it works:": "Jak to działa:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Żądanie Antigravity/Copilot IDE → Przekierowanie DNS na localhost:443 → Serwer proxy MITM przechwytuje → 9Router → odpowiedź do Antigravity/Copilot",
   "No API keys — create one in Keys page": "Brak kluczy API — utwórz jeden na stronie Klucze",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "np.: ciepły, delikatny głos, mówiący powoli z brytyjskim akcentem",
   "sk_9router (default)": "sk_9router (domyślnie)",
   "Server started": "Serwer uruchomiony",
   "Failed to start server": "Nie udało się uruchomić serwera",
diff --git a/public/i18n/literals/pt-BR.json b/public/i18n/literals/pt-BR.json
index f2b5f6d2..a4186636 100644
--- a/public/i18n/literals/pt-BR.json
+++ b/public/i18n/literals/pt-BR.json
@@ -864,6 +864,7 @@
   "Stopped": "Parado",
   "Stopping…": "Parando…",
   "Strict Proxy": "Proxy Estrito",
+  "Style": "Estilo",
   "Subagent Model": "Modelo de Subagente",
   "Subagent model overrides": "Substituições de modelo de subagente",
   "Submit": "Enviar",
@@ -978,6 +979,7 @@
   "Your OAuth application client ID": "ID do cliente do seu aplicativo OAuth",
   "Your requests start from your favorite tools or our unified SDK.": "Suas requisições começam de suas ferramentas favoritas ou do nosso SDK unificado.",
   "[ml] downloads ~1 GB (torch + huggingface-hub). Continue?": "[ml] baixa ~1 GB (torch + huggingface-hub). Continuar?",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "ex.: voz quente e suave, falando devagar com sotaque britânico",
   "extras status failed": "falha no status dos extras",
   "git/grep/ls/tree/logs → 60-90% fewer input tokens": "git/grep/ls/tree/logs → 60-90% menos tokens de entrada",
   "not installed": "não instalado",
@@ -985,4 +987,4 @@
   "tree-sitter AST compression for code responses": "Compressão AST tree-sitter para respostas de código",
   "⚠️ MITM intercepts HTTPS traffic of IDE tools (Antigravity, GitHub Copilot, Kiro) via local CA to redirect requests to your providers. May violate ToS → account ban. Use at your own risk.": "⚠️ MITM intercepta tráfego HTTPS de ferramentas IDE (Antigravity, GitHub Copilot, Kiro) via CA local para redirecionar solicitações aos seus provedores. Pode violar ToS → risco de banimento de conta. Use por sua conta e risco.",
   "⚠️ Risk Notice: This provider uses a subscription/OAuth session not officially licensed for proxy/router use. Account may be restricted or banned. Use at your own risk.": "⚠️ Aviso de Risco: Este provedor usa uma sessão de assinatura/OAuth não licenciada oficialmente para uso de proxy/roteador. A conta pode ser restrita ou banida. Use por sua conta e risco."
-}
\ No newline at end of file
+}
diff --git a/public/i18n/literals/pt-PT.json b/public/i18n/literals/pt-PT.json
index c17e932a..dfa1270f 100644
--- a/public/i18n/literals/pt-PT.json
+++ b/public/i18n/literals/pt-PT.json
@@ -12,6 +12,7 @@
   "Logout": "Terminar sessão",
   "Login": "Iniciar sessão",
   "Providers": "Fornecedores",
+  "Style": "Estilo",
   "Usage": "Estatísticas",
   "API Key": "Chave API",
   "Connected": "Ligado",
@@ -176,6 +177,7 @@
   "How it works:": "Como funciona:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Pedido do Antigravity/Copilot IDE → Redirecionamento DNS para localhost:443 → Proxy MITM interceta → 9Router → resposta para Antigravity/Copilot",
   "No API keys — create one in Keys page": "Sem chaves de API — crie uma na página Chaves",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "ex.: voz quente e suave, a falar devagar com sotaque britânico",
   "sk_9router (default)": "sk_9router (predefinição)",
   "Server started": "Servidor iniciado",
   "Failed to start server": "Falha ao iniciar o servidor",
diff --git a/public/i18n/literals/ro.json b/public/i18n/literals/ro.json
index 03384415..d9857d51 100644
--- a/public/i18n/literals/ro.json
+++ b/public/i18n/literals/ro.json
@@ -12,6 +12,7 @@
   "Logout": "Ieșire",
   "Login": "Conectare",
   "Providers": "Furnizori",
+  "Style": "Stil",
   "Usage": "Statistici de utilizare",
   "API Key": "Cheie API",
   "Connected": "Conectat",
@@ -176,6 +177,7 @@
   "How it works:": "Cum funcționează:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Solicitare Antigravity/Copilot IDE → Redirecționare DNS la localhost:443 → Proxy MITM interceptează → 9Router → răspuns la Antigravity/Copilot",
   "No API keys — create one in Keys page": "Nicio cheie API — creați una în pagina Chei",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "ex.: voce caldă și blândă, vorbind încet cu accent britanic",
   "sk_9router (default)": "sk_9router (implicit)",
   "Server started": "Server pornit",
   "Failed to start server": "Nu s-a putut porni serverul",
diff --git a/public/i18n/literals/ru.json b/public/i18n/literals/ru.json
index 92b9f0e7..c34535ee 100644
--- a/public/i18n/literals/ru.json
+++ b/public/i18n/literals/ru.json
@@ -12,6 +12,7 @@
   "Logout": "Выход",
   "Login": "Вход",
   "Providers": "Провайдеры",
+  "Style": "Стиль",
   "Usage": "Статистика",
   "API Key": "Ключ API",
   "Connected": "Подключено",
@@ -176,6 +177,7 @@
   "How it works:": "Как это работает:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Запрос Antigravity/Copilot IDE → Перенаправление DNS на localhost:443 → Прокси MITM перехватывает → 9Router → ответ для Antigravity/Copilot",
   "No API keys — create one in Keys page": "Нет ключей API — создайте один на странице ключей",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "напр.: тёплый мягкий голос, медленно говорящий с британским акцентом",
   "sk_9router (default)": "sk_9router (по умолчанию)",
   "Server started": "Сервер запущен",
   "Failed to start server": "Ошибка при запуске сервера",
diff --git a/public/i18n/literals/sv.json b/public/i18n/literals/sv.json
index 0e4c3b46..ef45f379 100644
--- a/public/i18n/literals/sv.json
+++ b/public/i18n/literals/sv.json
@@ -12,6 +12,7 @@
   "Logout": "Logga ut",
   "Login": "Logga in",
   "Providers": "Leverantörer",
+  "Style": "Stil",
   "Usage": "Användarstatistik",
   "API Key": "API-nyckel",
   "Connected": "Ansluten",
@@ -176,6 +177,7 @@
   "How it works:": "Hur det fungerar:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Antigravity/Copilot IDE-begäran → DNS-omdirigering till localhost:443 → MITM-proxy avlyssnar → 9Router → svar till Antigravity/Copilot",
   "No API keys — create one in Keys page": "Inga API-nycklar — skapa en på nyckelsidan",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "t.ex.: en varm, mjuk röst som talar långsamt med brittisk accent",
   "sk_9router (default)": "sk_9router (standard)",
   "Server started": "Servern startad",
   "Failed to start server": "Misslyckades att starta servern",
diff --git a/public/i18n/literals/th.json b/public/i18n/literals/th.json
index 7d528201..bc4d9376 100644
--- a/public/i18n/literals/th.json
+++ b/public/i18n/literals/th.json
@@ -1119,6 +1119,7 @@
   "Stop Server": "หยุดเซิร์ฟเวอร์",
   "Stopped": "หยุดแล้ว",
   "Strict Proxy": "Strict Proxy",
+  "Style": "สไตล์",
   "Subagent Model": "Subagent Model",
   "Sudo Password Required": "ต้องใช้ Sudo Password",
   "Sudo password is required": "ต้องใช้ Sudo password",
@@ -1312,6 +1313,7 @@
   "disabled": "ปิดใช้งานแล้ว",
   "dollars per million tokens": "ดอลลาร์ต่อล้าน tokens",
   "e.g. CwhRBWXzGAHq8TQ4Fs17": "เช่น CwhRBWXzGAHq8TQ4Fs17",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "เช่น เสียงอบอุ่นนุ่มนวล พูดช้าๆ ด้วยสำเนียงอังกฤษ",
   "e.g. claude-opus-4-5": "เช่น claude-opus-4-5",
   "e.g. my-model-id": "เช่น my-model-id",
   "e.g. tts-1-hd": "เช่น tts-1-hd",
@@ -1388,4 +1390,4 @@
   "✓ Confirm Add": "✓ ยืนยันการเพิ่ม",
   "📝 Configure providers in dashboard or use environment variables": "📝 กำหนดค่า providers ใน dashboard หรือใช้ environment variables",
   "🔐 OAuth required. Add now and authenticate after Apply; tool list will be discovered after first connect.": "🔐 ต้องใช้ OAuth เพิ่มตอนนี้แล้ว authenticate หลัง Apply; รายการเครื่องมือจะถูกค้นพบหลังการเชื่อมต่อครั้งแรก"
-}
\ No newline at end of file
+}
diff --git a/public/i18n/literals/tl.json b/public/i18n/literals/tl.json
index 51af4e24..7510740a 100644
--- a/public/i18n/literals/tl.json
+++ b/public/i18n/literals/tl.json
@@ -12,6 +12,7 @@
   "Logout": "Maglog out",
   "Login": "Magsimula ng sesyon",
   "Providers": "Mga Provider",
+  "Style": "Estilo",
   "Usage": "Mga Istatistika ng Paggamit",
   "API Key": "Susi ng API",
   "Connected": "Konektado",
@@ -176,6 +177,7 @@
   "How it works:": "Paano ito gumagana:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Antigravity/Copilot IDE request → DNS redirect sa localhost:443 → MITM proxy intercepts → 9Router → response sa Antigravity/Copilot",
   "No API keys — create one in Keys page": "Walang API keys — lumikha ng isa sa Keys page",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "hal.: mainit at malumanay na boses, dahan-dahang nagsasalita nang may British accent",
   "sk_9router (default)": "sk_9router (default)",
   "Server started": "Ang server ay nagsimula",
   "Failed to start server": "Nabigo na magsimula ang server",
diff --git a/public/i18n/literals/tr.json b/public/i18n/literals/tr.json
index ac4042aa..bd7ec4f4 100644
--- a/public/i18n/literals/tr.json
+++ b/public/i18n/literals/tr.json
@@ -12,6 +12,7 @@
   "Logout": "Çıkış Yap",
   "Login": "Giriş Yap",
   "Providers": "Sağlayıcılar",
+  "Style": "Stil",
   "Usage": "Kullanım İstatistikleri",
   "API Key": "API Anahtarı",
   "Connected": "Bağlı",
@@ -176,6 +177,7 @@
   "How it works:": "Nasıl çalışır:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Antigravity/Copilot IDE isteği → DNS'i localhost:443'e yönlendir → MITM proxy yakalar → 9Router → Antigravity/Copilot'a yanıt",
   "No API keys — create one in Keys page": "API anahtarı yok — Keys sayfasında bir tane oluşturun",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "örn.: sıcak ve yumuşak bir ses, İngiliz aksanıyla yavaş konuşuyor",
   "sk_9router (default)": "sk_9router (varsayılan)",
   "Server started": "Sunucu başlatıldı",
   "Failed to start server": "Sunucu başlatılamadı",
diff --git a/public/i18n/literals/uk.json b/public/i18n/literals/uk.json
index e238ad2b..378476ef 100644
--- a/public/i18n/literals/uk.json
+++ b/public/i18n/literals/uk.json
@@ -12,6 +12,7 @@
   "Logout": "Вийти",
   "Login": "Увійти",
   "Providers": "Постачальники",
+  "Style": "Стиль",
   "Usage": "Статистика використання",
   "API Key": "Ключ API",
   "Connected": "Підключено",
@@ -176,6 +177,7 @@
   "How it works:": "Як це працює:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Запит Antigravity/Copilot IDE → Перенаправлення DNS на localhost:443 → MITM проксі перехопити → 9Router → відповідь на Antigravity/Copilot",
   "No API keys — create one in Keys page": "Немає ключів API — створіть один на сторінці ключів",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "напр.: теплий м'який голос, що повільно говорить з британським акцентом",
   "sk_9router (default)": "sk_9router (за замовчуванням)",
   "Server started": "Сервер запущено",
   "Failed to start server": "Не вдалося запустити сервер",
diff --git a/public/i18n/literals/ur.json b/public/i18n/literals/ur.json
index e5921755..e0aa8cf7 100644
--- a/public/i18n/literals/ur.json
+++ b/public/i18n/literals/ur.json
@@ -12,6 +12,7 @@
   "Logout": "لاگ آؤٹ",
   "Login": "لاگ ان",
   "Providers": "فراہم کنندگان",
+  "Style": "انداز",
   "Usage": "استعمال کے اعدادوشمار",
   "API Key": "API کلید",
   "Connected": "منسلک",
@@ -176,6 +177,7 @@
   "How it works:": "یہ کیسے کام کرتا ہے:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Antigravity/Copilot IDE درخواست → DNS کو localhost:443 کی طرف ری ڈائریکٹ کریں → MITM پروکسی روکے → 9Router → Antigravity/Copilot کو جواب",
   "No API keys — create one in Keys page": "کوئی API کلید نہیں — Keys صفحہ میں ایک بنائیں",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "مثلاً: گرم، نرم آواز، برطانوی لہجے کے ساتھ آہستہ بولتی ہوئی",
   "sk_9router (default)": "sk_9router (ڈیفالٹ)",
   "Server started": "سرور شروع ہوگیا",
   "Failed to start server": "سرور شروع کرنے میں ناکام",
diff --git a/public/i18n/literals/vi.json b/public/i18n/literals/vi.json
index 5358d068..51100780 100644
--- a/public/i18n/literals/vi.json
+++ b/public/i18n/literals/vi.json
@@ -12,6 +12,7 @@
   "Logout": "Đăng xuất",
   "Login": "Đăng nhập",
   "Providers": "Nhà cung cấp",
+  "Style": "Phong cách",
   "Usage": "Thống kê",
   "API Key": "Khóa API",
   "Connected": " Đã kết nối",
@@ -176,6 +177,7 @@
   "How it works:": "Cách hoạt động:",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Yêu cầu Antigravity/Copilot IDE → Chuyển hướng DNS đến localhost:443 → MITM proxy chặn → 9Router → phản hồi đến Antigravity/Copilot",
   "No API keys — create one in Keys page": "Không có khóa API — tạo một khóa trong trang Keys",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "vd.: giọng ấm áp, nhẹ nhàng, nói chậm với giọng Anh-Anh",
   "sk_9router (default)": "sk_9router (mặc định)",
   "Server started": "Đã khởi động máy chủ",
   "Failed to start server": "Không thể khởi động máy chủ",
diff --git a/public/i18n/literals/zh-CN.json b/public/i18n/literals/zh-CN.json
index 8459ae22..da045742 100644
--- a/public/i18n/literals/zh-CN.json
+++ b/public/i18n/literals/zh-CN.json
@@ -1119,6 +1119,7 @@
   "Stop Server": "停止服务器",
   "Stopped": "已停止",
   "Strict Proxy": "严格代理",
+  "Style": "风格",
   "Subagent Model": "子代理模型",
   "Sudo Password Required": "需要 sudo 密码",
   "Sudo password is required": "需要 sudo 密码",
@@ -1312,6 +1313,7 @@
   "disabled": "已禁用",
   "dollars per million tokens": "美元 / 百万 Token",
   "e.g. CwhRBWXzGAHq8TQ4Fs17": "例如 CwhRBWXzGAHq8TQ4Fs17",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "例如：温暖柔和的嗓音，用英式口音缓慢说话",
   "e.g. claude-opus-4-5": "例如 claude-opus-4-5",
   "e.g. my-model-id": "例如 my-model-id",
   "e.g. tts-1-hd": "例如 tts-1-hd",
diff --git a/public/i18n/literals/zh-TW.json b/public/i18n/literals/zh-TW.json
index ea9183eb..f8f41a86 100644
--- a/public/i18n/literals/zh-TW.json
+++ b/public/i18n/literals/zh-TW.json
@@ -12,6 +12,7 @@
   "Logout": "登出",
   "Login": "登錄",
   "Providers": "提供者",
+  "Style": "風格",
   "Usage": "統計",
   "API Key": "API 金鑰",
   "Connected": "已連接",
@@ -176,6 +177,7 @@
   "How it works:": "工作原理：",
   "Antigravity/Copilot IDE request → DNS redirect to localhost:443 → MITM proxy intercepts → 9Router → response to Antigravity/Copilot": "Antigravity/Copilot IDE 請求 → DNS 重定向到 localhost:443 → MITM 代理攔截 → 9Router → 响應到 Antigravity/Copilot",
   "No API keys — create one in Keys page": "沒有 API 金鑰 — 在金鑰頁面中創建一個",
+  "e.g. a warm, gentle voice, speaking slowly with a British accent": "例如：溫暖柔和的嗓音，用英式口音緩慢說話",
   "sk_9router (default)": "sk_9router（默認）",
   "Server started": "服務器已啟動",
   "Failed to start server": "啟動服務器失敗",
diff --git a/src/app/(dashboard)/dashboard/media-providers/[kind]/[id]/components/TtsExampleCard.js b/src/app/(dashboard)/dashboard/media-providers/[kind]/[id]/components/TtsExampleCard.js
index e0191903..a3fb1d32 100644
--- a/src/app/(dashboard)/dashboard/media-providers/[kind]/[id]/components/TtsExampleCard.js
+++ b/src/app/(dashboard)/dashboard/media-providers/[kind]/[id]/components/TtsExampleCard.js
@@ -6,6 +6,7 @@ import { AI_PROVIDERS, getProviderAlias } from "@/shared/constants/providers";
 import { getModelsByProviderId, getModelKind } from "@/shared/constants/models";
 import { useCopyToClipboard } from "@/shared/hooks/useCopyToClipboard";
 import { TTS_PROVIDER_CONFIG } from "@/shared/constants/ttsProviders";
+import { translate } from "@/i18n/runtime";
 import { getTtsVoicesForModel } from "open-sse/config/ttsModels.js";
 import { GOOGLE_TTS_LANGUAGES } from "open-sse/config/googleTtsLanguages.js";
 import { Row } from "./exampleShared";
@@ -40,6 +41,7 @@ export function TtsExampleCard({ providerId }) {
 
   // Form state
   const [input, setInput]               = useState("Hello, this is a text to speech test.");
+  const [style, setStyle]               = useState(""); // style/voice instructions (e.g. MiMo voicedesign)
   const [apiKey, setApiKey]             = useState("");
   const [useTunnel, setUseTunnel]       = useState(false);
   const [localEndpoint, setLocalEndpoint]   = useState("");
@@ -59,8 +61,10 @@ export function TtsExampleCard({ providerId }) {
   const [modalSearch, setModalSearch]       = useState("");
   const [modalError, setModalError]         = useState("");
   const [byLang, setByLang]                 = useState({});
-  // Language hint (e.g. Gemini): controls the spoken language without affecting voice selection
+  // Language hint (e.g. Gemini/MiMo): guides the spoken language without affecting voice selection
   const [languageHint, setLanguageHint]     = useState("");
+  // Number of stored provider connections (shown when no dashboard API key)
+  const [connectionCount, setConnectionCount] = useState(0);
 
   useEffect(() => {
     setLocalEndpoint(window.location.origin);
@@ -68,6 +72,10 @@ export function TtsExampleCard({ providerId }) {
       .then((r) => r.json())
       .then((d) => { setApiKey((d.keys || []).find((k) => k.isActive !== false)?.key || ""); })
       .catch(() => {});
+    fetch("/api/providers", { cache: "no-store" })
+      .then((r) => r.json())
+      .then((d) => { setConnectionCount((d.connections || []).filter((c) => c.provider === providerId && c.isActive !== false).length); })
+      .catch(() => {});
     fetch("/api/tunnel/status")
       .then((r) => r.json())
       .then((d) => { if (d.publicUrl) setTunnelEndpoint(d.publicUrl); })
@@ -111,6 +119,10 @@ export function TtsExampleCard({ providerId }) {
     if (voices.length) {
       setSelectedVoice(voices[0].id);
       setSelectedVoiceName(voices[0].name || voices[0].id);
+    } else {
+      // Model has no preset voices (voicedesign/voiceclone) — drop stale voice
+      setSelectedVoice("");
+      setSelectedVoiceName("");
     }
   }, [selectedModel]);
 
@@ -184,6 +196,7 @@ export function TtsExampleCard({ providerId }) {
   const ttsBody = (() => {
     const b = { model: modelFull, input };
     if (config.hasLanguageHint && languageHint) b.language = languageHint;
+    if (config.hasStyleInput && style.trim()) b.style = style.trim();
     return b;
   })();
   const curlSnippet = `curl -X POST ${endpoint}/v1/audio/speech${responseFormat === "json" ? "?response_format=json" : ""} \\
@@ -218,7 +231,8 @@ export function TtsExampleCard({ providerId }) {
       if (responseFormat === "json") {
         const data = await res.json();
         setJsonResponse(data); // Store full JSON response
-        const audioBlob = await fetch(`data:audio/mp3;base64,${data.audio}`).then(r => r.blob());
+        const format = data.format || "mp3";
+        const audioBlob = await fetch(`data:audio/${format};base64,${data.audio}`).then(r => r.blob());
         setAudioUrl(URL.createObjectURL(audioBlob));
       } else {
         const blob = await res.blob();
@@ -259,7 +273,11 @@ export function TtsExampleCard({ providerId }) {
           </Row>
           <Row label="API Key">
             <span className="px-3 py-1.5 text-sm font-mono text-text-main bg-sidebar rounded-lg truncate block">
-              {apiKey ? `${apiKey.slice(0, 8)}${"•".repeat(Math.min(20, apiKey.length - 8))}` : <span className="text-text-muted italic">No key configured</span>}
+              {apiKey
+                ? `${apiKey.slice(0, 8)}${"•".repeat(Math.min(20, apiKey.length - 8))}`
+                : connectionCount > 0
+                  ? <span className="text-text-muted italic">Using stored key(s) · {connectionCount} connection{connectionCount > 1 ? "s" : ""}</span>
+                  : <span className="text-text-muted italic">No key configured</span>}
             </span>
           </Row>
 
@@ -281,7 +299,7 @@ export function TtsExampleCard({ providerId }) {
             </Row>
           )}
 
-          {/* Language hint dropdown (Gemini) — sends body.language to guide pronunciation */}
+          {/* Language hint dropdown (Gemini, Xiaomi MiMo) — sends body.language to guide pronunciation */}
           {config.hasLanguageHint && (
             <Row label="Language">
               <select
@@ -290,9 +308,11 @@ export function TtsExampleCard({ providerId }) {
                 className="w-full px-3 py-1.5 text-sm border border-border rounded-lg bg-background focus:outline-none focus:border-primary"
               >
                 <option value="">Auto-detect</option>
-                {GOOGLE_TTS_LANGUAGES.map((l) => (
-                  <option key={l.id} value={l.name}>{l.name}</option>
-                ))}
+                {(config.languageOptions || GOOGLE_TTS_LANGUAGES).map((l) =>
+                  typeof l === "string"
+                    ? <option key={l} value={l}>{l}</option>
+                    : <option key={l.id} value={l.name}>{l.name}</option>
+                )}
               </select>
             </Row>
           )}
@@ -320,7 +340,7 @@ export function TtsExampleCard({ providerId }) {
             </Row>
           )}
 
-          {/* Voice chips — shown after language picked (edge-tts, local-device) or always (OpenAI/ElevenLabs) */}
+          {/* Voice chips — shown after language picked (edge-tts, local-device) or always (OpenAI/ElevenLabs/MiMo) */}
           {countryVoices.length > 0 && (
             <Row label="Voice">
               <div className="flex flex-wrap gap-1.5">
@@ -338,7 +358,9 @@ export function TtsExampleCard({ providerId }) {
                         : "border-border text-text-muted hover:text-primary hover:border-primary/40"
                     }`}
                   >
-                    {v.name}{v.gender ? ` · ${v.gender[0].toUpperCase()}` : ""}
+                    {v.name}
+                    {v.language ? ` · ${v.language}` : ""}
+                    {v.gender ? ` · ${v.gender[0].toUpperCase()}` : ""}
                     {v.free_users_allowed === true && (
                       <span className="ml-1.5 px-1 py-0.5 text-[9px] font-semibold rounded bg-green-500/15 text-green-600 border border-green-500/20">Free</span>
                     )}
@@ -418,6 +440,30 @@ export function TtsExampleCard({ providerId }) {
             </div>
           </Row>
 
+          {/* Style / voice instructions (Xiaomi MiMo) */}
+          {config.hasStyleInput && (
+            <Row label={translate("Style")}>
+              <div className="relative">
+                <textarea
+                  value={style}
+                  onChange={(e) => setStyle(e.target.value)}
+                  placeholder={translate("e.g. a warm, gentle voice, speaking slowly with a British accent")}
+                  rows={2}
+                  className="w-full px-3 py-1.5 pr-7 text-sm border border-border rounded-lg bg-background focus:outline-none focus:border-primary resize-none"
+                />
+                {style && (
+                  <button
+                    type="button"
+                    onClick={() => setStyle("")}
+                    className="absolute right-2 top-1/2 -translate-y-1/2 text-text-muted hover:text-primary transition-colors"
+                  >
+                    <span className="material-symbols-outlined text-[14px]">close</span>
+                  </button>
+                )}
+              </div>
+            </Row>
+          )}
+
           {/* Output Format */}
           <Row label="Output Format">
             <select
diff --git a/src/shared/constants/ttsProviders.js b/src/shared/constants/ttsProviders.js
index f1b990d3..a4f2544d 100644
--- a/src/shared/constants/ttsProviders.js
+++ b/src/shared/constants/ttsProviders.js
@@ -135,4 +135,16 @@ export const TTS_PROVIDER_CONFIG = {
     voiceKey: "gemini-tts-voices",
     voicesPerModel: true,
   },
+  "xiaomi-mimo": {
+    hasLanguageDropdown: false,
+    hasModelSelector: true,
+    hasBrowseButton: false,
+    hasVoiceIdInput: false,
+    hasStyleInput: true, // style/voice instructions (role: user)
+    hasLanguageHint: true, // language dropdown (Auto-detect default); voices are language-independent
+    languageOptions: ["Chinese", "English"],
+    voiceSource: "hardcoded",
+    modelKey: "xiaomi-mimo-tts-models",
+    voicesPerModel: true,
+  },
 };
diff --git a/src/sse/handlers/tts.js b/src/sse/handlers/tts.js
index 828d45b6..539c8c7c 100644
--- a/src/sse/handlers/tts.js
+++ b/src/sse/handlers/tts.js
@@ -30,6 +30,7 @@ export async function handleTts(request) {
   const modelStr = body.model;
   const responseFormat = url.searchParams.get("response_format") || "mp3"; // mp3 (default) | json
   const language = body.language || ""; // Optional language hint (currently used by Gemini)
+  const style = body.style || ""; // Optional style/voice instructions (e.g. Xiaomi MiMo)
   log.request("POST", `${url.pathname} | ${modelStr} | format=${responseFormat}${language ? ` | lang=${language}` : ""}`);
 
   const settings = await getSettings();
@@ -53,7 +54,7 @@ export async function handleTts(request) {
     return handleComboChat({
       body,
       models: comboModels,
-      handleSingleModel: (b, m) => handleSingleModelTts(b, m, responseFormat, language),
+      handleSingleModel: (b, m) => handleSingleModelTts(b, m, responseFormat, language, style),
       log,
       comboName: modelStr,
       comboStrategy,
@@ -61,10 +62,10 @@ export async function handleTts(request) {
     });
   }
 
-  return handleSingleModelTts(body, modelStr, responseFormat, language);
+  return handleSingleModelTts(body, modelStr, responseFormat, language, style);
 }
 
-async function handleSingleModelTts(body, modelStr, responseFormat, language) {
+async function handleSingleModelTts(body, modelStr, responseFormat, language, style) {
   const modelInfo = await getModelInfo(modelStr);
   if (!modelInfo.provider) return errorResponse(HTTP_STATUS.BAD_REQUEST, "Invalid model format");
 
@@ -73,7 +74,7 @@ async function handleSingleModelTts(body, modelStr, responseFormat, language) {
 
   // noAuth providers — no credential needed
   if (!CREDENTIALED_PROVIDERS.has(provider)) {
-    const result = await handleTtsCore({ provider, model, input: body.input, responseFormat, language });
+    const result = await handleTtsCore({ provider, model, input: body.input, responseFormat, language, style });
     if (result.success) return result.response;
     return errorResponse(result.status || HTTP_STATUS.BAD_GATEWAY, result.error || "TTS failed");
   }
@@ -98,7 +99,7 @@ async function handleSingleModelTts(body, modelStr, responseFormat, language) {
 
     log.info("AUTH", `\x1b[32mUsing ${provider} account: ${credentials.connectionName}\x1b[0m`);
 
-    const result = await handleTtsCore({ provider, model, input: body.input, credentials, responseFormat, language });
+    const result = await handleTtsCore({ provider, model, input: body.input, credentials, responseFormat, language, style });
 
     if (result.success) return result.response;
 
diff --git a/tests/unit/xiaomi-mimo-tts.test.js b/tests/unit/xiaomi-mimo-tts.test.js
new file mode 100644
index 00000000..d204be42
--- /dev/null
+++ b/tests/unit/xiaomi-mimo-tts.test.js
@@ -0,0 +1,150 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { handleTtsCore } from "../../open-sse/handlers/ttsCore.js";
+import { buildTtsProviderModels, getTtsVoicesForModel } from "../../open-sse/config/ttsModels.js";
+import { AI_PROVIDERS } from "../../src/shared/constants/providers.js";
+import { getTtsAdapter } from "../../open-sse/handlers/ttsProviders/index.js";
+import { PROVIDER_MODELS } from "../../open-sse/config/providerModels.js";
+import { TTS_PROVIDER_CONFIG } from "../../src/shared/constants/ttsProviders.js";
+
+const originalFetch = global.fetch;
+
+function mockMiMoAudioResponse() {
+  global.fetch.mockResolvedValueOnce(
+    new Response(
+      JSON.stringify({
+        choices: [
+          {
+            message: {
+              role: "assistant",
+              audio: {
+                data: Buffer.from([0, 1, 2, 3]).toString("base64"),
+                format: "wav",
+                transcript: "Hello from MiMo",
+              },
+            },
+          },
+        ],
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } }
+    )
+  );
+}
+
+describe("Xiaomi MiMo TTS", () => {
+  beforeEach(() => {
+    global.fetch = vi.fn();
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+  });
+
+  it("posts to chat completions with text as assistant message and voice in audio.voice", async () => {
+    mockMiMoAudioResponse();
+
+    const result = await handleTtsCore({
+      provider: "xiaomi-mimo",
+      model: "mimo-v2.5-tts/冰糖",
+      input: "Hello from MiMo",
+      credentials: { apiKey: "test-key" },
+      responseFormat: "json",
+    });
+
+    expect(result.success).toBe(true);
+    expect(global.fetch.mock.calls[0][0]).toBe("https://api.xiaomimimo.com/v1/chat/completions");
+    expect(global.fetch.mock.calls[0][1].headers.Authorization).toBe("Bearer test-key");
+
+    const sent = JSON.parse(global.fetch.mock.calls[0][1].body);
+    expect(sent.model).toBe("mimo-v2.5-tts");
+    expect(sent.stream).toBe(false);
+    expect(sent.audio.format).toBe("wav");
+    expect(sent.audio.voice).toBe("冰糖");
+    const assistant = sent.messages.find((m) => m.role === "assistant");
+    expect(assistant.content).toBe("Hello from MiMo");
+
+    const body = await result.response.json();
+    expect(body.format).toBe("wav");
+    expect(body.audio).toEqual(expect.any(String));
+  });
+
+  it("uses mimo_default when no voice is provided", async () => {
+    mockMiMoAudioResponse();
+
+    await handleTtsCore({
+      provider: "xiaomi-mimo",
+      model: "mimo-v2.5-tts",
+      input: "Hello from MiMo",
+      credentials: { apiKey: "test-key" },
+      responseFormat: "json",
+    });
+
+    const sent = JSON.parse(global.fetch.mock.calls[0][1].body);
+    expect(sent.model).toBe("mimo-v2.5-tts");
+    expect(sent.audio.voice).toBe("mimo_default");
+  });
+
+  it("threads the style field into the role:user message", async () => {
+    mockMiMoAudioResponse();
+
+    await handleTtsCore({
+      provider: "xiaomi-mimo",
+      model: "mimo-v2.5-tts/Chloe",
+      input: "Hello from MiMo",
+      style: "a calm, warm female voice speaking slowly",
+      credentials: { apiKey: "test-key" },
+      responseFormat: "json",
+    });
+
+    const sent = JSON.parse(global.fetch.mock.calls[0][1].body);
+    const user = sent.messages.find((m) => m.role === "user");
+    expect(user.content).toBe("a calm, warm female voice speaking slowly");
+  });
+
+  it("exposes MiMo TTS models + preset voices in the TTS catalog", () => {
+    const entries = buildTtsProviderModels();
+
+    expect(entries["xiaomi-mimo-tts-models"].map((model) => model.id)).toEqual(["mimo-v2.5-tts"]);
+
+    const voices = getTtsVoicesForModel("xiaomi-mimo", "mimo-v2.5-tts");
+    expect(voices.map((v) => v.id)).toEqual([
+      "mimo_default", "冰糖", "茉莉", "苏打", "白桦", "Mia", "Chloe", "Milo", "Dean",
+    ]);
+    expect(voices.find((v) => v.id === "冰糖")).toMatchObject({ name: "冰糖" });
+    expect(voices.find((v) => v.id === "Dean")).toMatchObject({ name: "Dean" });
+    // Voices are language-independent and gender-neutral (no language/gender labels in the UI)
+    expect(voices[0]).not.toHaveProperty("language");
+    expect(voices[0]).not.toHaveProperty("gender");
+    expect(getTtsVoicesForModel("xiaomi-mimo", "mimo-v2.5-tts-voiceclone")).toBeNull();
+  });
+
+  it("threads the language hint into a role:user instruction", async () => {
+    mockMiMoAudioResponse();
+
+    await handleTtsCore({
+      provider: "xiaomi-mimo",
+      model: "mimo-v2.5-tts/冰糖",
+      input: "Hello from MiMo",
+      language: "English",
+      credentials: { apiKey: "test-key" },
+      responseFormat: "json",
+    });
+
+    const sent = JSON.parse(global.fetch.mock.calls[0][1].body);
+    const user = sent.messages.find((m) => m.role === "user");
+    expect(user.content).toBe("Speak in English.");
+  });
+
+  it("wires the provider into media-providers TTS (serviceKind, adapter, UI config)", () => {
+    expect(AI_PROVIDERS["xiaomi-mimo"].serviceKinds).toContain("tts");
+    expect(AI_PROVIDERS["xiaomi-mimo"].ttsConfig.baseUrl).toBe("https://api.xiaomimimo.com/v1/chat/completions");
+    expect(getTtsAdapter("xiaomi-mimo")).toBeTruthy();
+
+    const ttsModels = PROVIDER_MODELS["xiaomi-mimo"].filter((m) => (m.kind || m.type) === "tts").map((m) => m.id);
+    expect(ttsModels).toEqual(["mimo-v2.5-tts"]);
+
+    expect(TTS_PROVIDER_CONFIG["xiaomi-mimo"].hasStyleInput).toBe(true);
+    expect(TTS_PROVIDER_CONFIG["xiaomi-mimo"].hasLanguageHint).toBe(true);
+    expect(TTS_PROVIDER_CONFIG["xiaomi-mimo"].languageOptions).toEqual(["Chinese", "English"]);
+    expect(TTS_PROVIDER_CONFIG["xiaomi-mimo"].hasVoiceIdInput).toBe(false);
+  });
+});

From 25e4bf1c6c9f1db7d5031727b4a3a3c655178a3b Mon Sep 17 00:00:00 2001
From: Matt Van Horn <455140+mvanhorn@users.noreply.github.com>
Date: Wed, 5 Aug 2026 11:49:45 +0700
Subject: [PATCH 22/42] fix(cli): include complete API artifacts in CLI package

Merge the complete generated .next-cli-build/server tree into the
packaged CLI after the standalone copy, since Next's standalone output
is trace-pruned and can omit route modules (e.g. /api/v1/messages) or
chunks loaded dynamically. Add a post-copy integrity check for the
required API route artifacts so an incomplete package fails during
pack:cli instead of at runtime.

Fixes #2945
---
 cli/scripts/build-cli.js               | 451 ++++++++++++++-----------
 tests/unit/cli-build-artifacts.test.js | 141 ++++++++
 2 files changed, 400 insertions(+), 192 deletions(-)
 create mode 100644 tests/unit/cli-build-artifacts.test.js

diff --git a/cli/scripts/build-cli.js b/cli/scripts/build-cli.js
index 3af3120f..d4e4d279 100644
--- a/cli/scripts/build-cli.js
+++ b/cli/scripts/build-cli.js
@@ -81,205 +81,272 @@ function copyRecursive(src, dest) {
   }
 }
 
-console.log("📦 Building 9Router CLI package with Next.js...\n");
+function resolveStandaloneBuild(appDir, buildDistDir) {
+  const legacyStandaloneRoot = path.join(appDir, ".next", "standalone");
+  const resolvedStandaloneRoot = path.join(buildDistDir, "standalone");
+  let standaloneRoot = fs.existsSync(resolvedStandaloneRoot)
+    ? resolvedStandaloneRoot
+    : legacyStandaloneRoot;
 
-fs.mkdirSync(buildHomeDir, { recursive: true });
-fs.mkdirSync(path.join(buildHomeDir, "AppData", "Roaming"), { recursive: true });
-fs.mkdirSync(path.join(buildHomeDir, "AppData", "Local"), { recursive: true });
-
-// Step 0: Sync version from app/cli/package.json to app/package.json
-console.log("0️⃣  Syncing version to app/package.json...");
-const cliPkg = JSON.parse(fs.readFileSync(path.join(cliDir, "package.json"), "utf8"));
-const appPkgPath = path.join(appDir, "package.json");
-const appPkg = JSON.parse(fs.readFileSync(appPkgPath, "utf8"));
-if (appPkg.version !== cliPkg.version) {
-  appPkg.version = cliPkg.version;
-  fs.writeFileSync(appPkgPath, JSON.stringify(appPkg, null, 2) + "\n");
-  console.log(`✅ Version synced: ${cliPkg.version}\n`);
-} else {
-  console.log(`✅ Version already synced: ${cliPkg.version}\n`);
-}
-
-// Step 1: Build app with Next.js (workspace tracing root → traced node_modules in standalone).
-console.log("1️⃣  Building Next.js app...");
-try {
-  execSync("npm run build", {
-    stdio: "inherit",
-    cwd: appDir,
-    env: {
-      ...process.env,
-      HOME: buildHomeDir,
-      USERPROFILE: buildHomeDir,
-      APPDATA: path.join(buildHomeDir, "AppData", "Roaming"),
-      LOCALAPPDATA: path.join(buildHomeDir, "AppData", "Local"),
-      NEXT_DIST_DIR: buildDistDirName,
-      NEXT_TRACING_ROOT_MODE: "workspace",
-    }
-  });
-  console.log("✅ Next.js build completed\n");
-} catch (error) {
-  console.error("❌ Next.js build failed");
-  process.exit(1);
-}
-
-// Step 2: Clean old app/cli/app if exists
-console.log("2️⃣  Cleaning old app/cli/app...");
-if (fs.existsSync(cliAppDir)) {
-  fs.rmSync(cliAppDir, { recursive: true, force: true });
-}
-console.log("✅ Cleaned\n");
-
-// Step 3: Copy Next.js standalone build to app/cli/app.
-// Newer Next.js standalone output writes server.js/package.json plus .next/, src/, and
-// node_modules/ directly under .next/standalone. Older builds may still use a nested app/.
-console.log("3️⃣  Copying Next.js standalone build to app/cli/app...");
-const standaloneRoot = path.join(appDir, ".next", "standalone");
-const standaloneRootResolved = path.join(buildDistDir, "standalone");
-let standaloneRootToUse = fs.existsSync(standaloneRootResolved) ? standaloneRootResolved : standaloneRoot;
-// Next.js 16 nests standalone output under the project name when NEXT_TRACING_ROOT_MODE=workspace
-// e.g. .next-cli-build/standalone/9router/server.js
-const pkgName = path.basename(appDir);
-const nestedRoot = path.join(standaloneRootToUse, pkgName);
-if (fs.existsSync(path.join(nestedRoot, "server.js")) && !fs.existsSync(path.join(standaloneRootToUse, "server.js"))) {
-  console.log(`ℹ️  Detected nested standalone output: ${pkgName}/`);
-  standaloneRootToUse = nestedRoot;
-}
-const standaloneApp = fs.existsSync(path.join(standaloneRootToUse, "server.js"))
-  ? standaloneRootToUse
-  : path.join(standaloneRootToUse, "app");
-if (!fs.existsSync(standaloneApp)) {
-  console.error("❌ Next.js standalone build not found under .next/standalone");
-  console.error("Expected either .next/standalone/server.js or .next/standalone/app/");
-  process.exit(1);
-}
-copyRecursive(standaloneApp, cliAppDir);
-
-// Older nested-app layout stores traced node_modules at standalone root.
-const standaloneNodeModules = path.join(standaloneRootToUse, "node_modules");
-if (standaloneApp !== standaloneRootToUse && fs.existsSync(standaloneNodeModules)) {
-  copyRecursive(standaloneNodeModules, path.join(cliAppDir, "node_modules"));
-}
-console.log("✅ Copied standalone build\n");
-
-// Step 3a: Copy custom server (injects real socket IP, strips spoofable XFF).
-const customServerSrc = path.join(appDir, "custom-server.js");
-if (fs.existsSync(customServerSrc)) {
-  fs.copyFileSync(customServerSrc, path.join(cliAppDir, "custom-server.js"));
-  console.log("✅ Copied custom-server.js\n");
-} else {
-  console.warn("⚠️  custom-server.js not found — server will run without real-IP injection\n");
-}
-
-// Step 3b: Ensure sql.js (pure JS fallback) bundled in app/cli/app/node_modules.
-// Strip better-sqlite3 (native) — it lives in ~/.9router/runtime to avoid
-// Windows EBUSY during global CLI updates. node:sqlite (Node ≥22.5) is also
-// available as a no-install middle tier.
-console.log("3️⃣ b Configuring SQLite drivers...");
-function ensureModuleInBundle(pkg) {
-  const dest = path.join(cliAppDir, "node_modules", pkg);
-  if (fs.existsSync(dest)) {
-    console.log(`✅ ${pkg} already bundled`);
-    return;
+  // Next.js 16 nests standalone output under the project name when
+  // NEXT_TRACING_ROOT_MODE=workspace, e.g. standalone/9router/server.js.
+  const pkgName = path.basename(appDir);
+  const nestedRoot = path.join(standaloneRoot, pkgName);
+  if (fs.existsSync(path.join(nestedRoot, "server.js")) && !fs.existsSync(path.join(standaloneRoot, "server.js"))) {
+    console.log(`ℹ️  Detected nested standalone output: ${pkgName}/`);
+    standaloneRoot = nestedRoot;
   }
-  const candidates = [
-    path.join(appDir, "node_modules", pkg),
-    path.join(rootDir, "node_modules", pkg),
+
+  const standaloneApp = fs.existsSync(path.join(standaloneRoot, "server.js"))
+    ? standaloneRoot
+    : path.join(standaloneRoot, "app");
+  if (!fs.existsSync(standaloneApp)) {
+    throw new Error(
+      "Next.js standalone build not found under .next/standalone; " +
+      "expected either .next/standalone/server.js or .next/standalone/app/",
+    );
+  }
+
+  return { standaloneApp, standaloneRoot };
+}
+
+function copyStandaloneBuild(appDir, buildDistDir, cliAppDir) {
+  const { standaloneApp, standaloneRoot } = resolveStandaloneBuild(appDir, buildDistDir);
+  copyRecursive(standaloneApp, cliAppDir);
+
+  // Older nested-app layout stores traced node_modules at standalone root.
+  const standaloneNodeModules = path.join(standaloneRoot, "node_modules");
+  if (standaloneApp !== standaloneRoot && fs.existsSync(standaloneNodeModules)) {
+    copyRecursive(standaloneNodeModules, path.join(cliAppDir, "node_modules"));
+  }
+}
+
+function mergeServerArtifacts(buildDistDir, cliAppDir) {
+  const serverSrc = path.join(buildDistDir, "server");
+  const serverDest = path.join(cliAppDir, buildDistDirName, "server");
+  if (!fs.existsSync(serverSrc)) {
+    throw new Error(`Complete Next.js server build not found: ${serverSrc}`);
+  }
+  copyRecursive(serverSrc, serverDest);
+}
+
+function assertRequiredApiArtifacts(cliAppDir) {
+  const requiredArtifacts = [
+    "app/api/v1/chat/completions/route.js",
+    "app/api/v1/messages/route.js",
   ];
-  const src = candidates.find((p) => fs.existsSync(p));
-  if (!src) {
-    console.warn(`⚠️  ${pkg} not found locally — bundle will rely on node:sqlite or runtime install`);
-    return;
+  const serverDir = path.join(cliAppDir, buildDistDirName, "server");
+  const missingArtifacts = requiredArtifacts
+    .map((artifact) => path.join(serverDir, artifact))
+    .filter((artifact) => !fs.existsSync(artifact));
+
+  if (missingArtifacts.length > 0) {
+    throw new Error(
+      `Required CLI API route artifact${missingArtifacts.length === 1 ? " is" : "s are"} missing:\n` +
+      missingArtifacts.join("\n"),
+    );
   }
-  fs.mkdirSync(path.dirname(dest), { recursive: true });
-  copyRecursive(src, dest);
-  console.log(`✅ Bundled ${pkg}`);
-}
-ensureModuleInBundle("sql.js");
-// `open` is external (see serverExternalPackages in next.config.mjs), so it must exist in
-// the bundle's node_modules or every importer throws MODULE_NOT_FOUND at runtime. Output
-// tracing normally copies it; this is the same belt-and-braces guard used for sql.js.
-ensureModuleInBundle("open");
-const betterDir = path.join(cliAppDir, "node_modules", "better-sqlite3");
-if (fs.existsSync(betterDir)) {
-  fs.rmSync(betterDir, { recursive: true, force: true });
-  console.log("✅ Stripped better-sqlite3 (lives in ~/.9router/runtime)");
-}
-console.log("");
-
-// Step 4: Copy static files
-console.log("4️⃣  Copying static files...");
-const staticSrc = path.join(appDir, ".next", "static");
-const staticSrcResolved = path.join(buildDistDir, "static");
-const staticDest = path.join(cliAppDir, buildDistDirName, "static");
-if (fs.existsSync(staticSrcResolved) || fs.existsSync(staticSrc)) {
-  copyRecursive(fs.existsSync(staticSrcResolved) ? staticSrcResolved : staticSrc, staticDest);
-  console.log("✅ Copied static files\n");
-} else {
-  console.log("⏭️  No static files found\n");
 }
 
-// Step 5: Copy public folder if exists
-console.log("5️⃣  Copying public folder...");
-const publicSrc = path.join(appDir, "public");
-const publicDest = path.join(cliAppDir, "public");
-if (fs.existsSync(publicSrc)) {
-  copyRecursive(publicSrc, publicDest);
-  console.log("✅ Copied public folder\n");
-} else {
-  console.log("⏭️  No public folder found\n");
+function buildCliPackage() {
+  console.log("📦 Building 9Router CLI package with Next.js...\n");
+
+  fs.mkdirSync(buildHomeDir, { recursive: true });
+  fs.mkdirSync(path.join(buildHomeDir, "AppData", "Roaming"), { recursive: true });
+  fs.mkdirSync(path.join(buildHomeDir, "AppData", "Local"), { recursive: true });
+
+  // Step 0: Sync version from app/cli/package.json to app/package.json
+  console.log("0️⃣  Syncing version to app/package.json...");
+  const cliPkg = JSON.parse(fs.readFileSync(path.join(cliDir, "package.json"), "utf8"));
+  const appPkgPath = path.join(appDir, "package.json");
+  const appPkg = JSON.parse(fs.readFileSync(appPkgPath, "utf8"));
+  if (appPkg.version !== cliPkg.version) {
+    appPkg.version = cliPkg.version;
+    fs.writeFileSync(appPkgPath, JSON.stringify(appPkg, null, 2) + "\n");
+    console.log(`✅ Version synced: ${cliPkg.version}\n`);
+  } else {
+    console.log(`✅ Version already synced: ${cliPkg.version}\n`);
+  }
+
+  // Step 1: Build app with Next.js (workspace tracing root → traced node_modules in standalone).
+  console.log("1️⃣  Building Next.js app...");
+  try {
+    execSync("npm run build", {
+      stdio: "inherit",
+      cwd: appDir,
+      env: {
+        ...process.env,
+        HOME: buildHomeDir,
+        USERPROFILE: buildHomeDir,
+        APPDATA: path.join(buildHomeDir, "AppData", "Roaming"),
+        LOCALAPPDATA: path.join(buildHomeDir, "AppData", "Local"),
+        NEXT_DIST_DIR: buildDistDirName,
+        NEXT_TRACING_ROOT_MODE: "workspace",
+      }
+    });
+    console.log("✅ Next.js build completed\n");
+  } catch (error) {
+    console.error("❌ Next.js build failed");
+    process.exit(1);
+  }
+
+  // Step 2: Clean old app/cli/app if exists
+  console.log("2️⃣  Cleaning old app/cli/app...");
+  if (fs.existsSync(cliAppDir)) {
+    fs.rmSync(cliAppDir, { recursive: true, force: true });
+  }
+  console.log("✅ Cleaned\n");
+
+  // Step 3: Copy Next.js standalone build to app/cli/app.
+  // Newer Next.js standalone output writes server.js/package.json plus .next/, src/, and
+  // node_modules/ directly under .next/standalone. Older builds may still use a nested app/.
+  console.log("3️⃣  Copying Next.js standalone build to app/cli/app...");
+  try {
+    copyStandaloneBuild(appDir, buildDistDir, cliAppDir);
+  } catch (error) {
+    console.error("❌ Next.js standalone build not found under .next/standalone");
+    console.error("Expected either .next/standalone/server.js or .next/standalone/app/");
+    process.exit(1);
+  }
+  console.log("✅ Copied standalone build\n");
+
+  // Step 3a: Copy custom server (injects real socket IP, strips spoofable XFF).
+  const customServerSrc = path.join(appDir, "custom-server.js");
+  if (fs.existsSync(customServerSrc)) {
+    fs.copyFileSync(customServerSrc, path.join(cliAppDir, "custom-server.js"));
+    console.log("✅ Copied custom-server.js\n");
+  } else {
+    console.warn("⚠️  custom-server.js not found — server will run without real-IP injection\n");
+  }
+
+  // Step 3b: Ensure sql.js (pure JS fallback) bundled in app/cli/app/node_modules.
+  // Strip better-sqlite3 (native) — it lives in ~/.9router/runtime to avoid
+  // Windows EBUSY during global CLI updates. node:sqlite (Node ≥22.5) is also
+  // available as a no-install middle tier.
+  console.log("3️⃣ b Configuring SQLite drivers...");
+  function ensureModuleInBundle(pkg) {
+    const dest = path.join(cliAppDir, "node_modules", pkg);
+    if (fs.existsSync(dest)) {
+      console.log(`✅ ${pkg} already bundled`);
+      return;
+    }
+    const candidates = [
+      path.join(appDir, "node_modules", pkg),
+      path.join(rootDir, "node_modules", pkg),
+    ];
+    const src = candidates.find((p) => fs.existsSync(p));
+    if (!src) {
+      console.warn(`⚠️  ${pkg} not found locally — bundle will rely on node:sqlite or runtime install`);
+      return;
+    }
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    copyRecursive(src, dest);
+    console.log(`✅ Bundled ${pkg}`);
+  }
+  ensureModuleInBundle("sql.js");
+  // `open` is external (see serverExternalPackages in next.config.mjs), so it must exist in
+  // the bundle's node_modules or every importer throws MODULE_NOT_FOUND at runtime. Output
+  // tracing normally copies it; this is the same belt-and-braces guard used for sql.js.
+  ensureModuleInBundle("open");
+  const betterDir = path.join(cliAppDir, "node_modules", "better-sqlite3");
+  if (fs.existsSync(betterDir)) {
+    fs.rmSync(betterDir, { recursive: true, force: true });
+    console.log("✅ Stripped better-sqlite3 (lives in ~/.9router/runtime)");
+  }
+  console.log("");
+
+  // Step 4: Copy static files
+  console.log("4️⃣  Copying static files...");
+  const staticSrc = path.join(appDir, ".next", "static");
+  const staticSrcResolved = path.join(buildDistDir, "static");
+  const staticDest = path.join(cliAppDir, buildDistDirName, "static");
+  if (fs.existsSync(staticSrcResolved) || fs.existsSync(staticSrc)) {
+    copyRecursive(fs.existsSync(staticSrcResolved) ? staticSrcResolved : staticSrc, staticDest);
+    console.log("✅ Copied static files\n");
+  } else {
+    console.log("⏭️  No static files found\n");
+  }
+
+  // Step 5: Copy public folder if exists
+  console.log("5️⃣  Copying public folder...");
+  const publicSrc = path.join(appDir, "public");
+  const publicDest = path.join(cliAppDir, "public");
+  if (fs.existsSync(publicSrc)) {
+    copyRecursive(publicSrc, publicDest);
+    console.log("✅ Copied public folder\n");
+  } else {
+    console.log("⏭️  No public folder found\n");
+  }
+
+  // Step 6: Copy vendor-chunks (required for production)
+  console.log("6️⃣  Copying vendor-chunks...");
+  const vendorChunksSrc = path.join(appDir, ".next", "server", "vendor-chunks");
+  const vendorChunksSrcResolved = path.join(buildDistDir, "server", "vendor-chunks");
+  const vendorChunksDest = path.join(cliAppDir, buildDistDirName, "server", "vendor-chunks");
+  if (fs.existsSync(vendorChunksSrcResolved) || fs.existsSync(vendorChunksSrc)) {
+    copyRecursive(fs.existsSync(vendorChunksSrcResolved) ? vendorChunksSrcResolved : vendorChunksSrc, vendorChunksDest);
+    console.log("✅ Copied vendor-chunks\n");
+  } else {
+    console.log("⏭️  No vendor-chunks found\n");
+  }
+
+  // Step 6b: Merge the complete generated server tree. Next.js standalone output
+  // is trace-pruned and can omit route modules or chunks loaded dynamically.
+  console.log("6️⃣ b Copying complete server artifacts...");
+  mergeServerArtifacts(buildDistDir, cliAppDir);
+  assertRequiredApiArtifacts(cliAppDir);
+  console.log("✅ Copied complete server artifacts\n");
+
+  // Step 7: Copy MITM server files (not bundled by Next.js standalone)
+  console.log("7️⃣  Copying MITM server files...");
+  const mitmSrc = path.join(appDir, "src", "mitm");
+  const mitmDest = path.join(cliAppDir, "src", "mitm");
+  if (fs.existsSync(mitmSrc)) {
+    copyRecursive(mitmSrc, mitmDest);
+    console.log("✅ Copied MITM files\n");
+  } else {
+    console.log("⏭️  No MITM files found\n");
+  }
+
+  // Step 7b: Copy standalone updater (headless Node process for install progress)
+  console.log("7️⃣ b Copying updater files...");
+  const updaterSrc = path.join(appDir, "src", "lib", "updater");
+  const updaterDest = path.join(cliAppDir, "src", "lib", "updater");
+  if (fs.existsSync(updaterSrc)) {
+    copyRecursive(updaterSrc, updaterDest);
+    console.log("✅ Copied updater files\n");
+  } else {
+    console.log("⏭️  No updater files found\n");
+  }
+
+  // Step 8: Build MITM server (config driven - see app/cli/scripts/buildMitm.js)
+  console.log("8️⃣  Building MITM server...");
+  try {
+    execSync("node scripts/buildMitm.js", { stdio: "inherit", cwd: cliDir });
+    console.log("✅ MITM server build completed\n");
+  } catch (error) {
+    console.error("❌ MITM build failed");
+    process.exit(1);
+  }
+
+  console.log("✨ CLI package build completed!");
+  console.log(`📁 Output: ${cliAppDir}`);
+
+  try {
+    const { execSync: exec } = require("child_process");
+    const size = exec(`du -sh "${cliAppDir}"`, { encoding: "utf8" }).trim();
+    console.log(`📊 Package size: ${size.split("\t")[0]}`);
+  } catch (e) {
+    // Silent fail on size check
+  }
 }
 
-// Step 6: Copy vendor-chunks (required for production)
-console.log("6️⃣  Copying vendor-chunks...");
-const vendorChunksSrc = path.join(appDir, ".next", "server", "vendor-chunks");
-const vendorChunksSrcResolved = path.join(buildDistDir, "server", "vendor-chunks");
-const vendorChunksDest = path.join(cliAppDir, buildDistDirName, "server", "vendor-chunks");
-if (fs.existsSync(vendorChunksSrcResolved) || fs.existsSync(vendorChunksSrc)) {
-  copyRecursive(fs.existsSync(vendorChunksSrcResolved) ? vendorChunksSrcResolved : vendorChunksSrc, vendorChunksDest);
-  console.log("✅ Copied vendor-chunks\n");
-} else {
-  console.log("⏭️  No vendor-chunks found\n");
-}
+module.exports = {
+  assertRequiredApiArtifacts,
+  copyStandaloneBuild,
+  mergeServerArtifacts,
+};
 
-// Step 7: Copy MITM server files (not bundled by Next.js standalone)
-console.log("7️⃣  Copying MITM server files...");
-const mitmSrc = path.join(appDir, "src", "mitm");
-const mitmDest = path.join(cliAppDir, "src", "mitm");
-if (fs.existsSync(mitmSrc)) {
-  copyRecursive(mitmSrc, mitmDest);
-  console.log("✅ Copied MITM files\n");
-} else {
-  console.log("⏭️  No MITM files found\n");
-}
-
-// Step 7b: Copy standalone updater (headless Node process for install progress)
-console.log("7️⃣ b Copying updater files...");
-const updaterSrc = path.join(appDir, "src", "lib", "updater");
-const updaterDest = path.join(cliAppDir, "src", "lib", "updater");
-if (fs.existsSync(updaterSrc)) {
-  copyRecursive(updaterSrc, updaterDest);
-  console.log("✅ Copied updater files\n");
-} else {
-  console.log("⏭️  No updater files found\n");
-}
-
-// Step 8: Build MITM server (config driven - see app/cli/scripts/buildMitm.js)
-console.log("8️⃣  Building MITM server...");
-try {
-  execSync("node scripts/buildMitm.js", { stdio: "inherit", cwd: cliDir });
-  console.log("✅ MITM server build completed\n");
-} catch (error) {
-  console.error("❌ MITM build failed");
-  process.exit(1);
-}
-
-console.log("✨ CLI package build completed!");
-console.log(`📁 Output: ${cliAppDir}`);
-
-try {
-  const { execSync: exec } = require("child_process");
-  const size = exec(`du -sh "${cliAppDir}"`, { encoding: "utf8" }).trim();
-  console.log(`📊 Package size: ${size.split("\t")[0]}`);
-} catch (e) {
-  // Silent fail on size check
+if (require.main === module) {
+  buildCliPackage();
 }
diff --git a/tests/unit/cli-build-artifacts.test.js b/tests/unit/cli-build-artifacts.test.js
new file mode 100644
index 00000000..0644a1cd
--- /dev/null
+++ b/tests/unit/cli-build-artifacts.test.js
@@ -0,0 +1,141 @@
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+let testApi;
+try {
+  testApi = await import("vitest");
+} catch (error) {
+  if (error.code !== "ERR_MODULE_NOT_FOUND") throw error;
+  testApi = await import("node:test");
+}
+const { afterEach, describe, it } = testApi;
+
+const require = createRequire(import.meta.url);
+const {
+  assertRequiredApiArtifacts,
+  copyStandaloneBuild,
+  mergeServerArtifacts,
+} = require("../../cli/scripts/build-cli.js");
+
+const tempDirs = [];
+
+function createTempDir() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "9router-cli-build-"));
+  tempDirs.push(tempDir);
+  return tempDir;
+}
+
+function writeFixture(root, relativePath, contents = relativePath) {
+  const filePath = path.join(root, relativePath);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, contents);
+  return filePath;
+}
+
+function createCompleteServer(buildDistDir) {
+  const serverDir = path.join(buildDistDir, "server");
+  writeFixture(serverDir, "app/api/v1/chat/completions/route.js", "chat route");
+  writeFixture(serverDir, "app/api/v1/messages/route.js", "messages route");
+  writeFixture(serverDir, "chunks/openai-provider.js", "openai chunk");
+  writeFixture(serverDir, "chunks/anthropic-provider.js", "anthropic chunk");
+  return serverDir;
+}
+
+afterEach(() => {
+  for (const tempDir of tempDirs.splice(0)) {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+describe("CLI build server artifacts", () => {
+  for (const { name, standalonePath } of [
+    {
+      name: "legacy nested app",
+      standalonePath: (appDir, buildDistDir) => path.join(appDir, ".next", "standalone", "app"),
+    },
+    {
+      name: "Next 16 workspace",
+      standalonePath: (appDir, buildDistDir) => path.join(buildDistDir, "standalone", path.basename(appDir)),
+    },
+  ]) {
+    it(`merges complete API routes and provider chunks for the ${name} layout`, () => {
+      const root = createTempDir();
+      const appDir = path.join(root, "9router");
+      const buildDistDir = path.join(appDir, ".next-cli-build");
+      const cliAppDir = path.join(root, "cli-app");
+      const standaloneDir = standalonePath(appDir, buildDistDir);
+
+      writeFixture(standaloneDir, "server.js", "standalone server");
+      writeFixture(
+        standaloneDir,
+        ".next-cli-build/server/app/api/v1/chat/completions/route.js",
+        "standalone chat route",
+      );
+      createCompleteServer(buildDistDir);
+
+      copyStandaloneBuild(appDir, buildDistDir, cliAppDir);
+      mergeServerArtifacts(buildDistDir, cliAppDir);
+      assertRequiredApiArtifacts(cliAppDir);
+
+      const packagedServer = path.join(cliAppDir, ".next-cli-build", "server");
+      assert.equal(
+        fs.readFileSync(path.join(packagedServer, "app/api/v1/messages/route.js"), "utf8"),
+        "messages route",
+      );
+      assert.equal(
+        fs.readFileSync(path.join(packagedServer, "chunks/openai-provider.js"), "utf8"),
+        "openai chunk",
+      );
+      assert.equal(
+        fs.readFileSync(path.join(packagedServer, "chunks/anthropic-provider.js"), "utf8"),
+        "anthropic chunk",
+      );
+    });
+  }
+
+  it("merges idempotently without removing standalone-generated files", () => {
+    const root = createTempDir();
+    const buildDistDir = path.join(root, ".next-cli-build");
+    const cliAppDir = path.join(root, "cli-app");
+    const packagedServer = path.join(cliAppDir, ".next-cli-build", "server");
+
+    createCompleteServer(buildDistDir);
+    writeFixture(packagedServer, "standalone-only.js", "keep me");
+
+    mergeServerArtifacts(buildDistDir, cliAppDir);
+    mergeServerArtifacts(buildDistDir, cliAppDir);
+
+    assert.equal(
+      fs.readFileSync(path.join(packagedServer, "standalone-only.js"), "utf8"),
+      "keep me",
+    );
+    assert.equal(
+      fs.readFileSync(path.join(packagedServer, "app/api/v1/messages/route.js"), "utf8"),
+      "messages route",
+    );
+  });
+
+  it("reports the missing required API route artifact path", () => {
+    const root = createTempDir();
+    const buildDistDir = path.join(root, ".next-cli-build");
+    const cliAppDir = path.join(root, "cli-app");
+
+    writeFixture(
+      path.join(buildDistDir, "server"),
+      "app/api/v1/chat/completions/route.js",
+      "chat route",
+    );
+    mergeServerArtifacts(buildDistDir, cliAppDir);
+
+    assert.throws(
+      () => assertRequiredApiArtifacts(cliAppDir),
+      (error) => error.message.includes(path.join(
+        cliAppDir,
+        ".next-cli-build/server/app/api/v1/messages/route.js",
+      )),
+    );
+  });
+});

From baebc9a06e3224f63d82ed0a8bdf7f67b253e0c3 Mon Sep 17 00:00:00 2001
From: huuanh20 <anhnhse180234@fpt.edu.vn>
Date: Wed, 5 Aug 2026 11:53:19 +0700
Subject: [PATCH 23/42] docs(i18n): fix port typo and add RTK Token Saver
 features

Fix port 201281 -> 20128/v1 typo in README.zh-CN.md diagram, add
RTK Token Saver mention to README.vi.md/README.zh-CN.md, update
Tier 3 free providers to 2026 lineup, and drop hardcoded /tmp
node_modules path from tests/package.json and tests/README.md.
---
 i18n/README.vi.md    | 78 +++++++++++++++++++++-----------------------
 i18n/README.zh-CN.md | 29 ++++++++--------
 tests/README.md      | 17 +++++-----
 tests/package.json   |  4 +--
 4 files changed, 64 insertions(+), 64 deletions(-)

diff --git a/i18n/README.vi.md b/i18n/README.vi.md
index d0a51de4..5e01d8aa 100644
--- a/i18n/README.vi.md
+++ b/i18n/README.vi.md
@@ -1,21 +1,15 @@
-Dưới đây là bản dịch tiếng Việt của tài liệu Markdown, giữ nguyên toàn bộ cú pháp và cấu trúc kỹ thuật.
-
 <div align="center">
   <img src="../images/9router.png?1" alt="Bảng điều khiển 9Router" width="800"/>
   
-  # 9Router - Free AI Router
+  # 9Router - Free AI Router & Token Saver
   
-  **Không bao giờ ngừng code. Tự động định tuyến tới các mô hình AI MIỄN PHÍ & giá rẻ với cơ chế dự phòng thông minh.**
+  **Không bao giờ ngừng code. Tiết kiệm 20-40% token với RTK + tự động dự phòng sang các mô hình AI MIỄN PHÍ & giá rẻ.**
   
-  **Nhà cung cấp AI Miễn cho OpenClaw.**
-  
-  <p align="center">
-    <img src="../public/providers/openclaw.png" alt="OpenClaw" width="80"/>
-  </p>
+  **Kết nối tất cả công cụ AI Code (Claude Code, Codex, Cursor, Cline, Copilot, Antigravity...) tới 40+ Nhà cung cấp AI & 100+ Mô hình.**
   
   [![npm](https://img.shields.io/npm/v/9router.svg)](https://www.npmjs.com/package/9router)
   [![Downloads](https://img.shields.io/npm/dm/9router.svg)](https://www.npmjs.com/package/9router)
-  [![License](https://img.shields.io/npm/l/9router.svg)](https://github.com/decolua/9router/blob/main/LICENSE)
+  [![License](https://github.com/decolua/9router/blob/main/LICENSE)](https://github.com/decolua/9router/blob/main/LICENSE)
   
   [🚀 Bắt đầu nhanh](#-quick-start) • [💡 Tính năng](#-key-features) • [📖 Cài đặt](#-setup-guide) • [🌐 Website](https://9router.com)
 </div>
@@ -24,19 +18,21 @@ Dưới đây là bản dịch tiếng Việt của tài liệu Markdown, giữ
 
 ## 🤔 Tại sao chọn 9Router?
 
-**Ngừng lãng phí tiền bạc và gặp phải giới hạn:**
+**Ngừng lãng phí tiền bạc, token và không bao giờ lo chạm giới hạn (rate limit):**
 
 - ❌ Hạn mức gói đăng ký hết hạn mỗi tháng mà không dùng hết
-- ❌ Giới hạn tốc độ (rate limit) ngăn bạn giữaừng khi code
-- ❌ Các API đắt đỏ ($20-50/tháng cho mỗi nhà cung cấp)
-- ❌ Phải chuyển đổi thủ công giữa các nhà cung cấp
+- ❌ Giới hạn tốc độ (rate limit) làm gián đoạn công việc mid-coding
+- ❌ Kết quả của công cụ (git diff, grep, ls...) ngốn rất nhiều token
+- ❌ Chi phí API đắt đỏ ($20-50/tháng cho từng nhà cung cấp)
+- ❌ Phải chuyển đổi thủ công giữa các nhà cung cấp AI
 
 **9Router giải quyết vấn đề này:**
 
-- ✅ **Tối đa hóa gói đăng ký** - Theo dõi hạn mức, sử dụng từng bit trước khi reset
-- ✅ **Tự động dự phòng** - Gói đăng ký → Giá rẻ → Miễn phí, thời gian chết bằng không
-- ✅ **Đa tài khoản** - Vòng tròn (round-robin) các tài khoản của mỗi nhà cung cấp
-- ✅ **Phổ quát** - Hoạt động với Claude Code, Codex, Gemini CLI, Cursor, Cline, bất kỳ công cụ CLI nào
+- ✅ **RTK Token Saver** - Tự động nén nội dung `tool_result`, tiết kiệm 20-40% token trên mỗi request
+- ✅ **Tối đa hóa gói đăng ký** - Theo dõi hạn mức, tận dụng triệt để trước khi reset
+- ✅ **Tự động dự phòng (Auto Fallback)** - Gói đăng ký → Giá rẻ → Miễn phí, không lo downtime
+- ✅ **Đa tài khoản (Multi-account)** - Xoay vòng (round-robin) các tài khoản cho mỗi nhà cung cấp
+- ✅ **Phổ quát (Universal)** - Hoạt động với Claude Code, Codex, Cursor, Cline, Antigravity và mọi công cụ CLI
 
 ---
 
@@ -44,25 +40,26 @@ Dưới đây là bản dịch tiếng Việt của tài liệu Markdown, giữ
 
 ```
 ┌─────────────┐
-│  Your CLI   │  (Claude Code, Codex, Gemini CLI, OpenClaw, Cursor, Cline...)
-│   Tool      │
+│  Công cụ    │  (Claude Code, Codex, OpenClaw, Cursor, Cline, Antigravity...)
+│  CLI AI     │
 └──────┬──────┘
        │ http://localhost:20128/v1
        ↓
-┌────────────────────────────────────────┐
-│           9Router (Smart Router)        │
-│  • Format translation (OpenAI ↔ Claude) │
-│  • Quota tracking                       │
-│  • Auto token refresh                   │
-└──────┬──────────────────────────────────┘
+┌─────────────────────────────────────────────┐
+│           9Router (Smart Router)            │
+│  • RTK Token Saver (nén tool_result token) │
+│  • Dịch chuyển định dạng (OpenAI ↔ Claude) │
+│  • Quota tracking (theo dõi hạn mức)       │
+│  • Tự động làm mới OAuth Token             │
+└──────┬──────────────────────────────────────┘
        │
-       ├─→ [Tier 1: SUBSCRIPTION] Claude Code, Codex, Gemini CLI
-       │   ↓ quota exhausted
-       ├─→ [Tier 2: CHEAP] GLM ($0.6/1M), MiniMax ($0.2/1M)
-       │   budget limit
-       └─→ [Tier 3: FREE] iFlow, Qwen, Kiro (unlimited)
+       ├─→ [Tier 1: GÓI ĐĂNG KÝ] Claude Code, Codex, GitHub Copilot
+       │   ↓ hết hạn mức quota
+       ├─→ [Tier 2: GIÁ RẺ] GLM ($0.6/1M), MiniMax ($0.2/1M)
+       │   ↓ chạm ngân sách
+       └─→ [Tier 3: MIỄN PHÍ] Kiro AI, OpenCode Free, Vertex AI ($300 credits)
 
-Result: Never stop coding, minimal cost
+Kết quả: Không bao giờ ngừng code, chi phí tối thiểu + tiết kiệm 20-40% token qua RTK
 ```
 
 ---
@@ -76,26 +73,26 @@ npm install -g 9router
 9router
 ```
 
-🎉 Bảng điều khiển mở tại `http://localhost:20128`
+🎉 Bảng điều khiển (Dashboard) sẽ tự động mở tại `http://localhost:20128`
 
 **2. Kết nối nhà cung cấp MIỄN PHÍ (không cần đăng ký):**
 
-Bảng điều khiển → Providers -> Kết nối **ude Code** hoặc **Antigravity** -> Đăng nhập OAuth -> Xong!
+Bảng điều khiển → Providers → Kết nối **Kiro AI** (~50 credits/tháng miễn phí: Claude 4.5 + GLM-5 + MiniMax) hoặc **OpenCode Free** (không cần auth) → Xong!
 
 **3. Sử dụng trong công cụ CLI của bạn:**
 
 ```
-Cài đặt Claude Code/Codex/Gemini CLI/OpenClaw/Cursor/Cline:
+Cài đặt Claude Code/Codex/OpenClaw/Cursor/Cline/Antigravity:
   Endpoint: http://localhost:20128/v1
   API Key: [sao chép từ bảng điều khiển]
-  Model: if/kimi-k2-thinking
+  Model: kr/claude-sonnet-4.5
 ```
 
-**Xong rồi!** Bắt đầu code với các mô hình AI MIỄN PHÍ.
+**Thế là xong!** Bắt đầu code ngay với các mô hình AI MIỄN PHÍ.
 
-**Phương án khác: chạy từ nguồn (k lưu trữ này):**
+**Phương án khác: chạy từ mã nguồn (repository này):**
 
-Gói kho lưu trữ này là riêng tư (`9router-app`), vì vậy việc thực thi nguồn/Docker là đường dẫn phát triển cục bộ dự kiến.
+Gói kho lưu trữ này là riêng tư (`9router-app`), vì vậy việc chạy từ nguồn/Docker là cách phát triển cục bộ mặc định.
 
 ```bash
 cp .env.example .env
@@ -111,11 +108,12 @@ PORT=20128 HOSTNAME=0.0.0.0 NEXT_PUBLIC_BASE_URL=http://localhost:20128 npm run
 ```
 
 URL mặc định:
-- Bảng điều khiển: `http://localhost:20128/dashboard`
+- Bảng điều khiển Dashboard: `http://localhost:20128/dashboard`
 - API tương thích OpenAI: `http://localhost:20128/v1`
 
 ---
 
+
 ## 🎥 Hướng dẫn Video
 
 <div align="center">
diff --git a/i18n/README.zh-CN.md b/i18n/README.zh-CN.md
index 92e0624b..c090f608 100644
--- a/i18n/README.zh-CN.md
+++ b/i18n/README.zh-CN.md
@@ -42,25 +42,26 @@
 
 ```
 ┌─────────────┐
-│  Your CLI   │  (Claude Code, Codex, Gemini CLI, OpenClaw, Cursor, Cline...)
+│  Your CLI   │  (Claude Code, Codex, OpenClaw, Cursor, Cline, Antigravity...)
 │   Tool      │
 └──────┬──────┘
-       │ http://localhost:201281
+       │ http://localhost:20128/v1
        ↓
-┌─────────────────────────────────────────┐
-│           9Router (Smart Router)        │
-│  • Format translation (OpenAI ↔ Claude) │
-│  • Quota tracking                       │
-│  • Auto token refresh                   │
-└──────┬──────────────────────────────────┘
+┌─────────────────────────────────────────────┐
+│           9Router (Smart Router)            │
+│  • RTK Token Saver (节省 20-40% Token)      │
+│  • 格式转换 (OpenAI ↔ Claude)               │
+│  • 配额追踪 (Quota tracking)                │
+│  • 自动刷新 OAuth Token                     │
+└──────┬──────────────────────────────────────┘
        │
-       ├─→ [Tier 1: SUBSCRIPTION] Claude Code, Codex, Gemini CLI
-       │   ↓ quota exhausted
-       ├─→ [Tier 2: CHEAP] GLM ($0.6/1M), MiniMax ($0.2/1M)
-       │   ↓ budget limit
-       └─→ [Tier 3: FREE] iFlow, Qwen, Kiro (unlimited)
+       ├─→ [Tier 1: 订阅] Claude Code, Codex, GitHub Copilot
+       │   ↓ 配额用尽
+       ├─→ [Tier 2: 低价] GLM ($0.6/1M), MiniMax ($0.2/1M)
+       │   ↓ 触及预算上限
+       └─→ [Tier 3: 免费] Kiro AI, OpenCode Free, Vertex AI ($300 credits)
 
-Result: Never stop coding, minimal cost
+结果：永不停歇的编程体验，最低成本 + 通过 RTK 节省 20-40% Token
 ```
 
 ---
diff --git a/tests/README.md b/tests/README.md
index 807d5fbc..20913022 100644
--- a/tests/README.md
+++ b/tests/README.md
@@ -4,25 +4,26 @@ Unit tests for the `/v1/embeddings` endpoint implementation.
 
 ## Setup
 
-Vitest must be installed globally or in `/tmp/node_modules` (due to npm workspace hoisting from the root Next.js project):
+Install test dependencies from the `tests/` directory:
 
 ```bash
-cd /tmp && npm install vitest
+cd tests/ && npm install
 ```
 
 ## Running Tests
 
-```bash
-cd tests/
-NODE_PATH=/tmp/node_modules /tmp/node_modules/.bin/vitest run --reporter=verbose --config ./vitest.config.js
-```
-
-Or using the package script (from the `tests/` directory):
+From the `tests/` directory:
 
 ```bash
 npm test
 ```
 
+Or run vitest directly with npx:
+
+```bash
+npx vitest run --reporter=verbose --config ./vitest.config.js
+```
+
 ## Test Files
 
 | File | What it tests |
diff --git a/tests/package.json b/tests/package.json
index 0237ab1e..7d3544b8 100644
--- a/tests/package.json
+++ b/tests/package.json
@@ -5,8 +5,8 @@
   "type": "module",
   "description": "Unit tests for 9router embeddings endpoint",
   "scripts": {
-    "test": "NODE_PATH=/tmp/node_modules /tmp/node_modules/.bin/vitest run --reporter=verbose",
-    "test:watch": "NODE_PATH=/tmp/node_modules /tmp/node_modules/.bin/vitest --reporter=verbose"
+    "test": "vitest run --reporter=verbose",
+    "test:watch": "vitest --reporter=verbose"
   },
   "devDependencies": {
     "vitest": "^4.0.0"

From 646b3b9ba36fec43b413dde69e90cbb30976c76a Mon Sep 17 00:00:00 2001
From: Sutarto Jordan Chrisfivo <Jordannst@users.noreply.github.com>
Date: Wed, 5 Aug 2026 13:13:16 +0700
Subject: [PATCH 24/42] fix(cloudflare-ai): declare API key authentication

Cloudflare AI registry entry was missing authType/authModes, causing
the dashboard to report "No connections" despite an active API-key
connection. Closes #2969
---
 open-sse/providers/registry/cloudflare-ai.js | 2 ++
 tests/unit/provider-display-split.test.js    | 6 ++++++
 2 files changed, 8 insertions(+)

diff --git a/open-sse/providers/registry/cloudflare-ai.js b/open-sse/providers/registry/cloudflare-ai.js
index 4d440b74..53f1a697 100644
--- a/open-sse/providers/registry/cloudflare-ai.js
+++ b/open-sse/providers/registry/cloudflare-ai.js
@@ -19,6 +19,8 @@ export default {
     },
   },
   category: "freeTier",
+  authType: "apikey",
+  authModes: ["apikey"],
   hasProviderSpecificData: true,
   transport: {
     baseUrl: "https://api.cloudflare.com/client/v4/accounts/{accountId}/ai/v1/chat/completions",
diff --git a/tests/unit/provider-display-split.test.js b/tests/unit/provider-display-split.test.js
index e28963ba..af313f0c 100644
--- a/tests/unit/provider-display-split.test.js
+++ b/tests/unit/provider-display-split.test.js
@@ -31,4 +31,10 @@ describe("provider display split (E1)", () => {
     expect(m.ALIAS_TO_ID.kr).toBe("kiro");
     expect(m.getProvidersByKind("tts").length).toBeGreaterThan(0);
   });
+
+  it("Cloudflare exposes API-key authentication on its free-tier card", async () => {
+    const { FREE_TIER_PROVIDERS } = await import("../../src/shared/constants/providers.js");
+    expect(FREE_TIER_PROVIDERS["cloudflare-ai"].authType).toBe("apikey");
+    expect(FREE_TIER_PROVIDERS["cloudflare-ai"].authModes).toEqual(["apikey"]);
+  });
 });

From a7941ddab4094df2b8cd151260f375f9bdf41607 Mon Sep 17 00:00:00 2001
From: cardinusantara <cardinusantara@gmail.com>
Date: Wed, 5 Aug 2026 13:19:55 +0700
Subject: [PATCH 25/42] fix(translator): don't drop image-only user messages in
 prepareClaudeRequest

hasValidContent() only treated text/tool_use/tool_result blocks as valid
content, so a user message containing only an image block was filtered
out as empty. When it was the only non-system message, this left an
empty messages array and Anthropic rejected the request.
---
 open-sse/translator/formats/claude.js         |  4 +++-
 .../translator/bugs-toClaude-context.test.js  | 21 +++++++++++++++++++
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/open-sse/translator/formats/claude.js b/open-sse/translator/formats/claude.js
index adbd3ce8..128917ec 100644
--- a/open-sse/translator/formats/claude.js
+++ b/open-sse/translator/formats/claude.js
@@ -16,7 +16,9 @@ export function hasValidContent(msg) {
     return msg.content.some(block =>
       (block.type === CLAUDE_BLOCK.TEXT && block.text?.trim()) ||
       block.type === CLAUDE_BLOCK.TOOL_USE ||
-      block.type === CLAUDE_BLOCK.TOOL_RESULT
+      block.type === CLAUDE_BLOCK.TOOL_RESULT ||
+      block.type === CLAUDE_BLOCK.IMAGE ||
+      block.type === CLAUDE_BLOCK.DOCUMENT
     );
   }
   return false;
diff --git a/tests/translator/bugs-toClaude-context.test.js b/tests/translator/bugs-toClaude-context.test.js
index 96b704e8..45707177 100644
--- a/tests/translator/bugs-toClaude-context.test.js
+++ b/tests/translator/bugs-toClaude-context.test.js
@@ -67,6 +67,27 @@ describe("OpenAI → Claude context mapping", () => {
     expect(JSON.stringify(out), "remote image dropped").toContain("pic.png");
   });
 
+  // claude.js hasValidContent() — a user message whose content is only an
+  // image (no text block) was filtered out by prepareClaudeRequest's
+  // "drop empty messages" pass, so an image-only turn (e.g. a vision
+  // describe request with no accompanying prompt text in the user message)
+  // produced an empty `messages` array and Anthropic rejected the request
+  // with "messages: at least one message is required".
+  it("user message with only an image is not dropped as empty", () => {
+    const out = T({
+      messages: [
+        { role: "system", content: "Describe the image." },
+        { role: "user", content: [
+          { type: "image_url", image_url: { url: "data:image/png;base64,AAAA" } },
+        ] },
+      ],
+    });
+    expect(out.messages.length, "image-only user message was dropped").toBeGreaterThan(0);
+    expect(out.messages[0].content).toEqual(
+      expect.arrayContaining([expect.objectContaining({ type: "image" })])
+    );
+  });
+
   // prepareClaudeRequest reconciles max_tokens vs thinking.budget_tokens.
   // applyThinking runs after adjustMaxTokens caps max_tokens, so a claude-budget
   // model at "max" effort (budget 128000) can exceed the clamped max_tokens and

From 42c691b3ea22a88247a6168e74f344c32c95b48a Mon Sep 17 00:00:00 2001
From: whale9820 <admin@dyntech.cc>
Date: Wed, 5 Aug 2026 13:19:49 +0700
Subject: [PATCH 26/42] feat(antigravity): show Gemini 3.6 Flash usage bars in
 quota tracker

getAntigravityUsage filtered the fetchAvailableModels response through a
hardcoded importantModels list that only contained 3.5 Flash, silently
dropping the 3.6 Flash quota buckets so no usage bar rendered.
---
 open-sse/services/usage/google.js             |  3 +
 .../unit/antigravity-quota-gemini-3.6.test.js | 79 +++++++++++++++++++
 2 files changed, 82 insertions(+)
 create mode 100644 tests/unit/antigravity-quota-gemini-3.6.test.js

diff --git a/open-sse/services/usage/google.js b/open-sse/services/usage/google.js
index f0e4d23e..1844f32f 100644
--- a/open-sse/services/usage/google.js
+++ b/open-sse/services/usage/google.js
@@ -161,6 +161,9 @@ export async function getAntigravityUsage(accessToken, providerSpecificData, pro
     if (data.models) {
       // Filter only recommended/important models (must match PROVIDER_MODELS ag ids)
       const importantModels = [
+        'gemini-3.6-flash-high',
+        'gemini-3.6-flash-medium',
+        'gemini-3.6-flash-low',
         'gemini-3-flash-agent',
         'gemini-3.5-flash-low',
         'gemini-3.5-flash-extra-low',
diff --git a/tests/unit/antigravity-quota-gemini-3.6.test.js b/tests/unit/antigravity-quota-gemini-3.6.test.js
new file mode 100644
index 00000000..c67924d6
--- /dev/null
+++ b/tests/unit/antigravity-quota-gemini-3.6.test.js
@@ -0,0 +1,79 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+
+const proxyAwareFetch = vi.fn(async (url) => ({
+  ok: true,
+  status: 200,
+  json: async () => url.includes(":loadCodeAssist")
+    ? { cloudaicompanionProject: "project-1", currentTier: { name: "Pro" } }
+    : {
+        models: {
+          "gemini-3.6-flash-high": {
+            displayName: "Gemini 3.6 Flash (High)",
+            quotaInfo: { remainingFraction: 0.8, resetTime: "2026-07-25T12:00:00Z" },
+          },
+          "gemini-3.6-flash-medium": {
+            displayName: "Gemini 3.6 Flash (Medium)",
+            quotaInfo: { remainingFraction: 0.5, resetTime: "2026-07-25T12:00:00Z" },
+          },
+          "gemini-3.6-flash-low": {
+            displayName: "Gemini 3.6 Flash (Low)",
+            quotaInfo: { remainingFraction: 0.2, resetTime: "2026-07-25T12:00:00Z" },
+          },
+          "gemini-3.5-flash-low": {
+            displayName: "Gemini 3.5 Flash (Medium)",
+            quotaInfo: { remainingFraction: 0.9, resetTime: "2026-07-25T12:00:00Z" },
+          },
+          "internal-model": {
+            displayName: "Internal",
+            isInternal: true,
+            quotaInfo: { remainingFraction: 0.5 },
+          },
+        },
+      },
+  text: async () => "{}",
+}));
+
+vi.mock("../../open-sse/utils/proxyFetch.js", () => ({
+  proxyAwareFetch,
+}));
+
+describe("Antigravity quota tracker: Gemini 3.6 Flash usage bars", () => {
+  beforeEach(() => proxyAwareFetch.mockClear());
+
+  it("returns Gemini 3.6 Flash tier quotas so the dashboard can render usage bars", async () => {
+    const { getAntigravityUsage } = await import("../../open-sse/services/usage/google.js");
+
+    const usage = await getAntigravityUsage("access-token", {});
+
+    expect(usage.quotas["gemini-3.6-flash-high"]).toMatchObject({
+      used: 200,
+      total: 1000,
+      remainingPercentage: 80,
+      displayName: "Gemini 3.6 Flash (High)",
+    });
+    expect(usage.quotas["gemini-3.6-flash-medium"]).toMatchObject({
+      used: 500,
+      total: 1000,
+      remainingPercentage: 50,
+    });
+    expect(usage.quotas["gemini-3.6-flash-low"]).toMatchObject({
+      used: 800,
+      total: 1000,
+      remainingPercentage: 20,
+    });
+  });
+
+  it("still filters out internal and non-important models", async () => {
+    const { getAntigravityUsage } = await import("../../open-sse/services/usage/google.js");
+
+    const usage = await getAntigravityUsage("access-token", {});
+
+    expect(usage.quotas).not.toHaveProperty("internal-model");
+    expect(Object.keys(usage.quotas)).toEqual([
+      "gemini-3.6-flash-high",
+      "gemini-3.6-flash-medium",
+      "gemini-3.6-flash-low",
+      "gemini-3.5-flash-low",
+    ]);
+  });
+});

From b11be8be0ac62cbfc43611d5a1ace2e8ed6a27a6 Mon Sep 17 00:00:00 2001
From: decolua <decoluadt@gmail.com>
Date: Wed, 5 Aug 2026 13:24:57 +0700
Subject: [PATCH 27/42] fix(antigravity): drop retired Gemini 3.0 tiers from
 quota tracker

gemini-3-flash-agent, gemini-3-flash, and gemini-3-pro-image are retired;
they no longer need a quota bar in the tracker.
---
 open-sse/services/usage/google.js | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/open-sse/services/usage/google.js b/open-sse/services/usage/google.js
index 1844f32f..e79c018e 100644
--- a/open-sse/services/usage/google.js
+++ b/open-sse/services/usage/google.js
@@ -164,7 +164,6 @@ export async function getAntigravityUsage(accessToken, providerSpecificData, pro
         'gemini-3.6-flash-high',
         'gemini-3.6-flash-medium',
         'gemini-3.6-flash-low',
-        'gemini-3-flash-agent',
         'gemini-3.5-flash-low',
         'gemini-3.5-flash-extra-low',
         'gemini-pro-agent',
@@ -172,10 +171,8 @@ export async function getAntigravityUsage(accessToken, providerSpecificData, pro
         'claude-sonnet-4-6',
         'claude-opus-4-6-thinking',
         'gpt-oss-120b-medium',
-        'gemini-3-flash',
         // Image generation models
         'gemini-3.1-flash-image',
-        'gemini-3-pro-image',
       ];
 
       for (const [modelKey, info] of Object.entries(data.models)) {

From d06e0d26c636ef91218f28ed2af691072700072a Mon Sep 17 00:00:00 2001
From: nguyenha935 <nguyenha935@users.noreply.github.com>
Date: Wed, 5 Aug 2026 13:23:03 +0700
Subject: [PATCH 28/42] fix(translator): preserve Responses Lite tools across
 Chat providers

Codex Responses Lite clients routed to a chat-native OpenAI-compatible
provider lost tool use in three places: non-streaming Chat responses
leaked the raw chat.completion envelope instead of Responses output
items, internal reasoning continuity fields leaked into the outbound
Chat body causing some upstreams to reject the request, and the
Responses to Chat request translator ignored additional_tools,
custom_tool_call, and custom_tool_call_output items entirely.

Also fixes apiType (chat vs responses) for openai-compatible nodes
being resolved from the immutable provider ID instead of the stored
node config, so editing a node's API Type had no runtime effect.
---
 open-sse/executors/base.js                    |   3 +-
 open-sse/executors/default.js                 |   3 +-
 open-sse/handlers/chatCore.js                 |  32 +++-
 .../handlers/chatCore/nonStreamingHandler.js  |  98 ++++++++++-
 .../handlers/chatCore/sseToJsonHandler.js     |  90 ++++++++++-
 .../handlers/chatCore/streamingHandler.js     |  10 +-
 open-sse/services/provider.js                 |  22 ++-
 open-sse/translator/index.js                  |   2 +
 .../translator/request/openai-responses.js    |  54 ++++++-
 .../translator/response/openai-responses.js   |  75 ++++++---
 open-sse/translator/schema/blocks.js          |   3 +
 open-sse/utils/stream.js                      |   8 +-
 .../bugs-codexCli-responses.test.js           |   4 +-
 tests/unit/continuity-strip.test.js           |  80 +++++++++
 ...enai-compatible-apitype-resolution.test.js |  76 +++++++++
 .../openai-responses-custom-tools.test.js     | 153 ++++++++++++++++++
 tests/unit/openai-responses-nonstream.test.js | 148 +++++++++++++++++
 17 files changed, 803 insertions(+), 58 deletions(-)
 create mode 100644 tests/unit/continuity-strip.test.js
 create mode 100644 tests/unit/openai-compatible-apitype-resolution.test.js
 create mode 100644 tests/unit/openai-responses-custom-tools.test.js
 create mode 100644 tests/unit/openai-responses-nonstream.test.js

diff --git a/open-sse/executors/base.js b/open-sse/executors/base.js
index f1f8139b..a4c017e4 100644
--- a/open-sse/executors/base.js
+++ b/open-sse/executors/base.js
@@ -3,6 +3,7 @@ import { shouldRefreshCredentials } from "../services/oauthCredentialManager.js"
 import { proxyAwareFetch } from "../utils/proxyFetch.js";
 import { dbg } from "../utils/debugLog.js";
 import { ANTHROPIC_API_VERSION, OPENAI_COMPAT_BASE, ANTHROPIC_COMPAT_BASE } from "../providers/shared.js";
+import { resolveOpenAICompatibleApiType } from "../services/provider.js";
 
 /**
  * BaseExecutor - Base class for provider executors
@@ -30,7 +31,7 @@ export class BaseExecutor {
     if (this.provider?.startsWith?.("openai-compatible-")) {
       const baseUrl = credentials?.providerSpecificData?.baseUrl || OPENAI_COMPAT_BASE;
       const normalized = baseUrl.replace(/\/$/, "");
-      const path = this.provider.includes("responses") ? "/responses" : "/chat/completions";
+      const path = resolveOpenAICompatibleApiType(this.provider, credentials) === "responses" ? "/responses" : "/chat/completions";
       return `${normalized}${path}`;
     }
     if (this.provider?.startsWith?.("anthropic-compatible-")) {
diff --git a/open-sse/executors/default.js b/open-sse/executors/default.js
index cbd1ccce..eb000f37 100644
--- a/open-sse/executors/default.js
+++ b/open-sse/executors/default.js
@@ -1,6 +1,7 @@
 import { BaseExecutor } from "./base.js";
 import { PROVIDERS, PROVIDER_OAUTH } from "../config/providers.js";
 import { ANTHROPIC_API_VERSION, OPENAI_COMPAT_BASE, ANTHROPIC_COMPAT_BASE, selectAnthropicBeta } from "../providers/shared.js";
+import { resolveOpenAICompatibleApiType } from "../services/provider.js";
 import { OAUTH_ENDPOINTS, buildKimiHeaders } from "../config/appConstants.js";
 import { buildClineHeaders } from "../shared/clineAuth.js";
 import { proxyAwareFetch } from "../utils/proxyFetch.js";
@@ -109,7 +110,7 @@ export class DefaultExecutor extends BaseExecutor {
     if (this.provider?.startsWith?.("openai-compatible-")) {
       const baseUrl = credentials?.providerSpecificData?.baseUrl || OPENAI_COMPAT_BASE;
       const normalized = baseUrl.replace(/\/$/, "");
-      const path = this.provider.includes("responses") ? "/responses" : "/chat/completions";
+      const path = resolveOpenAICompatibleApiType(this.provider, credentials) === "responses" ? "/responses" : "/chat/completions";
       return `${normalized}${path}`;
     }
     if (this.provider?.startsWith?.("anthropic-compatible-")) {
diff --git a/open-sse/handlers/chatCore.js b/open-sse/handlers/chatCore.js
index c32b74bb..9f17cf94 100644
--- a/open-sse/handlers/chatCore.js
+++ b/open-sse/handlers/chatCore.js
@@ -37,6 +37,26 @@ import { resolveSessionId } from "../utils/sessionManager.js";
  * @param {object} options.credentials - Provider credentials
  * @param {string} options.sourceFormatOverride - Override detected source format (e.g. "openai-responses")
  */
+/**
+ * Remove translator-internal continuity fields from the outbound upstream
+ * body. The Responses→Chat request translator stashes reasoning
+ * `encrypted_content` on assistant messages so a later openai→responses
+ * round-trip can restore the store=false continuity blob; that stash must
+ * never reach an upstream provider. Chat-native proxies reject the unknown
+ * assistant-message field and answer every turn with a literal "400" body
+ * (observed with multi-turn Codex sessions via OpenAI-compatible nodes).
+ */
+export function stripContinuityFields(body) {
+  if (!body || !Array.isArray(body.messages)) return body;
+  for (const msg of body.messages) {
+    if (msg && typeof msg === "object") {
+      delete msg.encrypted_content;
+      delete msg.reasoning_encrypted_content;
+    }
+  }
+  return body;
+}
+
 export async function handleChatCore({ body, modelInfo, credentials, log, onCredentialsRefreshed, onRequestSuccess, onDisconnect, clientRawRequest, connectionId, userAgent, apiKey, ccFilterNaming, rtkEnabled, headroomEnabled, headroomUrl, headroomCompressUserMessages, cavemanEnabled, cavemanLevel, ponytailEnabled, ponytailLevel, pxpipeEnabled, pxpipeMinChars, pxpipeTimeoutMs, pxpipeTransform, onPxpipeEvent, sourceFormatOverride, providerThinking }) {
   const { provider, model } = modelInfo;
   const requestStartTime = Date.now();
@@ -60,7 +80,7 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
   const modelTargetFormat = getModelTargetFormat(alias, model);
   // Multi-endpoint providers: pick transport matching sourceFormat → zero translation
   const runtimeTransport = resolveTransport(provider, sourceFormat);
-  const targetFormat = modelTargetFormat || runtimeTransport?.format || getTargetFormat(provider);
+  const targetFormat = modelTargetFormat || runtimeTransport?.format || getTargetFormat(provider, credentials);
   if (runtimeTransport && credentials) credentials.runtimeTransport = runtimeTransport;
   const stripList = getModelStrip(alias, model);
   const upstreamModel = getModelUpstreamId(alias, model);
@@ -133,6 +153,7 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
 
   let translatedBody;
   let toolNameMap;
+  let customToolNames;
   if (passthrough) {
     log?.debug?.("PASSTHROUGH", `${clientTool} → ${provider} | native lossless`);
     translatedBody = { ...body, model: stripThinkingSuffix(upstreamModel) };
@@ -158,7 +179,10 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
     }
     toolNameMap = translatedBody._toolNameMap;
     delete translatedBody._toolNameMap;
+    customToolNames = translatedBody._customToolNames;
+    delete translatedBody._customToolNames;
     translatedBody.model = stripThinkingSuffix(upstreamModel);
+    stripContinuityFields(translatedBody);
   }
 
   // Dedupe duplicate built-in tools when equivalent MCP tools are present (Claude clients only).
@@ -406,20 +430,20 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
 
   // Provider forced streaming but client wants JSON
   if (!clientRequestedStreaming && providerRequiresStreaming) {
-    const result = await handleForcedSSEToJson({ ...sharedCtx, providerResponse, sourceFormat, trackDone, appendLog });
+    const result = await handleForcedSSEToJson({ ...sharedCtx, providerResponse, sourceFormat, targetFormat: providerResponseFormat, customToolNames, trackDone, appendLog });
     if (result) { streamController.handleComplete(); return result; }
   }
 
   // True non-streaming response
   if (!stream) {
-    const result = await handleNonStreamingResponse({ ...sharedCtx, providerResponse, sourceFormat, targetFormat: providerResponseFormat, reqLogger, toolNameMap, trackDone, appendLog });
+    const result = await handleNonStreamingResponse({ ...sharedCtx, providerResponse, sourceFormat, targetFormat: providerResponseFormat, reqLogger, toolNameMap, customToolNames, trackDone, appendLog });
     streamController.handleComplete();
     return result;
   }
 
   // Streaming response
   const { onStreamComplete, streamDetailId } = buildOnStreamComplete({ ...sharedCtx });
-  return handleStreamingResponse({ ...sharedCtx, providerResponse, sourceFormat, targetFormat: providerResponseFormat, userAgent, reqLogger, toolNameMap, streamController, onStreamComplete, streamDetailId });
+  return handleStreamingResponse({ ...sharedCtx, providerResponse, sourceFormat, targetFormat: providerResponseFormat, userAgent, reqLogger, toolNameMap, customToolNames, streamController, onStreamComplete, streamDetailId });
 }
 
 export function isTokenExpiringSoon(expiresAt, bufferMs = 5 * 60 * 1000) {
diff --git a/open-sse/handlers/chatCore/nonStreamingHandler.js b/open-sse/handlers/chatCore/nonStreamingHandler.js
index f93058fd..becc0842 100644
--- a/open-sse/handlers/chatCore/nonStreamingHandler.js
+++ b/open-sse/handlers/chatCore/nonStreamingHandler.js
@@ -9,6 +9,7 @@ import { parseSSEToOpenAIResponse } from "./sseToJsonHandler.js";
 import { buildRequestDetail, extractRequestConfig, extractUsageFromResponse, saveUsageStats, formatDoneLine } from "./requestDetail.js";
 import { appendRequestLog, saveRequestDetail } from "@/lib/usageDb.js";
 import { decloakToolNames } from "../../utils/claudeCloaking.js";
+import { ROLE, RESPONSES_ITEM } from "../../translator/schema/index.js";
 
 function parseToolArguments(value) {
   if (!value) return {};
@@ -60,11 +61,93 @@ function openAICompletionToClaudeMessage(responseBody) {
   };
 }
 
+/**
+ * Convert an OpenAI Chat Completions non-streaming response body into the
+ * OpenAI Responses API shape. Used when a Responses-format client (e.g. Codex)
+ * is routed to a Chat Completions upstream and `stream:false` — the streaming
+ * path already emits Responses events, but the JSON path returned a raw
+ * `chat.completion` body, so tool_calls were invisible to Responses clients.
+ */
+function extractCustomToolInput(argumentsValue) {
+  const argumentsText = typeof argumentsValue === "string" ? argumentsValue : JSON.stringify(argumentsValue || {});
+  try {
+    const parsed = JSON.parse(argumentsText);
+    if (parsed && typeof parsed === "object" && typeof parsed.input === "string") return parsed.input;
+  } catch { /* raw freeform input */ }
+  return argumentsText;
+}
+
+function openAICompletionToResponses(responseBody, customToolNames = null) {
+  const choice = responseBody?.choices?.[0];
+  if (!choice) return responseBody;
+
+  const message = choice.message || {};
+  const output = [];
+
+  // Reasoning → a reasoning item (summary text), mirroring the streaming path.
+  const reasoning = message.reasoning_content || message.reasoning;
+  if (typeof reasoning === "string" && reasoning.length > 0) {
+    output.push({
+      type: RESPONSES_ITEM.REASONING,
+      summary: [{ type: RESPONSES_ITEM.SUMMARY_TEXT, text: reasoning }],
+    });
+  }
+
+  // Assistant text → a message item with output_text content.
+  const text = typeof message.content === "string" ? message.content : "";
+  if (text.length > 0) {
+    output.push({
+      type: RESPONSES_ITEM.MESSAGE,
+      role: ROLE.ASSISTANT,
+      content: [{ type: RESPONSES_ITEM.OUTPUT_TEXT, text, annotations: [] }],
+    });
+  }
+
+  // tool_calls → function_call/custom_tool_call items (Responses-native tool shape).
+  for (const tc of message.tool_calls || []) {
+    const fn = tc.function || {};
+    const custom = customToolNames?.has(fn.name);
+    output.push({
+      type: custom ? RESPONSES_ITEM.CUSTOM_TOOL_CALL : RESPONSES_ITEM.FUNCTION_CALL,
+      id: `${custom ? "ctc" : "fc"}_${tc.id || ""}`,
+      call_id: tc.id || "",
+      name: fn.name || "",
+      ...(custom
+        ? { input: extractCustomToolInput(fn.arguments) }
+        : { arguments: typeof fn.arguments === "string" ? fn.arguments : JSON.stringify(fn.arguments || {}) }),
+    });
+  }
+
+  const usage = responseBody.usage || {};
+  const status = choice.finish_reason === "tool_calls" ? "completed" : (choice.finish_reason === "stop" ? "completed" : (choice.finish_reason || "completed"));
+
+  return {
+    id: `resp_${responseBody.id || ""}`.replace(/^resp_chatcmpl-/, "resp_"),
+    object: "response",
+    created_at: responseBody.created || Math.floor(Date.now() / 1000),
+    model: responseBody.model || "unknown",
+    status,
+    background: false,
+    error: null,
+    output,
+    usage: {
+      input_tokens: usage.prompt_tokens || usage.input_tokens || 0,
+      output_tokens: usage.completion_tokens || usage.output_tokens || 0,
+      total_tokens: usage.total_tokens || (usage.prompt_tokens || 0) + (usage.completion_tokens || 0),
+    },
+  };
+}
+
 /**
  * Translate non-streaming response body from provider format → OpenAI format.
  */
-export function translateNonStreamingResponse(responseBody, targetFormat, sourceFormat) {
+export function translateNonStreamingResponse(responseBody, targetFormat, sourceFormat, customToolNames = null) {
   if (targetFormat === sourceFormat) return responseBody;
+  // Provider responded in OpenAI Chat Completions shape but the client speaks
+  // Responses API — convert so tool_calls/text surface as Responses `output`.
+  if (targetFormat === FORMATS.OPENAI && sourceFormat === FORMATS.OPENAI_RESPONSES) {
+    return openAICompletionToResponses(responseBody, customToolNames);
+  }
   if (targetFormat === FORMATS.OPENAI && sourceFormat === FORMATS.CLAUDE) {
     return openAICompletionToClaudeMessage(responseBody);
   }
@@ -198,7 +281,7 @@ export function translateNonStreamingResponse(responseBody, targetFormat, source
 /**
  * Handle non-streaming response from provider.
  */
-export async function handleNonStreamingResponse({ providerResponse, provider, model, sourceFormat, targetFormat, body, stream, translatedBody, finalBody, requestStartTime, connectionId, apiKey, clientRawRequest, onRequestSuccess, reqLogger, toolNameMap, trackDone, appendLog, pxpipe, reqTag, log }) {
+export async function handleNonStreamingResponse({ providerResponse, provider, model, sourceFormat, targetFormat, body, stream, translatedBody, finalBody, requestStartTime, connectionId, apiKey, clientRawRequest, onRequestSuccess, reqLogger, toolNameMap, customToolNames, trackDone, appendLog, pxpipe, reqTag, log }) {
   trackDone();
   const contentType = providerResponse.headers.get("content-type") || "";
   let responseBody;
@@ -239,9 +322,12 @@ export async function handleNonStreamingResponse({ providerResponse, provider, m
   if (log?.line) log.line(reqTag, "📊", formatDoneLine({ usage, latency: { total: Date.now() - requestStartTime } }));
 
   const translatedResponse = needsTranslation(targetFormat, sourceFormat)
-    ? translateNonStreamingResponse(responseBody, targetFormat, sourceFormat)
+    ? translateNonStreamingResponse(responseBody, targetFormat, sourceFormat, customToolNames)
     : responseBody;
   const isClaudeMessageResponse = sourceFormat === FORMATS.CLAUDE && translatedResponse?.type === "message";
+  // Responses-format translation produces a `object:"response"` body with no
+  // `choices`; skip the Chat-Completions-specific post-processing below for it.
+  const isResponsesResponse = sourceFormat === FORMATS.OPENAI_RESPONSES && translatedResponse?.object === "response";
 
   // Fix finish_reason for tool_calls: some providers return non-standard values (e.g. "other")
   if (translatedResponse?.choices?.[0]) {
@@ -254,13 +340,13 @@ export async function handleNonStreamingResponse({ providerResponse, provider, m
   }
 
   // Ensure OpenAI-required fields
-  if (!isClaudeMessageResponse) {
+  if (!isClaudeMessageResponse && !isResponsesResponse) {
     if (!translatedResponse.object) translatedResponse.object = "chat.completion";
     if (!translatedResponse.created) translatedResponse.created = Math.floor(Date.now() / 1000);
   }
 
   // Strip Azure-specific fields
-  if (!isClaudeMessageResponse) {
+  if (!isClaudeMessageResponse && !isResponsesResponse) {
     delete translatedResponse.prompt_filter_results;
     if (translatedResponse?.choices) {
       for (const choice of translatedResponse.choices) delete choice.content_filter_results;
@@ -274,7 +360,7 @@ export async function handleNonStreamingResponse({ providerResponse, provider, m
   // Strip reasoning_content only when content is non-empty.
   // When content is empty (e.g. thinking models that used all tokens for reasoning),
   // reasoning_content is the only useful output and must be preserved.
-  if (!isClaudeMessageResponse && translatedResponse?.choices) {
+  if (!isClaudeMessageResponse && !isResponsesResponse && translatedResponse?.choices) {
     for (const choice of translatedResponse.choices) {
       if (choice?.message?.reasoning_content && choice.message.content) {
         delete choice.message.reasoning_content;
diff --git a/open-sse/handlers/chatCore/sseToJsonHandler.js b/open-sse/handlers/chatCore/sseToJsonHandler.js
index 91cff8ac..6801be89 100644
--- a/open-sse/handlers/chatCore/sseToJsonHandler.js
+++ b/open-sse/handlers/chatCore/sseToJsonHandler.js
@@ -4,6 +4,7 @@ import { HTTP_STATUS } from "../../config/runtimeConfig.js";
 import { FORMATS } from "../../translator/formats.js";
 import { PROVIDERS } from "../../config/providers.js";
 import { buildRequestDetail, extractRequestConfig, saveUsageStats, formatDoneLine } from "./requestDetail.js";
+import { ROLE, RESPONSES_ITEM } from "../../translator/schema/index.js";
 
 // Responses-API providers (e.g. codex) may emit SSE without content-type + use Responses output shape
 const isResponsesProvider = (p) => PROVIDERS[p]?.format === FORMATS.OPENAI_RESPONSES;
@@ -34,6 +35,76 @@ function pickAssistantMessageForChatCompletion(output) {
   return { msgItem: last, textContent: textFromResponsesMessageItem(last) };
 }
 
+/**
+ * Convert an OpenAI Chat Completions JSON body into the Responses API shape.
+ * Inlined here (not imported from nonStreamingHandler.js) to avoid a circular
+ * import. Mirrors openAICompletionToResponses in nonStreamingHandler.js.
+ */
+function extractCustomToolInput(argumentsValue) {
+  const argumentsText = typeof argumentsValue === "string" ? argumentsValue : JSON.stringify(argumentsValue || {});
+  try {
+    const parsed = JSON.parse(argumentsText);
+    if (parsed && typeof parsed === "object" && typeof parsed.input === "string") return parsed.input;
+  } catch { /* raw freeform input */ }
+  return argumentsText;
+}
+
+function chatCompletionToResponses(responseBody, customToolNames = null) {
+  const choice = responseBody?.choices?.[0];
+  if (!choice) return responseBody;
+
+  const message = choice.message || {};
+  const output = [];
+
+  const reasoning = message.reasoning_content || message.reasoning;
+  if (typeof reasoning === "string" && reasoning.length > 0) {
+    output.push({
+      type: RESPONSES_ITEM.REASONING,
+      summary: [{ type: RESPONSES_ITEM.SUMMARY_TEXT, text: reasoning }],
+    });
+  }
+
+  const text = typeof message.content === "string" ? message.content : "";
+  if (text.length > 0) {
+    output.push({
+      type: RESPONSES_ITEM.MESSAGE,
+      role: ROLE.ASSISTANT,
+      content: [{ type: RESPONSES_ITEM.OUTPUT_TEXT, text, annotations: [] }],
+    });
+  }
+
+  for (const tc of message.tool_calls || []) {
+    const fn = tc.function || {};
+    const custom = customToolNames?.has(fn.name);
+    output.push({
+      type: custom ? RESPONSES_ITEM.CUSTOM_TOOL_CALL : RESPONSES_ITEM.FUNCTION_CALL,
+      id: `${custom ? "ctc" : "fc"}_${tc.id || ""}`,
+      call_id: tc.id || "",
+      name: fn.name || "",
+      ...(custom
+        ? { input: extractCustomToolInput(fn.arguments) }
+        : { arguments: typeof fn.arguments === "string" ? fn.arguments : JSON.stringify(fn.arguments || {}) }),
+    });
+  }
+
+  const usage = responseBody.usage || {};
+  return {
+    id: `resp_${responseBody.id || ""}`.replace(/^resp_chatcmpl-/, "resp_"),
+    object: "response",
+    created_at: responseBody.created || Math.floor(Date.now() / 1000),
+    model: responseBody.model || "unknown",
+    status: "completed",
+    background: false,
+    error: null,
+    output,
+    usage: {
+      input_tokens: usage.prompt_tokens || usage.input_tokens || 0,
+      output_tokens: usage.completion_tokens || usage.output_tokens || 0,
+      total_tokens: usage.total_tokens || (usage.prompt_tokens || 0) + (usage.completion_tokens || 0),
+    },
+  };
+}
+
 /**
  * Parse OpenAI-style SSE text into a single chat completion JSON.
  * Used when provider forces streaming but client wants non-streaming.
@@ -108,7 +179,7 @@ export function parseSSEToOpenAIResponse(rawSSE, fallbackModel) {
  * Handle case: provider forced streaming but client wants JSON.
  * Supports both Codex/Responses API SSE and standard Chat Completions SSE.
  */
-export async function handleForcedSSEToJson({ providerResponse, sourceFormat, provider, model, body, stream, translatedBody, finalBody, requestStartTime, connectionId, apiKey, clientRawRequest, onRequestSuccess, trackDone, appendLog, reqTag, log }) {
+export async function handleForcedSSEToJson({ providerResponse, sourceFormat, targetFormat, provider, model, body, stream, translatedBody, finalBody, requestStartTime, connectionId, apiKey, clientRawRequest, onRequestSuccess, customToolNames, trackDone, appendLog, reqTag, log }) {
   const contentType = providerResponse.headers.get("content-type") || "";
   const isSSE = contentType.includes("text/event-stream") || (contentType === "" && isResponsesProvider(provider));
   if (!isSSE) return null; // not handled here
@@ -122,7 +193,10 @@ export async function handleForcedSSEToJson({ providerResponse, sourceFormat, pr
   };
 
   // Codex/Responses API SSE path
-  const isCodexResponsesApi = isResponsesProvider(provider) || sourceFormat === FORMATS.OPENAI_RESPONSES;
+  // Branch on the UPSTREAM format (targetFormat = format we spoke to the provider in),
+  // not the client format: a Responses-API client behind a chat-native forced-streaming
+  // provider still receives chat SSE chunks, which must go through the standard path.
+  const isCodexResponsesApi = isResponsesProvider(provider) || targetFormat === FORMATS.OPENAI_RESPONSES;
   if (isCodexResponsesApi) {
     try {
       const jsonResponse = await convertResponsesStreamToJson(providerResponse.body);
@@ -267,7 +341,17 @@ export async function handleForcedSSEToJson({ providerResponse, sourceFormat, pr
       }
     }
 
-    return { success: true, response: new Response(JSON.stringify(parsed), { headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" } }) };
+    // A Responses-format client (e.g. Codex) forced this provider to stream,
+    // but wants JSON back. parseSSEToOpenAIResponse yields a Chat Completions
+    // body; convert it to the Responses `output` shape so tool_calls are not
+    // lost on the non-streaming return path. Inlined (not imported from
+    // nonStreamingHandler.js) to avoid a circular import: nonStreamingHandler
+    // already imports parseSSEToOpenAIResponse from this module.
+    const finalBody = sourceFormat === FORMATS.OPENAI_RESPONSES
+      ? chatCompletionToResponses(parsed, customToolNames)
+      : parsed;
+
+    return { success: true, response: new Response(JSON.stringify(finalBody), { headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" } }) };
   } catch (err) {
     console.error("[ChatCore] Chat Completions SSE→JSON failed:", err);
     return createErrorResult(HTTP_STATUS.BAD_GATEWAY, "Failed to convert streaming response to JSON");
diff --git a/open-sse/handlers/chatCore/streamingHandler.js b/open-sse/handlers/chatCore/streamingHandler.js
index 1fb8a322..be008e7d 100644
--- a/open-sse/handlers/chatCore/streamingHandler.js
+++ b/open-sse/handlers/chatCore/streamingHandler.js
@@ -22,7 +22,7 @@ const CODEX_SOURCE_TO_TARGET = {
 /**
  * Determine which SSE transform stream to use based on provider/format.
  */
-function buildTransformStream({ provider, sourceFormat, targetFormat, userAgent, reqLogger, toolNameMap, model, connectionId, body, onStreamComplete, apiKey }) {
+function buildTransformStream({ provider, sourceFormat, targetFormat, userAgent, reqLogger, toolNameMap, customToolNames, model, connectionId, body, onStreamComplete, apiKey }) {
   const isDroidCLI = userAgent?.toLowerCase().includes("droid") || userAgent?.toLowerCase().includes("codex-cli");
   // Responses-API providers (e.g. codex) emit Responses SSE → translate into client format
   const isResponsesProvider = PROVIDERS[provider]?.format === FORMATS.OPENAI_RESPONSES;
@@ -30,11 +30,11 @@ function buildTransformStream({ provider, sourceFormat, targetFormat, userAgent,
 
   if (needsCodexTranslation) {
     const codexTarget = CODEX_SOURCE_TO_TARGET[sourceFormat] || FORMATS.OPENAI;
-    return createSSETransformStreamWithLogger(FORMATS.OPENAI_RESPONSES, codexTarget, provider, reqLogger, toolNameMap, model, connectionId, body, onStreamComplete, apiKey);
+    return createSSETransformStreamWithLogger(FORMATS.OPENAI_RESPONSES, codexTarget, provider, reqLogger, toolNameMap, model, connectionId, body, onStreamComplete, apiKey, customToolNames);
   }
 
   if (needsTranslation(targetFormat, sourceFormat)) {
-    return createSSETransformStreamWithLogger(targetFormat, sourceFormat, provider, reqLogger, toolNameMap, model, connectionId, body, onStreamComplete, apiKey);
+    return createSSETransformStreamWithLogger(targetFormat, sourceFormat, provider, reqLogger, toolNameMap, model, connectionId, body, onStreamComplete, apiKey, customToolNames);
   }
 
   return createPassthroughStreamWithLogger(provider, reqLogger, model, connectionId, body, onStreamComplete, apiKey);
@@ -43,7 +43,7 @@ function buildTransformStream({ provider, sourceFormat, targetFormat, userAgent,
 /**
  * Handle streaming response — pipe provider SSE through transform stream to client.
  */
-export async function handleStreamingResponse({ providerResponse, provider, model, sourceFormat, targetFormat, userAgent, body, stream, translatedBody, finalBody, requestStartTime, connectionId, apiKey, clientRawRequest, onRequestSuccess, reqLogger, toolNameMap, streamController, onStreamComplete, streamDetailId, pxpipe, reqTag, log }) {
+export async function handleStreamingResponse({ providerResponse, provider, model, sourceFormat, targetFormat, userAgent, body, stream, translatedBody, finalBody, requestStartTime, connectionId, apiKey, clientRawRequest, onRequestSuccess, reqLogger, toolNameMap, customToolNames, streamController, onStreamComplete, streamDetailId, pxpipe, reqTag, log }) {
   if (onRequestSuccess) {
     Promise.resolve()
       .then(onRequestSuccess)
@@ -79,7 +79,7 @@ export async function handleStreamingResponse({ providerResponse, provider, mode
     };
   }
 
-  const transformStream = buildTransformStream({ provider, sourceFormat, targetFormat, userAgent, reqLogger, toolNameMap, model, connectionId, body, onStreamComplete, apiKey });
+  const transformStream = buildTransformStream({ provider, sourceFormat, targetFormat, userAgent, reqLogger, toolNameMap, customToolNames, model, connectionId, body, onStreamComplete, apiKey });
 
   // Responses passthrough: synthesize response.failed + [DONE] if the stream aborts/stalls before a terminal event
   const isResponsesPassthrough = sourceFormat === FORMATS.OPENAI_RESPONSES && targetFormat === FORMATS.OPENAI_RESPONSES;
diff --git a/open-sse/services/provider.js b/open-sse/services/provider.js
index 1b02cd83..50f0589d 100644
--- a/open-sse/services/provider.js
+++ b/open-sse/services/provider.js
@@ -19,9 +19,15 @@ function isAnthropicCompatible(provider) {
   return typeof provider === "string" && provider.startsWith(ANTHROPIC_COMPATIBLE_PREFIX);
 }
 
-function getOpenAICompatibleType(provider) {
-  if (!isOpenAICompatible(provider)) return "chat";
-  return provider.includes("responses") ? "responses" : "chat";
+// Resolve the API type (chat vs responses) for an openai-compatible node.
+// The stored apiType on the connection's providerSpecificData (kept in sync with
+// the node on create/update) is authoritative. Falls back to the node ID
+// substring for legacy nodes created before apiType was persisted — their IDs
+// embed the type: openai-compatible-<chat|responses>-<uuid>.
+export function resolveOpenAICompatibleApiType(provider, credentials = null) {
+  const stored = credentials?.providerSpecificData?.apiType;
+  if (stored === "chat" || stored === "responses") return stored;
+  return typeof provider === "string" && provider.includes("responses") ? "responses" : "chat";
 }
 
 // Detect request format from body structure
@@ -105,9 +111,9 @@ export function detectFormat(body) {
 }
 
 // Get provider config (internal — no external runtime consumer)
-function getProviderConfig(provider) {
+function getProviderConfig(provider, credentials = null) {
   if (isOpenAICompatible(provider)) {
-    const apiType = getOpenAICompatibleType(provider);
+    const apiType = resolveOpenAICompatibleApiType(provider, credentials);
     return {
       ...PROVIDERS.openai,
       format: apiType === "responses" ? "openai-responses" : "openai",
@@ -125,14 +131,14 @@ function getProviderConfig(provider) {
 }
 
 // Get target format for provider
-export function getTargetFormat(provider) {
+export function getTargetFormat(provider, credentials = null) {
   if (isOpenAICompatible(provider)) {
-    return getOpenAICompatibleType(provider) === "responses" ? "openai-responses" : "openai";
+    return resolveOpenAICompatibleApiType(provider, credentials) === "responses" ? "openai-responses" : "openai";
   }
   if (isAnthropicCompatible(provider)) {
     return "claude";
   }
-  const config = getProviderConfig(provider);
+  const config = getProviderConfig(provider, credentials);
   return config.format || "openai";
 }
 
diff --git a/open-sse/translator/index.js b/open-sse/translator/index.js
index 48bd1530..e2f45339 100644
--- a/open-sse/translator/index.js
+++ b/open-sse/translator/index.js
@@ -258,8 +258,10 @@ export function initState(sourceFormat) {
       funcArgsBuf: {},
       funcNames: {},
       funcCallIds: {},
+      funcItemAdded: {},
       funcArgsDone: {},
       funcItemDone: {},
+      customToolNames: new Set(),
       completedSent: false
     };
   }
diff --git a/open-sse/translator/request/openai-responses.js b/open-sse/translator/request/openai-responses.js
index ecfa26d6..b821f3a4 100644
--- a/open-sse/translator/request/openai-responses.js
+++ b/open-sse/translator/request/openai-responses.js
@@ -32,6 +32,8 @@ export function openaiResponsesToOpenAIRequest(model, body, stream, credentials)
   let pendingToolResults = [];
   let pendingReasoning = "";
   let pendingReasoningEncrypted = "";
+  const additionalTools = [];
+  const customToolNames = new Set();
 
   const inputItems = normalizeResponsesInput(body.input);
   if (!inputItems) return body;
@@ -96,7 +98,7 @@ export function openaiResponsesToOpenAIRequest(model, body, stream, credentials)
       }
       result.messages.push(msg);
     }
-    else if (itemType === RESPONSES_ITEM.FUNCTION_CALL) {
+    else if (itemType === RESPONSES_ITEM.FUNCTION_CALL || itemType === RESPONSES_ITEM.CUSTOM_TOOL_CALL) {
       // Start or append to assistant message with tool_calls
       if (!currentAssistantMsg) {
         currentAssistantMsg = {
@@ -108,16 +110,20 @@ export function openaiResponsesToOpenAIRequest(model, body, stream, credentials)
       }
       // Skip items with empty/missing name — Codex/OpenAI reject nameless tool calls (#444)
       if (!item.name || typeof item.name !== "string" || item.name.trim() === "") continue;
+      if (itemType === RESPONSES_ITEM.CUSTOM_TOOL_CALL) customToolNames.add(item.name);
+      const toolInput = itemType === RESPONSES_ITEM.CUSTOM_TOOL_CALL
+        ? { input: typeof item.input === "string" ? item.input : JSON.stringify(item.input ?? "") }
+        : item.arguments;
       currentAssistantMsg.tool_calls.push({
         id: item.call_id,
         type: OPENAI_BLOCK.FUNCTION,
         function: {
           name: item.name,
-          arguments: item.arguments
+          arguments: typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput ?? {})
         }
       });
     }
-    else if (itemType === RESPONSES_ITEM.FUNCTION_CALL_OUTPUT) {
+    else if (itemType === RESPONSES_ITEM.FUNCTION_CALL_OUTPUT || itemType === RESPONSES_ITEM.CUSTOM_TOOL_CALL_OUTPUT) {
       // Flush assistant message first if exists
       if (currentAssistantMsg) {
         result.messages.push(currentAssistantMsg);
@@ -137,6 +143,9 @@ export function openaiResponsesToOpenAIRequest(model, body, stream, credentials)
         content: typeof item.output === "string" ? item.output : JSON.stringify(item.output)
       });
     }
+    else if (itemType === RESPONSES_ITEM.ADDITIONAL_TOOLS) {
+      if (Array.isArray(item.tools)) additionalTools.push(...item.tools);
+    }
     else if (itemType === RESPONSES_ITEM.REASONING) {
       // Buffer reasoning text; attached to next assistant message/function_call.
       // Also stash encrypted_content so a later openai→responses hop can restore
@@ -166,15 +175,45 @@ export function openaiResponsesToOpenAIRequest(model, body, stream, credentials)
   // explicit `name` field and cannot be represented as Chat Completions function declarations.
   // Filter them out to avoid sending nameless functionDeclarations to downstream providers
   // such as Gemini, which strictly validates function names.
-  if (body.tools && Array.isArray(body.tools)) {
-    result.tools = body.tools
+  const responseTools = [
+    ...(Array.isArray(body.tools) ? body.tools : []),
+    ...additionalTools,
+  ];
+  if (responseTools.length > 0) {
+    result.tools = responseTools
       .map(tool => {
         // Already in Chat Completions format: { type: "function", function: { name, ... } }
         if (tool.function) return tool;
-        // Responses API function tool: { type: "function", name, description, parameters }
-        // Only convert when a non-empty name is present; skip hosted tools without one.
+        // Responses API function/custom tool: { type, name, description, parameters|format }.
+        // Chat Completions has no freeform custom-tool declaration, so expose custom
+        // tools as functions with one raw `input` string while retaining their names
+        // in translator-only metadata for the response conversion.
         const name = tool.name;
         if (!name || typeof name !== "string" || name.trim() === "") return null;
+        if (tool.type === "custom") {
+          customToolNames.add(name);
+          const formatHint = [tool.format?.syntax, tool.format?.definition].filter(Boolean).join("\n");
+          return {
+            type: OPENAI_BLOCK.FUNCTION,
+            function: {
+              name,
+              description: [String(tool.description || ""), formatHint].filter(Boolean).join("\n\n"),
+              parameters: {
+                type: "object",
+                properties: {
+                  input: {
+                    type: "string",
+                    description: "Raw freeform input for this custom tool"
+                  }
+                },
+                required: ["input"],
+                additionalProperties: false
+              }
+            }
+          };
+        }
+        // Responses API function tool: { type: "function", name, description, parameters }
+        // Only convert when a non-empty name is present; skip hosted tools without one.
         return {
           type: OPENAI_BLOCK.FUNCTION,
           function: {
@@ -187,6 +226,7 @@ export function openaiResponsesToOpenAIRequest(model, body, stream, credentials)
       })
       .filter(Boolean);
   }
+  if (customToolNames.size > 0) result._customToolNames = [...customToolNames];
 
   // Cleanup Responses API specific fields
   // Map Responses-only max_output_tokens to Chat max_tokens (avoid leaking unknown field upstream)
diff --git a/open-sse/translator/response/openai-responses.js b/open-sse/translator/response/openai-responses.js
index b9336785..92e3cb52 100644
--- a/open-sse/translator/response/openai-responses.js
+++ b/open-sse/translator/response/openai-responses.js
@@ -258,24 +258,43 @@ function closeMessage(state, emit, idx) {
   }
 }
 
+function isCustomTool(state, name) {
+  return !!name && state.customToolNames?.has(name);
+}
+
+function extractCustomToolInput(argumentsText) {
+  if (typeof argumentsText !== "string") return "";
+  try {
+    const parsed = JSON.parse(argumentsText);
+    if (parsed && typeof parsed === "object" && typeof parsed.input === "string") return parsed.input;
+  } catch { /* incomplete or raw freeform input */ }
+  return argumentsText;
+}
+
 function emitToolCall(state, emit, tc) {
   const tcIdx = tc.index ?? 0;
   const newCallId = tc.id;
   const funcName = tc.function?.name;
 
   if (funcName) state.funcNames[tcIdx] = funcName;
+  if (newCallId) state.funcCallIds[tcIdx] = newCallId;
+
+  // Some compatible providers split the call id and function name across
+  // chunks. Wait for both before deciding whether this is a custom tool;
+  // otherwise an `exec` call can be irreversibly announced as function_call.
+  const callId = state.funcCallIds[tcIdx];
+  if (!state.funcItemAdded[tcIdx] && callId && state.funcNames[tcIdx]) {
+    state.funcItemAdded[tcIdx] = true;
+    const custom = isCustomTool(state, state.funcNames[tcIdx]);
 
-  if (!state.funcCallIds[tcIdx] && newCallId) {
-    state.funcCallIds[tcIdx] = newCallId;
-    
     emit("response.output_item.added", {
       type: "response.output_item.added",
       output_index: tcIdx,
       item: {
-        id: `fc_${newCallId}`,
-        type: RESPONSES_ITEM.FUNCTION_CALL,
-        arguments: "",
-        call_id: newCallId,
+        id: `${custom ? "ctc" : "fc"}_${callId}`,
+        type: custom ? RESPONSES_ITEM.CUSTOM_TOOL_CALL : RESPONSES_ITEM.FUNCTION_CALL,
+        ...(custom ? { input: "" } : { arguments: "" }),
+        call_id: callId,
         name: state.funcNames[tcIdx] || ""
       }
     });
@@ -285,7 +304,7 @@ function emitToolCall(state, emit, tc) {
 
   if (tc.function?.arguments) {
     const refCallId = state.funcCallIds[tcIdx] || newCallId;
-    if (refCallId) {
+    if (state.funcItemAdded[tcIdx] && refCallId && !isCustomTool(state, state.funcNames[tcIdx])) {
       emit("response.function_call_arguments.delta", {
         type: "response.function_call_arguments.delta",
         item_id: `fc_${refCallId}`,
@@ -293,6 +312,9 @@ function emitToolCall(state, emit, tc) {
         delta: tc.function.arguments
       });
     }
+    // Custom input is emitted once at close, after the Chat JSON wrapper can be
+    // parsed and unwrapped. Streaming the raw JSON fragments would expose
+    // {"input":"..."} instead of the freeform program Codex expects.
     state.funcArgsBuf[tcIdx] += tc.function.arguments;
   }
 }
@@ -301,21 +323,38 @@ function closeToolCall(state, emit, idx) {
   const callId = state.funcCallIds[idx];
   if (callId && !state.funcItemDone[idx]) {
     const args = state.funcArgsBuf[idx] || "{}";
-    
-    emit("response.function_call_arguments.done", {
-      type: "response.function_call_arguments.done",
-      item_id: `fc_${callId}`,
-      output_index: parseInt(idx),
-      arguments: args
-    });
+    const custom = isCustomTool(state, state.funcNames[idx]);
+
+    if (custom) {
+      const input = extractCustomToolInput(args);
+      emit("response.custom_tool_call_input.delta", {
+        type: "response.custom_tool_call_input.delta",
+        item_id: `ctc_${callId}`,
+        output_index: parseInt(idx),
+        delta: input
+      });
+      emit("response.custom_tool_call_input.done", {
+        type: "response.custom_tool_call_input.done",
+        item_id: `ctc_${callId}`,
+        output_index: parseInt(idx),
+        input
+      });
+    } else {
+      emit("response.function_call_arguments.done", {
+        type: "response.function_call_arguments.done",
+        item_id: `fc_${callId}`,
+        output_index: parseInt(idx),
+        arguments: args
+      });
+    }
 
     emit("response.output_item.done", {
       type: "response.output_item.done",
       output_index: parseInt(idx),
       item: {
-        id: `fc_${callId}`,
-        type: RESPONSES_ITEM.FUNCTION_CALL,
-        arguments: args,
+        id: `${custom ? "ctc" : "fc"}_${callId}`,
+        type: custom ? RESPONSES_ITEM.CUSTOM_TOOL_CALL : RESPONSES_ITEM.FUNCTION_CALL,
+        ...(custom ? { input: extractCustomToolInput(args) } : { arguments: args }),
         call_id: callId,
         name: state.funcNames[idx] || ""
       }
diff --git a/open-sse/translator/schema/blocks.js b/open-sse/translator/schema/blocks.js
index 61c25645..958122ce 100644
--- a/open-sse/translator/schema/blocks.js
+++ b/open-sse/translator/schema/blocks.js
@@ -27,6 +27,9 @@ export const RESPONSES_ITEM = {
   MESSAGE: "message",
   FUNCTION_CALL: "function_call",
   FUNCTION_CALL_OUTPUT: "function_call_output",
+  CUSTOM_TOOL_CALL: "custom_tool_call",
+  CUSTOM_TOOL_CALL_OUTPUT: "custom_tool_call_output",
+  ADDITIONAL_TOOLS: "additional_tools",
   REASONING: "reasoning",
   OUTPUT_TEXT: "output_text",
   INPUT_TEXT: "input_text",
diff --git a/open-sse/utils/stream.js b/open-sse/utils/stream.js
index 464acde4..33e7fb04 100644
--- a/open-sse/utils/stream.js
+++ b/open-sse/utils/stream.js
@@ -44,6 +44,7 @@ export function createSSEStream(options = {}) {
     provider = null,
     reqLogger = null,
     toolNameMap = null,
+    customToolNames = null,
     model = null,
     connectionId = null,
     body = null,
@@ -57,7 +58,9 @@ export function createSSEStream(options = {}) {
   // Per-stream decoder with stream:true to correctly handle multi-byte chars split across chunks
   const decoder = new TextDecoder("utf-8", { fatal: false });
 
-  const state = mode === STREAM_MODE.TRANSLATE ? { ...initState(sourceFormat), provider, toolNameMap, model } : null;
+  const state = mode === STREAM_MODE.TRANSLATE
+    ? { ...initState(sourceFormat), provider, toolNameMap, customToolNames: new Set(customToolNames || []), model }
+    : null;
 
   let totalContentLength = 0;
   let accumulatedContent = "";
@@ -464,7 +467,7 @@ export function createSSEStream(options = {}) {
   });
 }
 
-export function createSSETransformStreamWithLogger(targetFormat, sourceFormat, provider = null, reqLogger = null, toolNameMap = null, model = null, connectionId = null, body = null, onStreamComplete = null, apiKey = null) {
+export function createSSETransformStreamWithLogger(targetFormat, sourceFormat, provider = null, reqLogger = null, toolNameMap = null, model = null, connectionId = null, body = null, onStreamComplete = null, apiKey = null, customToolNames = null) {
   return createSSEStream({
     mode: STREAM_MODE.TRANSLATE,
     targetFormat,
@@ -472,6 +475,7 @@ export function createSSETransformStreamWithLogger(targetFormat, sourceFormat, p
     provider,
     reqLogger,
     toolNameMap,
+    customToolNames,
     model,
     connectionId,
     body,
diff --git a/tests/translator/bugs-codexCli-responses.test.js b/tests/translator/bugs-codexCli-responses.test.js
index c3401341..573b5eb0 100644
--- a/tests/translator/bugs-codexCli-responses.test.js
+++ b/tests/translator/bugs-codexCli-responses.test.js
@@ -20,9 +20,7 @@ describe("Codex CLI Responses → OpenAI", () => {
     expect(asst?.tool_calls?.length ?? 0, "empty tool_calls[] produced").toBeGreaterThan(0);
   });
 
-  // openai-responses.js:109-110 — arguments passed through without ensuring string type
-  // KNOWN BUG
-  it.fails("function_call arguments end up as a string", () => {
+  it("function_call arguments end up as a string", () => {
     const out = R2O({
       input: [{ type: "function_call", call_id: "c1", name: "f", arguments: { a: 1 } }],
     });
diff --git a/tests/unit/continuity-strip.test.js b/tests/unit/continuity-strip.test.js
new file mode 100644
index 00000000..c80d5945
--- /dev/null
+++ b/tests/unit/continuity-strip.test.js
@@ -0,0 +1,80 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("@/lib/usageDb.js", () => ({
+  appendRequestLog: vi.fn(async () => {}),
+  saveRequestDetail: vi.fn(async () => {}),
+  saveRequestUsage: vi.fn(async () => {})
+}));
+
+const { stripContinuityFields } = await import("../../open-sse/handlers/chatCore.js");
+const { openaiResponsesToOpenAIRequest } = await import("../../open-sse/translator/request/openai-responses.js");
+
+// Multi-turn Codex-style Responses input: reasoning item carrying a
+// store=false encrypted_content continuity blob between tool turns.
+const makeResponsesBody = () => ({
+  model: "x",
+  instructions: "You are Codex.",
+  store: false,
+  include: ["reasoning.encrypted_content"],
+  reasoning: { effort: "low", summary: "auto" },
+  input: [
+    { role: "user", content: [{ type: "input_text", text: "Run: echo hi" }] },
+    {
+      type: "reasoning",
+      id: "rs_1",
+      summary: [{ type: "summary_text", text: "thinking" }],
+      encrypted_content: "B".repeat(5000)
+    },
+    { type: "function_call", id: "fc_1", call_id: "call_1", name: "shell", arguments: "{\"command\":\"echo hi\"}" },
+    { type: "function_call_output", call_id: "call_1", output: "hi" },
+    { role: "user", content: [{ type: "input_text", text: "Now run: echo bye" }] }
+  ],
+  tools: [{
+    type: "function",
+    name: "shell",
+    description: "Run a shell command",
+    parameters: { type: "object", properties: { command: { type: "string" } }, required: ["command"] }
+  }]
+});
+
+describe("stripContinuityFields (outbound boundary)", () => {
+  it("removes continuity blobs from assistant messages", () => {
+    const body = {
+      messages: [
+        { role: "user", content: "hi" },
+        { role: "assistant", content: null, reasoning_content: "thinking",
+          encrypted_content: "B".repeat(500), reasoning_encrypted_content: "alias",
+          tool_calls: [{ id: "call_1", type: "function", function: { name: "shell", arguments: "{}" } }] }
+      ]
+    };
+    stripContinuityFields(body);
+    const assistant = body.messages[1];
+    expect(assistant).not.toHaveProperty("encrypted_content");
+    expect(assistant).not.toHaveProperty("reasoning_encrypted_content");
+    // legitimate fields survive
+    expect(assistant.reasoning_content).toBe("thinking");
+    expect(assistant.tool_calls[0].function.name).toBe("shell");
+  });
+
+  it("is a no-op for bodies without a messages array", () => {
+    const body = { input: [], instructions: "x" };
+    expect(stripContinuityFields(body)).toBe(body);
+    expect(stripContinuityFields(null)).toBe(null);
+  });
+
+  it("end-to-end: Responses multi-turn translation stripped before dispatch", () => {
+    const translated = openaiResponsesToOpenAIRequest("x", makeResponsesBody(), false, {});
+    // The translator stashes the blob for internal round-trip symmetry...
+    const assistantBefore = translated.messages.find((m) => m.role === "assistant");
+    expect(assistantBefore.encrypted_content).toBe("B".repeat(5000));
+    // ...and the outbound boundary removes it before it reaches any upstream.
+    stripContinuityFields(translated);
+    expect(JSON.stringify(translated)).not.toContain("encrypted_content");
+    expect(JSON.stringify(translated)).not.toContain("B".repeat(100));
+    const assistant = translated.messages.find((m) => m.role === "assistant");
+    expect(assistant.reasoning_content).toContain("thinking");
+    expect(assistant.tool_calls[0].function.name).toBe("shell");
+    const roles = translated.messages.map((m) => m.role);
+    expect(roles).toEqual(["system", "user", "assistant", "tool", "user"]);
+  });
+});
diff --git a/tests/unit/openai-compatible-apitype-resolution.test.js b/tests/unit/openai-compatible-apitype-resolution.test.js
new file mode 100644
index 00000000..0199ed4d
--- /dev/null
+++ b/tests/unit/openai-compatible-apitype-resolution.test.js
@@ -0,0 +1,76 @@
+// Locks openai-compatible apiType resolution: the stored apiType on the
+// connection's providerSpecificData (kept in sync with the node) is
+// authoritative, and the node-ID substring is only a legacy fallback.
+//
+// Regression for: editing a node's apiType to "responses" had no effect because
+// runtime derived chat/responses from the immutable node ID string
+// (`openai-compatible-<chat|responses>-<uuid>`) instead of the stored value.
+import { describe, it, expect } from "vitest";
+import { resolveOpenAICompatibleApiType, getTargetFormat } from "open-sse/services/provider.js";
+import { DefaultExecutor } from "open-sse/executors/default.js";
+import { BaseExecutor } from "open-sse/executors/base.js";
+
+const CHAT_ID = "openai-compatible-chat-3d8d3de8-1206-47ee-a42f-22113a5f2387";
+const RESPONSES_ID = "openai-compatible-responses-11111111-2222-3333-4444-555555555555";
+const BASE = "https://api.ericding.io.vn/v1";
+
+function creds(apiType) {
+  return { providerSpecificData: apiType === undefined ? { baseUrl: BASE } : { baseUrl: BASE, apiType } };
+}
+
+describe("resolveOpenAICompatibleApiType", () => {
+  it("prefers stored apiType over the ID substring (edited node on a legacy -chat- ID)", () => {
+    expect(resolveOpenAICompatibleApiType(CHAT_ID, creds("responses"))).toBe("responses");
+    expect(resolveOpenAICompatibleApiType(RESPONSES_ID, creds("chat"))).toBe("chat");
+  });
+
+  it("falls back to the ID substring when apiType is absent", () => {
+    expect(resolveOpenAICompatibleApiType(CHAT_ID, creds(undefined))).toBe("chat");
+    expect(resolveOpenAICompatibleApiType(RESPONSES_ID, creds(undefined))).toBe("responses");
+    expect(resolveOpenAICompatibleApiType(CHAT_ID, null)).toBe("chat");
+    expect(resolveOpenAICompatibleApiType(RESPONSES_ID, null)).toBe("responses");
+  });
+
+  it("ignores an invalid stored apiType and falls back to the ID", () => {
+    expect(resolveOpenAICompatibleApiType(RESPONSES_ID, creds("bogus"))).toBe("responses");
+    expect(resolveOpenAICompatibleApiType(CHAT_ID, creds(""))).toBe("chat");
+  });
+});
+
+describe("getTargetFormat", () => {
+  it("selects openai-responses when the stored apiType is responses (even on a -chat- ID)", () => {
+    expect(getTargetFormat(CHAT_ID, creds("responses"))).toBe("openai-responses");
+  });
+
+  it("selects openai for chat, and honors stored chat over a -responses- ID", () => {
+    expect(getTargetFormat(CHAT_ID, creds(undefined))).toBe("openai");
+    expect(getTargetFormat(RESPONSES_ID, creds("chat"))).toBe("openai");
+  });
+
+  it("keeps the ID-based fallback when credentials are absent", () => {
+    expect(getTargetFormat(RESPONSES_ID)).toBe("openai-responses");
+    expect(getTargetFormat(CHAT_ID)).toBe("openai");
+  });
+});
+
+describe("executor buildUrl endpoint path", () => {
+  for (const [name, Ex] of [["DefaultExecutor", DefaultExecutor], ["BaseExecutor", BaseExecutor]]) {
+    describe(name, () => {
+      const ex = new Ex(CHAT_ID);
+
+      it("routes to /responses when stored apiType is responses, despite the -chat- ID", () => {
+        expect(ex.buildUrl("cx/gpt-5.6-sol", true, 0, creds("responses"))).toBe(`${BASE}/responses`);
+      });
+
+      it("routes to /chat/completions when apiType is chat", () => {
+        expect(ex.buildUrl("cx/gpt-5.6-sol", true, 0, creds("chat"))).toBe(`${BASE}/chat/completions`);
+      });
+
+      it("falls back to the ID substring (legacy) when apiType is absent", () => {
+        expect(ex.buildUrl("cx/gpt-5.6-sol", true, 0, creds(undefined))).toBe(`${BASE}/chat/completions`);
+        const exResp = new Ex(RESPONSES_ID);
+        expect(exResp.buildUrl("m", true, 0, creds(undefined))).toBe(`${BASE}/responses`);
+      });
+    });
+  }
+});
diff --git a/tests/unit/openai-responses-custom-tools.test.js b/tests/unit/openai-responses-custom-tools.test.js
new file mode 100644
index 00000000..9145243c
--- /dev/null
+++ b/tests/unit/openai-responses-custom-tools.test.js
@@ -0,0 +1,153 @@
+import { describe, expect, it } from "vitest";
+import {
+  openaiResponsesToOpenAIRequest,
+} from "../../open-sse/translator/request/openai-responses.js";
+import { openaiToOpenAIResponsesResponse } from "../../open-sse/translator/response/openai-responses.js";
+import { initState } from "../../open-sse/translator/index.js";
+import { FORMATS } from "../../open-sse/translator/formats.js";
+
+const EXEC_TOOL = {
+  type: "custom",
+  name: "exec",
+  description: "Run JavaScript code to orchestrate tool calls.",
+  format: {
+    type: "grammar",
+    syntax: "lark",
+    definition: "start: /(.|\\n)+/",
+  },
+};
+
+describe("Codex Responses Lite custom tools → OpenAI Chat", () => {
+  it("promotes additional_tools custom declarations into Chat tools", () => {
+    const out = openaiResponsesToOpenAIRequest("cx/gpt-5.6-sol", {
+      input: [
+        { type: "additional_tools", role: "developer", tools: [EXEC_TOOL] },
+        { type: "message", role: "user", content: [{ type: "input_text", text: "Run pwd" }] },
+      ],
+      tool_choice: "auto",
+    }, true, null);
+
+    expect(out.tools).toHaveLength(1);
+    expect(out.tools[0]).toMatchObject({
+      type: "function",
+      function: {
+        name: "exec",
+        parameters: {
+          type: "object",
+          required: ["input"],
+          properties: { input: { type: "string" } },
+        },
+      },
+    });
+    expect(out._customToolNames).toEqual(["exec"]);
+    expect(out.messages.some((message) => message.role === "developer")).toBe(false);
+  });
+
+  it("translates custom tool call/output history into Chat assistant/tool messages", () => {
+    const program = "const result = await tools.shell({command: 'pwd'});\nreturn result;";
+    const out = openaiResponsesToOpenAIRequest("cx/gpt-5.6-sol", {
+      input: [
+        { type: "additional_tools", role: "developer", tools: [EXEC_TOOL] },
+        { type: "custom_tool_call", call_id: "call_exec_1", name: "exec", input: program },
+        { type: "custom_tool_call_output", call_id: "call_exec_1", output: "/srv/app" },
+        { type: "message", role: "user", content: [{ type: "input_text", text: "Continue" }] },
+      ],
+    }, true, null);
+
+    const assistant = out.messages.find((message) => message.role === "assistant");
+    expect(assistant.tool_calls[0]).toMatchObject({
+      id: "call_exec_1",
+      type: "function",
+      function: { name: "exec" },
+    });
+    expect(JSON.parse(assistant.tool_calls[0].function.arguments)).toEqual({ input: program });
+    expect(out.messages.find((message) => message.role === "tool")).toEqual({
+      role: "tool",
+      tool_call_id: "call_exec_1",
+      content: "/srv/app",
+    });
+  });
+
+  it("merges additional_tools with normal top-level function tools", () => {
+    const out = openaiResponsesToOpenAIRequest("cx/gpt-5.6-sol", {
+      input: [{ type: "additional_tools", role: "developer", tools: [EXEC_TOOL] }],
+      tools: [{ type: "function", name: "search", parameters: { type: "object", properties: {} } }],
+    }, true, null);
+
+    expect(out.tools.map((tool) => tool.function.name)).toEqual(["search", "exec"]);
+    expect(out._customToolNames).toEqual(["exec"]);
+  });
+});
+
+describe("OpenAI Chat stream → Codex custom_tool_call", () => {
+  it("unwraps the Chat input parameter and emits custom-tool events", () => {
+    const state = initState(FORMATS.OPENAI_RESPONSES);
+    state.customToolNames = new Set(["exec"]);
+    const chunks = [
+      {
+        id: "chatcmpl-custom",
+        choices: [{ index: 0, delta: { tool_calls: [{ index: 0, id: "call_exec_2", type: "function", function: { name: "exec", arguments: "" } }] }, finish_reason: null }],
+      },
+      {
+        id: "chatcmpl-custom",
+        choices: [{ index: 0, delta: { tool_calls: [{ index: 0, function: { arguments: "{\"input\":\"const x = await tools.shell({command: 'pwd'});\"}" } }] }, finish_reason: null }],
+      },
+      { id: "chatcmpl-custom", choices: [{ index: 0, delta: {}, finish_reason: "tool_calls" }] },
+    ];
+
+    const events = chunks.flatMap((chunk) => openaiToOpenAIResponsesResponse(chunk, state));
+    const added = events.find((event) => event.event === "response.output_item.added");
+    const delta = events.find((event) => event.event === "response.custom_tool_call_input.delta");
+    const done = events.find((event) => event.event === "response.output_item.done");
+
+    expect(added.data.item).toMatchObject({
+      type: "custom_tool_call",
+      call_id: "call_exec_2",
+      name: "exec",
+      input: "",
+    });
+    expect(delta.data.delta).toBe("const x = await tools.shell({command: 'pwd'});");
+    expect(done.data.item).toMatchObject({
+      type: "custom_tool_call",
+      call_id: "call_exec_2",
+      name: "exec",
+      input: "const x = await tools.shell({command: 'pwd'});",
+    });
+    expect(events.some((event) => event.event === "response.function_call_arguments.delta")).toBe(false);
+  });
+
+  it("waits for the function name when id and name arrive in separate chunks", () => {
+    const state = initState(FORMATS.OPENAI_RESPONSES);
+    state.customToolNames = new Set(["exec"]);
+    const chunks = [
+      { id: "chatcmpl-split", choices: [{ index: 0, delta: { tool_calls: [{ index: 0, id: "call_split", type: "function", function: { arguments: "" } }] }, finish_reason: null }] },
+      { id: "chatcmpl-split", choices: [{ index: 0, delta: { tool_calls: [{ index: 0, function: { name: "exec", arguments: "{\"input\":\"return 1;\"}" } }] }, finish_reason: null }] },
+      { id: "chatcmpl-split", choices: [{ index: 0, delta: {}, finish_reason: "tool_calls" }] },
+    ];
+
+    const events = chunks.flatMap((chunk) => openaiToOpenAIResponsesResponse(chunk, state));
+    const added = events.filter((event) => event.event === "response.output_item.added");
+    expect(added).toHaveLength(1);
+    expect(added[0].data.item).toMatchObject({
+      type: "custom_tool_call",
+      call_id: "call_split",
+      name: "exec",
+    });
+  });
+
+  it("leaves normal Chat tool calls as Responses function_call events", () => {
+    const state = initState(FORMATS.OPENAI_RESPONSES);
+    state.customToolNames = new Set(["exec"]);
+    const events = [
+      { id: "chatcmpl-normal", choices: [{ index: 0, delta: { tool_calls: [{ index: 0, id: "call_search", type: "function", function: { name: "search", arguments: "{\"q\":\"x\"}" } }] }, finish_reason: null }] },
+      { id: "chatcmpl-normal", choices: [{ index: 0, delta: {}, finish_reason: "tool_calls" }] },
+    ].flatMap((chunk) => openaiToOpenAIResponsesResponse(chunk, state));
+
+    expect(events.find((event) => event.event === "response.output_item.added").data.item.type).toBe("function_call");
+    expect(events.find((event) => event.event === "response.output_item.done").data.item).toMatchObject({
+      type: "function_call",
+      name: "search",
+      arguments: "{\"q\":\"x\"}",
+    });
+  });
+});
diff --git a/tests/unit/openai-responses-nonstream.test.js b/tests/unit/openai-responses-nonstream.test.js
new file mode 100644
index 00000000..a588a9da
--- /dev/null
+++ b/tests/unit/openai-responses-nonstream.test.js
@@ -0,0 +1,148 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("@/lib/usageDb.js", () => ({
+  appendRequestLog: vi.fn(async () => {}),
+  saveRequestDetail: vi.fn(async () => {}),
+  saveRequestUsage: vi.fn(async () => {})
+}));
+
+const { FORMATS } = await import("../../open-sse/translator/formats.js");
+const { translateNonStreamingResponse } = await import("../../open-sse/handlers/chatCore/nonStreamingHandler.js");
+const { handleForcedSSEToJson } = await import("../../open-sse/handlers/chatCore/sseToJsonHandler.js");
+
+// A chat.completion body as returned by a chat-native upstream (e.g. op-ericding)
+const CHAT_TOOL_BODY = {
+  id: "chatcmpl-abc123",
+  object: "chat.completion",
+  created: 1700000000,
+  model: "cl/claude-haiku-4-5",
+  choices: [{
+    index: 0,
+    message: {
+      role: "assistant",
+      content: null,
+      tool_calls: [{ id: "call_1", type: "function", function: { name: "shell", arguments: "{\"cmd\":\"ls\"}" } }]
+    },
+    finish_reason: "tool_calls"
+  }],
+  usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 }
+};
+
+describe("non-stream Chat upstream for a Responses-API client (op-ericding bug)", () => {
+  it("translates chat.completion tool_calls into Responses function_call output", () => {
+    // translateNonStreamingResponse(body, targetFormat=PROVIDER format, sourceFormat=CLIENT format)
+    const out = translateNonStreamingResponse(CHAT_TOOL_BODY, FORMATS.OPENAI, FORMATS.OPENAI_RESPONSES);
+    expect(out.object).toBe("response");
+    expect(out).not.toHaveProperty("choices");
+    const fc = (out.output || []).find((o) => o.type === "function_call");
+    expect(fc).toBeTruthy();
+    expect(fc.call_id).toBe("call_1");
+    expect(fc.name).toBe("shell");
+    expect(fc.arguments).toBe("{\"cmd\":\"ls\"}");
+  });
+
+  it("translates marked Chat tools into Responses custom_tool_call output", () => {
+    const customBody = structuredClone(CHAT_TOOL_BODY);
+    customBody.choices[0].message.tool_calls[0] = {
+      id: "call_exec",
+      type: "function",
+      function: {
+        name: "exec",
+        arguments: "{\"input\":\"return await tools.shell({command: 'pwd'});\"}"
+      }
+    };
+    const out = translateNonStreamingResponse(
+      customBody,
+      FORMATS.OPENAI,
+      FORMATS.OPENAI_RESPONSES,
+      new Set(["exec"])
+    );
+    const call = (out.output || []).find((item) => item.type === "custom_tool_call");
+    expect(call).toMatchObject({
+      call_id: "call_exec",
+      name: "exec",
+      input: "return await tools.shell({command: 'pwd'});"
+    });
+    expect(out.output.some((item) => item.type === "function_call")).toBe(false);
+  });
+
+  it("keeps chat.completion text content as a Responses message item", () => {
+    const body = {
+      ...CHAT_TOOL_BODY,
+      choices: [{ index: 0, message: { role: "assistant", content: "hello" }, finish_reason: "stop" }]
+    };
+    const out = translateNonStreamingResponse(body, FORMATS.OPENAI, FORMATS.OPENAI_RESPONSES);
+    const msg = (out.output || []).find((o) => o.type === "message");
+    expect(msg).toBeTruthy();
+    expect(msg.content[0].type).toBe("output_text");
+    expect(msg.content[0].text).toBe("hello");
+  });
+
+  it("leaves chat->chat untouched", () => {
+    const out = translateNonStreamingResponse(CHAT_TOOL_BODY, FORMATS.OPENAI, FORMATS.OPENAI);
+    expect(out.object).toBe("chat.completion");
+    expect(out.choices[0].message.tool_calls[0].function.name).toBe("shell");
+  });
+});
+
+describe("forced-SSE JSON path for a Responses-API client behind a chat upstream", () => {
+  const sseCtx = (sourceFormat, targetFormat) => {
+    const encoder = new TextEncoder();
+    const raw = [
+      'data: {"id":"chatcmpl-sse","object":"chat.completion.chunk","created":1700000000,"model":"gpt-x","choices":[{"delta":{"tool_calls":[{"index":0,"id":"call_9","type":"function","function":{"name":"shell","arguments":""}}]},"finish_reason":null}]}',
+      'data: {"id":"chatcmpl-sse","object":"chat.completion.chunk","created":1700000000,"model":"gpt-x","choices":[{"delta":{"tool_calls":[{"index":0,"function":{"arguments":"{\\"cmd\\":\\"pwd\\"}"}}]},"finish_reason":null}]}',
+      'data: {"id":"chatcmpl-sse","object":"chat.completion.chunk","created":1700000000,"model":"gpt-x","choices":[{"delta":{},"finish_reason":"tool_calls"}]}',
+      "data: [DONE]",
+      ""
+    ].join("\n\n");
+    return {
+      providerResponse: new Response(new ReadableStream({
+        start(controller) { controller.enqueue(encoder.encode(raw)); controller.close(); }
+      }), { headers: { "content-type": "text/event-stream" } }),
+      sourceFormat,
+      targetFormat,
+      provider: "op-test-chat",
+      model: "gpt-x",
+      body: { model: "gpt-x", messages: [] },
+      stream: false,
+      requestStartTime: Date.now(),
+      connectionId: "test-connection",
+      clientRawRequest: { endpoint: "/v1/responses" },
+      trackDone: vi.fn(),
+      appendLog: vi.fn()
+    };
+  };
+
+  it("parses chat SSE chunks and returns a Responses function_call body", async () => {
+    const result = await handleForcedSSEToJson(sseCtx(FORMATS.OPENAI_RESPONSES, FORMATS.OPENAI));
+    expect(result.success).toBe(true);
+    const json = await result.response.json();
+    expect(json.object).toBe("response");
+    const fc = (json.output || []).find((o) => o.type === "function_call");
+    expect(fc).toBeTruthy();
+    expect(fc.name).toBe("shell");
+    expect(fc.arguments).toBe("{\"cmd\":\"pwd\"}");
+  });
+
+  it("returns a custom_tool_call for a marked tool", async () => {
+    const ctx = sseCtx(FORMATS.OPENAI_RESPONSES, FORMATS.OPENAI);
+    ctx.customToolNames = new Set(["shell"]);
+    const result = await handleForcedSSEToJson(ctx);
+    expect(result.success).toBe(true);
+    const json = await result.response.json();
+    const call = (json.output || []).find((item) => item.type === "custom_tool_call");
+    expect(call).toMatchObject({
+      call_id: "call_9",
+      name: "shell",
+      input: "{\"cmd\":\"pwd\"}"
+    });
+  });
+
+  it("still returns chat.completion for a plain chat client", async () => {
+    const result = await handleForcedSSEToJson(sseCtx(FORMATS.OPENAI, FORMATS.OPENAI));
+    expect(result.success).toBe(true);
+    const json = await result.response.json();
+    expect(json.object).toBe("chat.completion");
+    expect(json.choices[0].message.tool_calls[0].function.name).toBe("shell");
+  });
+});

From 3fab15ae3e17b2d7f12e71a7d9878bc5d0d57d42 Mon Sep 17 00:00:00 2001
From: RobertsXML <RobertsXML@proton.me>
Date: Sat, 1 Aug 2026 10:07:50 +0700
Subject: [PATCH 29/42] fix(db): implement ENABLE_REQUEST_LOGS env var override

- Add config priority chain: ENABLE_REQUEST_LOGS > UI setting > OBSERVABILITY_ENABLED fallback
- Fix transaction callback syntax from arrow to function
- Update saveRequestDetail guard to early return instead of semicolon
- Default enableObservability to false (opt-in)
---
 src/lib/db/repos/requestDetailsRepo.js | 25 ++++++++++++++++++++-----
 src/lib/db/repos/settingsRepo.js       |  6 +++---
 2 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/src/lib/db/repos/requestDetailsRepo.js b/src/lib/db/repos/requestDetailsRepo.js
index defd294b..ceed4c01 100644
--- a/src/lib/db/repos/requestDetailsRepo.js
+++ b/src/lib/db/repos/requestDetailsRepo.js
@@ -15,10 +15,25 @@ async function getObservabilityConfig() {
   try {
     const { getSettings } = await import("./settingsRepo.js");
     const settings = await getSettings();
-    const envEnabled = process.env.OBSERVABILITY_ENABLED !== "false";
-    const enabled = typeof settings.enableObservability2 === "boolean"
-      ? settings.enableObservability2
-      : envEnabled;
+    const envRequestLogs = process.env.ENABLE_REQUEST_LOGS;
+    if (envRequestLogs !== undefined) {
+      const enabled = envRequestLogs.toLowerCase() === "true";
+      cachedConfig = {
+        enabled,
+        maxRecords: settings.observabilityMaxRecords || parseInt(process.env.OBSERVABILITY_MAX_RECORDS || String(DEFAULT_MAX_RECORDS), 10),
+        batchSize: settings.observabilityBatchSize || parseInt(process.env.OBSERVABILITY_BATCH_SIZE || String(DEFAULT_BATCH_SIZE), 10),
+        flushIntervalMs: settings.observabilityFlushIntervalMs || parseInt(process.env.OBSERVABILITY_FLUSH_INTERVAL_MS || String(DEFAULT_FLUSH_INTERVAL_MS), 10),
+        maxJsonSize: (settings.observabilityMaxJsonSize || parseInt(process.env.OBSERVABILITY_MAX_JSON_SIZE || "5", 10)) * 1024,
+      };
+      cachedConfigTs = Date.now();
+      return cachedConfig;
+    }
+    const envFallback = process.env.OBSERVABILITY_ENABLED !== "false";
+    const uiFlag = typeof settings.enableObservability === "boolean";
+    const enabled = uiFlag
+      ? settings.enableObservability
+      : envFallback;
+
     cachedConfig = {
       enabled,
       maxRecords: settings.observabilityMaxRecords || parseInt(process.env.OBSERVABILITY_MAX_RECORDS || String(DEFAULT_MAX_RECORDS), 10),
@@ -125,7 +140,7 @@ async function flushToDatabase() {
 
 export async function saveRequestDetail(detail) {
   const config = await getObservabilityConfig();
-  if (!config.enabled) return;
+  if (!config.enabled) {return;}
 
   writeBuffer.push(detail);
 
diff --git a/src/lib/db/repos/settingsRepo.js b/src/lib/db/repos/settingsRepo.js
index 0f53eecf..1abe4360 100644
--- a/src/lib/db/repos/settingsRepo.js
+++ b/src/lib/db/repos/settingsRepo.js
@@ -25,7 +25,7 @@ const DEFAULT_SETTINGS = {
   oidcClientSecret: "",
   oidcScopes: "openid profile email",
   oidcLoginLabel: "Sign in with OIDC",
-  enableObservability: true,
+  enableObservability: false,
   observabilityMaxRecords: 1000,
   observabilityBatchSize: 20,
   observabilityFlushIntervalMs: 5000,
@@ -83,13 +83,13 @@ export async function getSettings() {
 export async function updateSettings(updates) {
   const db = await getAdapter();
   let next;
-  db.transaction(() => {
+  db.transaction(function () {
     const row = db.get(`SELECT data FROM settings WHERE id = 1`);
     const current = row ? parseJson(row.data, {}) : {};
     next = { ...current, ...updates };
     db.run(
       `INSERT INTO settings(id, data) VALUES(1, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data`,
-      [stringifyJson(next)]
+      [stringifyJson(next)],
     );
   });
   return mergeWithDefaults(next);

From b48089295259cd84e50335d0c78e2b9e7aad516d Mon Sep 17 00:00:00 2001
From: Ubuntu <dasepmoch@jokiarea.com>
Date: Wed, 5 Aug 2026 13:31:56 +0700
Subject: [PATCH 30/42] feat(providers): add TokenRouter provider

OpenAI-compatible gateway exposing 300+ models (OpenAI, Claude, Gemini,
Qwen, DeepSeek, Kimi, GLM, and more). Registered as p116, append-only.
---
 open-sse/providers/registry/index.js       |   2 +
 open-sse/providers/registry/tokenrouter.js | 156 +++++++++++++++++++++
 2 files changed, 158 insertions(+)
 create mode 100644 open-sse/providers/registry/tokenrouter.js

diff --git a/open-sse/providers/registry/index.js b/open-sse/providers/registry/index.js
index 7bfdd0d7..ba8a4c17 100644
--- a/open-sse/providers/registry/index.js
+++ b/open-sse/providers/registry/index.js
@@ -116,6 +116,7 @@ import p113 from "./morph.js";
 // import p114 from "./devin-cli.js";
 // import p104 from "./windsurf.js";
 import p115 from "./poolside.js";
+import p116 from "./tokenrouter.js";
 
 export default [
   p0,
@@ -233,4 +234,5 @@ export default [
   // p114, // devin-cli — hidden, spawns local agent with shell/fs access
   // p104, // windsurf — hidden, no tool calling
   p115,
+  p116,
 ];
diff --git a/open-sse/providers/registry/tokenrouter.js b/open-sse/providers/registry/tokenrouter.js
new file mode 100644
index 00000000..8c5bf49f
--- /dev/null
+++ b/open-sse/providers/registry/tokenrouter.js
@@ -0,0 +1,156 @@
+export default {
+  id: "tokenrouter",
+  alias: "tokenrouter",
+  aliases: ["tr"],
+  uiAlias: "tokenrouter",
+  display: {
+    name: "TokenRouter",
+    icon: "hub",
+    color: "#0EA5E9",
+    textIcon: "TR",
+    website: "https://www.tokenrouter.com",
+    notice: {
+      text: "OpenAI-compatible gateway. 300+ models (OpenAI, Claude, Gemini, Qwen, DeepSeek, Kimi, GLM, dsb).",
+      apiKeyUrl: "https://www.tokenrouter.com",
+    },
+  },
+  category: "apikey",
+  transport: {
+    baseUrl: "https://api.tokenrouter.com/v1/chat/completions",
+    validateUrl: "https://api.tokenrouter.com/v1/models",
+    thinkingFormat: "openai",
+  },
+  // Seed snapshot dari live /v1/models (118 entri, 2026-07-31). Catalogue terbaru
+  // di-fetch via modelsFetcher; id lain tetap diterima via passthroughModels.
+  models: [
+    { id: "MiniMax-Hailuo-2.3", name: "Minimax Hailuo 2.3", kind: "video" },
+    { id: "MiniMax-M3", name: "Minimax M3" },
+    { id: "anthropic/claude-fable-5", name: "Claude Fable 5" },
+    { id: "anthropic/claude-haiku-4.5", name: "Claude Haiku 4.5" },
+    { id: "anthropic/claude-opus-4.5", name: "Claude Opus 4.5" },
+    { id: "anthropic/claude-opus-4.6", name: "Claude Opus 4.6" },
+    { id: "anthropic/claude-opus-4.7", name: "Claude Opus 4.7" },
+    { id: "anthropic/claude-opus-4.7-fast", name: "Claude Opus 4.7 Fast" },
+    { id: "anthropic/claude-opus-4.8", name: "Claude Opus 4.8" },
+    { id: "anthropic/claude-opus-4.8-fast", name: "Claude Opus 4.8 Fast" },
+    { id: "anthropic/claude-opus-5", name: "Claude Opus 5" },
+    { id: "anthropic/claude-opus-5-fast", name: "Claude Opus 5 Fast" },
+    { id: "anthropic/claude-sonnet-4", name: "Claude Sonnet 4" },
+    { id: "anthropic/claude-sonnet-4.5", name: "Claude Sonnet 4.5" },
+    { id: "anthropic/claude-sonnet-4.6", name: "Claude Sonnet 4.6" },
+    { id: "anthropic/claude-sonnet-5", name: "Claude Sonnet 5" },
+    { id: "bytedance-seed/seedream-4.5", name: "Seedream 4.5", kind: "image" },
+    { id: "bytedance-seed/seedream-5.0-lite", name: "Seedream 5.0 Lite", kind: "image" },
+    { id: "bytedance-seed/seedream-5.0-pro", name: "Seedream 5.0 Pro", kind: "image" },
+    { id: "claude-haiku-4-5", name: "Claude Haiku 4 5" },
+    { id: "claude-opus-4-8-m-aws", name: "Claude Opus 4 8 M Aws" },
+    { id: "deepseek/deepseek-v3.2", name: "Deepseek V3.2" },
+    { id: "deepseek/deepseek-v4-flash", name: "Deepseek V4 Flash" },
+    { id: "deepseek/deepseek-v4-pro", name: "Deepseek V4 Pro" },
+    { id: "ex/gpt-5.4", name: "Gpt 5.4" },
+    { id: "google/gemini-2.5-flash-image", name: "Gemini 2.5 Flash Image" },
+    { id: "google/gemini-3-flash-preview", name: "Gemini 3 Flash Preview" },
+    { id: "google/gemini-3-pro-image-preview", name: "Gemini 3 Pro Image Preview" },
+    { id: "google/gemini-3.1-flash-image-preview", name: "Gemini 3.1 Flash Image Preview" },
+    { id: "google/gemini-3.1-flash-lite-image", name: "Gemini 3.1 Flash Lite Image" },
+    { id: "google/gemini-3.1-pro-preview", name: "Gemini 3.1 Pro Preview" },
+    { id: "google/gemini-3.5-flash", name: "Gemini 3.5 Flash" },
+    { id: "google/gemini-3.5-flash-lite", name: "Gemini 3.5 Flash Lite" },
+    { id: "google/gemini-3.6-flash", name: "Gemini 3.6 Flash" },
+    { id: "google/gemini-embedding-2", name: "Gemini Embedding 2" },
+    { id: "google/gemma-4-26b-a4b-it", name: "Gemma 4 26B A4B It" },
+    { id: "happyhorse-1.0-t2v", name: "Happyhorse 1.0 T2V", kind: "video" },
+    { id: "kling-3.0-turbo", name: "Kling 3.0 Turbo", kind: "video" },
+    { id: "kling-v2-6", name: "Kling V2 6", kind: "video" },
+    { id: "kling-v3", name: "Kling V3", kind: "video" },
+    { id: "kling-v3-omni", name: "Kling V3 Omni", kind: "video" },
+    { id: "microsoft/mai-image-2.5", name: "Mai Image 2.5" },
+    { id: "minimax/minimax-m2-her", name: "Minimax M2 Her" },
+    { id: "minimax/minimax-m2.1", name: "Minimax M2.1" },
+    { id: "minimax/minimax-m2.1-highspeed", name: "Minimax M2.1 Highspeed" },
+    { id: "minimax/minimax-m2.5", name: "Minimax M2.5" },
+    { id: "minimax/minimax-m2.7", name: "Minimax M2.7" },
+    { id: "minimax/minimax-m2.7-highspeed", name: "Minimax M2.7 Highspeed" },
+    { id: "miromind/mirothinker-1-7-deepresearch", name: "Mirothinker 1 7 Deepresearch" },
+    { id: "miromind/mirothinker-1-7-deepresearch-mini", name: "Mirothinker 1 7 Deepresearch Mini" },
+    { id: "mistralai/devstral-2512", name: "Devstral 2512" },
+    { id: "mistralai/mistral-medium-3-5", name: "Mistral Medium 3 5" },
+    { id: "mistralai/mistral-small-2603", name: "Mistral Small 2603" },
+    { id: "mistralai/voxtral-small-24b-2507", name: "Voxtral Small 24B 2507" },
+    { id: "moonshotai/kimi-k2.5", name: "Kimi K2.5" },
+    { id: "moonshotai/kimi-k2.6", name: "Kimi K2.6" },
+    { id: "moonshotai/kimi-k2.7-code", name: "Kimi K2.7 Code" },
+    { id: "moonshotai/kimi-k3", name: "Kimi K3" },
+    { id: "moonshotai/kimi-k3-free", name: "Kimi K3 Free" },
+    { id: "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free", name: "Nemotron 3 Nano Omni 30B A3B Reasoning:Free" },
+    { id: "nvidia/nemotron-3-super-120b-a12b", name: "Nemotron 3 Super 120B A12B" },
+    { id: "openai/gpt-4o-mini", name: "Gpt 4O Mini" },
+    { id: "openai/gpt-5", name: "Gpt 5" },
+    { id: "openai/gpt-5-image", name: "Gpt 5 Image" },
+    { id: "openai/gpt-5-image-mini", name: "Gpt 5 Image Mini" },
+    { id: "openai/gpt-5-mini", name: "Gpt 5 Mini" },
+    { id: "openai/gpt-5.2", name: "Gpt 5.2" },
+    { id: "openai/gpt-5.4", name: "Gpt 5.4" },
+    { id: "openai/gpt-5.4-image-2", name: "Gpt 5.4 Image 2", kind: "image" },
+    { id: "openai/gpt-5.4-mini", name: "Gpt 5.4 Mini" },
+    { id: "openai/gpt-5.4-nano", name: "Gpt 5.4 Nano" },
+    { id: "openai/gpt-5.4-pro", name: "Gpt 5.4 Pro" },
+    { id: "openai/gpt-5.5", name: "Gpt 5.5" },
+    { id: "openai/gpt-5.5-pro", name: "Gpt 5.5 Pro" },
+    { id: "openai/gpt-5.6-luna", name: "Gpt 5.6 Luna" },
+    { id: "openai/gpt-5.6-sol", name: "Gpt 5.6 Sol" },
+    { id: "openai/gpt-5.6-terra", name: "Gpt 5.6 Terra" },
+    { id: "openai/gpt-audio", name: "Gpt Audio", kind: "audio" },
+    { id: "openai/gpt-audio-mini", name: "Gpt Audio Mini", kind: "audio" },
+    { id: "openai/gpt-oss-120b", name: "Gpt Oss 120B" },
+    { id: "qwen/qwen3-coder-next", name: "Qwen3 Coder Next" },
+    { id: "qwen/qwen3.5-122b-a10b", name: "Qwen3.5 122B A10B" },
+    { id: "qwen/qwen3.5-35b-a3b", name: "Qwen3.5 35B A3B" },
+    { id: "qwen/qwen3.5-397b-a17b", name: "Qwen3.5 397B A17B" },
+    { id: "qwen/qwen3.5-9b", name: "Qwen3.5 9B" },
+    { id: "qwen/qwen3.5-flash", name: "Qwen3.5 Flash" },
+    { id: "qwen/qwen3.5-plus-02-15", name: "Qwen3.5 Plus 02 15" },
+    { id: "qwen/qwen3.6-plus", name: "Qwen3.6 Plus" },
+    { id: "qwen/qwen3.7-max", name: "Qwen3.7 Max" },
+    { id: "qwen/qwen3.7-plus", name: "Qwen3.7 Plus" },
+    { id: "qwen3.5-omni-plus", name: "Qwen3.5 Omni Plus" },
+    { id: "qwen3.6-flash", name: "Qwen3.6 Flash" },
+    { id: "sakana/fugu-ultra", name: "Fugu Ultra" },
+    { id: "seed-2-0-code-preview-260328", name: "Seed 2 0 Code Preview 260328" },
+    { id: "seed-2-0-lite-260428", name: "Seed 2 0 Lite 260428" },
+    { id: "seed-2-0-mini-260428", name: "Seed 2 0 Mini 260428" },
+    { id: "seed-2-0-pro-260328", name: "Seed 2 0 Pro 260328" },
+    { id: "stepfun/step-3.5-flash", name: "Step 3.5 Flash" },
+    { id: "stepfun/step-3.7-flash", name: "Step 3.7 Flash" },
+    { id: "tencent/hy3-preview", name: "Hy3 Preview" },
+    { id: "x-ai/grok-4.1-fast", name: "Grok 4.1 Fast" },
+    { id: "x-ai/grok-4.20-beta", name: "Grok 4.20 Beta" },
+    { id: "x-ai/grok-4.3", name: "Grok 4.3" },
+    { id: "x-ai/grok-4.5", name: "Grok 4.5" },
+    { id: "x-ai/grok-build-0.1", name: "Grok Build 0.1" },
+    { id: "xiaomi/mimo-v2-flash", name: "Mimo V2 Flash" },
+    { id: "xiaomi/mimo-v2-omni", name: "Mimo V2 Omni" },
+    { id: "xiaomi/mimo-v2-pro", name: "Mimo V2 Pro" },
+    { id: "xiaomi/mimo-v2.5", name: "Mimo V2.5" },
+    { id: "xiaomi/mimo-v2.5-pro", name: "Mimo V2.5 Pro" },
+    { id: "z-ai/glm-4.5-air", name: "Glm 4.5 Air" },
+    { id: "z-ai/glm-4.6", name: "Glm 4.6" },
+    { id: "z-ai/glm-4.6v", name: "Glm 4.6V" },
+    { id: "z-ai/glm-4.7", name: "Glm 4.7" },
+    { id: "z-ai/glm-5", name: "Glm 5" },
+    { id: "z-ai/glm-5-turbo", name: "Glm 5 Turbo" },
+    { id: "z-ai/glm-5.1", name: "Glm 5.1" },
+    { id: "z-ai/glm-5.2", name: "Glm 5.2" },
+  ],
+  serviceKinds: ["llm", "embedding", "image"],
+  embeddingConfig: {
+    baseUrl: "https://api.tokenrouter.com/v1/embeddings",
+    authType: "apikey",
+    authHeader: "bearer",
+  },
+  imageConfig: {
+    baseUrl: "https://api.tokenrouter.com/v1/images/generations",
+  },
+  modelsFetcher: { url: "https://api.tokenrouter.com/v1/models", type: "openai" },
+  passthroughModels: true,
+};

From fe547f4dc0a53a2fe8ffe5ca50cf1b98df29c959 Mon Sep 17 00:00:00 2001
From: omar-nahhas <omar@innovativerealities.com>
Date: Wed, 5 Aug 2026 13:33:28 +0700
Subject: [PATCH 31/42] feat(providers): self-hosted OpenAI-compatible STT, TTS
 and embedding providers

Add Self-hosted STT/TTS/Embedding providers that read baseUrl per connection
instead of a fixed registry endpoint, so 9Router can point at whisper.cpp,
faster-whisper, Kokoro-FastAPI, llama-server, vLLM, Infinity, and similar
OpenAI-compatible local servers.

Self-hosted Embedding refuses to run without a baseUrl rather than falling
back to api.openai.com like openaiCompatNode does, since that fallback would
silently send input text and the API key to OpenAI under a provider named
"Self-hosted". Also fixes embeddingsCore to catch adapter build errors as a
400 instead of letting them escape uncaught, and bounds the upstream fetch
with FETCH_CONNECT_TIMEOUT_MS to avoid hanging forever on a dead endpoint.

Self-hosted TTS treats a bare model value as the model rather than the voice,
since the generic OpenAI TTS convention (bare = voice) is backwards for a
provider where the model is the variable part.
---
 CHANGELOG.md                                  | 21 ++++++
 README.md                                     | 40 ++++++++++
 open-sse/handlers/embeddingProviders/index.js |  7 ++
 .../embeddingProviders/selfhostedEmbedding.js | 46 ++++++++++++
 open-sse/handlers/embeddingsCore.js           | 30 ++++++--
 open-sse/handlers/sttCore.js                  | 10 ++-
 open-sse/handlers/ttsProviders/index.js       |  2 +
 .../handlers/ttsProviders/selfhostedTts.js    | 69 ++++++++++++++++++
 open-sse/providers/registry/index.js          |  6 ++
 .../registry/selfhosted-embedding.js          | 73 +++++++++++++++++++
 open-sse/providers/registry/selfhosted-stt.js | 48 ++++++++++++
 open-sse/providers/registry/selfhosted-tts.js | 44 +++++++++++
 12 files changed, 387 insertions(+), 9 deletions(-)
 create mode 100644 open-sse/handlers/embeddingProviders/selfhostedEmbedding.js
 create mode 100644 open-sse/handlers/ttsProviders/selfhostedTts.js
 create mode 100644 open-sse/providers/registry/selfhosted-embedding.js
 create mode 100644 open-sse/providers/registry/selfhosted-stt.js
 create mode 100644 open-sse/providers/registry/selfhosted-tts.js

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 20900a68..3279d542 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,24 @@
+# Unreleased
+
+## Features
+- **Providers**: add Self-hosted STT / TTS / Embedding — point 9Router at your own
+  OpenAI-compatible speech and embedding servers (whisper.cpp, faster-whisper,
+  Kokoro-FastAPI, llama-server, vLLM, Infinity). Unlike the named cloud providers
+  these read `baseUrl` per connection, so one provider can front several machines
+
+## Fixes
+- **TTS**: a bare self-hosted model name is the MODEL, not the voice — `kokoro`
+  was parsed as a voice against a default model, 404ing or synthesising with the
+  wrong one
+- **Embeddings**: self-hosted embeddings no longer fall back to `api.openai.com`
+  when a connection has no `baseUrl` — that silently sent the input text and API
+  key to OpenAI under a provider named "Self-hosted"
+- **Embeddings**: an adapter that rejects a misconfigured connection now returns
+  400 with the reason instead of escaping the handler uncaught
+- **Embeddings**: bound the upstream fetch with `FETCH_CONNECT_TIMEOUT_MS` — an
+  endpoint that drops packets never returns headers, so the request previously
+  hung indefinitely
+
 # v0.5.45 (2026-07-30)
 
 ## Features
diff --git a/README.md b/README.md
index 4e90b9c4..a89c7dca 100644
--- a/README.md
+++ b/README.md
@@ -467,6 +467,46 @@ Default URLs:
   <p><i>...and 20+ more providers including Nebius, Chutes, Hyperbolic, and custom OpenAI/Anthropic compatible endpoints</i></p>
 </div>
 
+### 🏠 Self-hosted Providers
+
+For speech and embeddings served from **your own** machine — whisper.cpp,
+faster-whisper, Speaches, Kokoro-FastAPI, openedai-speech, llama.cpp/llama-server,
+vLLM, Infinity, text-embeddings-inference, or anything else that speaks the OpenAI
+shape.
+
+| Provider | Endpoint used | Typical server |
+| --- | --- | --- |
+| **Self-hosted STT** | `/v1/audio/transcriptions` | whisper.cpp, faster-whisper |
+| **Self-hosted TTS** | `/v1/audio/speech` | Kokoro-FastAPI, openedai-speech |
+| **Self-hosted Embedding** | `/v1/embeddings` | llama-server, vLLM, Infinity |
+
+Every other speech provider is a named cloud service with a fixed endpoint. These
+three read their address from **each connection**, so one provider can front
+several machines and load-balance across them like any other.
+
+Set it on the connection as `providerSpecificData.baseUrl`:
+
+| Provider | Give it | Result |
+| --- | --- | --- |
+| Self-hosted STT | the full URL — `http://host:8080/v1/audio/transcriptions` | used as-is |
+| Self-hosted TTS | the server root — `http://host:8880` | `+ /v1/audio/speech` |
+| Self-hosted Embedding | the **OpenAI base**, `/v1` included — `http://host:8080/v1` | `+ /embeddings` |
+
+> **Mind the `/v1` on embeddings.** The adapter appends `/embeddings`, so
+> `http://host:8080` resolves to `http://host:8080/embeddings` and misses the
+> OpenAI route — llama-server answers **501**. Give it the same base URL an OpenAI
+> client would use. A full `.../v1/embeddings` is also accepted, so a value pasted
+> from a `curl` example works too.
+
+The API key is not checked by most local servers, but the field must be non-empty:
+it is what gives the connection a credentials record, and `baseUrl` lives there.
+Any placeholder works.
+
+Self-hosted Embedding has **no cloud fallback by design** — a connection saved
+without a `baseUrl` is reported as a configuration error rather than quietly
+falling back to `api.openai.com`, which would send your input text and API key to
+a third party under a provider named "Self-hosted".
+
 ---
 
 ## 💡 Key Features
diff --git a/open-sse/handlers/embeddingProviders/index.js b/open-sse/handlers/embeddingProviders/index.js
index 62e52778..9dd6a604 100644
--- a/open-sse/handlers/embeddingProviders/index.js
+++ b/open-sse/handlers/embeddingProviders/index.js
@@ -2,6 +2,7 @@
 import createOpenAIEmbeddingAdapter from "./openai.js";
 import gemini from "./gemini.js";
 import openaiCompatNode from "./openaiCompatNode.js";
+import selfhostedEmbedding from "./selfhostedEmbedding.js";
 
 const OPENAI_COMPAT_PROVIDERS = [
   "openai", "openrouter", "mistral", "voyage-ai", "fireworks",
@@ -13,6 +14,12 @@ const ADAPTERS = {
   ...Object.fromEntries(OPENAI_COMPAT_PROVIDERS.map((id) => [id, createOpenAIEmbeddingAdapter(id)])),
   gemini,
   google_ai_studio: gemini,
+  // Self-hosted reads creds.providerSpecificData.baseUrl (one provider, many
+  // servers) — but via its OWN adapter, not openaiCompatNode: that one falls back
+  // to api.openai.com when no baseUrl is set, which under a provider called
+  // "Self-hosted Embedding" means silently shipping the input and API key to
+  // OpenAI. selfhostedEmbedding refuses instead.
+  "selfhosted-embedding": selfhostedEmbedding,
 };
 
 export function getEmbeddingAdapter(provider) {
diff --git a/open-sse/handlers/embeddingProviders/selfhostedEmbedding.js b/open-sse/handlers/embeddingProviders/selfhostedEmbedding.js
new file mode 100644
index 00000000..aa030439
--- /dev/null
+++ b/open-sse/handlers/embeddingProviders/selfhostedEmbedding.js
@@ -0,0 +1,46 @@
+// Self-hosted embeddings — like openaiCompatNode, but the baseUrl is REQUIRED.
+//
+// openaiCompatNode falls back to https://api.openai.com/v1 when a connection
+// carries no providerSpecificData.baseUrl. For a custom NODE that default is
+// defensible: the node was created by pointing at some OpenAI-compatible URL, and
+// OpenAI is the archetype. For a provider whose entire purpose is "my own
+// server", it is actively harmful — a connection saved without a baseUrl sends
+// the INPUT TEXT and the API KEY to OpenAI, silently, under a provider named
+// "Self-hosted Embedding".
+//
+// Observed exactly that with a placeholder connection (2026-08-04):
+//
+//   [selfhosted-embedding/embedding] [401]: Incorrect API key provided: abc.
+//   You can find your API key at https://platform.openai.com/account/api-keys.
+//
+// The key "abc" was typed as a throwaway for a LOCAL server and left the network.
+// A self-hosted provider must never have a cloud fallback, so this one refuses
+// instead: no baseUrl means a configuration error, reported as such.
+import createOpenAIEmbeddingAdapter from "./openai.js";
+
+const baseAdapter = createOpenAIEmbeddingAdapter("openai");
+
+export class MissingBaseUrlError extends Error {
+  constructor() {
+    super(
+      "Self-hosted Embedding needs an endpoint: set this connection's baseUrl to " +
+        "the OpenAI base URL of your server, e.g. http://host:8080/v1 (note the /v1 — " +
+        "\"/embeddings\" is appended to it). Refusing to fall back to api.openai.com, " +
+        "which would send your input and API key to OpenAI."
+    );
+    this.name = "MissingBaseUrlError";
+    this.isConfigError = true;
+  }
+}
+
+export default {
+  ...baseAdapter,
+  buildUrl: (_model, creds) => {
+    const rawBaseUrl = creds?.providerSpecificData?.baseUrl;
+    if (!rawBaseUrl || !String(rawBaseUrl).trim()) throw new MissingBaseUrlError();
+    // Accept either the OpenAI base or a full embeddings URL, so a value pasted
+    // from a curl example works as well as one typed from the help text.
+    const baseUrl = String(rawBaseUrl).trim().replace(/\/$/, "").replace(/\/embeddings$/, "");
+    return `${baseUrl}/embeddings`;
+  },
+};
diff --git a/open-sse/handlers/embeddingsCore.js b/open-sse/handlers/embeddingsCore.js
index aa81117c..1ee0f4cd 100644
--- a/open-sse/handlers/embeddingsCore.js
+++ b/open-sse/handlers/embeddingsCore.js
@@ -1,5 +1,5 @@
 import { createErrorResult, parseUpstreamError, formatProviderError } from "../utils/error.js";
-import { HTTP_STATUS } from "../config/runtimeConfig.js";
+import { HTTP_STATUS, FETCH_CONNECT_TIMEOUT_MS } from "../config/runtimeConfig.js";
 import { getExecutor } from "../executors/index.js";
 import { refreshWithRetry } from "../services/tokenRefresh.js";
 import { getEmbeddingAdapter } from "./embeddingProviders/index.js";
@@ -38,13 +38,24 @@ export async function handleEmbeddingsCore({
   }
 
   const ctx = { input };
-  const url = adapter.buildUrl(model, credentials, ctx);
-  const headers = adapter.buildHeaders(credentials, ctx);
-  const requestBody = adapter.buildBody(model, {
-    input,
-    encoding_format: body.encoding_format || "float",
-    dimensions: body.dimensions,
-  });
+  // buildUrl/buildHeaders/buildBody were called bare. An adapter that rejects a
+  // misconfigured connection — selfhosted-embedding throws when no baseUrl is set
+  // rather than silently falling back to api.openai.com — would have escaped this
+  // function uncaught, surfacing as a 500 or a request that never settles. A
+  // configuration mistake is a 400 with the reason in it.
+  let url, headers, requestBody;
+  try {
+    url = adapter.buildUrl(model, credentials, ctx);
+    headers = adapter.buildHeaders(credentials, ctx);
+    requestBody = adapter.buildBody(model, {
+      input,
+      encoding_format: body.encoding_format || "float",
+      dimensions: body.dimensions,
+    });
+  } catch (error) {
+    log?.debug?.("EMBEDDINGS", `Request build failed: ${error.message}`);
+    return createErrorResult(HTTP_STATUS.BAD_REQUEST, `[${provider}/${model}] ${error.message}`);
+  }
 
   log?.debug?.("EMBEDDINGS", `${provider.toUpperCase()} | ${model} | input_type=${Array.isArray(input) ? `array[${input.length}]` : "string"}`);
 
@@ -54,6 +65,9 @@ export async function handleEmbeddingsCore({
       method: "POST",
       headers,
       body: JSON.stringify(requestBody),
+      ...(typeof AbortSignal?.timeout === "function"
+        ? { signal: AbortSignal.timeout(FETCH_CONNECT_TIMEOUT_MS) }
+        : {}),
     });
   } catch (error) {
     const errMsg = formatProviderError(error, provider, model, HTTP_STATUS.BAD_GATEWAY);
diff --git a/open-sse/handlers/sttCore.js b/open-sse/handlers/sttCore.js
index acb7d13b..8127782a 100644
--- a/open-sse/handlers/sttCore.js
+++ b/open-sse/handlers/sttCore.js
@@ -170,9 +170,17 @@ export async function handleSttCore({ provider, model, formData, credentials, st
   const file = formData.get("file");
   if (!file) return createErrorResult(HTTP_STATUS.BAD_REQUEST, "Missing required field: file");
 
-  const cfg = sttConfig;
+  let cfg = sttConfig;
   if (!cfg) return createErrorResult(HTTP_STATUS.BAD_REQUEST, `Provider '${provider}' does not support STT`);
 
+  // Per-connection endpoint override. Registry entries carry a fixed baseUrl,
+  // which is right for a named cloud service but useless for a self-hosted one
+  // whose address only the operator knows. Opt-in: absent unless the connection
+  // sets it, so cloud providers are untouched. Mirrors the custom embedding
+  // providers, which already resolve baseUrl the same way.
+  const overrideUrl = credentials?.providerSpecificData?.baseUrl;
+  if (overrideUrl) cfg = { ...cfg, baseUrl: String(overrideUrl).replace(/\/+$/, "") };
+
   const token = cfg.authType === "none" ? null : (credentials?.apiKey || credentials?.accessToken);
   if (cfg.authType !== "none" && !token) {
     return createErrorResult(HTTP_STATUS.UNAUTHORIZED, `No credentials for STT provider: ${provider}`);
diff --git a/open-sse/handlers/ttsProviders/index.js b/open-sse/handlers/ttsProviders/index.js
index 80e104d2..d2be03fa 100644
--- a/open-sse/handlers/ttsProviders/index.js
+++ b/open-sse/handlers/ttsProviders/index.js
@@ -7,6 +7,7 @@ import openai from "./openai.js";
 import openrouter from "./openrouter.js";
 import gemini, { fetchGeminiVoices } from "./gemini.js";
 import xiaomiMimo from "./xiaomi-mimo.js";
+import selfhostedTts from "./selfhostedTts.js";
 import { FORMAT_HANDLERS } from "./genericFormats.js";
 import { parseModelVoice } from "./_base.js";
 
@@ -20,6 +21,7 @@ const SPECIAL_ADAPTERS = {
   openrouter,
   gemini,
   "xiaomi-mimo": xiaomiMimo,
+  "selfhosted-tts": selfhostedTts,
 };
 
 export function getTtsAdapter(provider) {
diff --git a/open-sse/handlers/ttsProviders/selfhostedTts.js b/open-sse/handlers/ttsProviders/selfhostedTts.js
new file mode 100644
index 00000000..fdfdbf76
--- /dev/null
+++ b/open-sse/handlers/ttsProviders/selfhostedTts.js
@@ -0,0 +1,69 @@
+// Self-hosted OpenAI-compatible TTS — POST {baseUrl}/v1/audio/speech.
+//
+// A SPECIAL_ADAPTER rather than a genericFormats handler on purpose: the generic
+// dispatcher resolves baseUrl from the static registry entry
+// (`synthesizeViaConfig` reads `cfg.baseUrl`) and never looks at the connection,
+// which is exactly the limitation this provider exists to lift.
+import { Buffer } from "node:buffer";
+
+const DEFAULT_BASE_URL = "http://localhost:8880";
+const DEFAULT_MODEL = "kokoro";
+const DEFAULT_VOICE = "af_heart";
+
+export default {
+  async synthesize(text, model, credentials, responseFormat = "mp3") {
+    // Accept either providerSpecificData.baseUrl (how the custom embedding and
+    // STT providers carry it) or a bare credentials.baseUrl (how the OpenAI TTS
+    // adapter does), so a connection configured either way works.
+    const raw = credentials?.providerSpecificData?.baseUrl || credentials?.baseUrl || DEFAULT_BASE_URL;
+    // Tolerate a baseUrl given as the full endpoint or with a trailing /v1 —
+    // both are natural things to paste, and silently double-appending the path
+    // would 404 with nothing pointing at the cause.
+    const base = String(raw)
+      .replace(/\/+$/, "")
+      .replace(/\/v1\/audio\/speech$/, "")
+      .replace(/\/v1$/, "");
+
+    // The provider prefix is already stripped by getModelInfo, so `model` here is
+    // "kokoro" or "kokoro/af_heart" — NOT "selfhosted-tts/...".
+    //
+    // A bare value is the MODEL, not the voice. The OpenAI adapter reads a bare
+    // value as a voice, which is right for a service whose model is fixed
+    // ("tts-1") and whose voice varies — but wrong here, where the model is the
+    // variable part. Treating it as a voice sent voice="kokoro" upstream and
+    // Kokoro answered 400, so `selfhosted-tts/kokoro` — the obvious way to
+    // address this provider — was the one form that did not work (verified
+    // against a live Kokoro through 9router, 2026-08-03).
+    let ttsModel = DEFAULT_MODEL;
+    let voice = DEFAULT_VOICE;
+    if (model) {
+      const parts = String(model).split("/").filter(Boolean);
+      if (parts.length >= 2) {
+        ttsModel = parts[0];
+        voice = parts.slice(1).join("/");
+      } else if (parts.length === 1) {
+        ttsModel = parts[0];
+      }
+    }
+
+    const res = await fetch(`${base}/v1/audio/speech`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(credentials?.apiKey ? { Authorization: `Bearer ${credentials.apiKey}` } : {}),
+      },
+      body: JSON.stringify({
+        model: ttsModel,
+        voice,
+        input: text,
+        response_format: responseFormat,
+      }),
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err?.error?.message || `Self-hosted TTS failed: ${res.status}`);
+    }
+    const buf = await res.arrayBuffer();
+    return { base64: Buffer.from(buf).toString("base64"), format: responseFormat };
+  },
+};
diff --git a/open-sse/providers/registry/index.js b/open-sse/providers/registry/index.js
index ba8a4c17..c08c0597 100644
--- a/open-sse/providers/registry/index.js
+++ b/open-sse/providers/registry/index.js
@@ -117,6 +117,9 @@ import p113 from "./morph.js";
 // import p104 from "./windsurf.js";
 import p115 from "./poolside.js";
 import p116 from "./tokenrouter.js";
+import p117 from "./selfhosted-stt.js";
+import p118 from "./selfhosted-tts.js";
+import p119 from "./selfhosted-embedding.js";
 
 export default [
   p0,
@@ -235,4 +238,7 @@ export default [
   // p104, // windsurf — hidden, no tool calling
   p115,
   p116,
+  p117,
+  p118,
+  p119,
 ];
diff --git a/open-sse/providers/registry/selfhosted-embedding.js b/open-sse/providers/registry/selfhosted-embedding.js
new file mode 100644
index 00000000..90fa79c7
--- /dev/null
+++ b/open-sse/providers/registry/selfhosted-embedding.js
@@ -0,0 +1,73 @@
+// Self-hosted, OpenAI-compatible embeddings (llama.cpp / llama-server, vLLM,
+// Infinity, text-embeddings-inference, ...) — the embeddings counterpart of
+// selfhosted-stt and selfhosted-tts.
+//
+// Routing a self-hosted embeddings server already WORKS today, via a custom
+// provider node: getEmbeddingAdapter() matches `openai-compatible-*` and
+// `custom-embedding-*` and returns openaiCompatNode, whose buildUrl reads
+// creds.providerSpecificData.baseUrl. What is missing is a first-class provider,
+// and the gap is visible rather than functional:
+//
+//   /v1/embeddings on such a node          -> 200, correct vectors
+//   the Embedding page in the dashboard    -> the node is not listed at all
+//
+// The page renders getProvidersByKind("embedding") plus provider nodes filtered
+// to `type === "custom-embedding"`. A node created as `openai-compatible` — the
+// natural choice when ONE endpoint serves chat and embeddings behind the same
+// front door — satisfies neither, so a working self-hosted embeddings endpoint is
+// invisible on the page whose job is to show embeddings providers. Diagnosed on a
+// deployment serving Qwen3-Embedding-8B at 4096 dimensions through exactly that
+// shape (2026-08-04).
+//
+// Declaring it as a provider with serviceKinds: ["embedding"] puts it on the page
+// beside Voyage, Jina and the rest, and keeps the per-connection baseUrl that
+// makes self-hosting possible at all.
+//
+// authType is "apikey" rather than "none" for the same reason as the STT and TTS
+// entries: it is what gives the connection a credentials record, and
+// providerSpecificData.baseUrl lives there. Local servers ignore the key itself;
+// any non-empty value works.
+export default {
+  id: "selfhosted-embedding",
+  priority: 50,
+  hasFree: true,
+  alias: "selfhosted-embedding",
+  display: {
+    name: "Self-hosted Embedding",
+    icon: "cloud",
+    color: "#ffffffff",
+    textIcon: "SE",
+    website: "https://github.com/ggml-org/llama.cpp",
+  },
+  category: "apikey",
+  auth: {
+    apiKey: {
+      // Note the /v1: the adapter appends "/embeddings" to whatever it is given,
+      // so a bare http://host:8080 resolves to http://host:8080/embeddings and
+      // misses the OpenAI route entirely. Give it the OpenAI base, the same value
+      // an OpenAI client would use. A trailing /embeddings is tolerated.
+      text: "Set providerSpecificData.baseUrl to the OpenAI base URL, e.g. http://host:8080/v1 — /embeddings is appended. The API key is not checked by local servers; any value works.",
+    },
+  },
+  // A self-hosted server serves whatever model it was started with, so the id
+  // here is a placeholder for the UI: the request passes `model` straight
+  // through, and llama-server ignores an unknown value rather than rejecting it.
+  // Dimensions are deliberately NOT declared — they are a property of the loaded
+  // weights, and asserting a number here would be a guess that silently
+  // contradicts the server.
+  models: [
+    { id: "embedding", name: "Self-hosted embedding model", kind: "embedding" },
+  ],
+  serviceKinds: ["embedding"],
+  embeddingConfig: {
+    // Declared for shape-consistency with the other embedding providers, and
+    // read by the UI — but NOT by the request path. openaiCompatNode resolves the
+    // URL purely from creds.providerSpecificData.baseUrl (falling back to
+    // api.openai.com), so unlike a fixed cloud provider this baseUrl never
+    // reaches the wire. Stated plainly because a reader would otherwise
+    // reasonably assume it is the default endpoint.
+    baseUrl: "http://localhost:8080/v1/embeddings",
+    authType: "apikey",
+    authHeader: "bearer",
+  },
+};
diff --git a/open-sse/providers/registry/selfhosted-stt.js b/open-sse/providers/registry/selfhosted-stt.js
new file mode 100644
index 00000000..d2d9bc80
--- /dev/null
+++ b/open-sse/providers/registry/selfhosted-stt.js
@@ -0,0 +1,48 @@
+// Self-hosted, OpenAI-compatible speech-to-text (whisper.cpp, faster-whisper,
+// Speaches, vLLM-served Whisper, ...).
+//
+// Every other STT provider here is a named cloud service with a fixed endpoint.
+// This one exists so a locally-served /v1/audio/transcriptions can be used at
+// all: set the connection's providerSpecificData.baseUrl to the full URL of the
+// endpoint, exactly as the custom embedding providers already work.
+//
+// sttCore dispatches on `format`; anything that is not one of the five named
+// cloud shapes falls through to transcribeOpenAICompatible, which POSTs the
+// standard multipart body (file, model, and optional language / prompt /
+// response_format / temperature). That is precisely what whisper.cpp's OpenAI
+// endpoint accepts.
+//
+// authType is "apikey" rather than "none" so the connection carries a
+// credentials record — which is where providerSpecificData.baseUrl lives. Local
+// servers ignore the key itself; any non-empty value works.
+export default {
+  id: "selfhosted-stt",
+  priority: 50,
+  hasFree: true,
+  alias: "selfhosted-stt",
+  display: {
+    name: "Self-hosted STT",
+    icon: "cloud",
+    color: "#ffffffff",
+    textIcon: "ST",
+    website: "https://github.com/ggml-org/whisper.cpp",
+  },
+  category: "apikey",
+  auth: {
+    apiKey: {
+      text: "Set providerSpecificData.baseUrl to the full transcriptions URL, e.g. http://host:8080/v1/audio/transcriptions. The API key is not checked by local servers; any value works.",
+    },
+  },
+  models: [
+    { id: "whisper-1", name: "Whisper (self-hosted)", params: ["language", "response_format", "temperature", "prompt"], kind: "stt" },
+  ],
+  serviceKinds: ["stt"],
+  sttConfig: {
+    // Overridden per connection by providerSpecificData.baseUrl; this default
+    // only makes the provider usable out of the box on a same-host deployment.
+    baseUrl: "http://localhost:8080/v1/audio/transcriptions",
+    authType: "apikey",
+    authHeader: "bearer",
+    format: "openai",
+  },
+};
diff --git a/open-sse/providers/registry/selfhosted-tts.js b/open-sse/providers/registry/selfhosted-tts.js
new file mode 100644
index 00000000..ff0a67b1
--- /dev/null
+++ b/open-sse/providers/registry/selfhosted-tts.js
@@ -0,0 +1,44 @@
+// Self-hosted, OpenAI-compatible text-to-speech (Kokoro-FastAPI, openedai-speech,
+// vLLM-served TTS, ...) — the TTS counterpart of selfhosted-stt.
+//
+// Every other self-hostable TTS provider here (coqui, tortoise) carries a FIXED
+// localhost baseUrl in its registry entry and `authType: "none"`, and the generic
+// dispatcher reads `ttsConfig.baseUrl` from that entry rather than from the
+// connection. So there was no way to point TTS at a server on another host.
+//
+// `authType: "apikey"` is what makes the override possible at all: it gives the
+// connection a credentials record, which is where providerSpecificData.baseUrl
+// lives. Local servers ignore the key; any non-empty value works.
+export default {
+  id: "selfhosted-tts",
+  priority: 50,
+  hasFree: true,
+  alias: "selfhosted-tts",
+  display: {
+    name: "Self-hosted TTS",
+    icon: "cloud",
+    color: "#ffffffff",
+    textIcon: "TT",
+    website: "https://github.com/remsky/Kokoro-FastAPI",
+  },
+  category: "apikey",
+  auth: {
+    apiKey: {
+      text: "Set providerSpecificData.baseUrl to the server root, e.g. http://host:8080 — /v1/audio/speech is appended. The API key is not checked by local servers; any value works.",
+    },
+  },
+  // Voice is selected as "<model>/<voice>", the same convention the OpenAI TTS
+  // adapter uses, so existing clients need no special casing.
+  models: [
+    { id: "kokoro", name: "Kokoro (self-hosted)", params: ["voice", "response_format", "speed"], kind: "tts" },
+  ],
+  serviceKinds: ["tts"],
+  ttsConfig: {
+    // Overridden per connection by providerSpecificData.baseUrl; this default
+    // only makes the provider usable on a same-host deployment.
+    baseUrl: "http://localhost:8880",
+    defaultModel: "kokoro",
+    authType: "apikey",
+    format: "openai-speech",
+  },
+};

From cd13d904d76d6a3045915fb736e875e890ac0dae Mon Sep 17 00:00:00 2001
From: decolua <decoluadt@gmail.com>
Date: Wed, 5 Aug 2026 15:53:20 +0700
Subject: [PATCH 32/42] fix(passthrough): detect codex-tui/Codex Desktop as
 native Codex client
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

detectClientTool only matched the legacy "codex-cli" User-Agent, so the
current codex-tui CLI and Codex Desktop (UA "Codex Desktop", originator
"codex_work_desktop") fell through to null and lost native passthrough —
their requests got re-translated, stripping/overwriting fields like
reasoning.summary instead of forwarding the client body as-is.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 open-sse/utils/clientDetector.js | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/open-sse/utils/clientDetector.js b/open-sse/utils/clientDetector.js
index 2d1381bc..12020762 100644
--- a/open-sse/utils/clientDetector.js
+++ b/open-sse/utils/clientDetector.js
@@ -22,6 +22,7 @@ export function detectClientTool(headers = {}, body = {}) {
   const xApp = (headers["x-app"] || "").toLowerCase();
   const openaiIntent = (headers["openai-intent"] || "").toLowerCase();
   const initiator = (headers["x-initiator"] || headers["X-Initiator"] || "").toLowerCase();
+  const originator = (headers["originator"] || "").toLowerCase();
 
   // Antigravity: detected via body field (not header)
   if (body.userAgent === "antigravity") return "antigravity";
@@ -37,8 +38,10 @@ export function detectClientTool(headers = {}, body = {}) {
   // Gemini CLI
   if (ua.includes("gemini-cli")) return "gemini-cli";
 
-  // Codex CLI
-  if (ua.includes("codex-cli")) return "codex";
+  // Codex CLI/Desktop — codex-tui is the current Rust CLI, codex-cli/codex_cli_rs legacy;
+  // Codex Desktop identifies via UA "Codex Desktop" or originator "codex_work_desktop"
+  if (ua.includes("codex-tui") || ua.includes("codex-cli") || ua.includes("codex_cli_rs") ||
+      ua.includes("codex desktop") || originator.startsWith("codex_")) return "codex";
 
   // DeepSeek TUI
   if (ua.includes("deepseek-tui")) return "deepseek-tui";

From 8e59093db78ae699eb2f28e3c13e2c2fa1dd675e Mon Sep 17 00:00:00 2001
From: decolua <decoluadt@gmail.com>
Date: Wed, 5 Aug 2026 16:09:42 +0700
Subject: [PATCH 33/42] feat(combos): default-enable vision/audio adapter with
 mimo fallback

- Enable vision + audioInput capacity-adapter pools by default for new
  and existing users (mergeWithDefaults backward-compat)
- Fall back to oc/mimo-v2.5-free when an enabled pool has no models
  configured, both in the backend resolver and the combos UI (auto
  refill on removing the last model from a pool)
- Hide PDF/Video from the Vision Adapter UI (PDF never implemented,
  Video lacks translator support) while keeping the settings shape
- Exclude combos from the model picker when opened from the Vision
  Adapter section
- mimo-v2.5 registry entry now declares audioInput/videoInput
- Simplify combo strategy and Vision Adapter descriptions
---
 open-sse/providers/capabilities.js           |   2 +-
 open-sse/services/capacityAdapter.js         | 173 ++++++++++++++++
 src/app/(dashboard)/dashboard/combos/page.js | 205 ++++++++++++++++++-
 src/lib/db/repos/settingsRepo.js             |   7 +
 src/shared/components/ModelSelectModal.js    |   8 +-
 5 files changed, 391 insertions(+), 4 deletions(-)
 create mode 100644 open-sse/services/capacityAdapter.js

diff --git a/open-sse/providers/capabilities.js b/open-sse/providers/capabilities.js
index 526ceb9b..e91ad1f2 100644
--- a/open-sse/providers/capabilities.js
+++ b/open-sse/providers/capabilities.js
@@ -279,7 +279,7 @@ export const PATTERN_CAPABILITIES = [
   { pattern: "*minimax*",       caps: { reasoning: true, thinkingFormat: "minimax", thinkingCanDisable: false, contextWindow: 200000, maxOutput: 131072 } },
 
   // ── Xiaomi MiMo (vision, 1M / 262K ctx) ──────────────────────────
-  { pattern: "*mimo*v2.5*",     caps: { vision: true, contextWindow: 1048576, maxOutput: 131072 } },
+  { pattern: "*mimo*v2.5*",     caps: { vision: true, audioInput: true, videoInput: true, contextWindow: 1048576, maxOutput: 131072 } },
   { pattern: "*mimo*omni*",     caps: { vision: true, audioInput: true, contextWindow: 262144, maxOutput: 131072 } },
   { pattern: "*mimo*",          caps: { vision: true, contextWindow: 262144, maxOutput: 131072 } },
 
diff --git a/open-sse/services/capacityAdapter.js b/open-sse/services/capacityAdapter.js
new file mode 100644
index 00000000..7b096f97
--- /dev/null
+++ b/open-sse/services/capacityAdapter.js
@@ -0,0 +1,173 @@
+/**
+ * Capacity Adapter — global fallback pools of models per input-modality capability
+ * (vision / pdf / audioInput / videoInput).
+ *
+ * The pool models are appended as extra fallback candidates behind whatever models
+ * were already going to be tried (a combo's members, or a single target model).
+ * combo.js's existing reorderByCapabilities then floats a capable pool model to the
+ * front only when none of the original models can handle the request — so this
+ * never overrides a combo that already has a member covering the capability.
+ */
+import { getCapabilitiesForModel } from "../providers/capabilities.js";
+
+const CAPABILITY_KEYS = ["vision", "pdf", "audioInput", "videoInput"];
+const HARD_CAPS = new Set(CAPABILITY_KEYS);
+const DEFAULT_FALLBACK_MODEL = "oc/mimo-v2.5-free";
+
+// Normalize a capability entry to { enabled, roundRobin, models }. Backward-compat:
+// accept the legacy array form [{model, enabled}] (treated as enabled, fallback).
+function normalizeCapEntry(entry) {
+  if (Array.isArray(entry)) {
+    return { enabled: true, roundRobin: false, models: entry.map((e) => e?.model || e).filter(Boolean) };
+  }
+  if (entry && typeof entry === "object") {
+    return {
+      enabled: entry.enabled !== false,
+      roundRobin: !!entry.roundRobin,
+      models: Array.isArray(entry.models) ? entry.models.filter(Boolean) : [],
+    };
+  }
+  return { enabled: false, roundRobin: false, models: [] };
+}
+
+// Resolve one capability's full config. Enabled pools with no models fall back
+// to DEFAULT_FALLBACK_MODEL so the toggle is never a no-op.
+export function getCapacityAdapterConfig(cap, settings) {
+  const entry = normalizeCapEntry(settings?.capacityAdapter?.[cap]);
+  if (entry.enabled && entry.models.length === 0) {
+    return { ...entry, models: [DEFAULT_FALLBACK_MODEL] };
+  }
+  return entry;
+}
+
+// Flatten enabled models across all capability pools, in priority order, deduped.
+export function getCapacityAdapterModels(settings) {
+  const seen = new Set();
+  const models = [];
+  for (const cap of CAPABILITY_KEYS) {
+    const { enabled, models: pool } = getCapacityAdapterConfig(cap, settings);
+    if (!enabled) continue;
+    for (const m of pool) {
+      if (!seen.has(m)) {
+        seen.add(m);
+        models.push(m);
+      }
+    }
+  }
+  return models;
+}
+
+// Strategy for a capability: "round-robin" when enabled+roundRobin, else "fallback".
+export function getCapacityAdapterStrategy(cap, settings) {
+  const { enabled, roundRobin } = getCapacityAdapterConfig(cap, settings);
+  return enabled && roundRobin ? "round-robin" : "fallback";
+}
+
+// Strategy from the request's required capabilities: picks the first capability
+// whose adapter pool is enabled and can satisfy a hard requirement.
+export function getActiveAdapterStrategy(requiredCapabilities, settings) {
+  const hard = [...(requiredCapabilities || [])].filter((c) => HARD_CAPS.has(c));
+  for (const cap of hard) {
+    const { enabled, models } = getCapacityAdapterConfig(cap, settings);
+    if (!enabled || models.length === 0) continue;
+    return getCapacityAdapterStrategy(cap, settings);
+  }
+  return "fallback";
+}
+
+function modelSatisfies(modelStr, requiredHard) {
+  const slash = modelStr.indexOf("/");
+  const provider = slash > 0 ? modelStr.slice(0, slash) : "";
+  const model = slash > 0 ? modelStr.slice(slash + 1) : modelStr;
+  const caps = getCapabilitiesForModel(provider, model);
+  return requiredHard.every((c) => caps[c] === true);
+}
+
+// Prepend capacity-adapter models as priority candidates when NONE of the
+// original models (combo members, or the single target model) can satisfy the
+// request's required capabilities. Adapter models go FIRST (priority); the
+// original models follow as fallback. Leaves `models` untouched when the
+// original list already covers it (combo.js's reorderByCapabilities handles
+// that case via autoSwitch).
+export function augmentModelsWithCapacityAdapter(models, requiredCapabilities, settings) {
+  const hard = [...(requiredCapabilities || [])].filter((c) => HARD_CAPS.has(c));
+  if (hard.length === 0 || !Array.isArray(models) || models.length === 0) return models;
+  if (models.some((m) => modelSatisfies(m, hard))) return models;
+
+  const pool = getCapacityAdapterModels(settings).filter((m) => !models.includes(m) && modelSatisfies(m, hard));
+  if (pool.length === 0) return models;
+  return [...pool, ...models];
+}
+
+const CHARS_PER_TOKEN = 4; // rough estimate; avoids pulling in a tokenizer dependency
+const HEAD_KEEP = 6;      // messages after system kept verbatim before dropping the middle
+
+function blockLength(content) {
+  if (typeof content === "string") return content.length;
+  if (Array.isArray(content)) {
+    return content.reduce((sum, b) => sum + (typeof b?.text === "string" ? b.text.length : 50), 0);
+  }
+  return 0;
+}
+
+// Trim history to fit a (possibly smaller) context window by dropping the MIDDLE.
+// Preserves: all system/instruction messages (head), and the trailing user run
+// carrying the media the switch happened for (tail). Older middle turns between
+// the head instructions and the current turn are dropped first.
+export function stripHistoryForContext(body, contextWindow) {
+  const key = Array.isArray(body.messages) ? "messages"
+    : Array.isArray(body.input) ? "input"
+    : Array.isArray(body.contents) ? "contents"
+    : null;
+  if (!key) return body;
+  const arr = body[key];
+  if (!arr || arr.length === 0) return body;
+
+  const isSystem = (r) => r === "system" || r === "developer";
+  const systemMsgs = arr.filter((m) => isSystem(m?.role));
+  const rest = arr.filter((m) => !isSystem(m?.role));
+  if (rest.length === 0) return body;
+
+  const isAssistant = (r) => r === "assistant" || r === "model";
+  let i = rest.length - 1;
+  while (i >= 0 && !isAssistant(rest[i]?.role)) i--;
+  const tail = rest.slice(i + 1);          // current user turn (has media) — always kept
+  const older = rest.slice(0, i + 1);      // everything before it
+  if (older.length === 0) return body;
+
+  const contentOf = (m) => m.content ?? m.parts;
+  // Cap at 80% of the adapter model's context window — leaves room for the response.
+  const budgetChars = (contextWindow || 200000) * 0.8 * CHARS_PER_TOKEN;
+
+  // Prefer keeping the first HEAD_KEEP messages (initial instructions/context) verbatim;
+  // only trim further if even that exceeds the adapter model's context window.
+  const headKept = older.slice(0, HEAD_KEEP);
+  let total = systemMsgs.concat(headKept, tail).reduce((s, m) => s + blockLength(contentOf(m)), 0);
+
+  // If head + tail overflow, drop head turns from the end (closest to middle) first.
+  let head = headKept;
+  while (total > budgetChars && head.length > 0) {
+    const dropped = head.pop();
+    total -= blockLength(contentOf(dropped));
+  }
+
+  if (head.length === older.length) return body;
+  return { ...body, [key]: [...systemMsgs, ...head, ...tail] };
+}
+
+// Wrap a handleSingleModel callback so calls to a capacity-adapter model strip
+// history to fit its context window first. No-op passthrough when the pool is empty.
+export function withCapacityAdapterStripping(handleSingleModel, adapterModels) {
+  const adapterSet = new Set(adapterModels);
+  if (adapterSet.size === 0) return handleSingleModel;
+  return (body, modelStr, ...rest) => {
+    if (adapterSet.has(modelStr)) {
+      const slash = modelStr.indexOf("/");
+      const provider = slash > 0 ? modelStr.slice(0, slash) : "";
+      const model = slash > 0 ? modelStr.slice(slash + 1) : modelStr;
+      const { contextWindow } = getCapabilitiesForModel(provider, model);
+      body = stripHistoryForContext(body, contextWindow);
+    }
+    return handleSingleModel(body, modelStr, ...rest);
+  };
+}
diff --git a/src/app/(dashboard)/dashboard/combos/page.js b/src/app/(dashboard)/dashboard/combos/page.js
index fb4c17d6..fa093bfd 100644
--- a/src/app/(dashboard)/dashboard/combos/page.js
+++ b/src/app/(dashboard)/dashboard/combos/page.js
@@ -5,7 +5,7 @@ import { DndContext, closestCenter, KeyboardSensor, PointerSensor, useSensor, us
 import { arrayMove, SortableContext, sortableKeyboardCoordinates, useSortable, verticalListSortingStrategy } from "@dnd-kit/sortable";
 import { CSS } from "@dnd-kit/utilities";
 import { restrictToVerticalAxis, restrictToParentElement } from "@dnd-kit/modifiers";
-import { Card, Button, Modal, Input, CardSkeleton, ModelSelectModal, ConfirmModal, CapacityBadges, Select } from "@/shared/components";
+import { Card, Button, Modal, Input, CardSkeleton, ModelSelectModal, ConfirmModal, CapacityBadges, Select, Toggle } from "@/shared/components";
 import { useCopyToClipboard } from "@/shared/hooks/useCopyToClipboard";
 import { useModelCaps } from "@/shared/hooks/useModelCaps";
 import { isOpenAICompatibleProvider, isAnthropicCompatibleProvider } from "@/shared/constants/providers";
@@ -13,6 +13,37 @@ import { isOpenAICompatibleProvider, isAnthropicCompatibleProvider } from "@/sha
 // Validate combo name: only a-z, A-Z, 0-9, -, _
 const VALID_NAME_REGEX = /^[a-zA-Z0-9_.\-]+$/;
 
+// Capacity adapter: global fallback pools of models per input-modality capability.
+// A request needing a capability the target model/combo lacks switches straight
+// to the first enabled model here instead of erroring or dropping the data.
+const CAPACITY_ADAPTER_CAPS = [
+  { key: "vision", label: "Vision", icon: "visibility", desc: "Images" },
+  // pdf, videoInput temporarily hidden — no translator support yet for those blocks.
+  { key: "audioInput", label: "Audio", icon: "graphic_eq", desc: "Audio input" },
+];
+const DEFAULT_FALLBACK_MODEL = "oc/mimo-v2.5-free";
+const EMPTY_CAP_ENTRY = { enabled: true, roundRobin: false, models: [] };
+const EMPTY_CAPACITY_ADAPTER = {
+  vision: { ...EMPTY_CAP_ENTRY },
+  pdf: { ...EMPTY_CAP_ENTRY },
+  audioInput: { ...EMPTY_CAP_ENTRY },
+  videoInput: { ...EMPTY_CAP_ENTRY },
+};
+// Backward-compat: legacy stored form was an array of {model, enabled}.
+function normalizeCapEntry(entry) {
+  if (Array.isArray(entry)) {
+    return { enabled: true, roundRobin: false, models: entry.map((e) => e?.model || e).filter(Boolean) };
+  }
+  if (entry && typeof entry === "object") {
+    return {
+      enabled: entry.enabled !== false,
+      roundRobin: !!entry.roundRobin,
+      models: Array.isArray(entry.models) ? entry.models.filter(Boolean) : [],
+    };
+  }
+  return { ...EMPTY_CAP_ENTRY };
+}
+
 export default function CombosPage() {
   const [combos, setCombos] = useState([]);
   const [loading, setLoading] = useState(true);
@@ -20,6 +51,7 @@ export default function CombosPage() {
   const [editingCombo, setEditingCombo] = useState(null);
   const [activeProviders, setActiveProviders] = useState([]);
   const [comboStrategies, setComboStrategies] = useState({});
+  const [capacityAdapter, setCapacityAdapter] = useState(EMPTY_CAPACITY_ADAPTER);
   const { getCaps } = useModelCaps();
   const [confirmState, setConfirmState] = useState(null);
   const { copied, copy } = useCopyToClipboard();
@@ -45,6 +77,12 @@ export default function CombosPage() {
         setActiveProviders(providersData.connections || []);
       }
       setComboStrategies(settingsData.comboStrategies || {});
+      const rawAdapter = settingsData.capacityAdapter || {};
+      const normalized = {};
+      for (const cap of CAPACITY_ADAPTER_CAPS) {
+        normalized[cap.key] = normalizeCapEntry(rawAdapter[cap.key]);
+      }
+      setCapacityAdapter(normalized);
     } catch (error) {
       console.log("Error fetching data:", error);
     } finally {
@@ -52,6 +90,19 @@ export default function CombosPage() {
     }
   };
 
+  const handleSetCapacityAdapter = async (next) => {
+    setCapacityAdapter(next);
+    try {
+      await fetch("/api/settings", {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ capacityAdapter: next }),
+      });
+    } catch (error) {
+      console.log("Error updating capacity adapter:", error);
+    }
+  };
+
   const handleCreate = async (data) => {
     try {
       const res = await fetch("/api/combos", {
@@ -154,7 +205,6 @@ export default function CombosPage() {
             <li><span className="font-medium text-text-main">Fallback</span> — tries models in order (next on failure)</li>
             <li><span className="font-medium text-text-main">Round Robin</span> — rotates models across requests to spread load</li>
             <li><span className="font-medium text-text-main">Fusion</span> — queries all models in parallel, then a judge synthesizes one answer. Best quality, but costs the most: every request bills all panel models + the judge (N+1 calls)</li>
-            <li><span className="font-medium text-text-main">Capacity auto-switch</span> — sends image/PDF/audio requests to a model that supports them first</li>
           </ul>
         </div>
         <Button icon="add" onClick={() => setShowCreateModal(true)} className="w-full sm:w-auto whitespace-nowrap">
@@ -195,6 +245,14 @@ export default function CombosPage() {
         </div>
       )}
 
+      {/* Capacity Adapter */}
+      <CapacityAdapterSection
+        capacityAdapter={capacityAdapter}
+        onChange={handleSetCapacityAdapter}
+        activeProviders={activeProviders}
+        getCaps={getCaps}
+      />
+
       {/* Create Modal - Use key to force remount and reset state */}
       {showCreateModal && (
         <ComboFormModal
@@ -351,6 +409,149 @@ function ComboCard({ combo, getCaps, activeProviders = [], copied, onCopy, onEdi
   );
 }
 
+function CapacityAdapterSection({ capacityAdapter, onChange, activeProviders, getCaps }) {
+  return (
+    <div className="flex flex-col gap-3">
+      <div className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
+        <div className="min-w-0">
+          <p className="text-sm font-medium">Vision Adapter</p>
+          <p className="text-xs text-text-muted mt-0.5">
+            Your model can&apos;t read image/audio? Auto-switches to a model in the pool below.
+          </p>
+          <ul className="mt-1.5 text-[11px] text-text-muted flex flex-col gap-0.5">
+            <li><span className="font-medium text-text-main">Vision</span> — images (png, jpg, webp, …)</li>
+            <li><span className="font-medium text-text-main">Audio</span> — audio input</li>
+          </ul>
+        </div>
+      </div>
+      <div className="flex flex-col gap-4">
+        {CAPACITY_ADAPTER_CAPS.map((cap) => (
+          <CapacityAdapterCap
+            key={cap.key}
+            cap={cap}
+            entry={capacityAdapter[cap.key] || EMPTY_CAP_ENTRY}
+            onChange={(entry) => onChange({ ...capacityAdapter, [cap.key]: entry })}
+            activeProviders={activeProviders}
+            getCaps={getCaps}
+          />
+        ))}
+      </div>
+    </div>
+  );
+}
+
+function CapacityAdapterCap({ cap, entry, onChange, activeProviders, getCaps }) {
+  const [showModelSelect, setShowModelSelect] = useState(false);
+  const { enabled, roundRobin, models } = entry;
+
+  const patch = (p) => onChange({ ...entry, ...p });
+
+  const handleAdd = (model) => {
+    if (models.includes(model.value)) return;
+    patch({ models: [...models, model.value] });
+  };
+
+  const handleRemove = (index) => {
+    const next = models.filter((_, i) => i !== index);
+    patch({ models: next.length === 0 ? [DEFAULT_FALLBACK_MODEL] : next });
+  };
+
+  const handleMove = (index, delta) => {
+    const target = index + delta;
+    if (target < 0 || target >= models.length) return;
+    const next = [...models];
+    [next[index], next[target]] = [next[target], next[index]];
+    patch({ models: next });
+  };
+
+  return (
+    <Card padding="sm" className={`group ${!enabled ? "opacity-50" : ""}`}>
+      <div className="flex min-w-0 flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
+        {/* Master toggle + icon + label + chips */}
+        <div className="flex min-w-0 flex-1 items-start gap-2.5 sm:items-center">
+          <Toggle
+            checked={enabled}
+            onChange={(v) => patch({ enabled: v })}
+            aria-label={`Enable ${cap.label} adapter`}
+          />
+          <div className="size-8 rounded-lg bg-primary/10 flex items-center justify-center shrink-0">
+            <span className="material-symbols-outlined text-primary text-[18px]">{cap.icon}</span>
+          </div>
+          <div className="min-w-0 flex-1">
+            <div className="flex items-center gap-1.5">
+              <code className="font-mono text-sm font-medium">{cap.label}</code>
+              <span className="text-[10px] text-text-muted">— {cap.desc}</span>
+            </div>
+            <div className="mt-1 flex min-w-0 flex-wrap items-center gap-1">
+              {models.length === 0 ? (
+                <span className="text-xs text-text-muted italic">No models</span>
+              ) : (
+                models.slice(0, 3).map((model, index) => (
+                  <code
+                    key={`${model}-${index}`}
+                    className="group/chip inline-flex items-center gap-1 rounded bg-black/5 px-1.5 py-0.5 font-mono text-xs text-text-muted dark:bg-white/5"
+                  >
+                    <span>{model}</span>
+                    <CapacityBadges caps={getCaps?.(model)} />
+                    <button onClick={() => handleMove(index, -1)} disabled={index === 0} className={`leading-none opacity-0 group-hover/chip:opacity-100 ${index === 0 ? "text-text-muted/20" : "text-text-muted hover:text-primary"}`}>
+                      <span className="material-symbols-outlined text-[12px]">arrow_upward</span>
+                    </button>
+                    <button onClick={() => handleMove(index, 1)} disabled={index === models.length - 1} className={`leading-none opacity-0 group-hover/chip:opacity-100 ${index === models.length - 1 ? "text-text-muted/20" : "text-text-muted hover:text-primary"}`}>
+                      <span className="material-symbols-outlined text-[12px]">arrow_downward</span>
+                    </button>
+                    <button onClick={() => handleRemove(index)} className="leading-none opacity-0 group-hover/chip:opacity-100 text-text-muted hover:text-red-500">
+                      <span className="material-symbols-outlined text-[12px]">close</span>
+                    </button>
+                  </code>
+                ))
+              )}
+              {models.length > 3 && (
+                <span className="text-[10px] text-text-muted">+{models.length - 3} more</span>
+              )}
+            </div>
+          </div>
+        </div>
+
+        {/* Actions: Round-robin toggle + Add Model */}
+        <div className="flex w-full flex-col gap-2 sm:w-auto sm:flex-row sm:items-center sm:gap-3 sm:shrink-0">
+          <label className="flex items-center gap-1.5 text-xs text-text-muted cursor-pointer select-none">
+            <Toggle
+              checked={roundRobin}
+              onChange={(v) => patch({ roundRobin: v })}
+              disabled={!enabled}
+              aria-label={`Round-robin ${cap.label} adapter`}
+            />
+            <span>Round</span>
+          </label>
+          <Button
+            icon="add"
+            variant="ghost"
+            size="sm"
+            onClick={() => setShowModelSelect(true)}
+            disabled={!enabled}
+            title={`Add ${cap.label} model`}
+          >
+            Add Model
+          </Button>
+        </div>
+      </div>
+
+      {showModelSelect && (
+        <ModelSelectModal
+          isOpen={showModelSelect}
+          onClose={() => setShowModelSelect(false)}
+          onSelect={handleAdd}
+          activeProviders={activeProviders}
+          title={`Add ${cap.label} Model`}
+          addedModelValues={models}
+          capFilter={cap.key}
+          closeOnSelect={false}
+        />
+      )}
+    </Card>
+  );
+}
+
 function ModelItem({ id, index, model, isFirst, isLast, onEdit, onMoveUp, onMoveDown, onRemove }) {
   const { attributes, listeners, setNodeRef, transform, isDragging } = useSortable({ id });
   const style = {
diff --git a/src/lib/db/repos/settingsRepo.js b/src/lib/db/repos/settingsRepo.js
index 1abe4360..7bae5b9f 100644
--- a/src/lib/db/repos/settingsRepo.js
+++ b/src/lib/db/repos/settingsRepo.js
@@ -17,7 +17,14 @@ const DEFAULT_SETTINGS = {
   comboStrategy: "fallback",
   comboStickyRoundRobinLimit: 1,
   comboStrategies: {},
+  capacityAdapter: {
+    vision: { enabled: true, roundRobin: false, models: [] },
+    pdf: { enabled: false, roundRobin: false, models: [] },
+    audioInput: { enabled: true, roundRobin: false, models: [] },
+    videoInput: { enabled: false, roundRobin: false, models: [] },
+  },
   requireLogin: true,
+  requireApiKey: true,
   tunnelDashboardAccess: true,
   authMode: "password",
   oidcIssuerUrl: "",
diff --git a/src/shared/components/ModelSelectModal.js b/src/shared/components/ModelSelectModal.js
index 3419140b..2cbc11a2 100644
--- a/src/shared/components/ModelSelectModal.js
+++ b/src/shared/components/ModelSelectModal.js
@@ -30,6 +30,7 @@ export default function ModelSelectModal({
   title = "Select Model",
   modelAliases = {},
   kindFilter = null,
+  capFilter = null,
   addedModelValues = [],
   closeOnSelect = true,
 }) {
@@ -397,7 +398,7 @@ export default function ModelSelectModal({
 
   // Filter combos by search query (and hide combos when kindFilter is set — combos are LLM-only by design)
   const filteredCombos = useMemo(() => {
-    if (kindFilter) return [];
+    if (kindFilter || capFilter) return [];
     if (!searchQuery.trim()) return combos;
     const query = searchQuery.toLowerCase();
     return combos.filter(c => c.name.toLowerCase().includes(query));
@@ -417,6 +418,11 @@ export default function ModelSelectModal({
     const filtered = {};
     Object.entries(groupedModels).forEach(([providerId, group]) => {
       let models = group.models;
+      // Filter by input-modality capability (vision/pdf/audioInput/videoInput).
+      if (capFilter) {
+        models = models.filter((m) => getCaps(m.value)?.[capFilter] === true);
+        if (models.length === 0) return;
+      }
       if (query) {
         const providerNameMatches = group.name.toLowerCase().includes(query);
         models = models.filter(

From 6498b3122f5583e506b27d35503090f4350eb5ce Mon Sep 17 00:00:00 2001
From: decolua <decoluadt@gmail.com>
Date: Wed, 5 Aug 2026 16:12:55 +0700
Subject: [PATCH 34/42] feat(combos): wire capacity adapter into chat handler
 routing

- detectRequiredCapabilities: infer audioInput/videoInput from block
  type and embedded mime, not just vision/pdf
- handleChat / handleSingleModelChat: augment combo and single-model
  routing with capacity-adapter models when the target lacks a
  required capability, wrapped with history stripping for the
  adapter model's context window
---
 open-sse/services/combo.js | 25 ++++++++++++++++----
 src/sse/handlers/chat.js   | 48 +++++++++++++++++++++++++++++++-------
 2 files changed, 61 insertions(+), 12 deletions(-)

diff --git a/open-sse/services/combo.js b/open-sse/services/combo.js
index 9216ab2f..fdfc189a 100644
--- a/open-sse/services/combo.js
+++ b/open-sse/services/combo.js
@@ -106,15 +106,32 @@ export function detectRequiredCapabilities(body) {
   const required = new Set();
   if (!body || typeof body !== "object") return required;
 
+  const addByMime = (mime) => {
+    if (typeof mime !== "string") return;
+    if (mime.startsWith("image/")) required.add("vision");
+    else if (mime === "application/pdf") required.add("pdf");
+    else if (mime.startsWith("audio/")) required.add("audioInput");
+    else if (mime.startsWith("video/")) required.add("videoInput");
+  };
+
   const scanBlock = (b) => {
     if (!b || typeof b !== "object") return;
     const t = b.type;
     if (t === "image_url" || t === "image" || t === "input_image") required.add("vision");
-    if (t === "file" || t === "document" || t === "input_file") required.add("pdf");
+    if (t === "input_audio" || t === "audio_url" || t === "audio") required.add("audioInput");
+    if (t === "input_video" || t === "video_url" || t === "video") required.add("videoInput");
+    if (t === "file" || t === "document" || t === "input_file") {
+      // Infer modality from embedded mime when available; fall back to pdf for generic files.
+      let fmime = null;
+      if (b.input_audio?.format) fmime = `audio/${b.input_audio.format}`;
+      else if (b.file?.file_data) fmime = String(b.file.file_data).match(/^data:([^;,]+)/)?.[1];
+      else if (b.source?.media_type) fmime = b.source.media_type;
+      else if (b.source?.data) fmime = String(b.source.data).match(/^data:([^;,]+)/)?.[1];
+      if (fmime) addByMime(fmime);
+      else required.add("pdf");
+    }
     // gemini parts: inlineData/fileData carry a mime
-    const mime = b.inlineData?.mimeType || b.fileData?.mimeType;
-    if (typeof mime === "string" && mime.startsWith("image/")) required.add("vision");
-    if (mime === "application/pdf") required.add("pdf");
+    addByMime(b.inlineData?.mimeType || b.fileData?.mimeType);
   };
 
   const scanContent = (content) => {
diff --git a/src/sse/handlers/chat.js b/src/sse/handlers/chat.js
index b44727ab..88353c50 100644
--- a/src/sse/handlers/chat.js
+++ b/src/sse/handlers/chat.js
@@ -14,7 +14,8 @@ import { DEFAULT_HEADROOM_URL } from "@/lib/headroom/detect";
 import { getTransform as getPxpipeTransform } from "@/lib/pxpipe/loader.js";
 import { appendPxpipeEvent } from "@/lib/pxpipe/events.js";
 import { errorResponse, unavailableResponse } from "open-sse/utils/error.js";
-import { handleComboChat, handleFusionChat } from "open-sse/services/combo.js";
+import { handleComboChat, handleFusionChat, detectRequiredCapabilities } from "open-sse/services/combo.js";
+import { augmentModelsWithCapacityAdapter, withCapacityAdapterStripping, getActiveAdapterStrategy } from "open-sse/services/capacityAdapter.js";
 import { handleBypassRequest } from "open-sse/utils/bypassHandler.js";
 import { HTTP_STATUS } from "open-sse/config/runtimeConfig.js";
 import { detectFormatByEndpoint } from "open-sse/translator/formats.js";
@@ -83,6 +84,8 @@ export async function handleChat(request, clientRawRequest = null) {
   const bypassResponse = handleBypassRequest(body, modelStr, userAgent, !!settings.ccFilterNaming);
   if (bypassResponse) return bypassResponse.response || bypassResponse;
 
+  const requiredCapabilities = detectRequiredCapabilities(body);
+
   // Check if model is a combo (has multiple models with fallback)
   const comboModels = await getComboModels(modelStr);
   if (comboModels) {
@@ -90,6 +93,8 @@ export async function handleChat(request, clientRawRequest = null) {
     const comboStrategies = settings.comboStrategies || {};
     const comboSpecificStrategy = comboStrategies[modelStr]?.fallbackStrategy;
     const comboStrategy = comboSpecificStrategy || settings.comboStrategy || "fallback";
+    const augmentedModels = augmentModelsWithCapacityAdapter(comboModels, requiredCapabilities, settings);
+    const adapterAdded = augmentedModels.filter((m) => !comboModels.includes(m));
 
     if (comboStrategy === "fusion") {
       log.info("CHAT", `Combo "${modelStr}" with ${comboModels.length} models (strategy: fusion)`);
@@ -112,11 +117,14 @@ export async function handleChat(request, clientRawRequest = null) {
     }
 
     const comboStickyLimit = settings.comboStickyRoundRobinLimit;
-    log.info("CHAT", `Combo "${modelStr}" with ${comboModels.length} models (strategy: ${comboStrategy}, sticky: ${comboStickyLimit})`);
+    log.info("CHAT", `Combo "${modelStr}" with ${augmentedModels.length} models (strategy: ${comboStrategy}, sticky: ${comboStickyLimit})`);
     return handleComboChat({
       body,
-      models: comboModels,
-      handleSingleModel: (b, m) => handleSingleModelChat(b, m, clientRawRequest, request, apiKey),
+      models: augmentedModels,
+      handleSingleModel: withCapacityAdapterStripping(
+        (b, m) => handleSingleModelChat(b, m, clientRawRequest, request, apiKey),
+        adapterAdded
+      ),
       log,
       comboName: modelStr,
       comboStrategy,
@@ -124,7 +132,25 @@ export async function handleChat(request, clientRawRequest = null) {
     });
   }
 
-  // Single model request
+  // Single model request — may still switch to a capacity-adapter model if the
+  // target lacks a capability the request needs (e.g. no vision, request has an image).
+  const soloAugmented = augmentModelsWithCapacityAdapter([modelStr], requiredCapabilities, settings);
+  if (soloAugmented.length > 1) {
+    const adapterAdded = soloAugmented.filter((m) => m !== modelStr);
+    log.info("CHAT", `Capacity adapter for [${[...requiredCapabilities].join(",")}] on "${modelStr}" → trying ${soloAugmented.join(", ")}`);
+    return handleComboChat({
+      body,
+      models: soloAugmented,
+      handleSingleModel: withCapacityAdapterStripping(
+        (b, m) => handleSingleModelChat(b, m, clientRawRequest, request, apiKey),
+        adapterAdded
+      ),
+      log,
+      comboName: modelStr,
+      comboStrategy: getActiveAdapterStrategy(requiredCapabilities, settings)
+    });
+  }
+
   return handleSingleModelChat(body, modelStr, clientRawRequest, request, apiKey);
 }
 
@@ -143,6 +169,9 @@ async function handleSingleModelChat(body, modelStr, clientRawRequest = null, re
       const comboStrategies = chatSettings.comboStrategies || {};
       const comboSpecificStrategy = comboStrategies[modelStr]?.fallbackStrategy;
       const comboStrategy = comboSpecificStrategy || chatSettings.comboStrategy || "fallback";
+      const requiredCapabilities = detectRequiredCapabilities(body);
+      const augmentedModels = augmentModelsWithCapacityAdapter(comboModels, requiredCapabilities, chatSettings);
+      const adapterAdded = augmentedModels.filter((m) => !comboModels.includes(m));
 
       if (comboStrategy === "fusion") {
         log.info("CHAT", `Combo "${modelStr}" with ${comboModels.length} models (strategy: fusion)`);
@@ -165,11 +194,14 @@ async function handleSingleModelChat(body, modelStr, clientRawRequest = null, re
       }
 
       const comboStickyLimit = chatSettings.comboStickyRoundRobinLimit;
-      log.info("CHAT", `Combo "${modelStr}" with ${comboModels.length} models (strategy: ${comboStrategy}, sticky: ${comboStickyLimit})`);
+      log.info("CHAT", `Combo "${modelStr}" with ${augmentedModels.length} models (strategy: ${comboStrategy}, sticky: ${comboStickyLimit})`);
       return handleComboChat({
         body,
-        models: comboModels,
-        handleSingleModel: (b, m) => handleSingleModelChat(b, m, clientRawRequest, request, apiKey),
+        models: augmentedModels,
+        handleSingleModel: withCapacityAdapterStripping(
+          (b, m) => handleSingleModelChat(b, m, clientRawRequest, request, apiKey),
+          adapterAdded
+        ),
         log,
         comboName: modelStr,
         comboStrategy,

From dcdd4628b32c760125a75061970d071892d7ff28 Mon Sep 17 00:00:00 2001
From: decolua <decoluadt@gmail.com>
Date: Wed, 5 Aug 2026 16:17:26 +0700
Subject: [PATCH 35/42] fix(providers): remove Qwen provider support

Qwen OAuth flow (portal.qwen.ai) stopped working reliably; drop the
executor, registry entry, OAuth provider/service, token refresh
profile, usage handler, and related test coverage and baselines.
---
 open-sse/config/appConstants.js              |   1 -
 open-sse/executors/default.js                |   1 -
 open-sse/executors/index.js                  |   3 -
 open-sse/executors/qwen.js                   | 129 --------------
 open-sse/index.js                            |   1 -
 open-sse/providers/registry/index.js         |   2 -
 open-sse/providers/registry/qwen.js          |  33 ----
 open-sse/services/tokenRefresh.js            |   4 -
 open-sse/services/tokenRefresh/providers.js  |  10 --
 open-sse/services/usage.js                   |   2 -
 open-sse/services/usage/misc.js              |  19 +--
 src/app/api/providers/[id]/models/route.js   |  23 ---
 src/app/api/providers/[id]/test/testUtils.js |  17 --
 src/lib/oauth/constants/oauth.js             |   4 -
 src/lib/oauth/providers/index.js             |   2 -
 src/lib/oauth/providers/qwen.js              |  56 ------
 src/lib/oauth/services/index.js              |   1 -
 src/lib/oauth/services/qwen.js               | 170 -------------------
 src/shared/components/OAuthModal.js          |   1 -
 src/shared/components/Sidebar.js             |   2 +-
 src/sse/services/tokenRefresh.js             |   4 -
 tests/__baseline__/oauth-urls-baseline.json  |   6 -
 tests/__baseline__/verify-oauth-urls.mjs     |   3 -
 tests/translator/golden-url-header.test.js   |   2 +-
 tests/unit/codex-refresh-token.test.js       |   1 -
 tests/unit/token-refresh-generic.test.js     |  34 +---
 tests/unit/usage-dispatch.test.js            |   2 +-
 27 files changed, 8 insertions(+), 525 deletions(-)
 delete mode 100644 open-sse/executors/qwen.js
 delete mode 100644 open-sse/providers/registry/qwen.js
 delete mode 100644 src/lib/oauth/providers/qwen.js
 delete mode 100644 src/lib/oauth/services/qwen.js

diff --git a/open-sse/config/appConstants.js b/open-sse/config/appConstants.js
index 5e3ec4be..62e2f888 100644
--- a/open-sse/config/appConstants.js
+++ b/open-sse/config/appConstants.js
@@ -176,7 +176,6 @@ export const OAUTH_ENDPOINTS = {
   google:    { token: "https://oauth2.googleapis.com/token", auth: "https://accounts.google.com/o/oauth2/auth" },
   openai:    { token: PROVIDER_OAUTH["codex"]?.tokenUrl, auth: PROVIDER_OAUTH["codex"]?.authorizeUrl },
   anthropic: { token: PROVIDER_OAUTH["claude"]?.tokenUrl, auth: "https://api.anthropic.com/v1/oauth/authorize" }, // ≠ claude.authorizeUrl (claude.ai login) — keep
-  qwen:      { token: PROVIDER_OAUTH["qwen"]?.tokenUrl, auth: PROVIDER_OAUTH["qwen"]?.deviceCodeUrl },
   iflow:     { token: PROVIDER_OAUTH["iflow"]?.tokenUrl, auth: PROVIDER_OAUTH["iflow"]?.authorizeUrl },
   github:    { token: PROVIDER_OAUTH["github"]?.tokenUrl, auth: PROVIDER_OAUTH["github"]?.authorizeUrl, deviceCode: PROVIDER_OAUTH["github"]?.deviceCodeUrl },
 };
diff --git a/open-sse/executors/default.js b/open-sse/executors/default.js
index eb000f37..92c78e92 100644
--- a/open-sse/executors/default.js
+++ b/open-sse/executors/default.js
@@ -211,7 +211,6 @@ export class DefaultExecutor extends BaseExecutor {
     const refreshers = {
       claude: () => this.refreshFromGrant(credentials, proxyOptions),
       codex: () => this.refreshFromGrant(credentials, proxyOptions),
-      qwen: () => this.refreshWithForm(OAUTH_ENDPOINTS.qwen.token, { grant_type: "refresh_token", refresh_token: credentials.refreshToken, client_id: PROVIDERS.qwen.clientId }, proxyOptions),
       iflow: () => this.refreshIflow(credentials.refreshToken, proxyOptions),
       gemini: () => this.refreshFromGrant(credentials, proxyOptions),
       kiro: () => this.refreshKiro(credentials.refreshToken, proxyOptions),
diff --git a/open-sse/executors/index.js b/open-sse/executors/index.js
index 92e10464..8dd03421 100644
--- a/open-sse/executors/index.js
+++ b/open-sse/executors/index.js
@@ -9,7 +9,6 @@ import { KimchiExecutor } from "./kimchi.js";
 import { CodexExecutor } from "./codex.js";
 import { CursorExecutor } from "./cursor.js";
 import { VertexExecutor } from "./vertex.js";
-import { QwenExecutor } from "./qwen.js";
 import { OpenCodeExecutor } from "./opencode.js";
 import { OpenCodeGoExecutor } from "./opencode-go.js";
 import { GrokWebExecutor } from "./grok-web.js";
@@ -41,7 +40,6 @@ const executors = {
   cu: new CursorExecutor(), // Alias for cursor
   vertex: new VertexExecutor("vertex"),
   "vertex-partner": new VertexExecutor("vertex-partner"),
-  qwen: new QwenExecutor(),
   opencode: new OpenCodeExecutor(),
   "opencode-go": new OpenCodeGoExecutor(),
   "grok-web": new GrokWebExecutor(),
@@ -87,7 +85,6 @@ export { CodexExecutor } from "./codex.js";
 export { CursorExecutor } from "./cursor.js";
 export { VertexExecutor } from "./vertex.js";
 export { DefaultExecutor } from "./default.js";
-export { QwenExecutor } from "./qwen.js";
 export { OpenCodeExecutor } from "./opencode.js";
 export { OpenCodeGoExecutor } from "./opencode-go.js";
 export { GrokWebExecutor } from "./grok-web.js";
diff --git a/open-sse/executors/qwen.js b/open-sse/executors/qwen.js
deleted file mode 100644
index ae828118..00000000
--- a/open-sse/executors/qwen.js
+++ /dev/null
@@ -1,129 +0,0 @@
-import { DefaultExecutor } from "./default.js";
-import { PROVIDERS } from "../config/providers.js";
-import { OAUTH_ENDPOINTS } from "../config/appConstants.js";
-
-/** portal.qwen.ai — static fingerprint matching stable Qwen Code release */
-const QWEN_USER_AGENT = "QwenCode/0.12.3 (linux; x64)";
-const QWEN_STAINLESS = {
-  os: "Linux",
-  arch: "x64",
-  lang: "js",
-  runtime: "node",
-  runtimeVersion: "v18.19.1",
-  packageVersion: "5.11.0",
-  retryCount: "1"
-};
-const QWEN_DEFAULT_SYSTEM_MESSAGE = {
-  role: "system",
-  content: [{ type: "text", text: "", cache_control: { type: "ephemeral" } }]
-};
-
-function ensureQwenSystemMessage(body) {
-  if (!body || typeof body !== "object") return body;
-  const next = { ...body };
-  if (Array.isArray(next.messages)) {
-    next.messages = [QWEN_DEFAULT_SYSTEM_MESSAGE, ...next.messages];
-  } else {
-    next.messages = [QWEN_DEFAULT_SYSTEM_MESSAGE];
-  }
-  return next;
-}
-
-function isQwenThinkingActive(body) {
-  const thinking = body?.thinking;
-  if (thinking === true || body?.enable_thinking === true) return true;
-  return typeof thinking === "object" && thinking !== null && !Array.isArray(thinking) && thinking.type === "enabled";
-}
-
-// Qwen rejects tool_choice="required" or object forms when thinking is active; neutralize to "auto".
-function sanitizeQwenThinkingToolChoice(body) {
-  if (!isQwenThinkingActive(body)) return body;
-  const tc = body.tool_choice;
-  const incompatible = tc === "required" || (typeof tc === "object" && tc !== null);
-  if (!incompatible) return body;
-  return { ...body, tool_choice: "auto" };
-}
-
-function buildQwenUpstreamHeaders(credentials, stream = true) {
-  const token = credentials?.apiKey || credentials?.accessToken || "";
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${token}`,
-    "User-Agent": QWEN_USER_AGENT,
-    "X-DashScope-AuthType": "qwen-oauth",
-    "X-DashScope-CacheControl": "enable",
-    "X-DashScope-UserAgent": QWEN_USER_AGENT,
-    "X-Stainless-Arch": QWEN_STAINLESS.arch,
-    "X-Stainless-Lang": QWEN_STAINLESS.lang,
-    "X-Stainless-Os": QWEN_STAINLESS.os,
-    "X-Stainless-Package-Version": QWEN_STAINLESS.packageVersion,
-    "X-Stainless-Retry-Count": QWEN_STAINLESS.retryCount,
-    "X-Stainless-Runtime": QWEN_STAINLESS.runtime,
-    "X-Stainless-Runtime-Version": QWEN_STAINLESS.runtimeVersion,
-    Connection: "keep-alive",
-    "Accept-Language": "*",
-    "Sec-Fetch-Mode": "cors"
-  };
-  headers.Accept = stream ? "text/event-stream" : "application/json";
-  return headers;
-}
-
-export class QwenExecutor extends DefaultExecutor {
-  constructor() {
-    super("qwen");
-  }
-
-  // Qwen tokens are bound to a resource_url returned at OAuth time.
-  // Using portal.qwen.ai when the token is issued for another shard returns 401/403.
-  buildUrl(model, stream, urlIndex = 0, credentials = null) {
-    const resourceUrl = credentials?.providerSpecificData?.resourceUrl;
-    const host = resourceUrl ? resourceUrl.replace(/^https?:\/\//, "").replace(/\/$/, "") : "portal.qwen.ai";
-    return `https://${host}/v1/chat/completions`;
-  }
-
-  buildHeaders(credentials, stream = true) {
-    return buildQwenUpstreamHeaders(credentials, stream);
-  }
-
-  transformRequest(model, body, stream, credentials) {
-    let next = body && typeof body === "object" ? { ...body } : body;
-    if (stream && next?.messages && !next.stream_options && !next.thinking && !next.enable_thinking && next.stream !== false) {
-      next.stream_options = { include_usage: true };
-    }
-    next = sanitizeQwenThinkingToolChoice(next);
-    return ensureQwenSystemMessage(next);
-  }
-
-  // Override to capture resource_url from refresh response (required for buildUrl).
-  async refreshCredentials(credentials, log) {
-    if (!credentials?.refreshToken) return null;
-    try {
-      const response = await fetch(OAUTH_ENDPOINTS.qwen.token, {
-        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" },
-        body: new URLSearchParams({
-          grant_type: "refresh_token",
-          refresh_token: credentials.refreshToken,
-          client_id: PROVIDERS.qwen.clientId
-        })
-      });
-      if (!response.ok) return null;
-      const tokens = await response.json();
-      log?.info?.("TOKEN", "qwen refreshed");
-      return {
-        accessToken: tokens.access_token,
-        refreshToken: tokens.refresh_token || credentials.refreshToken,
-        expiresIn: tokens.expires_in,
-        providerSpecificData: {
-          ...(credentials.providerSpecificData || {}),
-          ...(tokens.resource_url ? { resourceUrl: tokens.resource_url } : {})
-        }
-      };
-    } catch (error) {
-      log?.error?.("TOKEN", `qwen refresh error: ${error.message}`);
-      return null;
-    }
-  }
-}
-
-export default QwenExecutor;
diff --git a/open-sse/index.js b/open-sse/index.js
index b8181f0b..c0694580 100644
--- a/open-sse/index.js
+++ b/open-sse/index.js
@@ -47,7 +47,6 @@ export {
   refreshAccessToken,
   refreshClaudeOAuthToken,
   refreshGoogleToken,
-  refreshQwenToken,
   refreshCodexToken,
   refreshIflowToken,
   refreshGitHubToken,
diff --git a/open-sse/providers/registry/index.js b/open-sse/providers/registry/index.js
index c08c0597..467d1c4d 100644
--- a/open-sse/providers/registry/index.js
+++ b/open-sse/providers/registry/index.js
@@ -75,7 +75,6 @@ import p72 from "./perplexity.js";
 import p73 from "./perplexity-agent.js";
 import p74 from "./playht.js";
 import p75 from "./qoder.js";
-import p76 from "./qwen.js";
 import p77 from "./recraft.js";
 import p78 from "./runwayml.js";
 import p79 from "./sdwebui.js";
@@ -198,7 +197,6 @@ export default [
   p73,
   p74,
   p75,
-  p76,
   p77,
   p78,
   p79,
diff --git a/open-sse/providers/registry/qwen.js b/open-sse/providers/registry/qwen.js
deleted file mode 100644
index 0df381ab..00000000
--- a/open-sse/providers/registry/qwen.js
+++ /dev/null
@@ -1,33 +0,0 @@
-export default {
-  id: "qwen",
-  hidden: true,
-  priority: 130,
-  alias: "qw",
-  display: {
-    name: "Qwen Code",
-    icon: "psychology",
-    color: "#10B981",
-    website: "https://chat.qwen.ai",
-    notice: {
-      signupUrl: "https://chat.qwen.ai",
-    },
-  },
-  category: "oauth",
-  transport: {
-    baseUrl: "https://portal.qwen.ai/v1/chat/completions",
-  },
-  models: [
-    { id: "qwen3-coder-plus", name: "Qwen3 Coder Plus" },
-    { id: "qwen3-coder-flash", name: "Qwen3 Coder Flash" },
-    { id: "vision-model", name: "Qwen3 Vision Model" },
-    { id: "coder-model", name: "Qwen3.6 Coder Model" },
-  ],
-  oauth: {
-    clientId: "f0304373b74a44d2b584a3fb70ca9e56",
-    deviceCodeUrl: "https://chat.qwen.ai/api/v1/oauth2/device/code",
-    tokenUrl: "https://chat.qwen.ai/api/v1/oauth2/token",
-    scope: "openid profile email model.completion",
-    codeChallengeMethod: "S256",
-    refreshLeadMs: 1200000,
-  },
-};
diff --git a/open-sse/services/tokenRefresh.js b/open-sse/services/tokenRefresh.js
index 634fd633..3160f4a7 100644
--- a/open-sse/services/tokenRefresh.js
+++ b/open-sse/services/tokenRefresh.js
@@ -6,7 +6,6 @@ import {
   refreshKimiToken,
   refreshClaudeOAuthToken,
   refreshGoogleToken,
-  refreshQwenToken,
   refreshCodexToken,
   refreshKiroToken,
   refreshIflowToken,
@@ -26,7 +25,6 @@ export {
   refreshKimiToken,
   refreshClaudeOAuthToken,
   refreshGoogleToken,
-  refreshQwenToken,
   refreshCodexToken,
   refreshKiroToken,
   refreshIflowToken,
@@ -137,7 +135,6 @@ const REFRESH_HANDLERS = {
   antigravity: (c, log) => refreshGoogleToken(c.refreshToken, PROVIDERS.antigravity.clientId, PROVIDERS.antigravity.clientSecret, log),
   claude: (c, log) => refreshClaudeOAuthToken(c.refreshToken, log),
   codex: (c, log) => refreshCodexToken(c.refreshToken, log),
-  qwen: (c, log) => refreshQwenToken(c.refreshToken, log),
   iflow: (c, log) => refreshIflowToken(c.refreshToken, log),
   github: (c, log) => refreshGitHubToken(c.refreshToken, log),
   kiro: (c, log) => refreshKiroToken(c.refreshToken, c.providerSpecificData, log),
@@ -205,7 +202,6 @@ export function formatProviderCredentials(provider, credentials, log) {
       };
 
     case "codex":
-    case "qwen":
     case "iflow":
     case "openai":
     case "openrouter":
diff --git a/open-sse/services/tokenRefresh/providers.js b/open-sse/services/tokenRefresh/providers.js
index 7c13ae77..40f27f51 100644
--- a/open-sse/services/tokenRefresh/providers.js
+++ b/open-sse/services/tokenRefresh/providers.js
@@ -40,11 +40,6 @@ const REFRESH_PROFILES = {
     url: () => OAUTH_ENDPOINTS.anthropic.token,
     dedupKey: "claude",
   },
-  qwen: {
-    url: () => OAUTH_ENDPOINTS.qwen.token,
-    dedupKey: "qwen",
-    parse: (tokens) => tokens.resource_url ? { providerSpecificData: { resourceUrl: tokens.resource_url } } : {},
-  },
   iflow: {
     url: () => OAUTH_ENDPOINTS.iflow.token,
     dedupKey: "iflow",
@@ -191,11 +186,6 @@ export async function refreshGoogleToken(refreshToken, clientId, clientSecret, l
   }, log);
 }
 
-// Qwen: form body + clientId, surfaces resource_url. Delegate to refreshAccessToken("qwen", ...).
-export async function refreshQwenToken(refreshToken, log) {
-  return refreshAccessToken("qwen", refreshToken, {}, log);
-}
-
 export function classifyOAuthRefreshError(errorText = "", status = 0) {
   let parsed = null;
   try {
diff --git a/open-sse/services/usage.js b/open-sse/services/usage.js
index 93bfeca6..70a38ea6 100644
--- a/open-sse/services/usage.js
+++ b/open-sse/services/usage.js
@@ -16,7 +16,6 @@ import { getKimiUsage } from "./usage/kimi.js";
 import { getDeepseekUsage } from "./usage/deepseek.js";
 import { resolveQoderCredentials } from "./qoderModels.js";
 import {
-  getQwenUsage,
   getIflowUsage,
   getOllamaUsage,
   getGlmUsage,
@@ -43,7 +42,6 @@ const USAGE_HANDLERS = {
     const resolved = await resolveQoderCredentials(c, c.proxyOptions).catch(() => null);
     return getQoderUsage(resolved?.accessToken || c.accessToken, c.proxyOptions);
   },
-  qwen: (c) => getQwenUsage(c.accessToken, c.providerSpecificData),
   iflow: (c) => getIflowUsage(c.accessToken),
   ollama: (c) => getOllamaUsage(c.apiKey, c.providerSpecificData, c.proxyOptions),
   glm: (c) => getGlmUsage(c.apiKey, c.provider, c.proxyOptions),
diff --git a/open-sse/services/usage/misc.js b/open-sse/services/usage/misc.js
index 6a4323c8..fc133eff 100644
--- a/open-sse/services/usage/misc.js
+++ b/open-sse/services/usage/misc.js
@@ -1,5 +1,5 @@
 /**
- * Misc usage handlers (Qwen, iFlow, Ollama, GLM, Vercel AI Gateway, Qoder)
+ * Misc usage handlers (iFlow, Ollama, GLM, Vercel AI Gateway, Qoder)
  */
 
 import { proxyAwareFetch } from "../../utils/proxyFetch.js";
@@ -15,23 +15,6 @@ const GLM_QUOTA_URLS = {
 // Returns { balance: "95.50", total_used: "4.50" } (USD as decimal strings).
 const VERCEL_AI_GATEWAY_CREDITS_URL = U("vercel-ai-gateway").url;
 
-/**
- * Qwen Usage
- */
-export async function getQwenUsage(accessToken, providerSpecificData) {
-  try {
-    const resourceUrl = providerSpecificData?.resourceUrl;
-    if (!resourceUrl) {
-      return { message: "Qwen connected. No resource URL available." };
-    }
-
-    // Qwen may have usage endpoint at resource URL
-    return { message: "Qwen connected. Usage tracked per request." };
-  } catch (error) {
-    return { message: "Unable to fetch Qwen usage." };
-  }
-}
-
 /**
  * iFlow Usage
  */
diff --git a/src/app/api/providers/[id]/models/route.js b/src/app/api/providers/[id]/models/route.js
index 018db024..d73ec11d 100644
--- a/src/app/api/providers/[id]/models/route.js
+++ b/src/app/api/providers/[id]/models/route.js
@@ -79,18 +79,6 @@ const createOpenAIModelsConfig = (url) => ({
   parseResponse: parseOpenAIStyleModels
 });
 
-const resolveQwenModelsUrl = (connection) => {
-  const fallback = "https://portal.qwen.ai/v1/models";
-  const raw = connection?.providerSpecificData?.resourceUrl;
-  if (!raw || typeof raw !== "string") return fallback;
-  const value = raw.trim();
-  if (!value) return fallback;
-  if (value.startsWith("http://") || value.startsWith("https://")) {
-    return `${value.replace(/\/$/, "")}/models`;
-  }
-  return `https://${value.replace(/\/$/, "")}/v1/models`;
-};
-
 const getStaticProviderModels = (providerId) =>
   getModelsByProviderId(providerId).map((model) => ({
     ...model,
@@ -156,14 +144,6 @@ const PROVIDER_MODELS_CONFIG = {
     authQuery: "key", // Use query param for API key
     parseResponse: (data) => data.models || []
   },
-  qwen: {
-    url: "https://portal.qwen.ai/v1/models",
-    method: "GET",
-    headers: { "Content-Type": "application/json" },
-    authHeader: "Authorization",
-    authPrefix: "Bearer ",
-    parseResponse: (data) => data.data || []
-  },
   codex: {
     customResolver: buildOAuthResolver({
       refreshFn: (conn) => refreshCodexToken(conn.refreshToken),
@@ -572,9 +552,6 @@ export async function GET(request, { params }) {
 
     // Build request URL
     let url = config.url;
-    if (connection.provider === "qwen") {
-      url = resolveQwenModelsUrl(connection);
-    }
     if (config.authQuery) {
       url += `?${config.authQuery}=${token}`;
     }
diff --git a/src/app/api/providers/[id]/test/testUtils.js b/src/app/api/providers/[id]/test/testUtils.js
index 8ee8c496..0ea46b2d 100644
--- a/src/app/api/providers/[id]/test/testUtils.js
+++ b/src/app/api/providers/[id]/test/testUtils.js
@@ -12,7 +12,6 @@ import {
   GEMINI_CONFIG,
   ANTIGRAVITY_CONFIG,
   KIRO_CONFIG,
-  QWEN_CONFIG,
   CLAUDE_CONFIG,
   CLINE_CONFIG,
   KILOCODE_CONFIG,
@@ -62,7 +61,6 @@ const OAUTH_TEST_CONFIG = {
     method: "GET",
     noAuth: true,
   },
-  qwen: { checkExpiry: true, refreshable: true },
   kiro: { checkExpiry: true, refreshable: true },
   qoder: {
     // Test by hitting Qoder's userinfo endpoint with the device token.
@@ -285,21 +283,6 @@ async function refreshOAuthToken(connection) {
       return { accessToken: data.accessToken, expiresIn: data.expiresIn || 3600, refreshToken: data.refreshToken || refreshToken };
     }
 
-    if (provider === "qwen") {
-      const response = await fetch(QWEN_CONFIG.tokenUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json" },
-        body: new URLSearchParams({
-          grant_type: "refresh_token",
-          refresh_token: refreshToken,
-          client_id: QWEN_CONFIG.clientId,
-        }),
-      });
-      if (!response.ok) return null;
-      const data = await response.json();
-      return { accessToken: data.access_token, expiresIn: data.expires_in, refreshToken: data.refresh_token || refreshToken };
-    }
-
     if (provider === "cline") {
       const response = await fetch(CLINE_CONFIG.refreshUrl, {
         method: "POST",
diff --git a/src/lib/oauth/constants/oauth.js b/src/lib/oauth/constants/oauth.js
index d66e32c5..c9e3cae6 100644
--- a/src/lib/oauth/constants/oauth.js
+++ b/src/lib/oauth/constants/oauth.js
@@ -28,9 +28,6 @@ export const CODEX_CONFIG = { ...PROVIDER_OAUTH["codex"] };
 // clientId/clientSecret from GOOGLE_OAUTH_CLIENT (shared.js) — not stored in registry
 export const GEMINI_CONFIG = { ...GOOGLE_OAUTH_CLIENT, ...PROVIDER_OAUTH["gemini-cli"] };
 
-// Qwen OAuth Configuration (Device Code Flow with PKCE)
-export const QWEN_CONFIG = { ...PROVIDER_OAUTH["qwen"] };
-
 // Qoder OAuth Configuration (Device Token Flow with PKCE).
 // Device tokens are long-lived (~30 days for access, ~360 for refresh).
 // The upstream refresh endpoint at center.qoder.sh returns 403 for our
@@ -206,7 +203,6 @@ export const PROVIDERS = {
   CLAUDE: "claude",
   CODEX: "codex",
   GEMINI: "gemini-cli",
-  QWEN: "qwen",
   QODER: "qoder",
   IFLOW: "iflow",
   ANTIGRAVITY: "antigravity",
diff --git a/src/lib/oauth/providers/index.js b/src/lib/oauth/providers/index.js
index 8449ecef..e505b01d 100644
--- a/src/lib/oauth/providers/index.js
+++ b/src/lib/oauth/providers/index.js
@@ -12,7 +12,6 @@ import geminiCli from "./gemini-cli.js";
 import antigravity from "./antigravity.js";
 import iflow from "./iflow.js";
 import qoder from "./qoder.js";
-import qwen from "./qwen.js";
 import github from "./github.js";
 import kiro from "./kiro.js";
 import cursor from "./cursor.js";
@@ -38,7 +37,6 @@ const PROVIDERS = {
   antigravity,
   iflow,
   qoder,
-  qwen,
   github,
   kiro,
   cursor,
diff --git a/src/lib/oauth/providers/qwen.js b/src/lib/oauth/providers/qwen.js
deleted file mode 100644
index e8048654..00000000
--- a/src/lib/oauth/providers/qwen.js
+++ /dev/null
@@ -1,56 +0,0 @@
-import { QWEN_CONFIG } from "../constants/oauth.js";
-
-const qwen = {
-  config: QWEN_CONFIG,
-  flowType: "device_code",
-  requestDeviceCode: async (config, codeChallenge) => {
-    const response = await fetch(config.deviceCodeUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        Accept: "application/json",
-      },
-      body: new URLSearchParams({
-        client_id: config.clientId,
-        scope: config.scope,
-        code_challenge: codeChallenge,
-        code_challenge_method: config.codeChallengeMethod,
-      }),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Device code request failed: ${error}`);
-    }
-
-    return await response.json();
-  },
-  pollToken: async (config, deviceCode, codeVerifier) => {
-    const response = await fetch(config.tokenUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        Accept: "application/json",
-      },
-      body: new URLSearchParams({
-        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-        client_id: config.clientId,
-        device_code: deviceCode,
-        code_verifier: codeVerifier,
-      }),
-    });
-
-    return {
-      ok: response.ok,
-      data: await response.json(),
-    };
-  },
-  mapTokens: (tokens) => ({
-    accessToken: tokens.access_token,
-    refreshToken: tokens.refresh_token,
-    expiresIn: tokens.expires_in,
-    providerSpecificData: { resourceUrl: tokens.resource_url },
-  }),
-};
-
-export default qwen;
diff --git a/src/lib/oauth/services/index.js b/src/lib/oauth/services/index.js
index 33cea03c..f8f0214a 100644
--- a/src/lib/oauth/services/index.js
+++ b/src/lib/oauth/services/index.js
@@ -6,7 +6,6 @@ export { OAuthService } from "./oauth.js";
 export { ClaudeService } from "./claude.js";
 export { CodexService } from "./codex.js";
 export { GeminiCLIService } from "./gemini.js";
-export { QwenService } from "./qwen.js";
 export { IFlowService } from "./iflow.js";
 export { QoderService } from "./qoder.js";
 export { AntigravityService } from "./antigravity.js";
diff --git a/src/lib/oauth/services/qwen.js b/src/lib/oauth/services/qwen.js
deleted file mode 100644
index ee4489ea..00000000
--- a/src/lib/oauth/services/qwen.js
+++ /dev/null
@@ -1,170 +0,0 @@
-import open from "open";
-import { QWEN_CONFIG } from "../constants/oauth.js";
-import { getServerCredentials } from "../config/index.js";
-import { generatePKCE } from "../utils/pkce.js";
-import { spinner as createSpinner } from "../utils/ui.js";
-
-/**
- * Qwen OAuth Service
- * Uses Device Code Flow with PKCE
- */
-export class QwenService {
-  constructor() {
-    this.config = QWEN_CONFIG;
-  }
-
-  /**
-   * Request device code
-   */
-  async requestDeviceCode(codeChallenge) {
-    const response = await fetch(this.config.deviceCodeUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        Accept: "application/json",
-      },
-      body: new URLSearchParams({
-        client_id: this.config.clientId,
-        scope: this.config.scope,
-        code_challenge: codeChallenge,
-        code_challenge_method: this.config.codeChallengeMethod,
-      }),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Device code request failed: ${error}`);
-    }
-
-    return await response.json();
-  }
-
-  /**
-   * Poll for token
-   */
-  async pollForToken(deviceCode, codeVerifier, interval = 5) {
-    const maxAttempts = 60; // 5 minutes
-    const pollInterval = interval * 1000;
-
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      await new Promise((r) => setTimeout(r, pollInterval));
-
-      const response = await fetch(this.config.tokenUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded",
-          Accept: "application/json",
-        },
-        body: new URLSearchParams({
-          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-          client_id: this.config.clientId,
-          device_code: deviceCode,
-          code_verifier: codeVerifier,
-        }),
-      });
-
-      if (response.ok) {
-        return await response.json();
-      }
-
-      const error = await response.json();
-
-      if (error.error === "authorization_pending") {
-        continue;
-      } else if (error.error === "slow_down") {
-        await new Promise((r) => setTimeout(r, 5000));
-        continue;
-      } else if (error.error === "expired_token") {
-        throw new Error("Device code expired");
-      } else if (error.error === "access_denied") {
-        throw new Error("Access denied");
-      } else {
-        throw new Error(error.error_description || error.error);
-      }
-    }
-
-    throw new Error("Authorization timeout");
-  }
-
-  /**
-   * Save Qwen tokens to server
-   */
-  async saveTokens(tokens) {
-    const { server, token, userId } = getServerCredentials();
-
-    const response = await fetch(`${server}/api/cli/providers/qwen`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`,
-        "X-User-Id": userId,
-      },
-      body: JSON.stringify({
-        accessToken: tokens.access_token,
-        refreshToken: tokens.refresh_token,
-        expiresIn: tokens.expires_in,
-        resourceUrl: tokens.resource_url,
-      }),
-    });
-
-    if (!response.ok) {
-      const error = await response.json();
-      throw new Error(error.error || "Failed to save tokens");
-    }
-
-    return await response.json();
-  }
-
-  /**
-   * Complete Qwen OAuth flow
-   */
-  async connect() {
-    const spinner = createSpinner("Starting Qwen OAuth...").start();
-
-    try {
-      spinner.text = "Generating PKCE...";
-
-      // Generate PKCE
-      const { codeVerifier, codeChallenge } = generatePKCE();
-
-      spinner.text = "Requesting device code...";
-
-      // Request device code
-      const deviceData = await this.requestDeviceCode(codeChallenge);
-
-      spinner.stop();
-
-      console.log("\n📋 Please visit the following URL and enter the code:\n");
-      console.log(`   ${deviceData.verification_uri}\n`);
-      console.log(`   Code: ${deviceData.user_code}\n`);
-
-      // Open browser
-      if (deviceData.verification_uri_complete) {
-        await open(deviceData.verification_uri_complete);
-      } else {
-        await open(deviceData.verification_uri);
-      }
-
-      spinner.start("Waiting for authorization...");
-
-      // Poll for token
-      const tokens = await this.pollForToken(
-        deviceData.device_code,
-        codeVerifier,
-        deviceData.interval || 5
-      );
-
-      spinner.text = "Saving tokens to server...";
-
-      // Save tokens to server
-      await this.saveTokens(tokens);
-
-      spinner.succeed("Qwen connected successfully!");
-      return true;
-    } catch (error) {
-      spinner.fail(`Failed: ${error.message}`);
-      throw error;
-    }
-  }
-}
-
diff --git a/src/shared/components/OAuthModal.js b/src/shared/components/OAuthModal.js
index 808a7a8b..805301da 100644
--- a/src/shared/components/OAuthModal.js
+++ b/src/shared/components/OAuthModal.js
@@ -226,7 +226,6 @@ export default function OAuthModal({ isOpen, provider, providerInfo, onSuccess,
       // Device code flow providers (must match oauth providers with flowType: "device_code")
       const deviceCodeProviders = [
         "github",
-        "qwen",
         "kiro",
         "kimi",
         "kimi-coding",
diff --git a/src/shared/components/Sidebar.js b/src/shared/components/Sidebar.js
index cded1824..812e319e 100644
--- a/src/shared/components/Sidebar.js
+++ b/src/shared/components/Sidebar.js
@@ -21,7 +21,7 @@ const navItems = [
   { href: "/dashboard/endpoint", label: "Endpoint & Key", icon: "api" },
   { href: "/dashboard/providers", label: "Providers", icon: "dns" },
   // { href: "/dashboard/basic-chat", label: "Basic Chat", icon: "chat" }, // Hidden
-  { href: "/dashboard/combos", label: "Combos", icon: "layers" },
+  { href: "/dashboard/combos", label: "Combo & Vision Adapter", icon: "layers" },
   { href: "/dashboard/usage", label: "Usage", icon: "bar_chart" },
   { href: "/dashboard/quota", label: "Quota Tracker", icon: "data_usage" },
   { href: "/dashboard/token-saver", label: "Token Saver", icon: "savings" },
diff --git a/src/sse/services/tokenRefresh.js b/src/sse/services/tokenRefresh.js
index 4e75a8ad..6c808f07 100644
--- a/src/sse/services/tokenRefresh.js
+++ b/src/sse/services/tokenRefresh.js
@@ -11,7 +11,6 @@ import {
   refreshAccessToken as _refreshAccessToken,
   refreshClaudeOAuthToken as _refreshClaudeOAuthToken,
   refreshGoogleToken as _refreshGoogleToken,
-  refreshQwenToken as _refreshQwenToken,
   refreshCodexToken as _refreshCodexToken,
   refreshIflowToken as _refreshIflowToken,
   refreshGitHubToken as _refreshGitHubToken,
@@ -41,9 +40,6 @@ export const refreshClaudeOAuthToken = (refreshToken) =>
 export const refreshGoogleToken = (refreshToken, clientId, clientSecret) =>
   _refreshGoogleToken(refreshToken, clientId, clientSecret, log);
 
-export const refreshQwenToken = (refreshToken) =>
-  _refreshQwenToken(refreshToken, log);
-
 export const refreshCodexToken = (refreshToken) =>
   _refreshCodexToken(refreshToken, log);
 
diff --git a/tests/__baseline__/oauth-urls-baseline.json b/tests/__baseline__/oauth-urls-baseline.json
index b4468678..98a27684 100644
--- a/tests/__baseline__/oauth-urls-baseline.json
+++ b/tests/__baseline__/oauth-urls-baseline.json
@@ -12,10 +12,6 @@
       "token": "https://api.anthropic.com/v1/oauth/token",
       "auth": "https://api.anthropic.com/v1/oauth/authorize"
     },
-    "qwen": {
-      "token": "https://chat.qwen.ai/api/v1/oauth2/token",
-      "auth": "https://chat.qwen.ai/api/v1/oauth2/device/code"
-    },
     "iflow": {
       "token": "https://iflow.cn/oauth/token",
       "auth": "https://iflow.cn/oauth"
@@ -29,7 +25,6 @@
   "tokenUrls": {
     "claude": "https://api.anthropic.com/v1/oauth/token",
     "codex": "https://auth.openai.com/oauth/token",
-    "qwen": "https://chat.qwen.ai/api/v1/oauth2/token",
     "iflow": "https://iflow.cn/oauth/token",
     "kiro": "https://prod.us-east-1.auth.desktop.kiro.dev/refreshToken",
     "xai": "https://auth.x.ai/oauth2/token",
@@ -49,7 +44,6 @@
   "clientIds": {
     "claude": "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
     "codex": "app_EMoamEEZ73f0CkXaXp7hrann",
-    "qwen": "f0304373b74a44d2b584a3fb70ca9e56",
     "iflow": "10009311001",
     "kimi": "17e5f671-d194-4dfb-9706-5516cb48c098",
     "grok-cli": "b1a00492-073a-47ea-816f-4c329264a828"
diff --git a/tests/__baseline__/verify-oauth-urls.mjs b/tests/__baseline__/verify-oauth-urls.mjs
index d385d102..a43dc9fc 100644
--- a/tests/__baseline__/verify-oauth-urls.mjs
+++ b/tests/__baseline__/verify-oauth-urls.mjs
@@ -15,7 +15,6 @@ const resolved = {
   tokenUrls: {
     claude: PROVIDERS.claude?.tokenUrl,
     codex: PROVIDERS.codex?.tokenUrl,
-    qwen: PROVIDERS.qwen?.tokenUrl,
     iflow: PROVIDERS.iflow?.tokenUrl,
     kiro: PROVIDERS.kiro?.tokenUrl,
     xai: PROVIDERS.xai?.tokenUrl,
@@ -25,7 +24,6 @@ const resolved = {
     kimi: PROVIDERS.kimi?.tokenUrl,
   },
   authUrls: {
-    qwen: PROVIDERS.qwen?.authUrl,
     iflow: PROVIDERS.iflow?.authUrl,
     kiro: PROVIDERS.kiro?.authUrl,
   },
@@ -38,7 +36,6 @@ const resolved = {
   clientIds: {
     claude: PROVIDERS.claude?.clientId,
     codex: PROVIDERS.codex?.clientId,
-    qwen: PROVIDERS.qwen?.clientId,
     iflow: PROVIDERS.iflow?.clientId,
     kimi: PROVIDERS.kimi?.clientId,
     "grok-cli": PROVIDERS["grok-cli"]?.clientId,
diff --git a/tests/translator/golden-url-header.test.js b/tests/translator/golden-url-header.test.js
index b9f6bff3..5e92bdf0 100644
--- a/tests/translator/golden-url-header.test.js
+++ b/tests/translator/golden-url-header.test.js
@@ -18,7 +18,7 @@ const SPECIAL_CRED = {
 // Chúng được lock riêng ở 11-provider edge tests / unit test chuyên biệt.
 const SPECIALIZED = new Set([
   "antigravity", "azure", "gemini-cli", "github", "iflow", "qoder", "kiro",
-  "codex", "cursor", "vertex", "vertex-partner", "qwen", "opencode",
+  "codex", "cursor", "vertex", "vertex-partner", "opencode",
   "opencode-go", "grok-web", "perplexity-web", "ollama-local", "commandcode",
   "xiaomi-tokenplan", "mimo-free",
 ]);
diff --git a/tests/unit/codex-refresh-token.test.js b/tests/unit/codex-refresh-token.test.js
index e6274c16..4be86e64 100644
--- a/tests/unit/codex-refresh-token.test.js
+++ b/tests/unit/codex-refresh-token.test.js
@@ -151,7 +151,6 @@ describe("Codex Refresh Token", () => {
       expect(getRefreshLeadMs("codex")).toBe(5 * 24 * 60 * 60 * 1000);   // 5 days
       expect(getRefreshLeadMs("claude")).toBe(4 * 60 * 60 * 1000);       // 4 hours
       expect(getRefreshLeadMs("iflow")).toBe(24 * 60 * 60 * 1000);       // 24 hours
-      expect(getRefreshLeadMs("qwen")).toBe(20 * 60 * 1000);             // 20 minutes
       expect(getRefreshLeadMs("kimi")).toBe(5 * 60 * 1000);              // 5 minutes
       expect(getRefreshLeadMs("kimi-coding")).toBe(5 * 60 * 1000);       // legacy alias
       expect(getRefreshLeadMs("antigravity")).toBe(5 * 60 * 1000);       // 5 minutes
diff --git a/tests/unit/token-refresh-generic.test.js b/tests/unit/token-refresh-generic.test.js
index d4507c2e..e14c9038 100644
--- a/tests/unit/token-refresh-generic.test.js
+++ b/tests/unit/token-refresh-generic.test.js
@@ -1,8 +1,8 @@
 /**
  * Generic OAuth2 token refresh — config-driven profiles.
  *
- * Verifies refreshAccessToken() handles the 5 foldable providers
- * (qwen, iflow, github, kimi, claude) via a REFRESH_PROFILES table,
+ * Verifies refreshAccessToken() handles the 4 foldable providers
+ * (iflow, github, kimi, claude) via a REFRESH_PROFILES table,
  * while preserving the legacy generic path for unknown providers.
  */
 
@@ -25,32 +25,6 @@ describe("refreshAccessToken — config-driven profiles", () => {
   beforeEach(() => { vi.clearAllMocks(); vi.resetModules(); global.fetch = originalFetch; });
   afterEach(() => { global.fetch = originalFetch; });
 
-  it("qwen: form body + clientId, surfaces resource_url as providerSpecificData", async () => {
-    const fm = mockFetchOnce({
-      access_token: "qw-acc",
-      refresh_token: "qw-refresh-rotated",
-      expires_in: 7200,
-      resource_url: "https://dashscope.aliyuncs.com",
-    });
-    const { refreshAccessToken } = await import("open-sse/services/tokenRefresh/providers.js");
-
-    const out = await refreshAccessToken("qwen", "qw-old-refresh", {}, console);
-
-    expect(out).toEqual({
-      accessToken: "qw-acc",
-      refreshToken: "qw-refresh-rotated",
-      expiresIn: 7200,
-      providerSpecificData: { resourceUrl: "https://dashscope.aliyuncs.com" },
-    });
-    const [url, init] = fm.mock.calls[0];
-    expect(init.method).toBe("POST");
-    expect(init.headers["Content-Type"]).toBe("application/x-www-form-urlencoded");
-    const body = new URLSearchParams(init.body);
-    expect(body.get("grant_type")).toBe("refresh_token");
-    expect(body.get("refresh_token")).toBe("qw-old-refresh");
-    expect(body.get("client_id")).toBeTruthy();
-  });
-
   it("iflow: Basic Auth header from clientId:clientSecret, form body keeps client_secret", async () => {
     const fm = mockFetchOnce({ access_token: "if-acc", refresh_token: "if-rot", expires_in: 3600 });
     const { refreshAccessToken } = await import("open-sse/services/tokenRefresh/providers.js");
@@ -107,13 +81,13 @@ describe("refreshAccessToken — config-driven profiles", () => {
   it("returns null on non-ok response", async () => {
     mockFetchOnce({ error: "invalid_grant" }, { ok: false, status: 400 });
     const { refreshAccessToken } = await import("open-sse/services/tokenRefresh/providers.js");
-    const out = await refreshAccessToken("qwen", "dead", {}, console);
+    const out = await refreshAccessToken("iflow", "dead", {}, console);
     expect(out).toBeNull();
   });
 
   it("returns null when refreshToken missing", async () => {
     const { refreshAccessToken } = await import("open-sse/services/tokenRefresh/providers.js");
-    const out = await refreshAccessToken("qwen", "", {}, console);
+    const out = await refreshAccessToken("iflow", "", {}, console);
     expect(out).toBeNull();
   });
 
diff --git a/tests/unit/usage-dispatch.test.js b/tests/unit/usage-dispatch.test.js
index 21078e39..e0e80840 100644
--- a/tests/unit/usage-dispatch.test.js
+++ b/tests/unit/usage-dispatch.test.js
@@ -14,7 +14,7 @@ vi.mock("../../open-sse/utils/proxyFetch.js", () => ({
 const load = () => import("../../open-sse/services/usage.js");
 const SUPPORTED = [
   "github", "gemini-cli", "antigravity", "claude", "codex", "kiro",
-  "qoder", "qwen", "iflow", "ollama", "glm", "glm-cn",
+  "qoder", "iflow", "ollama", "glm", "glm-cn",
   "minimax", "minimax-cn", "vercel-ai-gateway", "grok-cli", "kimi",
   "deepseek",
 ];

From 02c66fe2bd3f3bbcab2b47c64af689e85dc0ed55 Mon Sep 17 00:00:00 2001
From: decolua <decoluadt@gmail.com>
Date: Wed, 5 Aug 2026 16:22:06 +0700
Subject: [PATCH 36/42] feat(endpoint): auto-provision default API key for
 first-time users

- Endpoint page auto-creates a "Default Key" when no keys exist yet,
  so /v1 works out of the box without a manual dashboard step
- Show/copy key buttons stay visible instead of opacity-0 by default
---
 .../dashboard/endpoint/EndpointPageClient.js  | 27 ++++++++++++++-----
 1 file changed, 21 insertions(+), 6 deletions(-)

diff --git a/src/app/(dashboard)/dashboard/endpoint/EndpointPageClient.js b/src/app/(dashboard)/dashboard/endpoint/EndpointPageClient.js
index a7183741..b6bfd2e4 100644
--- a/src/app/(dashboard)/dashboard/endpoint/EndpointPageClient.js
+++ b/src/app/(dashboard)/dashboard/endpoint/EndpointPageClient.js
@@ -255,11 +255,26 @@ export default function APIPageClient({ machineId }) {
 
   const fetchData = async () => {
     try {
-      const keysRes = await fetch("/api/keys");
-      const keysData = await keysRes.json();
-      if (keysRes.ok) {
-        setKeys(keysData.keys || []);
+      const fetchKeys = async () => {
+        const res = await fetch("/api/keys");
+        if (!res.ok) return [];
+        const data = await res.json();
+        return data.keys || [];
+      };
+
+      let existing = await fetchKeys();
+      // Auto-provision a default key for first-time users so the endpoint works out of the box.
+      if (existing.length === 0) {
+        try {
+          const createRes = await fetch("/api/keys", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: "Default Key" }),
+          });
+          if (createRes.ok) existing = await fetchKeys();
+        } catch { /* fall through to empty render */ }
       }
+      setKeys(existing);
     } catch (error) {
       console.log("Error fetching data:", error);
     } finally {
@@ -1005,7 +1020,7 @@ export default function APIPageClient({ machineId }) {
                     </code>
                     <button
                       onClick={() => toggleKeyVisibility(key.id)}
-                      className="p-1 hover:bg-black/5 dark:hover:bg-white/5 rounded text-text-muted hover:text-primary opacity-100 sm:opacity-0 sm:group-hover:opacity-100 transition-all"
+                      className="p-1 hover:bg-black/5 dark:hover:bg-white/5 rounded text-text-muted hover:text-primary transition-all"
                       title={visibleKeys.has(key.id) ? "Hide key" : "Show key"}
                     >
                       <span className="material-symbols-outlined text-[14px]">
@@ -1014,7 +1029,7 @@ export default function APIPageClient({ machineId }) {
                     </button>
                     <button
                       onClick={() => copy(key.key, key.id)}
-                      className="p-1 hover:bg-black/5 dark:hover:bg-white/5 rounded text-text-muted hover:text-primary opacity-100 sm:opacity-0 sm:group-hover:opacity-100 transition-all"
+                      className="p-1 hover:bg-black/5 dark:hover:bg-white/5 rounded text-text-muted hover:text-primary transition-all"
                     >
                       <span className="material-symbols-outlined text-[14px]">
                         {copied === key.id ? "check" : "content_copy"}

From e41d85037dd966b4ff00ac1161083095517c3d18 Mon Sep 17 00:00:00 2001
From: decolua <decoluadt@gmail.com>
Date: Wed, 5 Aug 2026 16:25:12 +0700
Subject: [PATCH 37/42] test(capacity-adapter): add unit coverage for the
 capacity adapter service

Covers pool flattening, model augmentation for required capabilities,
context-window history stripping, and the withCapacityAdapterStripping
wrapper.
---
 tests/unit/capacity-adapter.test.js | 180 ++++++++++++++++++++++++++++
 1 file changed, 180 insertions(+)
 create mode 100644 tests/unit/capacity-adapter.test.js

diff --git a/tests/unit/capacity-adapter.test.js b/tests/unit/capacity-adapter.test.js
new file mode 100644
index 00000000..fd3945dd
--- /dev/null
+++ b/tests/unit/capacity-adapter.test.js
@@ -0,0 +1,180 @@
+import { describe, it, expect, vi } from "vitest";
+
+// Mock capabilities: claude-sonnet has vision + small context to exercise stripping;
+// everything else is text-only. This isolates tests from the real registry.
+vi.mock("../../open-sse/providers/capabilities.js", () => ({
+  getCapabilitiesForModel: (provider, model) => {
+    const base = model.includes("/") ? model.split("/").pop() : model;
+    return {
+      vision: base.includes("claude-sonnet"),
+      pdf: false,
+      audioInput: false,
+      videoInput: false,
+      contextWindow: base.includes("claude-sonnet") ? 2000 : 128000,
+    };
+  },
+}));
+
+import {
+  getCapacityAdapterModels,
+  augmentModelsWithCapacityAdapter,
+  stripHistoryForContext,
+  withCapacityAdapterStripping,
+} from "../../open-sse/services/capacityAdapter.js";
+
+const VISION_MODEL = "anthropic/claude-sonnet-4.6";
+const TEXT_MODEL = "deepseek/deepseek-chat";
+
+const settingsWith = (cap, entry) => ({
+  capacityAdapter: {
+    vision: { enabled: false, roundRobin: false, models: [] },
+    pdf: { enabled: false, roundRobin: false, models: [] },
+    audioInput: { enabled: false, roundRobin: false, models: [] },
+    videoInput: { enabled: false, roundRobin: false, models: [] },
+    [cap]: entry,
+  },
+});
+
+describe("getCapacityAdapterModels", () => {
+  it("flattens enabled pools in priority order, deduped across pools", () => {
+    const settings = {
+      capacityAdapter: {
+        vision: { enabled: true, roundRobin: false, models: ["a/x", "b/y"] },
+        pdf: { enabled: true, roundRobin: false, models: ["a/x", "c/z"] },
+        audioInput: { enabled: false, roundRobin: false, models: ["d/w"] },
+        videoInput: { enabled: false, roundRobin: false, models: [] },
+      },
+    };
+    expect(getCapacityAdapterModels(settings)).toEqual(["a/x", "b/y", "c/z"]);
+  });
+
+  it("returns [] when no settings", () => {
+    expect(getCapacityAdapterModels(undefined)).toEqual([]);
+    expect(getCapacityAdapterModels({})).toEqual([]);
+  });
+});
+
+describe("augmentModelsWithCapacityAdapter", () => {
+  it("prepends a capable adapter model (priority) when no original model satisfies vision", () => {
+    const settings = settingsWith("vision", [{ model: VISION_MODEL, enabled: true }]);
+    const out = augmentModelsWithCapacityAdapter([TEXT_MODEL], new Set(["vision"]), settings);
+    expect(out).toEqual([VISION_MODEL, TEXT_MODEL]);
+  });
+
+  it("leaves models untouched when an original model already satisfies the cap", () => {
+    const settings = settingsWith("vision", [{ model: VISION_MODEL, enabled: true }]);
+    const out = augmentModelsWithCapacityAdapter([VISION_MODEL, TEXT_MODEL], new Set(["vision"]), settings);
+    expect(out).toEqual([VISION_MODEL, TEXT_MODEL]);
+  });
+
+  it("skips disabled adapter entries", () => {
+    const settings = settingsWith("vision", { enabled: false, roundRobin: false, models: [VISION_MODEL] });
+    const out = augmentModelsWithCapacityAdapter([TEXT_MODEL], new Set(["vision"]), settings);
+    expect(out).toEqual([TEXT_MODEL]);
+  });
+
+  it("skips adapter models that don't satisfy the required cap", () => {
+    // adapter pool only has a text model -> useless for vision
+    const settings = settingsWith("vision", [{ model: TEXT_MODEL, enabled: true }]);
+    const out = augmentModelsWithCapacityAdapter([TEXT_MODEL], new Set(["vision"]), settings);
+    expect(out).toEqual([TEXT_MODEL]);
+  });
+
+  it("no required capabilities -> unchanged", () => {
+    const settings = settingsWith("vision", [{ model: VISION_MODEL, enabled: true }]);
+    const out = augmentModelsWithCapacityAdapter([TEXT_MODEL], new Set(), settings);
+    expect(out).toEqual([TEXT_MODEL]);
+  });
+
+  it("filters to hard caps only (ignores soft caps like search)", () => {
+    const settings = settingsWith("vision", [{ model: VISION_MODEL, enabled: true }]);
+    const out = augmentModelsWithCapacityAdapter([TEXT_MODEL], new Set(["search"]), settings);
+    expect(out).toEqual([TEXT_MODEL]);
+  });
+});
+
+describe("stripHistoryForContext", () => {
+  const big = "x".repeat(10000);
+
+  it("keeps system + trailing user turn, drops oldest when over budget", () => {
+    const body = {
+      messages: [
+        { role: "system", content: "sys" },
+        { role: "user", content: big },
+        { role: "assistant", content: big },
+        { role: "user", content: big },
+        { role: "assistant", content: big },
+        { role: "user", content: [{ type: "image_url", image_url: { url: "data:x" } }] },
+      ],
+    };
+    // Tiny budget forces dropping. ~4000 chars budget.
+    const out = stripHistoryForContext(body, 2000);
+    // System + the last (image) user turn must always survive.
+    expect(out.messages[0]).toMatchObject({ role: "system" });
+    expect(out.messages.at(-1)).toMatchObject({ role: "user" });
+    expect(out.messages.length).toBeLessThan(body.messages.length);
+  });
+
+  it("returns body unchanged when already within budget", () => {
+    const body = { messages: [
+      { role: "user", content: "hi" },
+      { role: "assistant", content: "hey" },
+      { role: "user", content: "again" },
+    ] };
+    expect(stripHistoryForContext(body, 200000)).toBe(body);
+  });
+
+  it("no-op on unsupported shape", () => {
+    const body = { foo: 1 };
+    expect(stripHistoryForContext(body, 1000)).toBe(body);
+  });
+
+  it("handles gemini contents/parts shape", () => {
+    const body = {
+      contents: [
+        { role: "user", parts: [{ text: big }] },
+        { role: "model", parts: [{ text: big }] },
+        { role: "user", parts: [{ inlineData: { mimeType: "image/png", data: "x" } }] },
+      ],
+    };
+    const out = stripHistoryForContext(body, 2000);
+    expect(out.contents.at(-1).role).toBe("user");
+    expect(out.contents.length).toBeLessThan(body.contents.length);
+  });
+});
+
+describe("withCapacityAdapterStripping", () => {
+  it("strips history only for adapter models", async () => {
+    const seen = [];
+    const inner = vi.fn(async (body, modelStr) => {
+      seen.push({ model: modelStr, len: body.messages?.length });
+      return { ok: true };
+    });
+    const wrapped = withCapacityAdapterStripping(inner, [VISION_MODEL]);
+
+    const big = "x".repeat(10000);
+    const body = {
+      messages: [
+        { role: "user", content: big },
+        { role: "assistant", content: big },
+        { role: "user", content: big },
+        { role: "assistant", content: big },
+        { role: "user", content: [{ type: "image_url", image_url: { url: "x" } }] },
+      ],
+    };
+
+    // Adapter model -> history stripped (fewer messages)
+    await wrapped(body, VISION_MODEL);
+    expect(seen[0].len).toBeLessThan(body.messages.length);
+
+    // Non-adapter model -> body untouched (same length)
+    await wrapped(body, TEXT_MODEL);
+    expect(seen[1].len).toBe(body.messages.length);
+  });
+
+  it("passthrough when adapterModels empty", async () => {
+    const inner = vi.fn(async () => ({ ok: true }));
+    const wrapped = withCapacityAdapterStripping(inner, []);
+    expect(wrapped).toBe(inner);
+  });
+});

From 99639c05406ff9da07a79c22fa72299130827835 Mon Sep 17 00:00:00 2001
From: decolua <decoluadt@gmail.com>
Date: Wed, 5 Aug 2026 16:25:47 +0700
Subject: [PATCH 38/42] test(capacity-adapter): remove unit test file

---
 tests/unit/capacity-adapter.test.js | 180 ----------------------------
 1 file changed, 180 deletions(-)
 delete mode 100644 tests/unit/capacity-adapter.test.js

diff --git a/tests/unit/capacity-adapter.test.js b/tests/unit/capacity-adapter.test.js
deleted file mode 100644
index fd3945dd..00000000
--- a/tests/unit/capacity-adapter.test.js
+++ /dev/null
@@ -1,180 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-
-// Mock capabilities: claude-sonnet has vision + small context to exercise stripping;
-// everything else is text-only. This isolates tests from the real registry.
-vi.mock("../../open-sse/providers/capabilities.js", () => ({
-  getCapabilitiesForModel: (provider, model) => {
-    const base = model.includes("/") ? model.split("/").pop() : model;
-    return {
-      vision: base.includes("claude-sonnet"),
-      pdf: false,
-      audioInput: false,
-      videoInput: false,
-      contextWindow: base.includes("claude-sonnet") ? 2000 : 128000,
-    };
-  },
-}));
-
-import {
-  getCapacityAdapterModels,
-  augmentModelsWithCapacityAdapter,
-  stripHistoryForContext,
-  withCapacityAdapterStripping,
-} from "../../open-sse/services/capacityAdapter.js";
-
-const VISION_MODEL = "anthropic/claude-sonnet-4.6";
-const TEXT_MODEL = "deepseek/deepseek-chat";
-
-const settingsWith = (cap, entry) => ({
-  capacityAdapter: {
-    vision: { enabled: false, roundRobin: false, models: [] },
-    pdf: { enabled: false, roundRobin: false, models: [] },
-    audioInput: { enabled: false, roundRobin: false, models: [] },
-    videoInput: { enabled: false, roundRobin: false, models: [] },
-    [cap]: entry,
-  },
-});
-
-describe("getCapacityAdapterModels", () => {
-  it("flattens enabled pools in priority order, deduped across pools", () => {
-    const settings = {
-      capacityAdapter: {
-        vision: { enabled: true, roundRobin: false, models: ["a/x", "b/y"] },
-        pdf: { enabled: true, roundRobin: false, models: ["a/x", "c/z"] },
-        audioInput: { enabled: false, roundRobin: false, models: ["d/w"] },
-        videoInput: { enabled: false, roundRobin: false, models: [] },
-      },
-    };
-    expect(getCapacityAdapterModels(settings)).toEqual(["a/x", "b/y", "c/z"]);
-  });
-
-  it("returns [] when no settings", () => {
-    expect(getCapacityAdapterModels(undefined)).toEqual([]);
-    expect(getCapacityAdapterModels({})).toEqual([]);
-  });
-});
-
-describe("augmentModelsWithCapacityAdapter", () => {
-  it("prepends a capable adapter model (priority) when no original model satisfies vision", () => {
-    const settings = settingsWith("vision", [{ model: VISION_MODEL, enabled: true }]);
-    const out = augmentModelsWithCapacityAdapter([TEXT_MODEL], new Set(["vision"]), settings);
-    expect(out).toEqual([VISION_MODEL, TEXT_MODEL]);
-  });
-
-  it("leaves models untouched when an original model already satisfies the cap", () => {
-    const settings = settingsWith("vision", [{ model: VISION_MODEL, enabled: true }]);
-    const out = augmentModelsWithCapacityAdapter([VISION_MODEL, TEXT_MODEL], new Set(["vision"]), settings);
-    expect(out).toEqual([VISION_MODEL, TEXT_MODEL]);
-  });
-
-  it("skips disabled adapter entries", () => {
-    const settings = settingsWith("vision", { enabled: false, roundRobin: false, models: [VISION_MODEL] });
-    const out = augmentModelsWithCapacityAdapter([TEXT_MODEL], new Set(["vision"]), settings);
-    expect(out).toEqual([TEXT_MODEL]);
-  });
-
-  it("skips adapter models that don't satisfy the required cap", () => {
-    // adapter pool only has a text model -> useless for vision
-    const settings = settingsWith("vision", [{ model: TEXT_MODEL, enabled: true }]);
-    const out = augmentModelsWithCapacityAdapter([TEXT_MODEL], new Set(["vision"]), settings);
-    expect(out).toEqual([TEXT_MODEL]);
-  });
-
-  it("no required capabilities -> unchanged", () => {
-    const settings = settingsWith("vision", [{ model: VISION_MODEL, enabled: true }]);
-    const out = augmentModelsWithCapacityAdapter([TEXT_MODEL], new Set(), settings);
-    expect(out).toEqual([TEXT_MODEL]);
-  });
-
-  it("filters to hard caps only (ignores soft caps like search)", () => {
-    const settings = settingsWith("vision", [{ model: VISION_MODEL, enabled: true }]);
-    const out = augmentModelsWithCapacityAdapter([TEXT_MODEL], new Set(["search"]), settings);
-    expect(out).toEqual([TEXT_MODEL]);
-  });
-});
-
-describe("stripHistoryForContext", () => {
-  const big = "x".repeat(10000);
-
-  it("keeps system + trailing user turn, drops oldest when over budget", () => {
-    const body = {
-      messages: [
-        { role: "system", content: "sys" },
-        { role: "user", content: big },
-        { role: "assistant", content: big },
-        { role: "user", content: big },
-        { role: "assistant", content: big },
-        { role: "user", content: [{ type: "image_url", image_url: { url: "data:x" } }] },
-      ],
-    };
-    // Tiny budget forces dropping. ~4000 chars budget.
-    const out = stripHistoryForContext(body, 2000);
-    // System + the last (image) user turn must always survive.
-    expect(out.messages[0]).toMatchObject({ role: "system" });
-    expect(out.messages.at(-1)).toMatchObject({ role: "user" });
-    expect(out.messages.length).toBeLessThan(body.messages.length);
-  });
-
-  it("returns body unchanged when already within budget", () => {
-    const body = { messages: [
-      { role: "user", content: "hi" },
-      { role: "assistant", content: "hey" },
-      { role: "user", content: "again" },
-    ] };
-    expect(stripHistoryForContext(body, 200000)).toBe(body);
-  });
-
-  it("no-op on unsupported shape", () => {
-    const body = { foo: 1 };
-    expect(stripHistoryForContext(body, 1000)).toBe(body);
-  });
-
-  it("handles gemini contents/parts shape", () => {
-    const body = {
-      contents: [
-        { role: "user", parts: [{ text: big }] },
-        { role: "model", parts: [{ text: big }] },
-        { role: "user", parts: [{ inlineData: { mimeType: "image/png", data: "x" } }] },
-      ],
-    };
-    const out = stripHistoryForContext(body, 2000);
-    expect(out.contents.at(-1).role).toBe("user");
-    expect(out.contents.length).toBeLessThan(body.contents.length);
-  });
-});
-
-describe("withCapacityAdapterStripping", () => {
-  it("strips history only for adapter models", async () => {
-    const seen = [];
-    const inner = vi.fn(async (body, modelStr) => {
-      seen.push({ model: modelStr, len: body.messages?.length });
-      return { ok: true };
-    });
-    const wrapped = withCapacityAdapterStripping(inner, [VISION_MODEL]);
-
-    const big = "x".repeat(10000);
-    const body = {
-      messages: [
-        { role: "user", content: big },
-        { role: "assistant", content: big },
-        { role: "user", content: big },
-        { role: "assistant", content: big },
-        { role: "user", content: [{ type: "image_url", image_url: { url: "x" } }] },
-      ],
-    };
-
-    // Adapter model -> history stripped (fewer messages)
-    await wrapped(body, VISION_MODEL);
-    expect(seen[0].len).toBeLessThan(body.messages.length);
-
-    // Non-adapter model -> body untouched (same length)
-    await wrapped(body, TEXT_MODEL);
-    expect(seen[1].len).toBe(body.messages.length);
-  });
-
-  it("passthrough when adapterModels empty", async () => {
-    const inner = vi.fn(async () => ({ ok: true }));
-    const wrapped = withCapacityAdapterStripping(inner, []);
-    expect(wrapped).toBe(inner);
-  });
-});

From 03f8487cc7d3327881f2dd113cdceb8dec5af4ca Mon Sep 17 00:00:00 2001
From: decolua <decoluadt@gmail.com>
Date: Wed, 5 Aug 2026 16:27:17 +0700
Subject: [PATCH 39/42] test(baseline): regenerate provider/alias snapshots

Sync alias-baseline.json and providers-baseline.json with the current
registry (poolside, tokenrouter, selfhosted-* providers already added;
stale claudeOverlay hook and Kiro X-Amz-Target header already removed).
---
 tests/__baseline__/alias-baseline.json     | 18 +++++++++------
 tests/__baseline__/providers-baseline.json | 26 +++++++++++-----------
 2 files changed, 24 insertions(+), 20 deletions(-)

diff --git a/tests/__baseline__/alias-baseline.json b/tests/__baseline__/alias-baseline.json
index ad667294..eda1604e 100644
--- a/tests/__baseline__/alias-baseline.json
+++ b/tests/__baseline__/alias-baseline.json
@@ -3,7 +3,7 @@
     "cc": "claude",
     "cx": "codex",
     "gc": "gemini-cli",
-    "qw": "qwen",
+    "qw": "qw",
     "if": "iflow",
     "ag": "antigravity",
     "gh": "github",
@@ -112,8 +112,8 @@
     "qianfan": "baidu",
     "baidu": "baidu",
     "ernie": "baidu",
-    "dv": "devin-cli",
-    "devin": "devin-cli",
+    "dv": "dv",
+    "devin": "devin",
     "devin-cli": "devin-cli",
     "morph": "morph",
     "morphllm": "morph"
@@ -146,7 +146,6 @@
     "cursor": "cu",
     "deepgram": "deepgram",
     "deepseek": "deepseek",
-    "devin-cli": "dv",
     "featherless": "featherless",
     "fireworks": "fireworks",
     "gemini": "gemini",
@@ -184,12 +183,13 @@
     "perplexity": "perplexity",
     "perplexity-agent": "perplexity-agent",
     "perplexity-web": "perplexity-web",
+    "poolside": "poolside",
     "qoder": "qd",
-    "qwen": "qw",
     "sambanova": "samba",
     "siliconflow": "siliconflow",
     "tencent": "hunyuan",
     "together": "together",
+    "tokenrouter": "tokenrouter",
     "venice": "venice",
     "vercel-ai-gateway": "vercel-ai-gateway",
     "vertex": "vertex",
@@ -227,7 +227,6 @@
     "cx",
     "deepgram",
     "deepseek",
-    "dv",
     "edge-tts",
     "elevenlabs-tts-models",
     "fal-ai",
@@ -275,16 +274,20 @@
     "perplexity",
     "perplexity-agent",
     "perplexity-web",
+    "poolside",
     "qd",
     "qianfan",
-    "qw",
     "recraft",
     "runwayml",
     "samba",
     "sdwebui",
+    "selfhosted-embedding",
+    "selfhosted-stt",
+    "selfhosted-tts",
     "siliconflow",
     "stability-ai",
     "together",
+    "tokenrouter",
     "venice",
     "vertex",
     "vertex-partner",
@@ -292,6 +295,7 @@
     "voyage-ai",
     "xai",
     "xiaomi-mimo",
+    "xiaomi-mimo-tts-models",
     "xiaomi-tokenplan",
     "zd"
   ]
diff --git a/tests/__baseline__/providers-baseline.json b/tests/__baseline__/providers-baseline.json
index 4ceb52a6..7cc326c9 100644
--- a/tests/__baseline__/providers-baseline.json
+++ b/tests/__baseline__/providers-baseline.json
@@ -115,10 +115,7 @@
       "oauth": {
         "header": "Authorization",
         "scheme": "bearer"
-      },
-      "hooks": [
-        "claudeOverlay"
-      ]
+      }
     },
     "usage": {
       "oauthUrl": "https://api.anthropic.com/api/oauth/usage",
@@ -548,7 +545,6 @@
     "headers": {
       "Content-Type": "application/json",
       "Accept": "application/vnd.amazon.eventstream",
-      "X-Amz-Target": "AmazonCodeWhispererStreamingService.GenerateAssistantResponse",
       "User-Agent": "AWS-SDK-JS/3.0.0 kiro-ide/1.0.0",
       "X-Amz-User-Agent": "aws-sdk-js/3.0.0 kiro-ide/1.0.0"
     },
@@ -756,12 +752,6 @@
     },
     "format": "openai"
   },
-  "qwen": {
-    "baseUrl": "https://portal.qwen.ai/v1/chat/completions",
-    "format": "openai",
-    "clientId": "f0304373b74a44d2b584a3fb70ca9e56",
-    "tokenUrl": "https://chat.qwen.ai/api/v1/oauth2/token"
-  },
   "siliconflow": {
     "baseUrl": "https://api.siliconflow.com/v1/chat/completions",
     "validateUrl": "https://api.siliconflow.com/v1/models",
@@ -898,6 +888,9 @@
       "header": "Authorization",
       "scheme": "bearer"
     },
+    "usage": {
+      "url": "https://www.codebuddy.ai/v2/billing/meter/get-user-resource"
+    },
     "format": "openai",
     "tokenUrl": "https://www.codebuddy.ai/v2/plugin/auth/token"
   },
@@ -967,8 +960,15 @@
     "validateUrl": "https://api.morphllm.com/v1/models",
     "format": "openai"
   },
-  "devin-cli": {
-    "baseUrl": "devin://acp/stdio",
+  "poolside": {
+    "baseUrl": "https://inference.poolside.ai/v1/chat/completions",
+    "validateUrl": "https://inference.poolside.ai/v1/models",
+    "format": "openai"
+  },
+  "tokenrouter": {
+    "baseUrl": "https://api.tokenrouter.com/v1/chat/completions",
+    "validateUrl": "https://api.tokenrouter.com/v1/models",
+    "thinkingFormat": "openai",
     "format": "openai"
   }
 }
\ No newline at end of file

From 41588bea0100018adf01621e231ef918abddd1ae Mon Sep 17 00:00:00 2001
From: Dasep Moch Luay <dasepmm@gmail.com>
Date: Wed, 5 Aug 2026 16:31:03 +0700
Subject: [PATCH 40/42] feat(providers): add TokenRouter accurate pricing +
 thinking config

Adds exact per-model rates for 110 TokenRouter models (pulled from
TokenRouter's own pricing API) plus a dedicated thinkingFormat case
(reasoning_effort enum low/medium/high/xhigh/max) and the provider
logo. Provider registration itself already landed in a prior commit;
this fills in what PR #3043 added on top.
---
 open-sse/providers/pricing.js                 | 116 ++++++++++++++++++
 open-sse/providers/registry/tokenrouter.js    |  12 +-
 .../translator/concerns/thinkingUnified.js    |   9 ++
 public/providers/tokenrouter.png              | Bin 0 -> 5890 bytes
 4 files changed, 134 insertions(+), 3 deletions(-)
 create mode 100644 public/providers/tokenrouter.png

diff --git a/open-sse/providers/pricing.js b/open-sse/providers/pricing.js
index 9a0768ef..e9f2b612 100644
--- a/open-sse/providers/pricing.js
+++ b/open-sse/providers/pricing.js
@@ -141,6 +141,122 @@ export const PROVIDER_PRICING = {
   gh: {
     "gpt-5.3-codex": { input: 1.75, output: 14.00, cached: 0.175, reasoning: 14.00, cache_creation: 1.75 },
   },
+  // TokenRouter — exact rates from https://api.tokenrouter.com/api/pricing ($1/1M tokens).
+  // Ratio→USD: input = model_ratio×2, output = model_ratio×completion_ratio×2.
+  // These override the canonical MODEL_PRICING/PATTERN_PRICING, whose rates often
+  // differ from TokenRouter's reseller pricing.
+  tokenrouter: {
+    "MiniMax-M3": { input: 0.3, output: 1.2, cached: 0.06, reasoning: 1.2 },
+    "anthropic/claude-fable-5": { input: 10, output: 50, cached: 1.0, cache_creation: 12.5, reasoning: 50 },
+    "anthropic/claude-haiku-4.5": { input: 1.0, output: 5.0, cached: 0.1, cache_creation: 1.25, reasoning: 5.0 },
+    "anthropic/claude-opus-4.5": { input: 5.0, output: 25.0, cached: 0.5, cache_creation: 6.25, reasoning: 25.0 },
+    "anthropic/claude-opus-4.6": { input: 5.0, output: 25.0, cached: 0.5, cache_creation: 6.25, reasoning: 25.0 },
+    "anthropic/claude-opus-4.7": { input: 5.0, output: 25.0, cached: 0.5, cache_creation: 6.25, reasoning: 25.0 },
+    "anthropic/claude-opus-4.7-fast": { input: 30, output: 150, cached: 3.0, reasoning: 150 },
+    "anthropic/claude-opus-4.8": { input: 5.0, output: 25.0, cached: 0.5, cache_creation: 6.25, reasoning: 25.0 },
+    "anthropic/claude-opus-4.8-fast": { input: 10, output: 50, cached: 1.0, cache_creation: 12.5, reasoning: 50 },
+    "anthropic/claude-opus-5": { input: 5.0, output: 25.0, cached: 0.5, cache_creation: 6.25, reasoning: 25.0 },
+    "anthropic/claude-opus-5-fast": { input: 10, output: 50, cached: 1.0, cache_creation: 12.5, reasoning: 50 },
+    "anthropic/claude-sonnet-4": { input: 3.0, output: 15.0, cached: 0.3, cache_creation: 3.75, reasoning: 15.0 },
+    "anthropic/claude-sonnet-4.5": { input: 3.0, output: 15.0, cached: 0.3, cache_creation: 3.75, reasoning: 15.0 },
+    "anthropic/claude-sonnet-4.6": { input: 3.0, output: 15.0, cached: 0.3, cache_creation: 3.75, reasoning: 15.0 },
+    "anthropic/claude-sonnet-5": { input: 2, output: 10, cached: 0.2, reasoning: 10 },
+    "claude-opus-4-8-m-aws": { input: 5.0, output: 25.0, cached: 0.5, cache_creation: 6.25, reasoning: 25.0 },
+    "deepseek/deepseek-v3.2": { input: 0.26, output: 0.38, cached: 0.13, reasoning: 0.38 },
+    "deepseek/deepseek-v4-flash": { input: 0.14, output: 0.28, cached: 0.0028, reasoning: 0.28 },
+    "deepseek/deepseek-v4-flash-0731": { input: 0.14, output: 0.28, cached: 0.0028, reasoning: 0.28 },
+    "deepseek/deepseek-v4-pro": { input: 0.435, output: 0.87, cached: 0.003625, reasoning: 0.87 },
+    "ex/gpt-5.4": { input: 2.5, output: 15.0, cached: 0.25, reasoning: 15.0 },
+    "google/gemini-2.5-flash-image": { input: 0.3, output: 2.5, reasoning: 2.5 },
+    "google/gemini-3-flash-preview": { input: 0.5, output: 3.0, cached: 0.05, cache_creation: 0.08333, reasoning: 3.0 },
+    "google/gemini-3-pro-image-preview": { input: 2, output: 12, reasoning: 12 },
+    "google/gemini-3.1-flash-image-preview": { input: 0.5, output: 3.0, reasoning: 3.0 },
+    "google/gemini-3.1-flash-lite-image": { input: 0.25, output: 1.5, reasoning: 1.5 },
+    "google/gemini-3.1-pro-preview": { input: 2, output: 12, cached: 0.2, cache_creation: 0.375, reasoning: 12 },
+    "google/gemini-3.5-flash": { input: 1.5, output: 9.0, cached: 0.15, cache_creation: 0.08333, reasoning: 9.0 },
+    "google/gemini-3.5-flash-lite": { input: 0.3, output: 2.5, cached: 0.03, cache_creation: 0.08333, reasoning: 2.5 },
+    "google/gemini-3.6-flash": { input: 1.5, output: 7.5, cached: 0.15, cache_creation: 0.08333, reasoning: 7.5 },
+    "google/gemini-embedding-2": { input: 1.0, output: 6.0, cached: 0.1, reasoning: 6.0 },
+    "google/gemma-4-26b-a4b-it": { input: 0.06, output: 0.33, reasoning: 0.33 },
+    "kling-3.0-turbo": { input: 2.1, output: 2.1, reasoning: 2.1 },
+    "microsoft/mai-image-2.5": { input: 5.0, output: 47.0, reasoning: 47.0 },
+    "minimax/minimax-m2-her": { input: 0.3, output: 1.2, cached: 0.03, reasoning: 1.2 },
+    "minimax/minimax-m2.1": { input: 0.3, output: 1.2, cached: 0.03, reasoning: 1.2 },
+    "minimax/minimax-m2.1-highspeed": { input: 0.6, output: 2.4, cached: 0.06, reasoning: 2.4 },
+    "minimax/minimax-m2.5": { input: 0.3, output: 1.2, cached: 0.03, reasoning: 1.2 },
+    "minimax/minimax-m2.7": { input: 0.3, output: 1.2, cached: 0.06, reasoning: 1.2 },
+    "minimax/minimax-m2.7-highspeed": { input: 0.6, output: 2.4, cached: 0.06, reasoning: 2.4 },
+    "miromind/mirothinker-1-7-deepresearch": { input: 4, output: 25.0, reasoning: 25.0 },
+    "miromind/mirothinker-1-7-deepresearch-mini": { input: 1.25, output: 10.0, reasoning: 10.0 },
+    "mistralai/devstral-2512": { input: 0.4, output: 2.0, cached: 0.04, reasoning: 2.0 },
+    "mistralai/mistral-medium-3-5": { input: 1.5, output: 7.5, reasoning: 7.5 },
+    "mistralai/mistral-small-2603": { input: 0.15, output: 0.6, cached: 0.015, reasoning: 0.6 },
+    "mistralai/voxtral-small-24b-2507": { input: 0.1, output: 0.3, cached: 0.01, reasoning: 0.3 },
+    "moonshotai/kimi-k2.5": { input: 0.6, output: 3.0, cached: 0.1, reasoning: 3.0 },
+    "moonshotai/kimi-k2.6": { input: 0.95, output: 4.0, cached: 0.16, reasoning: 4.0 },
+    "moonshotai/kimi-k2.7-code": { input: 0.9286, output: 3.8571, cached: 0.1857, reasoning: 3.8571 },
+    "moonshotai/kimi-k3": { input: 3.0, output: 15.0, cached: 0.3, reasoning: 15.0 },
+    "nvidia/nemotron-3-super-120b-a12b": { input: 0.3, output: 0.9, cached: 0.1, reasoning: 0.9 },
+    "openai/gpt-4o-mini": { input: 0.15, output: 0.6, cached: 0.075, reasoning: 0.6 },
+    "openai/gpt-5": { input: 1.25, output: 10.0, cached: 0.125, reasoning: 10.0 },
+    "openai/gpt-5-image": { input: 10, output: 40, cached: 2.5, reasoning: 40 },
+    "openai/gpt-5-image-mini": { input: 2.5, output: 8.0, cached: 0.25, reasoning: 8.0 },
+    "openai/gpt-5-mini": { input: 0.25, output: 2.0, cached: 0.025, reasoning: 2.0 },
+    "openai/gpt-5.2": { input: 1.75, output: 14.0, cached: 0.175, reasoning: 14.0 },
+    "openai/gpt-5.3-codex": { input: 1.75, output: 14.0, cached: 0.175, reasoning: 14.0 },
+    "openai/gpt-5.4": { input: 2.5, output: 15.0, cached: 0.25, reasoning: 15.0 },
+    "openai/gpt-5.4-image-2": { input: 8, output: 30.0, cached: 2.0, reasoning: 30.0 },
+    "openai/gpt-5.4-mini": { input: 0.75, output: 4.5, cached: 0.075, reasoning: 4.5 },
+    "openai/gpt-5.4-nano": { input: 0.2, output: 1.25, cached: 0.02, reasoning: 1.25 },
+    "openai/gpt-5.4-pro": { input: 30, output: 180, reasoning: 180 },
+    "openai/gpt-5.5": { input: 5.0, output: 30.0, cached: 0.5, reasoning: 30.0 },
+    "openai/gpt-5.5-pro": { input: 30, output: 180, reasoning: 180 },
+    "openai/gpt-5.6-luna": { input: 0.2, output: 1.2, cached: 0.02, cache_creation: 0.25, reasoning: 1.2 },
+    "openai/gpt-5.6-sol": { input: 5.0, output: 30.0, cached: 0.5, cache_creation: 6.25, reasoning: 30.0 },
+    "openai/gpt-5.6-terra": { input: 2, output: 12, cached: 0.2, cache_creation: 2.5, reasoning: 12 },
+    "openai/gpt-audio": { input: 2.5, output: 10.0, reasoning: 10.0 },
+    "openai/gpt-audio-mini": { input: 0.6, output: 2.4, reasoning: 2.4 },
+    "openai/gpt-oss-120b": { input: 0.039, output: 0.18, reasoning: 0.18 },
+    "qwen/qwen3-coder-next": { input: 0.12, output: 0.75, cached: 0.06, reasoning: 0.75 },
+    "qwen/qwen3.5-122b-a10b": { input: 0.26, output: 2.08, reasoning: 2.08 },
+    "qwen/qwen3.5-35b-a3b": { input: 0.1625, output: 1.3, reasoning: 1.3 },
+    "qwen/qwen3.5-397b-a17b": { input: 0.39, output: 2.34, reasoning: 2.34 },
+    "qwen/qwen3.5-9b": { input: 0.1, output: 0.15, reasoning: 0.15 },
+    "qwen/qwen3.5-flash": { input: 0.1048, output: 0.4194, reasoning: 0.4194 },
+    "qwen/qwen3.5-plus-02-15": { input: 0.26, output: 1.56, reasoning: 1.56 },
+    "qwen/qwen3.6-plus": { input: 0.54, output: 3.21, reasoning: 3.21 },
+    "qwen/qwen3.7-max": { input: 1.25, output: 3.75, cached: 0.25, reasoning: 3.75 },
+    "qwen/qwen3.7-plus": { input: 0.4, output: 1.6, cached: 0.08, reasoning: 1.6 },
+    "qwen/qwen3.8-max": { input: 2, output: 6, cached: 0.25, cache_creation: 2.5, reasoning: 6 },
+    "qwen3.5-omni-plus": { input: 1.0, output: 5.7143, reasoning: 5.7143 },
+    "qwen3.6-flash": { input: 0.171, output: 1.029, cached: 0.017, cache_creation: 0.214, reasoning: 1.029 },
+    "sakana/fugu-ultra": { input: 5.0, output: 30.0, cached: 0.5, reasoning: 30.0 },
+    "seed-2-0-code-preview-260328": { input: 1.0, output: 6.0, cached: 0.2, cache_creation: 0.008333, reasoning: 6.0 },
+    "seed-2-0-lite-260428": { input: 0.5, output: 4.0, cached: 0.1, cache_creation: 0.008333, reasoning: 4.0 },
+    "seed-2-0-mini-260428": { input: 0.2, output: 0.8, cached: 0.04, cache_creation: 0.00833, reasoning: 0.8 },
+    "seed-2-0-pro-260328": { input: 1.0, output: 6.0, cached: 0.2, cache_creation: 0.008333, reasoning: 6.0 },
+    "stepfun/step-3.5-flash": { input: 0.1, output: 0.3, cached: 0.02, reasoning: 0.3 },
+    "stepfun/step-3.7-flash": { input: 0.2, output: 1.15, cached: 0.04, reasoning: 1.15 },
+    "tencent/hy3-preview": { input: 0.066, output: 0.26, cached: 0.029, reasoning: 0.26 },
+    "x-ai/grok-4.1-fast": { input: 0.2, output: 0.5, cached: 0.05, reasoning: 0.5 },
+    "x-ai/grok-4.20-beta": { input: 2, output: 6, cached: 0.2, reasoning: 6 },
+    "x-ai/grok-4.3": { input: 1.25, output: 2.5, cached: 0.2, reasoning: 2.5 },
+    "x-ai/grok-4.5": { input: 2, output: 6, cached: 0.5, reasoning: 6 },
+    "x-ai/grok-build-0.1": { input: 1.0, output: 2.0, cached: 0.2, reasoning: 2.0 },
+    "xiaomi/mimo-v2-flash": { input: 0.1, output: 0.3, cached: 0.01, reasoning: 0.3 },
+    "xiaomi/mimo-v2-omni": { input: 0.4, output: 2.0, cached: 0.08, reasoning: 2.0 },
+    "xiaomi/mimo-v2-pro": { input: 1.0, output: 3.0, cached: 0.2, reasoning: 3.0 },
+    "xiaomi/mimo-v2.5": { input: 0.4, output: 2.0, cached: 0.08, reasoning: 2.0 },
+    "xiaomi/mimo-v2.5-pro": { input: 1.0, output: 3.0, cached: 0.2, reasoning: 3.0 },
+    "z-ai/glm-4.5-air": { input: 0.13, output: 0.85, cached: 0.025, reasoning: 0.85 },
+    "z-ai/glm-4.6": { input: 0.6, output: 2.2, cached: 0.11, reasoning: 2.2 },
+    "z-ai/glm-4.6v": { input: 0.3, output: 0.9, reasoning: 0.9 },
+    "z-ai/glm-4.7": { input: 0.6, output: 2.2, cached: 0.11, reasoning: 2.2 },
+    "z-ai/glm-5": { input: 1.0, output: 3.2, cached: 0.2, reasoning: 3.2 },
+    "z-ai/glm-5-turbo": { input: 1.2, output: 4.0, cached: 0.24, reasoning: 4.0 },
+    "z-ai/glm-5.1": { input: 1.05, output: 3.5, cached: 0.525, reasoning: 3.5 },
+    "z-ai/glm-5.2": { input: 1.4, output: 4.4, cached: 0.26, reasoning: 4.4 },
+  },
 };
 
 /**
diff --git a/open-sse/providers/registry/tokenrouter.js b/open-sse/providers/registry/tokenrouter.js
index 8c5bf49f..2e3cd248 100644
--- a/open-sse/providers/registry/tokenrouter.js
+++ b/open-sse/providers/registry/tokenrouter.js
@@ -15,13 +15,17 @@ export default {
     },
   },
   category: "apikey",
+  thinkingConfig: {
+    options: ["low", "medium", "high", "xhigh", "max"],
+    defaultMode: "high",
+  },
   transport: {
     baseUrl: "https://api.tokenrouter.com/v1/chat/completions",
     validateUrl: "https://api.tokenrouter.com/v1/models",
-    thinkingFormat: "openai",
+    thinkingFormat: "tokenrouter",
   },
-  // Seed snapshot dari live /v1/models (118 entri, 2026-07-31). Catalogue terbaru
-  // di-fetch via modelsFetcher; id lain tetap diterima via passthroughModels.
+  // Seed snapshot from live /v1/models (120 entries). Latest catalogue is
+  // fetched via modelsFetcher; other ids still accepted via passthroughModels.
   models: [
     { id: "MiniMax-Hailuo-2.3", name: "Minimax Hailuo 2.3", kind: "video" },
     { id: "MiniMax-M3", name: "Minimax M3" },
@@ -46,6 +50,7 @@ export default {
     { id: "claude-opus-4-8-m-aws", name: "Claude Opus 4 8 M Aws" },
     { id: "deepseek/deepseek-v3.2", name: "Deepseek V3.2" },
     { id: "deepseek/deepseek-v4-flash", name: "Deepseek V4 Flash" },
+    { id: "deepseek/deepseek-v4-flash-0731", name: "Deepseek V4 Flash 0731" },
     { id: "deepseek/deepseek-v4-pro", name: "Deepseek V4 Pro" },
     { id: "ex/gpt-5.4", name: "Gpt 5.4" },
     { id: "google/gemini-2.5-flash-image", name: "Gemini 2.5 Flash Image" },
@@ -113,6 +118,7 @@ export default {
     { id: "qwen/qwen3.6-plus", name: "Qwen3.6 Plus" },
     { id: "qwen/qwen3.7-max", name: "Qwen3.7 Max" },
     { id: "qwen/qwen3.7-plus", name: "Qwen3.7 Plus" },
+    { id: "qwen/qwen3.8-max", name: "Qwen3.8 Max" },
     { id: "qwen3.5-omni-plus", name: "Qwen3.5 Omni Plus" },
     { id: "qwen3.6-flash", name: "Qwen3.6 Flash" },
     { id: "sakana/fugu-ultra", name: "Fugu Ultra" },
diff --git a/open-sse/translator/concerns/thinkingUnified.js b/open-sse/translator/concerns/thinkingUnified.js
index 5dbf756b..d18f47b6 100644
--- a/open-sse/translator/concerns/thinkingUnified.js
+++ b/open-sse/translator/concerns/thinkingUnified.js
@@ -310,6 +310,15 @@ function applyFormat(fmt, body, cfg, caps, supportedLevels) {
       if (level) body.reasoning_effort = level === "xhigh" || level === "max" ? "high" : level;
       break;
     }
+    case "tokenrouter": {
+      // TokenRouter's reasoning_effort enum is low/medium/high/xhigh/max — it rejects
+      // "none"/"auto" with a 400 and supports "max" natively (no clamp like openai).
+      // "none" → omit the field so the upstream default applies; pass levels through.
+      if (none || eff.mode === "auto") break;
+      const level = toLevel(eff);
+      if (level) body.reasoning_effort = level;
+      break;
+    }
     case "kiro":
       // Kiro thinking handled via system-tag injection in openai-to-kiro.js; no body field here.
       break;
diff --git a/public/providers/tokenrouter.png b/public/providers/tokenrouter.png
new file mode 100644
index 0000000000000000000000000000000000000000..58f7eac234aefcb4651ad33625fd3254ee2f587b
GIT binary patch
literal 5890
zcmb7|<y#b9u*a8fSfoK(=>}Ok7f@14O1irw1nF2(M3e?;P$ZWIX%_^R?pz7!UUFf%
z{O(_H?~6I#IWy<XoAW$p=J~|G)>b1Sq$dOb03@$og7qFX{6E9TeO&wGtcM?k!0V-n
z@1tV;ujxGRpZ(AA)l*Z#Sop&i_PAlOeW|Af00eP7-i!tSZXZM8I{<*65CE`e1pr88
z0su5#xox^Kj|pr?MJ+`Dpe}{z&Kd^*00Lft6%7J&56uYzskUbFTU%efR8qnxuwy53
zHGc90Ga_06Gosdhjg`P!Egism;M7YxQ{*1zj54Z{lUrO|Thwb5sA`yPn>G!o;Ok8x
z>`F0xJu&Iy*m-<+9N@^&+PX}Oq5sEjb^Co*JF)1R<o5lj<l5$H>u0;3NE{++KI2-e
z|ErUSZ6Z#?-=cW^+ab-(!s0XBBR~&kYtj_5#J(@1fL~uVV*z(yusGttOm+83{L6T>
z|6IdDPF#Q7;aH+OR;a&3h$_16MPJ8ahes5y5(M_DFVRtb!HmA-b32*(`8SzoRe?9}
zoew8KrLeSt(&Xd3PvZHz>(M0pI*b|gtCDP0L5KFv6MxG~hVYKR`d*3s;Xdcts+fNE
z2Q;|0;%aV5Jc>LLpNg{WEuD@r)Y}?6j?n+89(--T3rI!Eo{*mSpR^;~5mg);?rrXP
z@61SYx|E-JqON~-oCKu&S;(0iN-b7vdPOt(WOv5@Y<XO0vIAp{MV{MFv9;kOOL?+-
z_?vWcr*goMg;(=X=}N*6UHeHUMVOZQzlOTs7C22l<@lx?k-+}!X3M%QG50Sh;sn3b
z{bT`b6BmkWM2na6Y=ndJ5~pJ>1`X~J1%{Cr9zNt?MrC}Z6>?5(eXwQP6i&M-d+@pH
za*k|qoio|<v=Y9L%STc@M4WWMPIc$i)iHdUmDD|q>M<uwvo0WR91b3|QCo&fd?*_N
zLXzTbqgXnqWzRGD1w^Z6wpSTJlX+yq`@epf<=eZP+q-rmQ)ygUNn+>yd49NqwwqQ0
zm*G1zq&2t3(o_yhzXxN{Jw*0X78m0>?!Ss|ok`U=u4n5b&Npwfe}x5op4%%HTqF;a
z#`Ih(thhAKJrF989%n#CtjJ!vAXkcIul(Ozj?eYUS)yd54ILoBgF*b&CBeMr6wA8W
zQj<HW;XO}E@nDUiX06p##IF>}<9iz`(wSgR&SP`Cpj$SsP__b_^dkj$C(iN@-yHM@
zX}xRGWIZT)Q9L6gyU~_z;Pggn8@A~~NUC)5J$RiwC+wvlKd>sRB`vCEj%iK75_RVo
zy330jS%7jg${N!?onJ;SRZY;1^P92+A8&}E1+)`Mz1uF{Ym@!bLPDm%VX_)X7zA7s
zB^aWBoPJe=vfy;NW!JrV0Frc3C@n4oJ(Z4LPqDq4pXrhC#}AV>VEz)#WF{wRn*yh;
z)EUtp#cmtglv6GWnf>+fhK#tod7<#uMxm3o!(;)ASmAZhfm`0zX|t~>nyXwb#ryVz
zNP7-5_QC&v86421YJl`DvZ`a7|7lO?E%#t<DO{b`c6=ov8rSED?2sI#jUV34J8Q;c
zzn<7oyKK3cgoGBQzmPPLCx&^pOFq`0|E@ctx5S@&cI5bO=Qs(y<;3vrRMWc3pjEYO
z>Sp;O#J`kf)co1)ss=bdV9(^QLy-b&G~=RiHEr=p2y`e$;l3*>gu~rs9BhS(RVlz*
zqZSoj2$K%s`LerKA|%5B6#)=0I#0W4Z^_#to1yN-4%nY9%`m+ZRO9-9N&EXnNza)3
zTS3-kAZJ_WfDX9kCma@bl-5G03PlgdZ{lUmO;g--bU259k0iT?u8D$Z6Nf!8cag%(
znO%2LQ8i3zhCa}cZ2kr8j<@H+wtamxBfj_2Nol81nIU7_+n1cCky9jMtwd|TVcy(R
zr@#`C8ntnY>(&`44(vI85A6+7N_DUoiabs>IgT>v+OAbstuSmhSzPd<>U{`_VET&@
zXN9F6Ifx5CO#Y@nW|m3cK*mNZ+hzK#d#*(aIETdP_)r@Dl@m=JeI(|UQ<Q*_`Pr#M
zsmWE;9TBQ3m}kutb^0xOJSU1SCGIFt5uc)G1@=7vD*lfJBpvBtZ8IEn`0O`G+;_Rr
z5%Yem8NJojrt_{`(TveWFn9dt0Tx7kKfXS!VlpPog*>1lFKw@eT9uvK>zYzM(iq3>
zALV3H%kn`_zB><%Jzrp-{OAJKE%yFtM*?qb(8?8^ndKbA1!rKQG6^hxWJqY_>G#wM
z<m&8~2Y2{wO(d{{c5O|bBY~>2Rx4L2XR(fmq6w6Jfygco3--eVGV4B}$ESNT6U>Y1
zxPtcw7c*T_)5vHJc6t?be5_c0ex0B01R^9R?+A|IBDG(zj6<aRAN2JfMiDIgF8|nC
z>_<zLD(Kutycm;XN-&_PH?d}|kan=Mlo(|Y4ZBTgQ#~P}Ws^8d<v>_);T0~)EX0Y_
zB?s>O3$sL$9x*R?bBt51OV>9E5i^E;(@LOEz>4t@ra^^={H@L3`9X0d+;%O<zh};R
zjY~`}6M|_1@Q;p{XdQ5=6phu?++4LMdr%rXIkd-UE!`(Gxk1+n=`w&snPRcBl0*FP
zVpu{tPa~$%Kz8tB{A~O<k9+pi5E9*f@v+NT51XHsqHoB&O(+`Tk9OHo<xuxi^cm60
z!XY3j<2Cqv_NUZLI=RYtQn|_|Z#$zXF4MPN#90p%c9D&_Y)wJ6@6(2E3k{-Y<WLa*
zp>T1Oefu|lx2@KIKJQPV40Okk7j+A?@pKc=2&c<D)0M8-;T8~KL!y4Jb{;4HHG^b~
z=cN@&^{ZOZ_9^qHG(UT4A%};GQo~d@_%8z`b;N_+n^<w5Abp*C^Y2H^kaRsST8%zK
z@C5MvHLOXTz03t08~EmQ-V<rj-AL^8?SLTfYR^}<f}MPyF0mhD1cuI}Lwk)cLfSl5
zuCS{gP=YaBIK!Reez`^BtqUot!k9^`VA8em=$@)l1<NZGxQtUtlFvo9nCrkvm5>v;
z*1dxq$OahG=sZ*l^?#Tn0%P#T+koDmC>9r8(qwc%{XIS5cR{yg`Dgd$!aH}xbKEY-
zAU7?T#7HEIL>U_6yd>0!)&!w}rz?_va!)Vu+s*4-nSFzeNR?mi@?#Zz0LM;{+h*cV
zvrR!ZdcRhmy@|tyn3f0+X%645DIehmV6YP%p!szXK1J8bOm`7yK!^lNEtz5JN!Yhg
zTgZS13w0F8HU_E*3nae_D%x#sv^W)I&+KHAxMg*?k+Md8Jxy|cJspUAUzi04HRH2z
z`Q6uJ7%TNx8%|5ysX@J2u*Y5LCa&_ujLx?SV15xD(k!=Mb8*GmZi*G{PX_@LhPN*;
zB0_N>Otf)}z^*rj8+EGU40zoqJ3-o>xx$v`+oa0NYat00Ah3MP#0qon`srf$R~msp
z6a-tktBetfm`+v9e2z6MB4<@KpACtk2cN`?G>f+V3?Aq|oeO5r7VJ#4UsH#pBaT8%
z`kaO6`|~I0Hl7E+{&3wLG>{Q>0#oP^b|T42Q2ra<nMp8wG`ZJBmm_cF^@~j6LFXrK
z6U!F+dHj6atsTNeg)veDDB`lq_D3+tXAxKutyoD%0?To*#l!|SW$xhVWOkt$gl@x&
zu$*u`*Tvqsn|&kxVKiO1PH24@u~brE?N>_h5--Y#+ilQ=4eCvslw#bw8*c<}zw?Dy
z+xFdq|0cFh;Z@7gy{-8{z;z>hlOn@+K?iLNmB1Ey_uL@D)LERP8*#mrYaw3+3SUtG
zsHRJwNMP5-IrW=@x_;^{2#LY4cr34>)1dS2kL0hFF|mb+J+qSuDiPs9s*ZA#9X9`{
z!ZFyfmLHzhuPGI!x-N(GwhR(Rxu!f#W#d@$3uX%nx8|kvlgPCfCpB06ve><|F@~g4
zXeI}gE7w@zU}HS1_CFt1he0+P3(p^}8Ym^V@}pk8#Our8-NWZ&80k+H61SF|xK>rA
z>D&p$3_SCjevi-ceH9MkrDbNV@435@`&7iS=Icc%wM7o>emU~k-^gL4?eScUnAZ&q
zga~eY7HUk|#-SBZ5~mWNFAsCDbN`YOpXHQ8MXTRUm?F*U03V;lUF(VuBL)4H%R^50
zOg&&tDF0bd@%tidyQlNQ^dyRtA}WkHj#&vx*z;w4jz|lT8z%DyYRpVEu^@Z1u4gO#
zf%Q8${|X2WGU^-UsLa<ZN)xh^KyVmkoYgg(wrBpH+^~W&K>nH}y}QvV(x~C$PlY`X
z1OIKY9v_x+?DW@<ifWl1U~BGSgix9{F}6@3Q+c`NZYWKp_?og<MY?ndVlQp8^oJC#
zY&Rn7@eOfQwY3?rVv;O+osfDWj03&b5i{V2d#5Y%aBuFGAi->e6h5M?N$!=&&k9@C
z@D>6*kF*b%8>mtNpAV9_o+Sc3qZ)$-no+09u5q)w%vhjc0wFXlayJ9KuygoX7Y%kZ
z5BW@pkrV~!RpT>x_D8(^i^2Q7IIro<-$^OINgZtHlbB<)B|O=She^*LBr|t;!;L-`
zFV##Pcy6Tq9+j91w1ZiY(=GBl;ps>t6{Lo`=T&}W$1;w<yoF@!<;vMt3djvEj`8nk
zNf6_b;9ZTC`yOsB{KBJN9Of?I;VK4s{C<X3IAD^R?FC<CpC*i0g0(PVr&`&CfisI-
z^}c2)X3K)49QoV>ZCp|R&JNZ8AtNOkC;B7fN5+Ngm|U3PvngS$Astob*HhE7a+E=5
zd>rSP|9vh`n-z3LQ_&l+mJeJ8ANXWS4>rxRUTfT9!bGE|G+_j<!+0F}83y2HxJe`a
z+kIemo;VJH&PlReB8hkjJjgyXQO1Q}Y<~(0UCmb#n<S-@2e`;gPGbpwCSi|Cfww*t
zYkSamQ0+@R3VS;HkVUj~%VI0Hkp=ucUvGOnj|>ifRga#j?XE?FCF1R8g@?d%ZmQY<
zP5~=q59A-}U9B*RITTk(kaNg%vj_b?A^TU76T<kg(%NUA-?l*zQnvZ)_N_R2qyIfm
zjxnU_Pi8V*D)IKgeSB-SqV1)nKk%zq!K{&Qw%8h!te*N)v7_hVaACdoH-O3P7oc#U
zvmxnTU%zRLRyL%;S;S$+c_cjQW7ZD4O@hE?FqtBv6s%7jSljhRx18lZCA%y{_N_lE
zs0GS0-*M-*YrnmkM|@#7Ba)x|;3Tdc;qJVH^X5QkfP^iHNZwI?(rsAj@X9XWP1R62
zTRTM685H+v<@mYVbQHReA!AdCdtruDyfu9=DVI>Kl$t^o*|PqwXfj44qVC8NikECj
zSN`44XfemUxc>Vfp{+wxa3XC6pVj$S5%pDh4pOnw>{D)I`J80Q#zpa9f%1*=b`N<g
z{HxFsw6F?zYENcKx;4A*Ek28wUi+(QDrlD>rYSXkN)3N*M6C1BTNOAtX{9)Gxgs`&
zE+LQ6cVua(>wNVz8Q19M?_EL9f<84{=|)`Wn(UhwqqOzA_@O>c{y7q@_e=eBY~vo3
zSyC4Z1CA_)|3-A@4W5p?%heFWVjEQ8t_WyVnx_I6>|Ei?+{?KEL$s*Mm+9eUP2xV;
zZ?rz_Ek6!RWYZp$+yU=~jW^oD!w?1jIpP2SuH}C$;8TUO@BDVFZ~XRX4}q7Ls1FDD
zlf}yhzp%L$vkKw!vBF*6o&^5(+^Hn`u_mo5p9-ijY6DW$_NQ@dA6Op>-N|IV@OwXq
z+4_~#@AfGh)JObjrY?Z|z?Zy-WS)YyN8UHRLKC~|%hXT$G4ZVg1iN&})($8!z5475
zCt2^)=bK8@*}m5}Aw;T}kb9tHM0sdrL``!3$E3<V`zG7WDt;wcH$7<*xwr(rDT-G)
zaWo2UvJWa9a%9EQ<V6j%GKDT4u1jm)GfgTC|FD`opa>g=Ogb2F?eXPWmC>0H4D=S7
zaN+r;i%6YmyAocDYefE-3yx4@QZ^O*eW1EHmQ$I0qb{8}FM@AMa9DnC)jy|wZ{&dC
z-ip{}o&z;+t}lEjNzbAp%t@xmNrl$(aD^vNsUtR@Xp`L)x%*y!a|4=djNcG}wNP;!
z@L5<EL}BbqBJ@i%VHq{6azE*GsEBIkD)Sey+X#za`V<ZsP$C?On**PitsWBxd&SZw
zc=oG?`qYUW&t_GNI7Cn=_dzAg$KBOnnOkh#?=1ys1K)w`Bc1`vTm)M`Od~@eN#mhn
zL&md~AY!VRXl>0=!R>F<gm_=M`Iz^0p!ER0$a!BPY{|o0(qanEr7{3HpMRc>P~=g*
zIT|T5k<jRbWa(X~xU%6pOvzwnO8Q!)Nv1I!Dqg*kC_Bd+iTHHN?nq;KTMH(xm@Xt#
zqxzDSp+ZGpKB|<!zdqfNHjx-+{q9EOiuNU^iR&M)^176AA0M>L1ncz8mTR1kS0^3N
zQkcWcI#`anM^L{t@NI0q)sEL8gni5N4#K_y29Eo_e0TKoYK=!torlZ2BIdOdE3U4w
zi^!fhm9?2(p}Q}6rZXb)dG662d3jgI$Zl_ps|JRWnBy3^?0s<2N^txTd4KNi4)m<?
zoGPO|sSn;|!`FNDn`$(K(ff2!XJ9Dra;mP1&1;sbU3NS`>7QuV&uIJvZ~~96i7>8%
ze|oy>NS})}edG&9?lu>Jau`W&=!s=6(+ySmHhN?i-W;c$%OVw$y+avzKs!-cL(V9t
ziA0RWU9KficBxC3NoWgv)HhDb;=?q(oUsL>1^E0csBCUbPyS?$3mpy=chzOD72<Es
zeoN7zZTeOCGwBOqp)v6f>=j>vHYX^QGJ*>N90F%?Ddnj`@)H%bhhw<PT*rt$^%4=i
z_-FfOEW7lV<3U<RIpeUzM+pbDZGM3_26bysvE@b2<JCTdG=59zI`VkfQ$cjhw4ARi
zy?hxo*^pZ-II8lChXRY=r=s+Cu6p6lk%G0aWTc+%torHOj-#Q=%SV>M#jR)Zio96T
zrijWyO5O=^79&7$_E=VS5WwkaXwmzrsxskRFvK8PF+DMYhR4N(eA~YF)k@OV;mMDW
zQDxAEm)7=dCxcH6fm*jMkkGwj<{2HL4!Hk?(X|vtwZ=y#SvFM3Gsb1hH;C(>s&}o1
zw0Zz`Lc=!}gWoZCCv8xCG<<eX<@A4_yI_Zqim3SiJ7y*#f@`{7v|cs8*k6iT=AgPk
z{f<qc_bzC4f^j;!Sc6HDDkx!!#8ka4m@r<}IQ8j)qtOJVQC>nJ#b`@JS}PY(<JP*Y
zKez944f6qml=Fwg40}NoiSYgs7A|KyVb2oNCe2!y;>{+~k<@V09Q}bQn#DMI<aG?k
zcM;32uQ&f8HEpG*h8)ihCJ$WejI0fD@Fh4@`6DeL@oY?E*>{(`@dR27Siz)^WUX=z
z6zW|r`d0uOBdja)1VfmJS5)=kF8?l9Uu}EyeE8hz`c5y|FHnZ8w<3nZ1)J!?-KfkX
zs`h)6F|?+-WM<W+!&2ma1DZA!b~PW@lQS2Kox-#*n_^+kdt#*IPuO#P?z3O%&&_4!
z^!8og=?HmLlUNdi-&N0nw+>Ub-09Y~qa$;OXxPx7jTrqkX<dm6O`7dsPC_4T#<85c
z(bTLoi(pC4`xAW%Rr$c<ifCD_(}~8fA(8rNpPt{>yvx3aX<y7?n$+*c`gOQP>{)lF
zz$w2RGFoI!>2(l9t;*Sj&~0ql$0>CsIosgHxjFgP%{fD>^aWS^&GE}K<Nsge_P@j9
bbk||YT_8Ols$zpj3=Mdtq7ANAvWom40g7Cw

literal 0
HcmV?d00001


From 35f86e5828dc9689fbb913177f0f48472b56fb00 Mon Sep 17 00:00:00 2001
From: decolua <decoluadt@gmail.com>
Date: Wed, 5 Aug 2026 16:40:09 +0700
Subject: [PATCH 41/42] fix(oauth): scope antigravity header fixes to
 loadCodeAssist/onboardUser only

Google fingerprints User-Agent/Client-Metadata on loadCodeAssist and
onboardUser, silently refusing to provision a cloudaicompanionProject
when they don't match the real IDE. Split antigravity's headers out of
the shared gemini-cli constants instead of overwriting them, so the fix
doesn't touch gemini-cli or any other provider.

Inspired by #3000 (thanks @stoXmod for flagging the resource-exhausted
issue), rewritten to keep gemini-cli untouched.
---
 open-sse/config/appConstants.js            |  7 +++++++
 open-sse/providers/registry/antigravity.js |  3 +--
 open-sse/services/projectId.js             | 12 +++++++-----
 src/lib/oauth/providers/antigravity.js     |  3 ---
 src/lib/oauth/services/antigravity.js      |  2 --
 5 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/open-sse/config/appConstants.js b/open-sse/config/appConstants.js
index 62e2f888..5ddf95ac 100644
--- a/open-sse/config/appConstants.js
+++ b/open-sse/config/appConstants.js
@@ -156,6 +156,13 @@ export const LOAD_CODE_ASSIST_HEADERS = {
   "Client-Metadata": JSON.stringify({ ideType: IDE_TYPE.ANTIGRAVITY, platform: getPlatformEnum(), pluginType: PLUGIN_TYPE.GEMINI }),
 };
 
+// Real Antigravity IDE doesn't send X-Goog-Api-Client/Client-Metadata on loadCodeAssist/onboardUser —
+// Google's backend fingerprints those and silently refuses to provision a cloudaicompanionProject.
+export const ANTIGRAVITY_LOAD_CODE_ASSIST_HEADERS = {
+  "Content-Type": "application/json",
+  "User-Agent": ANTIGRAVITY_IDE_USER_AGENT,
+};
+
 export const LOAD_CODE_ASSIST_METADATA = {
   ideType: IDE_TYPE.ANTIGRAVITY,
   platform: getPlatformEnum(),
diff --git a/open-sse/providers/registry/antigravity.js b/open-sse/providers/registry/antigravity.js
index a4ca7346..1a7c4347 100644
--- a/open-sse/providers/registry/antigravity.js
+++ b/open-sse/providers/registry/antigravity.js
@@ -76,8 +76,7 @@ export default {
     apiVersion: "v1internal",
     loadCodeAssistEndpoint: "https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist",
     onboardUserEndpoint: "https://cloudcode-pa.googleapis.com/v1internal:onboardUser",
-    loadCodeAssistUserAgent: "google-api-nodejs-client/9.15.1",
-    loadCodeAssistApiClient: "google-cloud-sdk vscode_cloudshelleditor/0.1",
+    loadCodeAssistUserAgent: ANTIGRAVITY_IDE_USER_AGENT,
     refreshLeadMs: 300000,
   },
   features: {
diff --git a/open-sse/services/projectId.js b/open-sse/services/projectId.js
index 3801ac69..84ab5a2b 100644
--- a/open-sse/services/projectId.js
+++ b/open-sse/services/projectId.js
@@ -7,7 +7,7 @@
  * This significantly reduces the risk of being flagged by Google's anti-abuse systems.
  */
 
-import { CLOUD_CODE_API, LOAD_CODE_ASSIST_HEADERS, LOAD_CODE_ASSIST_METADATA } from "../config/appConstants.js";
+import { CLOUD_CODE_API, LOAD_CODE_ASSIST_HEADERS, ANTIGRAVITY_LOAD_CODE_ASSIST_HEADERS, LOAD_CODE_ASSIST_METADATA } from "../config/appConstants.js";
 
 // ─── Cache ────────────────────────────────────────────────────────────────────
 // connectionId -> { projectId: string, fetchedAt: number }
@@ -157,9 +157,10 @@ export function removeConnection(connectionId) {
  */
 async function fetchProjectId(accessToken, signal, provider) {
     const endpoints = CLOUD_CODE_API[provider] || CLOUD_CODE_API["gemini-cli"];
+    const headers = provider === "antigravity" ? ANTIGRAVITY_LOAD_CODE_ASSIST_HEADERS : LOAD_CODE_ASSIST_HEADERS;
     const response = await fetch(endpoints.loadCodeAssist, {
         method: "POST",
-        headers: { ...LOAD_CODE_ASSIST_HEADERS, "Authorization": `Bearer ${accessToken}` },
+        headers: { ...headers, "Authorization": `Bearer ${accessToken}` },
         body: JSON.stringify({ metadata: LOAD_CODE_ASSIST_METADATA }),
         signal
     });
@@ -186,7 +187,7 @@ async function fetchProjectId(accessToken, signal, provider) {
         }
     }
 
-    return onboardUser(accessToken, tierID, signal, endpoints);
+    return onboardUser(accessToken, tierID, signal, endpoints, provider);
 }
 
 /**
@@ -197,10 +198,11 @@ async function fetchProjectId(accessToken, signal, provider) {
  * @param {AbortSignal} externalSignal  – propagated from the connection's AbortController
  * @returns {Promise<string|null>}
  */
-async function onboardUser(accessToken, tierID, externalSignal, endpoints) {
+async function onboardUser(accessToken, tierID, externalSignal, endpoints, provider) {
     console.log(`[ProjectId] Onboarding user with tier: ${tierID}`);
 
     const reqBody = { tierId: tierID, metadata: LOAD_CODE_ASSIST_METADATA };
+    const headers = provider === "antigravity" ? ANTIGRAVITY_LOAD_CODE_ASSIST_HEADERS : LOAD_CODE_ASSIST_HEADERS;
     const MAX_ATTEMPTS = 5;
 
     for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
@@ -216,7 +218,7 @@ async function onboardUser(accessToken, tierID, externalSignal, endpoints) {
         try {
             const response = await fetch(endpoints.onboardUser, {
                 method: "POST",
-                headers: { ...LOAD_CODE_ASSIST_HEADERS, "Authorization": `Bearer ${accessToken}` },
+                headers: { ...headers, "Authorization": `Bearer ${accessToken}` },
                 body: JSON.stringify(reqBody),
                 signal: localCtrl.signal
             });
diff --git a/src/lib/oauth/providers/antigravity.js b/src/lib/oauth/providers/antigravity.js
index 6cf28e81..10453ad8 100644
--- a/src/lib/oauth/providers/antigravity.js
+++ b/src/lib/oauth/providers/antigravity.js
@@ -39,13 +39,10 @@ const antigravity = {
     return await response.json();
   },
   postExchange: async (tokens) => {
-    // Numeric enums matching Antigravity binary ClientMetadata
     const loadHeaders = {
       "Authorization": `Bearer ${tokens.access_token}`,
       "Content-Type": "application/json",
       "User-Agent": ANTIGRAVITY_CONFIG.loadCodeAssistUserAgent,
-      "X-Goog-Api-Client": ANTIGRAVITY_CONFIG.loadCodeAssistApiClient,
-      "Client-Metadata": ANTIGRAVITY_CONFIG.loadCodeAssistClientMetadata,
       "x-request-source": "local",
     };
     const metadata = getOAuthClientMetadata();
diff --git a/src/lib/oauth/services/antigravity.js b/src/lib/oauth/services/antigravity.js
index cda6bde3..6540f055 100644
--- a/src/lib/oauth/services/antigravity.js
+++ b/src/lib/oauth/services/antigravity.js
@@ -85,8 +85,6 @@ export class AntigravityService {
       "Authorization": `Bearer ${accessToken}`,
       "Content-Type": "application/json",
       "User-Agent": this.config.loadCodeAssistUserAgent,
-      "X-Goog-Api-Client": this.config.loadCodeAssistApiClient,
-      "Client-Metadata": this.config.loadCodeAssistClientMetadata,
     };
   }
 

From 15223724c3e1ad898e84ef6e0cc1686cbafc8290 Mon Sep 17 00:00:00 2001
From: decolua <decoluadt@gmail.com>
Date: Wed, 5 Aug 2026 16:49:14 +0700
Subject: [PATCH 42/42] # v0.5.50 (2026-08-05)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Features
- **Providers**: add TokenRouter (300+ models via OpenAI-compatible gateway) with
  exact per-model pricing for 110 models and `reasoning_effort` thinking config
- **Providers**: add Self-hosted STT / TTS / Embedding — point 9Router at your own
  OpenAI-compatible speech and embedding servers (whisper.cpp, faster-whisper,
  Kokoro-FastAPI, llama-server, vLLM, Infinity). Unlike the named cloud providers
  these read `baseUrl` per connection, so one provider can front several machines
- **Combos**: default-enable vision/audio capacity adapter (auto-routes to a
  vision/audio-capable model when the target lacks that capability, falling back
  to `oc/mimo-v2.5-free`), wired into chat handler routing
- **Endpoint**: auto-provision a "Default Key" for first-time users so `/v1`
  works without a manual dashboard step
- **Codex**: support GPT-5.6 Max/Ultra reasoning-level overrides (cx/ routes only)
- **Qoder**: support PAT (Personal Access Token) connections end-to-end, alongside
  OAuth device flow
- **CLI tools**: add OpenDesign (manalkaff/opendesign) support
- **Headroom**: report effective payload savings (tool schema/history bytes broken
  out, byte-savings % reflects actual outbound reduction)
- **Ollama**: Cloud quota tracker (session + weekly) + proactive background OAuth
  token refresh scheduler for all providers

## Fixes
- **Providers**: remove Qwen (OAuth flow stopped working reliably)
- **Passthrough**: detect codex-tui/Codex Desktop as native Codex client — they
  were falling through to the translator and losing fields like `reasoning.summary`
- **OAuth**: scope antigravity header fixes to loadCodeAssist/onboardUser only
- **OAuth**: keep `open` external in the build so xAI/Grok token refresh works on
  Windows
- **OAuth**: declare missing `searchParams` in register-session handler (was a
  500 instead of JSON on error)
- **DB**: `ENABLE_REQUEST_LOGS` env var now overrides the UI setting correctly;
  observability defaults to off (opt-in)
- **Translator**: preserve Codex Responses Lite tool use across chat-native
  OpenAI-compatible providers
- **Translator**: don't drop image-only user messages in `prepareClaudeRequest`
- **Translator**: drop JSON Schema keywords Gemini rejects (`uniqueItems`,
  `contains`, `multipleOf`, `unevaluatedProperties`, `unevaluatedItems`,
  `contentSchema`)
- **Claude**: remove global header cache that leaked one client's identity
  headers onto another client/account sharing the server; gate `anthropic-beta`
  by model instead
- **Antigravity**: drop retired Gemini 3.0 quota tiers, show Gemini 3.6 Flash
  usage bars
- **Cloudflare AI**: declare API key authentication (dashboard showed "No
  connections" despite an active key)
- **GitHub Copilot**: hold monthly-exhausted accounts until UTC month reset
  instead of only cooling down 120s
- **CodeBuddy**: dodge Tencent CN content filter, add usage tracking, normalize
  codebuddy-intl messages
- **Usage**: stop losing cached prompt tokens in the forced-SSE→JSON path
- **Grok CLI**: display the public subscription tier from the OAuth token claim
- **Providers**: count apikey connections for Ollama free-tier card; free-tier/
  apikey providers without `authModes` now default to apikey (were treated
  oauth-only)
- **Build**: include static/public assets in standalone output (login page hung
  on 404s when run via PM2)
- **Server**: support IntelliJ IDEA OpenAI-compatible clients over HTTP (h2c
  upgrade handling)
- **Auth**: redirect already-logged-in sessions away from `/login`
- **CLI tools**: enable Apply button for dynamic OpenAI/Anthropic-compatible
  provider connections
- **CLI**: include complete API artifacts in the CLI package
- **TTS**: a bare self-hosted model name is the MODEL, not the voice — `kokoro`
  was parsed as a voice against a default model, 404ing or synthesising with the
  wrong one
  endpoint that drops packets never returns headers, so the request previously
  hung indefinitely
---
 CHANGELOG.md     | 60 +++++++++++++++++++++++++++++++++++++++++++++++-
 cli/package.json |  2 +-
 package.json     |  2 +-
 3 files changed, 61 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3279d542..e62edded 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,12 +1,67 @@
-# Unreleased
+# v0.5.50 (2026-08-05)
 
 ## Features
+- **Providers**: add TokenRouter (300+ models via OpenAI-compatible gateway) with
+  exact per-model pricing for 110 models and `reasoning_effort` thinking config
 - **Providers**: add Self-hosted STT / TTS / Embedding — point 9Router at your own
   OpenAI-compatible speech and embedding servers (whisper.cpp, faster-whisper,
   Kokoro-FastAPI, llama-server, vLLM, Infinity). Unlike the named cloud providers
   these read `baseUrl` per connection, so one provider can front several machines
+- **Combos**: default-enable vision/audio capacity adapter (auto-routes to a
+  vision/audio-capable model when the target lacks that capability, falling back
+  to `oc/mimo-v2.5-free`), wired into chat handler routing
+- **Endpoint**: auto-provision a "Default Key" for first-time users so `/v1`
+  works without a manual dashboard step
+- **Codex**: support GPT-5.6 Max/Ultra reasoning-level overrides (cx/ routes only)
+- **Qoder**: support PAT (Personal Access Token) connections end-to-end, alongside
+  OAuth device flow
+- **CLI tools**: add OpenDesign (manalkaff/opendesign) support
+- **Headroom**: report effective payload savings (tool schema/history bytes broken
+  out, byte-savings % reflects actual outbound reduction)
+- **Ollama**: Cloud quota tracker (session + weekly) + proactive background OAuth
+  token refresh scheduler for all providers
 
 ## Fixes
+- **Providers**: remove Qwen (OAuth flow stopped working reliably)
+- **Passthrough**: detect codex-tui/Codex Desktop as native Codex client — they
+  were falling through to the translator and losing fields like `reasoning.summary`
+- **OAuth**: scope antigravity header fixes to loadCodeAssist/onboardUser only
+- **OAuth**: keep `open` external in the build so xAI/Grok token refresh works on
+  Windows
+- **OAuth**: declare missing `searchParams` in register-session handler (was a
+  500 instead of JSON on error)
+- **DB**: `ENABLE_REQUEST_LOGS` env var now overrides the UI setting correctly;
+  observability defaults to off (opt-in)
+- **Translator**: preserve Codex Responses Lite tool use across chat-native
+  OpenAI-compatible providers
+- **Translator**: don't drop image-only user messages in `prepareClaudeRequest`
+- **Translator**: drop JSON Schema keywords Gemini rejects (`uniqueItems`,
+  `contains`, `multipleOf`, `unevaluatedProperties`, `unevaluatedItems`,
+  `contentSchema`)
+- **Claude**: remove global header cache that leaked one client's identity
+  headers onto another client/account sharing the server; gate `anthropic-beta`
+  by model instead
+- **Antigravity**: drop retired Gemini 3.0 quota tiers, show Gemini 3.6 Flash
+  usage bars
+- **Cloudflare AI**: declare API key authentication (dashboard showed "No
+  connections" despite an active key)
+- **GitHub Copilot**: hold monthly-exhausted accounts until UTC month reset
+  instead of only cooling down 120s
+- **CodeBuddy**: dodge Tencent CN content filter, add usage tracking, normalize
+  codebuddy-intl messages
+- **Usage**: stop losing cached prompt tokens in the forced-SSE→JSON path
+- **Grok CLI**: display the public subscription tier from the OAuth token claim
+- **Providers**: count apikey connections for Ollama free-tier card; free-tier/
+  apikey providers without `authModes` now default to apikey (were treated
+  oauth-only)
+- **Build**: include static/public assets in standalone output (login page hung
+  on 404s when run via PM2)
+- **Server**: support IntelliJ IDEA OpenAI-compatible clients over HTTP (h2c
+  upgrade handling)
+- **Auth**: redirect already-logged-in sessions away from `/login`
+- **CLI tools**: enable Apply button for dynamic OpenAI/Anthropic-compatible
+  provider connections
+- **CLI**: include complete API artifacts in the CLI package
 - **TTS**: a bare self-hosted model name is the MODEL, not the voice — `kokoro`
   was parsed as a voice against a default model, 404ing or synthesising with the
   wrong one
@@ -19,6 +74,9 @@
   endpoint that drops packets never returns headers, so the request previously
   hung indefinitely
 
+## Docs
+- **i18n**: fix port typo, add RTK Token Saver feature descriptions
+
 # v0.5.45 (2026-07-30)
 
 ## Features
diff --git a/cli/package.json b/cli/package.json
index efb786e4..98ad8cdc 100644
--- a/cli/package.json
+++ b/cli/package.json
@@ -1,6 +1,6 @@
 {
   "name": "9router",
-  "version": "0.5.45",
+  "version": "0.5.50",
   "description": "9Router CLI - Start and manage 9Router server",
   "bin": {
     "9router": "./cli.js"
diff --git a/package.json b/package.json
index 4f5f8f95..4374a515 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "9router-app",
-  "version": "0.5.45",
+  "version": "0.5.50",
   "description": "9Router web dashboard",
   "private": true,
   "scripts": {