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

package/dist/proxy/messages-cross-route.js

@@ -2,6 +2,7 @@ import express from "express";
 import { selectRoute } from "../providers/route-selector.js";
 import { anthropicToOpenAIResponses } from "../protocol/anthropic-to-openai.js";
 import { openAIResponseToAnthropicMessage } from "../protocol/openai-response-to-anthropic.js";
+import { OpenAIProtocolError } from "../protocol/openai-function-call.js";
 import { createOpenAIStreamToAnthropicNormalizer } from "../protocol/openai-stream-to-anthropic.js";
 import { encodeSseEvent, parseSseLines } from "../protocol/sse.js";
 import { forwardOpenAICodexResponse } from "../providers/openai/codex-transport.js";
@@ -143,16 +144,21 @@ async function collectOpenAIStreamAsAnthropicMessage(upstream, report) {
     let remainder = "";
     let id = "";
     let model = "";
-    let text = "";
     let failure;
     let completed = false;
     let usage = {};
     let status;
     let incompleteDetails;
+    const textByIndex = new Map();
+    const refusalByIndex = new Map();
+    const argumentsByIndex = new Map();
+    const pendingCallsByIndex = new Map();
+    const callsByIndex = new Map();
     const applyEvent = (event) => {
         if (typeof event !== "object" || event === null)
             return;
         const openAIEvent = event;
+        const outputIndex = openAIEvent.output_index ?? 0;
         // Reported the moment it is seen, not when this function returns: the
         // read after it can be cut short by a client disconnect, and losing the
         // verdict there turns a real backend failure into a benign cancellation.
@@ -172,7 +178,57 @@ async function collectOpenAIStreamAsAnthropicMessage(upstream, report) {
             return;
         }
         if (openAIEvent.type === "response.output_text.delta") {
-            text += openAIEvent.delta ?? "";
+            textByIndex.set(outputIndex, (textByIndex.get(outputIndex) ?? "") + (openAIEvent.delta ?? ""));
+            return;
+        }
+        if (openAIEvent.type === "response.refusal.delta") {
+            refusalByIndex.set(outputIndex, (refusalByIndex.get(outputIndex) ?? "") + (openAIEvent.delta ?? ""));
+            return;
+        }
+        if (openAIEvent.type === "response.output_item.added") {
+            const item = openAIEvent.item;
+            if (item?.type === "function_call") {
+                if (!item.call_id?.trim() || !item.name?.trim()) {
+                    throw new OpenAIProtocolError("Invalid OpenAI function call metadata");
+                }
+                pendingCallsByIndex.set(outputIndex, {
+                    type: "function_call",
+                    call_id: item.call_id,
+                    name: item.name,
+                    arguments: item.arguments ?? "",
+                });
+            }
+            return;
+        }
+        if (openAIEvent.type === "response.function_call_arguments.delta") {
+            if (!pendingCallsByIndex.has(outputIndex))
+                return;
+            argumentsByIndex.set(outputIndex, (argumentsByIndex.get(outputIndex) ?? "") + (openAIEvent.delta ?? ""));
+            return;
+        }
+        if (openAIEvent.type === "response.function_call_arguments.done") {
+            if (pendingCallsByIndex.has(outputIndex) && !argumentsByIndex.has(outputIndex) && openAIEvent.arguments) {
+                argumentsByIndex.set(outputIndex, openAIEvent.arguments);
+            }
+            return;
+        }
+        if (openAIEvent.type === "response.output_item.done") {
+            const item = openAIEvent.item;
+            const pending = pendingCallsByIndex.get(outputIndex);
+            if (item?.type === "function_call" || pending) {
+                const callId = item?.call_id || pending?.call_id;
+                const name = item?.name || pending?.name;
+                if (!callId?.trim() || !name?.trim()) {
+                    throw new OpenAIProtocolError("Invalid OpenAI function call metadata");
+                }
+                callsByIndex.set(outputIndex, {
+                    type: "function_call",
+                    call_id: callId,
+                    name,
+                    arguments: item?.arguments || argumentsByIndex.get(outputIndex) || pending?.arguments || "",
+                });
+                pendingCallsByIndex.delete(outputIndex);
+            }
             return;
         }
         if (terminalResponsePayload(event) !== undefined) {
@@ -199,15 +255,34 @@ async function collectOpenAIStreamAsAnthropicMessage(upstream, report) {
     if (tail || remainder) {
         parseSseLines(remainder + tail + "\n", { tolerant: true }).events.forEach(applyEvent);
     }
+    const output = [...new Set([
+            ...textByIndex.keys(),
+            ...refusalByIndex.keys(),
+            ...callsByIndex.keys(),
+        ])]
+        .sort((a, b) => a - b)
+        .flatMap((index) => {
+        const call = callsByIndex.get(index);
+        if (call)
+            return [{ ...call, arguments: call.arguments || argumentsByIndex.get(index) || "" }];
+        const text = textByIndex.get(index);
+        const refusal = refusalByIndex.get(index);
+        const content = [
+            ...(text ? [{ type: "output_text", text }] : []),
+            ...(refusal ? [{ type: "refusal", refusal }] : []),
+        ];
+        return content.length > 0 ? [{ type: "message", role: "assistant", content }] : [];
+    });
+    const protocolFailure = pendingCallsByIndex.size > 0
+        ? "OpenAI function call ended before completion"
+        : undefined;
+    if (protocolFailure)
+        report.upstreamReportedFailure = true;
     return {
         message: openAIResponseToAnthropicMessage({
             id,
             model,
-            output: text ? [{
-                    type: "message",
-                    role: "assistant",
-                    content: [{ type: "output_text", text }],
-                }] : [],
+            output,
             usage,
             ...(status ? { status } : {}),
             ...(incompleteDetails ? { incomplete_details: incompleteDetails } : {}),
@@ -222,7 +297,9 @@ async function collectOpenAIStreamAsAnthropicMessage(upstream, report) {
         // mid-flight) is a failure rather than an empty success. An explicit
         // `response.failed`/`error` message wins, since it says more about what
         // went wrong.
-        failure: failure ?? (completed ? undefined : "Upstream stream ended without a terminal response event"),
+        failure: failure
+            ?? protocolFailure
+            ?? (completed ? undefined : "Upstream stream ended without a terminal response event"),
     };
 }
 /** Returns the upstream failure message when the stream ended in one. */
@@ -250,6 +327,16 @@ async function sendOpenAIStreamAsAnthropic(upstream, res, onUsage, report) {
     let totals;
     let failure;
     let completed = false;
+    const pendingToolCalls = new Set();
+    const writeProtocolError = () => {
+        res.write(encodeSseEvent({
+            type: "error",
+            error: {
+                type: "api_error",
+                message: "Invalid or incomplete response from OpenAI",
+            },
+        }));
+    };
     const inspect = (event) => {
         totals = usageFromTerminalEvent(event) ?? totals;
         if (typeof event !== "object" || event === null)
@@ -268,6 +355,12 @@ async function sendOpenAIStreamAsAnthropic(upstream, res, onUsage, report) {
         else if (terminalResponsePayload(event) !== undefined) {
             completed = true;
         }
+        if (typed.type === "response.output_item.added" && typed.item?.type === "function_call") {
+            pendingToolCalls.add(typed.output_index ?? 0);
+        }
+        else if (typed.type === "response.output_item.done") {
+            pendingToolCalls.delete(typed.output_index ?? 0);
+        }
     };
     const relayEvents = (events) => {
         for (const event of events) {
@@ -298,6 +391,18 @@ async function sendOpenAIStreamAsAnthropic(upstream, res, onUsage, report) {
         if (tail || remainder) {
             relayEvents(parseSseLines(remainder + tail + "\n", { tolerant: true }).events);
         }
+        if (!completed && pendingToolCalls.size > 0 && failure === undefined) {
+            failure = "OpenAI function call ended before completion";
+            report.upstreamReportedFailure = true;
+            writeProtocolError();
+        }
+    }
+    catch (error) {
+        if (!(error instanceof OpenAIProtocolError))
+            throw error;
+        failure = error.message;
+        report.upstreamReportedFailure = true;
+        writeProtocolError();
     }
     finally {
         res.end();

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;
         }