@yansigit/opencodex 2.31.1 → 2.31.3

package/src/routing/account-pool/cooldown.ts

@@ -0,0 +1,145 @@
+import type { CooldownRegistry } from "./types";
+
+export const DEFAULT_RATE_LIMIT_COOLDOWN_MS = 60_000;
+export const MAX_RATE_LIMIT_COOLDOWN_MS = 15 * 60_000;
+export const DEFAULT_BILLING_COOLDOWN_MS = 24 * 60 * 60_000;
+export const STICK_WAIT_MAX_MS = 5_000;
+
+export type PoolCooldownReason = "rate_limit" | "billing";
+
+interface CooldownEntry {
+  until: number;
+  source?: string;
+  reason?: string;
+}
+
+function createRegistry(): CooldownRegistry & { entries: Map<string, CooldownEntry> } {
+  const entries = new Map<string, CooldownEntry>();
+  return {
+    entries,
+    set(accountId, until, meta) {
+      entries.set(accountId, { until, source: meta?.source, reason: meta?.reason });
+    },
+    get(accountId, now = Date.now()) {
+      const entry = entries.get(accountId);
+      if (!entry) return null;
+      if (entry.until <= now) {
+        entries.delete(accountId);
+        return null;
+      }
+      return { until: entry.until, reason: entry.reason, source: entry.source };
+    },
+    clear(accountId) {
+      entries.delete(accountId);
+    },
+    sweep(now = Date.now()) {
+      let removed = 0;
+      for (const [accountId, entry] of entries) {
+        if (entry.until > now) continue;
+        entries.delete(accountId);
+        removed += 1;
+      }
+      return removed;
+    },
+  };
+}
+
+const registryByPool = new Map<string, CooldownRegistry>();
+
+export function getPoolCooldownRegistry(poolKey: string): CooldownRegistry {
+  let registry = registryByPool.get(poolKey);
+  if (!registry) {
+    registry = createRegistry();
+    registryByPool.set(poolKey, registry);
+  }
+  return registry;
+}
+
+export function clearCooldownState(poolKey?: string): void {
+  if (poolKey === undefined) {
+    registryByPool.clear();
+    return;
+  }
+  registryByPool.delete(poolKey);
+}
+
+export function parseRetryAfterMs(
+  value: string | null | undefined,
+  now = Date.now(),
+): number | undefined {
+  const text = value?.trim();
+  if (!text) return undefined;
+  if (/^\d+(?:\.\d+)?$/.test(text)) {
+    const seconds = Number(text);
+    if (Number.isFinite(seconds) && seconds > 0) {
+      return Math.min(Math.max(Math.ceil(seconds * 1000), 1), MAX_RATE_LIMIT_COOLDOWN_MS);
+    }
+  }
+  const timestamp = Date.parse(text);
+  if (!Number.isFinite(timestamp)) return undefined;
+  const delay = timestamp - now;
+  return delay > 0 ? Math.min(delay, MAX_RATE_LIMIT_COOLDOWN_MS) : undefined;
+}
+
+/** Classify HTTP status for account-pool cooldown (billing never enters the 429 hop). */
+export function classifyPoolHttpStatus(status: number): PoolCooldownReason | null {
+  if (status === 429) return "rate_limit";
+  if (status === 402) return "billing";
+  return null;
+}
+
+function cooldownDurationMs(reason: PoolCooldownReason, retryAfterMs: number | undefined): number {
+  if (reason === "billing") {
+    return retryAfterMs ?? DEFAULT_BILLING_COOLDOWN_MS;
+  }
+  return retryAfterMs ?? DEFAULT_RATE_LIMIT_COOLDOWN_MS;
+}
+
+export function recordPoolAccountCooldown(
+  poolKey: string,
+  accountId: string,
+  reason: PoolCooldownReason,
+  retryAfterHeader: string | null | undefined,
+  now = Date.now(),
+): number {
+  const parsedRetry = reason === "rate_limit" ? parseRetryAfterMs(retryAfterHeader, now) : undefined;
+  const cooldownMs = cooldownDurationMs(reason, parsedRetry);
+  const registry = getPoolCooldownRegistry(poolKey);
+  registry.set(accountId, now + cooldownMs, {
+    source: parsedRetry ? "retry-after" : "default",
+    reason,
+  });
+  return cooldownMs;
+}
+
+export function isAccountInCooldown(
+  poolKey: string,
+  accountId: string,
+  now = Date.now(),
+): { until: number; reason?: string } | null {
+  return getPoolCooldownRegistry(poolKey).get(accountId, now);
+}
+
+export function isRateLimitStickWait(
+  poolKey: string,
+  accountId: string,
+  now = Date.now(),
+): boolean {
+  const entry = isAccountInCooldown(poolKey, accountId, now);
+  if (!entry || entry.reason !== "rate_limit") return false;
+  return entry.until - now <= STICK_WAIT_MAX_MS;
+}
+
+export function isAccountPoolEligible(
+  poolKey: string,
+  accountId: string,
+  now: number,
+  options?: { allowStickWait?: boolean },
+): boolean {
+  const entry = isAccountInCooldown(poolKey, accountId, now);
+  if (!entry) return true;
+  if (options?.allowStickWait && entry.reason === "rate_limit" && entry.until - now <= STICK_WAIT_MAX_MS) {
+    return true;
+  }
+  return false;
+}

