@timo972/cc-router 0.11.0 → 0.12.0-rc.0

package/dist/proxy/allowance.js

@@ -0,0 +1,142 @@
+// The 7-day (weekly) window is the headline constraint for both providers —
+// it is the one that actually forces a provider switch. The 5-hour window
+// resets hourly-scale and is only a secondary, tie-breaking signal. This
+// module is a PURE function over the already-in-memory HealthAccountView[]
+// (no upstream fetch, no I/O) so polling it can never itself rate-limit an
+// account.
+const CONSTRAINED_THRESHOLD = 0.85;
+const NO_WINDOWS = { sevenDayUtil: null, sevenDayResetMs: null, fiveHourUtil: null };
+export function createAllowanceView(views, now) {
+    return {
+        ts: now,
+        providers: {
+            anthropic: computeProviderAllowance(views.filter(v => v.provider === "anthropic_subscription"), now, anthropicWindows, isAnthropicRateLimited),
+            openai: computeProviderAllowance(views.filter(v => v.provider === "openai_subscription"), now, openAIWindows, isOpenAIRateLimited),
+        },
+    };
+}
+function isCandidate(view) {
+    return view.enabled !== false;
+}
+function isCooling(view, now) {
+    return Math.max(view.cooldownUntilMs ?? 0, view.globalCooldownUntilMs ?? 0) > now;
+}
+function isAnthropicRateLimited(view) {
+    return view.rateLimits?.status === "rate_limited";
+}
+function isOpenAIRateLimited(view) {
+    return view.codexRateLimits?.status === "rate_limited";
+}
+function anthropicWindows(view) {
+    const rl = view.rateLimits;
+    if (!rl)
+        return NO_WINDOWS;
+    return {
+        sevenDayUtil: typeof rl.sevenDayUtil === "number" ? rl.sevenDayUtil : null,
+        sevenDayResetMs: rl.sevenDayReset > 0 ? rl.sevenDayReset * 1000 : null,
+        fiveHourUtil: typeof rl.fiveHourUtil === "number" ? rl.fiveHourUtil : null,
+    };
+}
+// The default Codex bucket carries two windows: a short one (primary,
+// typically the 5h window) and a long one (secondary, typically the 7d /
+// weekly window). We identify the weekly window by whichever has the LARGER
+// windowMinutes rather than by name, since primary/secondary are positional,
+// not semantic. If only one window is present it is treated as the weekly
+// (7d-primary) signal and there is no secondary 5h reading.
+function openAIWindows(view) {
+    const bucket = view.codexRateLimits?.buckets?.[0];
+    if (!bucket)
+        return NO_WINDOWS;
+    const windows = [bucket.primary, bucket.secondary]
+        .filter((w) => w != null);
+    if (windows.length === 0)
+        return NO_WINDOWS;
+    const weekly = windows.reduce((best, w) => (w.windowMinutes > best.windowMinutes ? w : best));
+    const short = windows.length > 1 ? windows.find(w => w !== weekly) ?? null : null;
+    return {
+        sevenDayUtil: weekly.utilization,
+        sevenDayResetMs: weekly.resetAt > 0 ? weekly.resetAt * 1000 : null,
+        fiveHourUtil: short ? short.utilization : null,
+    };
+}
+function computeProviderAllowance(views, now, windowsOf, isRateLimited) {
+    const candidates = views.filter(isCandidate);
+    const available = candidates.filter(v => !isCooling(v, now) && !isRateLimited(v));
+    const availableWindows = available.map(windowsOf);
+    const sevenDayUtils = availableWindows
+        .map(w => w.sevenDayUtil)
+        .filter((u) => u != null);
+    const fiveHourUtils = availableWindows
+        .map(w => w.fiveHourUtil)
+        .filter((u) => u != null);
+    const worstSevenDayUtil = sevenDayUtils.length > 0 ? Math.max(...sevenDayUtils) : null;
+    const bestSevenDayUtil = sevenDayUtils.length > 0 ? Math.min(...sevenDayUtils) : null;
+    const sevenDayHeadroom = bestSevenDayUtil != null ? 1 - bestSevenDayUtil : null;
+    const sevenDaySpread = worstSevenDayUtil != null && bestSevenDayUtil != null
+        ? worstSevenDayUtil - bestSevenDayUtil
+        : null;
+    const fiveHourUtil = fiveHourUtils.length > 0 ? Math.min(...fiveHourUtils) : null;
+    const accountsTotal = candidates.length;
+    const accountsAvailable = available.length;
+    let status;
+    if (accountsAvailable === 0) {
+        status = "exhausted";
+    }
+    else if ((bestSevenDayUtil != null && bestSevenDayUtil >= CONSTRAINED_THRESHOLD)
+        || (fiveHourUtil != null && fiveHourUtil >= CONSTRAINED_THRESHOLD)) {
+        status = "constrained";
+    }
+    else {
+        status = "ok";
+    }
+    const earliestResetAt = computeEarliestResetAt({
+        status,
+        accountsAvailable,
+        available,
+        candidates,
+        windowsOf,
+        now,
+    });
+    const coolingModelFamilies = Array.from(new Set(candidates.flatMap(v => (v.modelCooldowns ?? [])
+        .filter(c => c.untilMs > now)
+        .map(c => c.modelFamily)))).sort();
+    return {
+        status,
+        accountsTotal,
+        accountsAvailable,
+        sevenDayUtil: worstSevenDayUtil,
+        sevenDayHeadroom,
+        sevenDaySpread,
+        fiveHourUtil,
+        earliestResetAt,
+        coolingModelFamilies,
+    };
+}
+function computeEarliestResetAt(args) {
+    const { status, accountsAvailable, available, candidates, windowsOf, now } = args;
+    if (accountsAvailable > 0) {
+        if (status !== "constrained")
+            return null;
+        const resets = available
+            .map(windowsOf)
+            .map(w => w.sevenDayResetMs)
+            .filter((r) => r != null);
+        return resets.length > 0 ? Math.min(...resets) : null;
+    }
+    // Exhausted: the earliest moment capacity could plausibly return, per
+    // candidate — whichever cooldown (account or global) is currently
+    // enforced, or otherwise its weekly reset if that lies in the future.
+    const candidateResets = [];
+    for (const view of candidates) {
+        const cooldownUntil = Math.max(view.cooldownUntilMs ?? 0, view.globalCooldownUntilMs ?? 0);
+        if (cooldownUntil > now) {
+            candidateResets.push(cooldownUntil);
+            continue;
+        }
+        const sevenDayResetMs = windowsOf(view).sevenDayResetMs;
+        if (sevenDayResetMs != null && sevenDayResetMs > now) {
+            candidateResets.push(sevenDayResetMs);
+        }
+    }
+    return candidateResets.length > 0 ? Math.min(...candidateResets) : null;
+}

package/dist/proxy/logger.js

@@ -1,12 +1,13 @@
 import chalk from "chalk";
 function ts() {
-    return new Date().toISOString().slice(11, 19); // HH:MM:SS
+    return new Date().toISOString().slice(0, 19).replace("T", " "); // YYYY-MM-DD HH:MM:SS
 }
-export function logRoute(accountId, requestCount, expiresInMin) {
+export function logRoute(accountId, requestCount, expiresInMin, reason) {
     console.log(chalk.gray(`[${ts()}]`) +
         chalk.green(` → ${accountId}`) +
         chalk.gray(` req#${requestCount}`) +
-        chalk.yellow(` exp=${expiresInMin}min`));
+        chalk.yellow(` exp=${expiresInMin}min`) +
+        (reason ? chalk.cyan(` ${reason}`) : ""));
 }
 export function logRefresh(accountId, ok, expiresInMin) {
     if (ok) {

package/dist/proxy/models-server.js

@@ -1,5 +1,6 @@
 import express from "express";
 import { fetchAnthropicModels, fetchOpenAICodexModels, } from "../providers/model-discovery.js";
+import { isBareOpenAIModel } from "../protocol/model-ref.js";
 import { buildModelRoutingUpdate } from "../protocol/model-routing-config.js";
 export function mountModelsRoute(app, opts) {
     const fetchAnthropic = opts.fetchAnthropicModels ?? fetchAnthropicModels;
@@ -52,6 +53,7 @@ async function discoverModelList(opts, prepareOpenAIAccount, fetchAnthropic, fet
         models.set(model.id, model);
     }
     addConfiguredAliases(models, currentModelRouting(opts));
+    addBareOpenAIEntries(models);
     return [...models.values()].sort((a, b) => a.id.localeCompare(b.id));
 }
 function currentModelRouting(opts) {
@@ -98,9 +100,36 @@ function addConfiguredAliases(models, config) {
         models.set("openai/default", modelEntry("openai/default", "openai_subscription"));
     }
 }
+/**
+ * Routing already claims bare `gpt-*` slugs for OpenAI (isBareOpenAIModel in
+ * model-ref.ts), because the Codex CLI writes those bare slugs into its own
+ * config. Without a matching metadata entry here, Codex warns "Model
+ * metadata not found" and falls back to generic defaults for a model the
+ * router routes correctly.
+ */
+function addBareOpenAIEntries(models) {
+    for (const model of [...models.values()]) {
+        if (model.owned_by !== "openai_subscription")
+            continue;
+        const bare = model.id.startsWith("openai/") ? model.id.slice("openai/".length) : model.id;
+        if (isBareOpenAIModel(bare) && !models.has(bare)) {
+            models.set(bare, modelEntry(bare, "openai_subscription"));
+        }
+    }
+}
 function modelEntry(id, ownedBy) {
     return { id, object: "model", owned_by: ownedBy };
 }
+/**
+ * Codex's hardcoded skills-context budget (2%) is carved out of
+ * context_window, so an undersized value here starves it. Use the
+ * official per-family windows instead of one shared guess.
+ */
+function contextWindowFor(ownedBy) {
+    return ownedBy === "openai_subscription"
+        ? { context_window: 272_000, max_context_window: 1_050_000 }
+        : { context_window: 200_000, max_context_window: 200_000 };
+}
 function toCodexCliModel(model) {
     return {
         prefer_websockets: true,
@@ -116,8 +145,7 @@ function toCodexCliModel(model) {
         multi_agent_version: null,
         use_responses_lite: false,
         auto_review_model_override: null,
-        context_window: 128_000,
-        max_context_window: 128_000,
+        ...contextWindowFor(model.owned_by),
         auto_compact_token_limit: null,
         reasoning_summary_format: "experimental",
         default_reasoning_summary: "none",

package/dist/proxy/openai-ingress.js

@@ -3,7 +3,7 @@ import { headersToRecord, parseCodexRateLimits } from "../providers/openai/usage
 import { applyCodexFailureRouting } from "../providers/openai/failure-routing.js";
 import { needsOpenAIRefresh } from "../providers/openai/token-refresher.js";
 import { stats, boundModelId, createLocalRoutingErrorLog } from "./stats.js";
-import { logError } from "./logger.js";
+import { logError, logRoute } from "./logger.js";
 import { EmptyPoolError, NoEligibleAccountError } from "./account-pool.js";
 import { acquireRequestRoute, routeReasonDetails, routeFailureDetails } from "./lease-lifecycle.js";
 import { MAX_UPSTREAM_ATTEMPTS, RETRY_REFRESH_TIMEOUT_MS, SAME_ACCOUNT_RETRY_DELAY_MS, boundedWait, isRetryableUpstreamStatus, retryDelay, } from "./upstream-retry.js";
@@ -159,6 +159,12 @@ export async function runOpenAIIngress(opts) {
         res.status(500).json(envelope.wrap("proxy_error", "Unexpected routing error"));
         return;
     }
+    // Mirrors the Anthropic path's route log (server.ts) — without this the
+    // OpenAI/Responses ingress made every routing decision (sticky/new-session/
+    // failover) invisible, unlike the Anthropic path which logs every routed
+    // request. `selected.details` is the pool's preformatted, session-id-free
+    // reason string — keep it that way.
+    logRoute(selected.route.account.id, selected.route.account.requestCount, Math.round((selected.route.account.expiresAt - now()) / 60_000), selected.details);
     const startedAt = now();
     const maxAttempts = Math.max(1, opts.maxAttempts ?? MAX_UPSTREAM_ATTEMPTS);
     const sameAccountDelayMs = opts.sameAccountRetryDelayMs ?? SAME_ACCOUNT_RETRY_DELAY_MS;

package/dist/proxy/openai-routing.js

@@ -1,6 +1,7 @@
 import { extractClaudeSessionId } from "./anthropic-routing.js";
 import { normalizeSessionId } from "./session-router.js";
-const CODEX_SESSION_HEADER = "session_id";
+const CODEX_SESSION_HEADER_DASHED = "session-id";
+const CODEX_SESSION_HEADER_UNDERSCORE = "session_id";
 /** Extract exactly one native HTTP header field without joined duplicates. */
 function extractSingleHeader(request, name) {
     const distinct = request.headersDistinct;
@@ -21,14 +22,18 @@ function extractSingleHeader(request, name) {
     return normalizeSessionId(values[0]);
 }
 /**
- * Resolve the OpenAI affinity key in priority order: Codex session_id header,
- * Claude Code session header, then the request body's prompt_cache_key
- * (Codex thread id). Returns undefined for unscoped requests.
+ * Resolve the OpenAI affinity key in priority order: Codex `session-id` header
+ * (current Codex CLI spelling), legacy `session_id` header, Claude Code session
+ * header, then the request body's prompt_cache_key (Codex thread id). Returns
+ * undefined for unscoped requests.
  */
 export function extractCodexSessionKey(request, body) {
-    const codexSession = extractSingleHeader(request, CODEX_SESSION_HEADER);
-    if (codexSession !== undefined)
-        return codexSession;
+    const codexSessionDashed = extractSingleHeader(request, CODEX_SESSION_HEADER_DASHED);
+    if (codexSessionDashed !== undefined)
+        return codexSessionDashed;
+    const codexSessionUnderscore = extractSingleHeader(request, CODEX_SESSION_HEADER_UNDERSCORE);
+    if (codexSessionUnderscore !== undefined)
+        return codexSessionUnderscore;
     const claudeSession = extractClaudeSessionId(request);
     if (claudeSession !== undefined)
         return claudeSession;

package/dist/proxy/server.js

@@ -4,7 +4,7 @@ import { ServerResponse } from "http";
 import { timingSafeEqual } from "crypto";
 import { TokenPool } from "./token-pool.js";
 import { needsRefresh, refreshAccountIfCurrent, saveAccounts, startRefreshLoop } from "./token-refresher.js";
-import { loadAccounts, loadOpenAIAccounts, saveOpenAIAccountsToPath, accountsFileExists, readAccountsFromPath, readConfig, writeConfig, getAutoFailoverEnabled, getProxyRequestTimeoutMs, migrateLegacyAccountProviders, setProviderAccountsEnabled } from "../config/manager.js";
+import { loadAccounts, loadOpenAIAccounts, saveOpenAIAccountsToPath, accountsFileExists, readAccountsFromPath, readConfig, writeConfig, getAutoFailoverEnabled, getProxyRequestTimeoutMs, migrateLegacyAccountProviders, setProviderAccountsEnabled, upsertAccountRecord, removeAccountRecordById } from "../config/manager.js";
 import { checkForUpdate, performUpdate, restartSelf, printUpdateBanner, getCurrentVersion } from "../utils/self-update.js";
 import { trackEvent, startHeartbeat } from "../utils/telemetry.js";
 import { loadTelemetryState } from "../config/telemetry.js";
@@ -13,6 +13,7 @@ import { createLocalRoutingErrorLog, stats } from "./stats.js";
 import { applyRateLimitHeaders } from "../providers/anthropic/rate-limit-headers.js";
 import { mountAnthropicMessagesRoute, withOAuthBeta } from "./anthropic-messages-route.js";
 import { PROXY_PORT, LITELLM_URL, ACCOUNTS_PATH } from "../config/paths.js";
+import { loadGrokHealthSnapshots } from "../providers/xai/overview.js";
 import { writePid, removePid, managesPidFile } from "../daemon/pid.js";
 import { applyOpenAIAccountPatch, validateAccountPatchBody } from "./account-patch.js";
 import { AccountRenameConflictError, renameAccountTransaction } from "./account-rename.js";
@@ -35,6 +36,7 @@ import { persistProviderEnabledState } from "./provider-routing.js";
 import { accountDeletionStatusCode, deleteAnthropicAccountTransaction, deleteOpenAIAccountTransaction, } from "./account-deletion.js";
 import { addOpenAIAccountTransaction } from "./account-add.js";
 import { createAnthropicRefreshMiddleware, createAnthropicRoutingMiddleware, } from "./anthropic-routing.js";
+import { createAllowanceView } from "./allowance.js";
 const zeroRoutingMetrics = () => ({
     inFlightRequests: 0,
     activeSessions: 0,
@@ -44,6 +46,7 @@ const zeroRoutingMetrics = () => ({
 export function createOperationalStatus(opts) {
     const anthropicAccounts = opts.accounts.filter(a => a.provider === "anthropic_subscription");
     const openAIAccounts = opts.accounts.filter(a => a.provider === "openai_subscription");
+    const xaiAccounts = opts.accounts.filter(a => a.provider === "xai_subscription");
     const modelRouting = opts.modelRouting ?? {};
     return {
         mode: opts.mode,
@@ -52,10 +55,12 @@ export function createOperationalStatus(opts) {
         providers: {
             anthropic: providerStatus(anthropicAccounts),
             openai: providerStatus(openAIAccounts),
+            xai: providerStatus(xaiAccounts),
         },
         endpoints: {
             health: "/cc-router/health",
             accounts: "/cc-router/accounts",
+            allowance: "/cc-router/allowance",
             messages: "/v1/messages",
             responses: "/v1/responses",
             models: "/v1/models",
@@ -75,12 +80,30 @@ export function createOperationalStatus(opts) {
         },
     };
 }
-export function createHealthAccountViews(anthropicAccounts, openAIAccounts, resolveRoutingMetrics = zeroRoutingMetrics, resolveOpenAIRouting) {
+export function createHealthAccountViews(anthropicAccounts, openAIAccounts, resolveRoutingMetrics = zeroRoutingMetrics, resolveOpenAIRouting, xaiAccounts = []) {
     return [
         ...anthropicAccounts.map(account => (publicAnthropicAccountView(account, resolveRoutingMetrics(account.id)))),
         ...openAIAccounts.map(account => publicOpenAIAccountView(account, resolveOpenAIRouting?.(account.id) ?? { metrics: zeroRoutingMetrics(account.id), cooldowns: { globalUntilMs: 0, bucketCooldowns: [] } })),
+        ...xaiAccounts.map(publicXaiAccountView),
     ];
 }
+function publicXaiAccountView(account) {
+    return {
+        id: account.id,
+        provider: "xai_subscription",
+        enabled: true,
+        healthy: account.healthy,
+        busy: account.busy,
+        inFlightRequests: 0,
+        activeSessions: account.activeSessions,
+        requestCount: account.requestCount,
+        errorCount: 0,
+        expiresInMs: account.expiresInMs,
+        lastUsedMs: 0,
+        lastRefreshMs: 0,
+        ...(account.tier !== undefined ? { xai: { tier: account.tier } } : {}),
+    };
+}
 function publicAnthropicAccountView(a, metrics) {
     return {
         id: a.id,
@@ -241,6 +264,7 @@ function publicCodexRateLimits(a, cooldowns) {
     const balance = typeof credits?.balance === "string"
         ? credits.balance.replace(/[\x00-\x1f\x7f]/g, "").trim().slice(0, 32)
         : "";
+    const resetAvailable = rl.resetCredits?.available;
     return {
         status: rl.status === "rate_limited" ? "rate_limited" : "ok",
         plan: publicCodexPlan(rl.plan),
@@ -252,6 +276,9 @@ function publicCodexRateLimits(a, cooldowns) {
                 ...(balance ? { balance } : {}),
             },
         } : {}),
+        ...(typeof resetAvailable === "number" && Number.isFinite(resetAvailable) ? {
+            resetCredits: { available: Math.max(0, Math.min(99, Math.floor(resetAvailable))) },
+        } : {}),
         lastUpdated: publicTimestamp(rl.lastUpdated),
     };
 }
@@ -453,7 +480,7 @@ export async function startServer(opts = {}) {
         pool.sweepExpiredCooldowns();
         openAIPool.sweepExpiredCooldowns();
         const resolveRoutingMetrics = createRoutingMetricsResolver();
-        const accountViews = createHealthAccountViews(pool.getAll(), openAIAccounts, resolveRoutingMetrics, createOpenAIRoutingResolver());
+        const accountViews = createHealthAccountViews(pool.getAll(), openAIAccounts, resolveRoutingMetrics, createOpenAIRoutingResolver(), loadGrokHealthSnapshots());
         const status = accountViews.some(a => a.healthy) ? "ok" : "degraded";
         if (secretBuf && !secretMatches(presentedSecret(req))) {
             res.json({ status });
@@ -487,6 +514,24 @@ export async function startServer(opts = {}) {
             recentLogs: stats.getRecentLogs(50),
         });
     });
+    // ─── Allowance endpoint (cc-router internal, NOT proxied) ─────────────────
+    // Operational-status sibling of /cc-router/health, not an account
+    // operation — hence a top-level route rather than living under
+    // accountsRouter. Read-only allowance signal (anthropic + openai only) —
+    // createAllowanceView is a PURE function over the already-in-memory account
+    // views, so polling it can never itself rate-limit an account. See
+    // ./allowance.ts for the 7d-primary logic. Behind the same secret gate as
+    // every other path except /cc-router/health (see ~line 757).
+    app.get("/cc-router/allowance", (_req, res) => {
+        // Sweep expired cooldowns on each poll, mirroring the health route, so an
+        // account that cooled down during idle time reads as available rather
+        // than stale.
+        pool.sweepExpiredCooldowns();
+        openAIPool.sweepExpiredCooldowns();
+        const resolveRoutingMetrics = createRoutingMetricsResolver();
+        const views = createHealthAccountViews(pool.getAll(), openAIAccounts, resolveRoutingMetrics, createOpenAIRoutingResolver(), loadGrokHealthSnapshots());
+        res.json(createAllowanceView(views, Date.now()));
+    });
     // ─── Account management endpoints (authenticated) ─────────────────────────
     // These are mounted BEFORE the /v1/* proxy middleware so they don't get
     // forwarded to Anthropic. express.json() is scoped to this sub-router so
@@ -497,13 +542,31 @@ export async function startServer(opts = {}) {
     accountsRouter.get("/", (_req, res) => {
         const resolveRoutingMetrics = createRoutingMetricsResolver();
         res.json({
-            accounts: createHealthAccountViews(pool.getAll(), openAIAccounts, resolveRoutingMetrics, createOpenAIRoutingResolver()),
+            accounts: createHealthAccountViews(pool.getAll(), openAIAccounts, resolveRoutingMetrics, createOpenAIRoutingResolver(), loadGrokHealthSnapshots()),
         });
     });
     accountsRouter.patch("/providers/:provider", (req, res) => {
         const providerParam = req.params.provider;
-        if (providerParam !== "anthropic_subscription" && providerParam !== "openai_subscription") {
-            res.status(400).json({ error: "provider must be anthropic_subscription or openai_subscription" });
+        if (providerParam !== "anthropic_subscription"
+            && providerParam !== "openai_subscription"
+            && providerParam !== "xai_subscription") {
+            res.status(400).json({ error: "provider must be anthropic_subscription, openai_subscription, or xai_subscription" });
+            return;
+        }
+        if (providerParam === "xai_subscription") {
+            const body = (req.body ?? {});
+            if (typeof body.enabled !== "boolean") {
+                res.status(400).json({ error: "enabled must be boolean" });
+                return;
+            }
+            try {
+                const changed = setProviderAccountsEnabled("xai_subscription", body.enabled, accountsPath);
+                res.json({ provider: providerParam, enabled: body.enabled, changed });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                res.status(500).json({ error: `Failed to persist accounts.json: ${message}` });
+            }
             return;
         }
         const body = (req.body ?? {});
@@ -743,6 +806,42 @@ export async function startServer(opts = {}) {
             res.status(409).json({ error: `Account "${body.id}" already exists` });
             return;
         }
+        if (body.provider === "xai_subscription") {
+            try {
+                upsertAccountRecord({
+                    id: body.id,
+                    provider: "xai_subscription",
+                    accessToken: body.accessToken,
+                    refreshToken: body.refreshToken,
+                    expiresAt: body.expiresAt,
+                    scopes: Array.isArray(body.scopes) ? body.scopes : [],
+                    enabled: body.enabled !== false,
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                res.status(500).json({ error: `Failed to persist accounts.json: ${message}` });
+                return;
+            }
+            const now = Date.now();
+            res.status(201).json({
+                account: publicXaiAccountView({
+                    id: body.id,
+                    provider: "xai_subscription",
+                    enabled: true,
+                    healthy: body.expiresAt > now,
+                    busy: false,
+                    inFlightRequests: 0,
+                    activeSessions: 0,
+                    requestCount: 0,
+                    errorCount: 0,
+                    expiresInMs: body.expiresAt - now,
+                    lastUsedMs: 0,
+                    lastRefreshMs: 0,
+                }),
+            });
+            return;
+        }
         if (body.provider === "openai_subscription") {
             let addedOpenAI;
             try {
@@ -803,6 +902,11 @@ export async function startServer(opts = {}) {
         const existing = pool.findById(id);
         const openAIExisting = openAIAccounts.find(account => account.id === id);
         if (!existing && !openAIExisting) {
+            const removedXai = removeAccountRecordById(id);
+            if (removedXai?.provider === "xai_subscription") {
+                res.json({ deleted: id, remaining: pool.getAll().length + openAIAccounts.length });
+                return;
+            }
             res.status(404).json({ error: `Account "${id}" not found` });
             return;
         }