package/src/routing/account-pool/index.ts

@@ -0,0 +1,45 @@
+export {
+  ACCOUNT_POOL_MAX_FAILOVERS,
+  type AccountPoolPickReason,
+  type AccountPoolPlugin,
+  type CooldownRegistry,
+} from "./types";
+
+export {
+  AFFINITY_IDLE_TTL_MS,
+  MAX_AFFINITY_ENTRIES,
+  MAX_AFFINITY_COMPONENT_BYTES,
+  affinitySizeForTests,
+  bindSessionAffinity,
+  buildSessionKeyFromParts,
+  clearAffinityState,
+  clearSessionAffinityForAccount,
+  getSessionAffinity,
+  normalizeAffinityComponent,
+  touchSessionAffinity,
+} from "./affinity";
+
+export {
+  DEFAULT_BILLING_COOLDOWN_MS,
+  DEFAULT_RATE_LIMIT_COOLDOWN_MS,
+  MAX_RATE_LIMIT_COOLDOWN_MS,
+  STICK_WAIT_MAX_MS,
+  classifyPoolHttpStatus,
+  clearCooldownState,
+  getPoolCooldownRegistry,
+  isAccountInCooldown,
+  isAccountPoolEligible,
+  isRateLimitStickWait,
+  parseRetryAfterMs,
+  recordPoolAccountCooldown,
+  type PoolCooldownReason,
+} from "./cooldown";
+
+export {
+  clearAccountPoolState,
+  clearResolveState,
+  resetPoolFailoverCount,
+  resolvePoolAccount,
+  rotatePoolAccountOn429,
+  rotatePoolAccountOnAuth,
+} from "./resolve";

package/src/routing/account-pool/resolve.ts

@@ -0,0 +1,356 @@
+import {
+  normalizeAccountPoolStickyLimit,
+  notePoolRotationFailure,
+  notePoolRotationSuccess,
+  pickRoundRobinAccount,
+} from "../../codex/pool-rotation";
+import {
+  bindSessionAffinity,
+  clearAffinityState,
+  clearSessionAffinityForAccount,
+  getSessionAffinity,
+  normalizeAffinityComponent,
+  touchSessionAffinity,
+} from "./affinity";
+import {
+  clearCooldownState,
+  isAccountPoolEligible,
+  isRateLimitStickWait,
+  recordPoolAccountCooldown,
+  STICK_WAIT_MAX_MS,
+} from "./cooldown";
+import {
+  ACCOUNT_POOL_MAX_FAILOVERS,
+  type AccountPoolPickReason,
+  type AccountPoolPlugin,
+} from "./types";
+
+const UNKNOWN_USAGE_SCORE = 100;
+const DEFAULT_AUTO_SWITCH_THRESHOLD = 80;
+
+const failoverCountByPool = new Map<string, Map<string, number>>();
+
+function failoverKey(sessionKey: string | null): string {
+  return normalizeAffinityComponent(sessionKey) || "__unbound__";
+}
+
+function getFailoverMap(poolKey: string): Map<string, number> {
+  let map = failoverCountByPool.get(poolKey);
+  if (!map) {
+    map = new Map();
+    failoverCountByPool.set(poolKey, map);
+  }
+  return map;
+}
+
+export function clearResolveState(poolKey?: string): void {
+  if (poolKey === undefined) {
+    failoverCountByPool.clear();
+    return;
+  }
+  failoverCountByPool.delete(poolKey);
+}
+
+export function clearAccountPoolState(poolKey?: string): void {
+  clearResolveState(poolKey);
+  clearAffinityState(poolKey);
+  clearCooldownState(poolKey);
+}
+
+function filterKernelEligible(
+  plugin: AccountPoolPlugin,
+  ids: readonly string[],
+  now: number,
+  stickWaitAccountId?: string,
+): string[] {
+  return ids.filter(id =>
+    isAccountPoolEligible(plugin.poolKey, id, now, {
+      allowStickWait: stickWaitAccountId === id,
+    }),
+  );
+}
+
+function usageScore(plugin: AccountPoolPlugin, accountId: string): number {
+  const score = plugin.usageScore?.(accountId);
+  if (typeof score !== "number" || !Number.isFinite(score)) return UNKNOWN_USAGE_SCORE;
+  return Math.max(0, Math.min(100, score));
+}
+
+function pickLowestUsage(
+  plugin: AccountPoolPlugin,
+  eligible: readonly string[],
+  excludeId?: string,
+): string | null {
+  const candidates = excludeId ? eligible.filter(id => id !== excludeId) : [...eligible];
+  if (candidates.length === 0) return null;
+  let best = candidates[0]!;
+  let bestScore = usageScore(plugin, best);
+  for (let i = 1; i < candidates.length; i++) {
+    const id = candidates[i]!;
+    const score = usageScore(plugin, id);
+    if (score < bestScore) {
+      best = id;
+      bestScore = score;
+    }
+  }
+  return best;
+}
+
+function pickFillFirst(
+  eligible: readonly string[],
+  activeAccountId: string | undefined,
+): string | null {
+  if (eligible.length === 0) return null;
+  const ordered = [...eligible].sort((a, b) => a.localeCompare(b));
+  if (!activeAccountId || !ordered.includes(activeAccountId)) return ordered[0] ?? null;
+  const startIdx = ordered.indexOf(activeAccountId);
+  for (let step = 1; step <= ordered.length; step++) {
+    const candidate = ordered[(startIdx + step) % ordered.length]!;
+    if (eligible.includes(candidate)) return candidate;
+  }
+  return ordered[0] ?? null;
+}
+
+function anyCooled(plugin: AccountPoolPlugin, accountIds: readonly string[], now: number): boolean {
+  return accountIds.some(id => !isAccountPoolEligible(plugin.poolKey, id, now));
+}
+
+function bindIfPossible(
+  plugin: AccountPoolPlugin,
+  sessionKey: string | null,
+  accountId: string | null,
+  now: number,
+): void {
+  if (!accountId) return;
+  const key = normalizeAffinityComponent(sessionKey);
+  if (!key || !normalizeAffinityComponent(accountId)) return;
+  bindSessionAffinity(plugin.poolKey, key, accountId, now);
+}
+
+/**
+ * Resolve which account should serve this session.
+ * Does not call setActiveAccount — callers promote after a usable token.
+ */
+export function resolvePoolAccount(
+  plugin: AccountPoolPlugin,
+  sessionKey: string | null,
+  opts: {
+    strategy: "quota" | "round-robin" | "fill-first";
+    enabled: boolean;
+    activeAccountId?: string;
+    stickyLimit?: number;
+    autoSwitchThreshold?: number;
+  },
+  now = Date.now(),
+): { accountId: string | null; reason: AccountPoolPickReason } {
+  const allEligible = plugin.listEligibleAccountIds(now);
+  if (allEligible.length === 0) {
+    return { accountId: null, reason: "none" };
+  }
+
+  if (!opts.enabled) {
+    const active = opts.activeAccountId;
+    if (active && allEligible.includes(active)) {
+      return { accountId: active, reason: "disabled" };
+    }
+    return { accountId: active ?? null, reason: active ? "disabled" : "none" };
+  }
+
+  const key = normalizeAffinityComponent(sessionKey);
+  if (key) {
+    const affined = getSessionAffinity(plugin.poolKey, key, now);
+    if (affined) {
+      const stickWait = isRateLimitStickWait(plugin.poolKey, affined.accountId, now);
+      const eligible = filterKernelEligible(
+        plugin,
+        allEligible,
+        now,
+        stickWait ? affined.accountId : undefined,
+      );
+      if (eligible.includes(affined.accountId)) {
+        touchSessionAffinity(plugin.poolKey, key, now);
+        return { accountId: affined.accountId, reason: "affinity" };
+      }
+      clearSessionAffinityForAccount(plugin.poolKey, affined.accountId);
+    }
+  }
+
+  const kernelEligible = filterKernelEligible(plugin, allEligible, now);
+  if (kernelEligible.length === 0) {
+    return { accountId: null, reason: anyCooled(plugin, allEligible, now) ? "all-cooled" : "none" };
+  }
+
+  const strategy = opts.strategy;
+  const stickyLimit = normalizeAccountPoolStickyLimit(opts.stickyLimit);
+  const threshold = opts.autoSwitchThreshold ?? DEFAULT_AUTO_SWITCH_THRESHOLD;
+  const active = opts.activeAccountId;
+  const activeOk = active !== undefined && kernelEligible.includes(active);
+
+  if (strategy === "round-robin") {
+    if (!key && activeOk) {
+      return { accountId: active, reason: "active" };
+    }
+    const picked = pickRoundRobinAccount(plugin.poolKey, kernelEligible, stickyLimit);
+    if (!picked) {
+      return { accountId: null, reason: anyCooled(plugin, allEligible, now) ? "all-cooled" : "none" };
+    }
+    notePoolRotationSuccess(plugin.poolKey, picked, stickyLimit);
+    bindIfPossible(plugin, sessionKey, picked, now);
+    return { accountId: picked, reason: "round-robin" };
+  }
+
+  if (strategy === "fill-first") {
+    if (!key && activeOk) {
+      return { accountId: active, reason: "active" };
+    }
+    const picked = pickFillFirst(kernelEligible, active);
+    if (!picked) {
+      return { accountId: null, reason: anyCooled(plugin, allEligible, now) ? "all-cooled" : "none" };
+    }
+    bindIfPossible(plugin, sessionKey, picked, now);
+    return { accountId: picked, reason: "fill-first" };
+  }
+
+  // quota strategy
+  let accountId: string | null = null;
+  let reason: AccountPoolPickReason = "none";
+
+  if (plugin.usageScore && threshold > 0) {
+    if (activeOk) {
+      const activeScore = usageScore(plugin, active);
+      const hasKnown = activeScore < UNKNOWN_USAGE_SCORE;
+      if (!hasKnown || activeScore < threshold) {
+        accountId = active;
+        reason = "active";
+      } else {
+        const picked = pickLowestUsage(plugin, kernelEligible);
+        if (picked) {
+          accountId = picked;
+          reason = activeOk && picked === active ? "active" : "lowest-usage";
+        } else if (activeOk) {
+          accountId = active;
+          reason = "active";
+        }
+      }
+    } else {
+      const picked = pickLowestUsage(plugin, kernelEligible);
+      if (picked) {
+        accountId = picked;
+        reason = "only-eligible";
+      }
+    }
+  } else if (activeOk) {
+    accountId = active;
+    reason = "active";
+  } else {
+    const picked = pickLowestUsage(plugin, kernelEligible, active);
+    if (picked) {
+      accountId = picked;
+      reason = "only-eligible";
+    }
+  }
+
+  if (!accountId) {
+    return { accountId: null, reason: anyCooled(plugin, allEligible, now) ? "all-cooled" : "none" };
+  }
+
+  bindIfPossible(plugin, sessionKey, accountId, now);
+  return { accountId, reason };
+}
+
+/**
+ * Record a rate-limit 429, cool the failed account, and pick a failover account.
+ * Billing (402) must use recordPoolAccountCooldown with reason billing — not this path.
+ * Does not call setActiveAccount.
+ */
+export function rotatePoolAccountOn429(
+  plugin: AccountPoolPlugin,
+  failedAccountId: string,
+  sessionKey: string | null,
+  retryAfterHeader: string | null,
+  now = Date.now(),
+): string | null {
+  const session = failoverKey(sessionKey);
+  const failoverMap = getFailoverMap(plugin.poolKey);
+  const prior = failoverMap.get(session) ?? 0;
+  if (prior >= ACCOUNT_POOL_MAX_FAILOVERS) return null;
+
+  const cooldownMs = recordPoolAccountCooldown(
+    plugin.poolKey,
+    failedAccountId,
+    "rate_limit",
+    retryAfterHeader,
+    now,
+  );
+
+  if (cooldownMs <= STICK_WAIT_MAX_MS) {
+    return null;
+  }
+
+  clearSessionAffinityForAccount(plugin.poolKey, failedAccountId);
+  notePoolRotationFailure(plugin.poolKey, failedAccountId);
+
+  const eligible = filterKernelEligible(
+    plugin,
+    plugin.listEligibleAccountIds(now).filter(id => id !== failedAccountId),
+    now,
+  );
+  if (eligible.length === 0) return null;
+
+  const next = pickRoundRobinAccount(plugin.poolKey, eligible, 1) ?? eligible[0] ?? null;
+  if (!next) return null;
+
+  failoverMap.set(session, prior + 1);
+
+  const affinityKey = normalizeAffinityComponent(sessionKey);
+  if (affinityKey && normalizeAffinityComponent(next)) {
+    bindSessionAffinity(plugin.poolKey, affinityKey, next, now);
+  }
+
+  return next;
+}
+
+/**
+ * Pick a failover account after auth death (401/403). Shares the per-session cap with 429 hops.
+ * Does not call setActiveAccount.
+ */
+export function rotatePoolAccountOnAuth(
+  plugin: AccountPoolPlugin,
+  failedAccountId: string,
+  sessionKey: string | null,
+  now = Date.now(),
+): string | null {
+  const session = failoverKey(sessionKey);
+  const failoverMap = getFailoverMap(plugin.poolKey);
+  const prior = failoverMap.get(session) ?? 0;
+  if (prior >= ACCOUNT_POOL_MAX_FAILOVERS) return null;
+
+  clearSessionAffinityForAccount(plugin.poolKey, failedAccountId);
+  notePoolRotationFailure(plugin.poolKey, failedAccountId);
+
+  const eligible = filterKernelEligible(
+    plugin,
+    plugin.listEligibleAccountIds(now).filter(id => id !== failedAccountId),
+    now,
+  );
+  if (eligible.length === 0) return null;
+
+  const next = pickRoundRobinAccount(plugin.poolKey, eligible, 1) ?? eligible[0] ?? null;
+  if (!next) return null;
+
+  failoverMap.set(session, prior + 1);
+
+  const affinityKey = normalizeAffinityComponent(sessionKey);
+  if (affinityKey && normalizeAffinityComponent(next)) {
+    bindSessionAffinity(plugin.poolKey, affinityKey, next, now);
+  }
+
+  return next;
+}
+
+export function resetPoolFailoverCount(
+  plugin: AccountPoolPlugin,
+  sessionKey: string | null,
+): void {
+  getFailoverMap(plugin.poolKey).delete(failoverKey(sessionKey));
+}

package/src/routing/account-pool/types.ts

@@ -0,0 +1,32 @@
+export const ACCOUNT_POOL_MAX_FAILOVERS = 3;
+
+export type AccountPoolPickReason =
+  | "affinity"
+  | "active"
+  | "lowest-usage"
+  | "round-robin"
+  | "fill-first"
+  | "only-eligible"
+  | "none"
+  | "all-cooled"
+  | "disabled";
+
+export interface AccountPoolPlugin {
+  readonly poolKey: string;
+  sessionKeyFromRequest(input: {
+    sessionIdHeader?: string | null;
+    threadIdHeader?: string | null;
+    clientThreadId?: string | null;
+    promptCacheKey?: string | null;
+    promptCacheKeyIsSharedCohort?: boolean;
+  }): string | null;
+  listEligibleAccountIds(now: number): string[];
+  usageScore?(accountId: string): number;
+}
+
+export interface CooldownRegistry {
+  set(accountId: string, until: number, meta?: { source?: string; reason?: string }): void;
+  get(accountId: string, now?: number): { until: number; reason?: string; source?: string } | null;
+  clear(accountId: string): void;
+  sweep(now?: number): number;
+}

package/src/routing/compatibility/behavior.ts

@@ -148,6 +148,9 @@ export function resolveProductionBehaviorValues(
     "wire.upstreamProtocol": behaviorRow("provider_config", upstreamProtocol),
     "wire.responsesPath": behaviorRow("provider_config", effective.responsesPath ?? null),
     "wire.commandCodeVersion": behaviorRow("provider_config", effective.commandCodeVersion ?? null),
+    ...(adapter === "command-code"
+      ? { "wire.commandCodeProjectContext": behaviorRow("provider_config", effective.projectContext ?? "off") }
+      : {}),
     "wire.modelSuffixMode": behaviorRow(
       "provider_config",
       effective.modelSuffixBracketStrip === true ? "bracket_strip" : "none",

package/src/server/management/oauth-account-routes.ts

@@ -309,19 +309,29 @@ export async function handleOauthAccountRoutes(ctx: ManagementContext): Promise<
     return jsonResponse({ ok: true, provider, activeAccountId: body.accountId });
   }
 
-  // Opt-in Anthropic OAuth account pool (#294): enable/threshold/strategy + clear cooldown.
+  // Opt-in OAuth account pool settings (Anthropic + Cursor).
   if (url.pathname === "/api/oauth/accounts/pool" && req.method === "GET") {
     const provider = (url.searchParams.get("provider") ?? "").trim().toLowerCase();
-    if (provider !== "anthropic") return jsonResponse({ error: "pool config is only supported for anthropic" }, 400);
-    const pool = config.anthropicAccountPool ?? {};
-    return jsonResponse({
-      provider,
-      enabled: pool.enabled === true,
-      autoSwitchThreshold: typeof pool.autoSwitchThreshold === "number" ? pool.autoSwitchThreshold : 80,
-      strategy: normalizeAccountPoolStrategy(pool.strategy),
-      stickyLimit: normalizeAccountPoolStickyLimit(pool.stickyLimit),
-      experimental: true,
-    });
+    if (provider === "anthropic") {
+      const pool = config.anthropicAccountPool ?? {};
+      return jsonResponse({
+        provider,
+        enabled: pool.enabled === true,
+        autoSwitchThreshold: typeof pool.autoSwitchThreshold === "number" ? pool.autoSwitchThreshold : 80,
+        strategy: normalizeAccountPoolStrategy(pool.strategy),
+        stickyLimit: normalizeAccountPoolStickyLimit(pool.stickyLimit),
+        experimental: true,
+      });
+    }
+    if (provider === "cursor") {
+      const pool = config.cursorAccountPool ?? {};
+      return jsonResponse({
+        provider,
+        enabled: pool.enabled === true,
+        experimental: true,
+      });
+    }
+    return jsonResponse({ error: "pool config is only supported for anthropic or cursor" }, 400);
   }
   if (url.pathname === "/api/oauth/accounts/pool" && (req.method === "PUT" || req.method === "PATCH")) {
     const parsedBody = await readManagementJsonBodyOr(req, {});
@@ -336,7 +346,32 @@ export async function handleOauthAccountRoutes(ctx: ManagementContext): Promise<
       stickyLimit?: unknown;
     };
     const provider = typeof body.provider === "string" ? body.provider.trim().toLowerCase() : "";
-    if (provider !== "anthropic") return jsonResponse({ error: "pool config is only supported for anthropic" }, 400);
+    if (provider !== "anthropic" && provider !== "cursor") {
+      return jsonResponse({ error: "pool config is only supported for anthropic or cursor" }, 400);
+    }
+    if (provider === "cursor") {
+      if (
+        body.autoSwitchThreshold !== undefined
+        || body.strategy !== undefined
+        || body.stickyLimit !== undefined
+      ) {
+        return jsonResponse({ error: "cursor pool only supports enabled" }, 400);
+      }
+      let enabled = config.cursorAccountPool?.enabled === true;
+      if (body.enabled !== undefined) {
+        if (typeof body.enabled !== "boolean") return jsonResponse({ error: "enabled must be a boolean" }, 400);
+        enabled = body.enabled;
+      }
+      config.cursorAccountPool = { enabled };
+      saveConfigPreservingClaudeCode(config);
+      reconcileLiveStateStores();
+      return jsonResponse({
+        ok: true,
+        provider,
+        enabled,
+        experimental: true,
+      });
+    }
     let enabled = config.anthropicAccountPool?.enabled === true;
     if (body.enabled !== undefined) {
       if (typeof body.enabled !== "boolean") return jsonResponse({ error: "enabled must be a boolean" }, 400);