@iislee/opencodex 2.11.0 → 2.35.0

package/src/providers/auto-compact-budget.ts

@@ -0,0 +1,65 @@
+import { SUPPORTED_NATIVE_OPENAI_SLUGS } from "../codex/catalog/native-models";
+import { redactSecretString } from "../lib/redact";
+
+const RESERVED_OBJECT_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+function positiveSafeInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+
+/**
+ * Resolve a client-facing soft compaction budget without changing any hard
+ * model limit. Configuration and measured input ceilings may only lower the
+ * default 90% envelope.
+ */
+export function clampAutoCompactTokenLimit(
+  contextWindow: number,
+  maxInputTokens?: number,
+  configuredLimit?: number,
+): number {
+  const candidates = [Math.floor(contextWindow * 0.9), contextWindow];
+  if (positiveSafeInteger(maxInputTokens)) candidates.push(maxInputTokens);
+  if (positiveSafeInteger(configuredLimit)) candidates.push(configuredLimit);
+  return Math.min(...candidates);
+}
+
+export type AutoCompactBudgetValidationOptions = Readonly<{
+  /** PATCH accepts null for whole-map and per-key deletion. */
+  allowTombstones?: boolean;
+  /** The canonical ChatGPT provider accepts only exact supported native ids. */
+  requireNativeIds?: boolean;
+}>;
+
+/** Shared config/load/management boundary for per-model soft budgets. */
+export function modelAutoCompactTokenLimitsConfigError(
+  value: unknown,
+  options: AutoCompactBudgetValidationOptions = {},
+): string | null {
+  const field = "modelAutoCompactTokenLimits";
+  if (value === undefined || (options.allowTombstones && value === null)) return null;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return `${field} must be a plain object${options.allowTombstones ? " or null" : ""}`;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    return `${field} must be a plain object with own properties`;
+  }
+  for (const [modelId, entry] of Object.entries(value as Record<string, unknown>)) {
+    const safeModelId = JSON.stringify(redactSecretString(modelId));
+    if (!modelId.trim()) return `${field} keys must be nonblank model ids`;
+    if (RESERVED_OBJECT_KEYS.has(modelId)) {
+      return `${field} key ${safeModelId} is reserved`;
+    }
+    if (options.requireNativeIds
+      && (modelId.includes("/") || !SUPPORTED_NATIVE_OPENAI_SLUGS.has(modelId))) {
+      return `${field} key ${safeModelId} must be an exact supported native model id`;
+    }
+    if (options.allowTombstones && entry === null) continue;
+    if (!positiveSafeInteger(entry)) {
+      return `${field}[${safeModelId}] must be a positive safe integer${
+        options.allowTombstones ? " or null" : ""
+      }`;
+    }
+  }
+  return null;
+}

package/src/providers/base-url-choices.ts

@@ -62,3 +62,13 @@ export function matchBaseUrlChoice(
   }
   return choices.some(c => c.id === "custom") ? "custom" : choices[0]!.id;
 }
+
+/** Moonshot/Kimi API endpoint presets (international default; China selectable). */
+export const MOONSHOT_INTL_BASE_URL = "https://api.moonshot.ai/v1";
+export const MOONSHOT_CN_BASE_URL = "https://api.moonshot.cn/v1";
+
+export const MOONSHOT_BASE_URL_CHOICES: readonly ProviderBaseUrlChoice[] = [
+  { id: "international", label: "International (.ai)", baseUrl: MOONSHOT_INTL_BASE_URL },
+  { id: "china", label: "China (.cn)", baseUrl: MOONSHOT_CN_BASE_URL },
+  { id: "custom", label: "Custom" },
+];

package/src/providers/codex-capacity.ts

@@ -0,0 +1,292 @@
+import { codexPlanKey, codexPlanValue } from "../codex/plan";
+
+export const CODEX_CONFIGURED_CAPACITY_WEIGHTS = {
+  plus: 1,
+  team: 1,
+  business: 1,
+  prolite: 5,
+  pro: 20,
+} as const;
+
+/** Match the provider-report last-good freshness bound. */
+export const CODEX_CAPACITY_MAX_QUOTA_AGE_MS = 30 * 60_000;
+
+export type CodexCapacityQuota = {
+  fiveHourPercent?: number;
+  fiveHourResetAt?: number;
+  weeklyPercent?: number;
+  weeklyResetAt?: number;
+  monthlyPercent?: number;
+  monthlyResetAt?: number;
+  customWindows?: Array<{ label: string; percent: number; resetAt?: number }>;
+  updatedAt: number;
+};
+
+export interface CodexCapacityAccount {
+  isMain: boolean;
+  active?: boolean;
+  plan?: unknown;
+  paused: boolean;
+  needsReauth?: boolean;
+  quota: CodexCapacityQuota | null;
+}
+
+export interface CodexCapacityWindowAggregation {
+  usedPercent: number;
+  includedAccounts: number;
+  excludedAccounts: number;
+  incomplete: boolean;
+  /** Internal calculation evidence; stripped from the management API response. */
+  totalWeight?: number;
+  /** Internal calculation evidence; stripped from the management API response. */
+  consumedWeight?: number;
+  /** Internal calculation evidence; stripped from the management API response. */
+  remainingWeight?: number;
+  updatedAt: number;
+  nextRecoveryAt?: number;
+  nextRecoveryPercent?: number;
+}
+
+export interface CodexCapacityAggregation {
+  kind: "capacity-weighted-v1";
+  scope: "routable-known";
+  includedAccounts: number;
+  excludedAccounts: number;
+  unknownPlanAccounts: number;
+  missingQuotaAccounts: number;
+  pausedAccounts: number;
+  reauthAccounts: number;
+  staleQuotaAccounts: number;
+  partialWindowAccounts: number;
+  incomplete: boolean;
+  presentation?: "aggregate" | "effective-account-fallback" | "coverage-only";
+  fiveHour?: CodexCapacityWindowAggregation;
+  weekly?: CodexCapacityWindowAggregation;
+  monthly?: CodexCapacityWindowAggregation;
+  customWindows?: Array<CodexCapacityWindowAggregation & { label: string }>;
+  currentAccount?: {
+    isMain: boolean;
+    plan?: string | null;
+    quota: CodexCapacityQuota | null;
+  };
+}
+
+export interface CodexCapacityResult {
+  quota: CodexCapacityQuota | null;
+  aggregation: CodexCapacityAggregation | null;
+  currentAccount?: CodexCapacityAggregation["currentAccount"];
+}
+
+type MutableWindow = {
+  totalWeight: number;
+  consumedWeight: number;
+  includedAccounts: number;
+  recoveries: Map<number, number>;
+  oldestUpdatedAt: number;
+};
+
+function configuredWeight(plan: unknown): number | undefined {
+  const normalized = codexPlanKey(plan);
+  return normalized && Object.hasOwn(CODEX_CONFIGURED_CAPACITY_WEIGHTS, normalized)
+    ? CODEX_CONFIGURED_CAPACITY_WEIGHTS[normalized as keyof typeof CODEX_CONFIGURED_CAPACITY_WEIGHTS]
+    : undefined;
+}
+
+function normalizedPercent(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value)
+    ? Math.max(0, Math.min(100, value))
+    : undefined;
+}
+
+function futureResetMs(value: unknown, now: number): number | undefined {
+  if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
+  const milliseconds = value > 10_000_000_000 ? value : value * 1000;
+  return milliseconds > now ? milliseconds : undefined;
+}
+
+function hasKnownQuotaWindow(quota: CodexCapacityQuota | null): quota is CodexCapacityQuota {
+  if (!quota) return false;
+  return normalizedPercent(quota.fiveHourPercent) !== undefined
+    || normalizedPercent(quota.weeklyPercent) !== undefined
+    || normalizedPercent(quota.monthlyPercent) !== undefined
+    || !!quota.customWindows?.some(window => normalizedPercent(window.percent) !== undefined);
+}
+
+function currentQuotaForDisplay(account: CodexCapacityAccount, now: number): CodexCapacityQuota | null {
+  const quota = account.quota;
+  const fresh = !!quota
+    && Number.isFinite(quota.updatedAt)
+    && now - quota.updatedAt <= CODEX_CAPACITY_MAX_QUOTA_AGE_MS;
+  return !account.paused && !account.needsReauth && fresh && hasKnownQuotaWindow(quota) ? quota : null;
+}
+
+function addWindow(
+  windows: Map<string, MutableWindow>,
+  key: string,
+  weight: number,
+  percent: number,
+  resetAt: number | undefined,
+  updatedAt: number,
+): void {
+  const window = windows.get(key) ?? {
+    totalWeight: 0,
+    consumedWeight: 0,
+    includedAccounts: 0,
+    recoveries: new Map<number, number>(),
+    oldestUpdatedAt: updatedAt,
+  };
+  const consumed = weight * percent / 100;
+  window.totalWeight += weight;
+  window.consumedWeight += consumed;
+  window.includedAccounts += 1;
+  window.oldestUpdatedAt = Math.min(window.oldestUpdatedAt, updatedAt);
+  if (resetAt !== undefined && consumed > 0) {
+    window.recoveries.set(resetAt, (window.recoveries.get(resetAt) ?? 0) + consumed);
+  }
+  windows.set(key, window);
+}
+
+function finalizeWindow(window: MutableWindow, totalAccounts: number): CodexCapacityWindowAggregation {
+  const nextRecoveryAt = [...window.recoveries.keys()].sort((a, b) => a - b)[0];
+  const recovered = nextRecoveryAt === undefined ? undefined : window.recoveries.get(nextRecoveryAt);
+  return {
+    usedPercent: window.consumedWeight / window.totalWeight * 100,
+    includedAccounts: window.includedAccounts,
+    excludedAccounts: totalAccounts - window.includedAccounts,
+    incomplete: window.includedAccounts < totalAccounts,
+    totalWeight: window.totalWeight,
+    consumedWeight: window.consumedWeight,
+    remainingWeight: window.totalWeight - window.consumedWeight,
+    updatedAt: window.oldestUpdatedAt,
+    ...(nextRecoveryAt !== undefined ? { nextRecoveryAt } : {}),
+    ...(recovered !== undefined ? { nextRecoveryPercent: recovered / window.totalWeight * 100 } : {}),
+  };
+}
+
+/** Display-only configured-weight estimate. It never participates in account selection or routing. */
+export function aggregateCodexPoolCapacity(
+  accounts: readonly CodexCapacityAccount[],
+  now = Date.now(),
+): CodexCapacityResult {
+  const current = accounts.find(account => account.active)
+    ?? accounts.find(account => account.isMain)
+    ?? accounts[0];
+  const currentPlan = codexPlanValue(current?.plan);
+  const currentAccount = current ? {
+    isMain: current.isMain,
+    ...(currentPlan !== undefined ? { plan: currentPlan } : {}),
+    quota: currentQuotaForDisplay(current, now),
+  } : undefined;
+  const windows = new Map<string, MutableWindow>();
+  const included = new Set<CodexCapacityAccount>();
+  const contributions = new Map<CodexCapacityAccount, Set<string>>();
+  let unknownPlanAccounts = 0;
+  let missingQuotaAccounts = 0;
+  let pausedAccounts = 0;
+  let reauthAccounts = 0;
+  let staleQuotaAccounts = 0;
+
+  for (const account of accounts) {
+    const weight = configuredWeight(account.plan);
+    if (weight === undefined) unknownPlanAccounts += 1;
+    if (account.paused) pausedAccounts += 1;
+    if (account.needsReauth) reauthAccounts += 1;
+    const quota = account.quota;
+    const quotaFresh = !!quota
+      && Number.isFinite(quota.updatedAt)
+      && now - quota.updatedAt <= CODEX_CAPACITY_MAX_QUOTA_AGE_MS;
+    if (quota && !quotaFresh) staleQuotaAccounts += 1;
+    const standard = quota ? [
+      ["fiveHour", quota.fiveHourPercent, quota.fiveHourResetAt],
+      ["weekly", quota.weeklyPercent, quota.weeklyResetAt],
+      ["monthly", quota.monthlyPercent, quota.monthlyResetAt],
+    ] as const : [];
+    const custom = quota?.customWindows ?? [];
+    const hasQuota = hasKnownQuotaWindow(quota);
+    if (!hasQuota) missingQuotaAccounts += 1;
+    if (account.paused || account.needsReauth || weight === undefined || !quota || !hasQuota || !quotaFresh) continue;
+
+    let contributed = false;
+    const contributionKeys = new Set<string>();
+    for (const [key, rawPercent, rawReset] of standard) {
+      const percent = normalizedPercent(rawPercent);
+      if (percent === undefined) continue;
+      addWindow(windows, key, weight, percent, futureResetMs(rawReset, now), quota.updatedAt);
+      contributionKeys.add(key);
+      contributed = true;
+    }
+    for (const customWindow of custom) {
+      const percent = normalizedPercent(customWindow.percent);
+      if (percent === undefined) continue;
+      addWindow(windows, `custom:${customWindow.label}`, weight, percent, futureResetMs(customWindow.resetAt, now), quota.updatedAt);
+      contributionKeys.add(`custom:${customWindow.label}`);
+      contributed = true;
+    }
+    if (contributed) {
+      included.add(account);
+      contributions.set(account, contributionKeys);
+    }
+  }
+
+  if (windows.size === 0) {
+    if (accounts.length === 0) return { quota: null, aggregation: null, ...(currentAccount ? { currentAccount } : {}) };
+    const aggregation: CodexCapacityAggregation = {
+      kind: "capacity-weighted-v1",
+      scope: "routable-known",
+      includedAccounts: 0,
+      excludedAccounts: accounts.length,
+      unknownPlanAccounts,
+      missingQuotaAccounts,
+      pausedAccounts,
+      reauthAccounts,
+      staleQuotaAccounts,
+      partialWindowAccounts: 0,
+      incomplete: true,
+      ...(currentAccount ? { currentAccount } : {}),
+    };
+    return { quota: null, aggregation, ...(currentAccount ? { currentAccount } : {}) };
+  }
+  const fiveHour = windows.get("fiveHour") ? finalizeWindow(windows.get("fiveHour")!, accounts.length) : undefined;
+  const weekly = windows.get("weekly") ? finalizeWindow(windows.get("weekly")!, accounts.length) : undefined;
+  const monthly = windows.get("monthly") ? finalizeWindow(windows.get("monthly")!, accounts.length) : undefined;
+  const customWindows = [...windows.entries()].flatMap(([key, window]) => key.startsWith("custom:")
+    ? [{ label: key.slice("custom:".length), ...finalizeWindow(window, accounts.length) }]
+    : []);
+  const quota: CodexCapacityQuota = {
+    ...(fiveHour ? { fiveHourPercent: fiveHour.usedPercent } : {}),
+    ...(weekly ? { weeklyPercent: weekly.usedPercent } : {}),
+    ...(monthly ? { monthlyPercent: monthly.usedPercent } : {}),
+    ...(customWindows.length > 0 ? {
+      customWindows: customWindows.map(window => ({ label: window.label, percent: window.usedPercent })),
+    } : {}),
+    updatedAt: Math.min(
+      ...[fiveHour, weekly, monthly, ...customWindows]
+        .flatMap(window => window ? [window.updatedAt] : []),
+    ),
+  };
+  const visibleWindowKeys = [...windows.keys()];
+  const partialWindowAccounts = accounts.filter(account => {
+    const keys = contributions.get(account);
+    return !!keys && visibleWindowKeys.some(key => !keys.has(key));
+  }).length;
+  const excludedAccounts = accounts.length - included.size;
+  const aggregation: CodexCapacityAggregation = {
+    kind: "capacity-weighted-v1",
+    scope: "routable-known",
+    includedAccounts: included.size,
+    excludedAccounts,
+    unknownPlanAccounts,
+    missingQuotaAccounts,
+    pausedAccounts,
+    reauthAccounts,
+    staleQuotaAccounts,
+    partialWindowAccounts,
+    incomplete: excludedAccounts > 0 || partialWindowAccounts > 0,
+    ...(fiveHour ? { fiveHour } : {}),
+    ...(weekly ? { weekly } : {}),
+    ...(monthly ? { monthly } : {}),
+    ...(customWindows.length > 0 ? { customWindows } : {}),
+    ...(currentAccount ? { currentAccount } : {}),
+  };
+  return { quota, aggregation, ...(currentAccount ? { currentAccount } : {}) };
+}

package/src/providers/command-code-efforts.ts

@@ -0,0 +1,176 @@
+import { readBoundedResponseBody } from "../lib/bounded-body";
+
+const COMMAND_CODE_MODEL_EFFORTS = {
+  "deepseek/deepseek-v4-pro": {
+    efforts: ["high", "max"],
+    profileUrl: "https://commandcode.ai/models/deepseek-v4-pro",
+  },
+  "deepseek/deepseek-v4-flash": {
+    efforts: ["high", "max"],
+    profileUrl: "https://commandcode.ai/models/deepseek-v4-flash",
+  },
+  /*
+   * Three live routes that reached the catalog without an effort ladder (#2647).
+   * Without a row here the model advertises no efforts at all, so a client that
+   * sends one gets it stripped or rejected rather than honored.
+   *
+   * PROVENANCE, stated plainly: these three ladders are the reporter's
+   * (darwintree, #2647), recorded as reported and NOT independently verified.
+   * All three profileUrls return HTTP 200, but commandcode.ai renders these
+   * pages client-side and ships the ladder inside a serialized React payload
+   * whose `reasoningEfforts` array is EMPTY in the delivered HTML. There is no
+   * fetchable statement of these ladders to check them against.
+   *
+   * Do not assume the refresh path launders this. It does not:
+   * `parsedProfileEfforts` below matches prose of the form
+   * "Reasoning efforts ... are supported;", and `grep -c -i 'reasoning efforts'`
+   * against the live pages returns 0 — for these three AND for the older rows
+   * (deepseek-v4-pro, GLM-5.3, muse-spark-1.2 all measured 0 on 2026-08-27).
+   * So `refreshCommandCodeReasoningEfforts` returns undefined and the caller
+   * keeps whatever is written here, indefinitely. The self-correction mechanism
+   * is currently dead for EVERY row in this table, which is a pre-existing
+   * defect worth its own fix (teach the parser to read the embedded payload),
+   * not something these three rows introduced.
+   *
+   * The practical consequence: a wrong ladder here stays wrong until a human
+   * changes it. It degrades safely — an effort the upstream rejects surfaces as
+   * an error rather than silent corruption — but it does not self-heal.
+   */
+  "deepseek/deepseek-v4-flash-vision-exp": {
+    efforts: ["high", "max"],
+    profileUrl: "https://commandcode.ai/models/deepseek-v4-flash-vision-exp",
+  },
+  "gpt-5.6-luna": {
+    efforts: ["low", "medium", "high", "xhigh", "max"],
+    profileUrl: "https://commandcode.ai/models/gpt-5-6-luna",
+  },
+  "google/gemini-3.7-flash": {
+    efforts: ["low", "medium", "high"],
+    profileUrl: "https://commandcode.ai/models/gemini-3-7-flash",
+  },
+  // Keys must match the EXACT upstream /provider/v1/models ids (GLM ships as
+  // `zai-org/GLM-5.3`, not `zai-org/glm-5.3`). The table doubles as the router's
+  // known-ids decode source (via `knownModelIdsForProvider`), so a case mismatch
+  // makes the Codex-facing slug `commandcode/zai-org-GLM-5.3` pass through
+  // undecoded and upstream rejects it with `unsupported_model`.
+  "zai-org/GLM-5": {
+    efforts: ["high", "max"],
+    profileUrl: "https://commandcode.ai/models/glm-5",
+  },
+  "zai-org/GLM-5.1": {
+    efforts: ["high", "max"],
+    profileUrl: "https://commandcode.ai/models/glm-5-1",
+  },
+  "zai-org/GLM-5.2": {
+    efforts: ["high", "max"],
+    profileUrl: "https://commandcode.ai/models/glm-5-2",
+  },
+  "zai-org/GLM-5.2-Fast": {
+    efforts: ["high", "max"],
+    profileUrl: "https://commandcode.ai/models/glm-5-2-fast",
+  },
+  "zai-org/GLM-5.3": {
+    efforts: ["low", "high", "max"],
+    profileUrl: "https://commandcode.ai/models/glm-5-3",
+  },
+  // Muse Spark: CLI currently prints "has no adjustable reasoning effort" and
+  // blocks --effort locally, but the upstream /alpha/generate endpoint accepts
+  // reasoning_effort low..max for meta/muse-spark-1.2-contributor (verified
+  // 2026-08-13: direct upstream POST with low/medium/high/xhigh/max all 200,
+  // ultra 400; reasoningTokens differentiated 114..253; proxy previously stripped
+  // the field so effort changes had no effect).
+  "meta/muse-spark-1.2": {
+    efforts: ["low", "medium", "high", "xhigh", "max"],
+    profileUrl: "https://commandcode.ai/models/meta-muse-spark-1.2",
+  },
+  "meta/muse-spark-1.2-contributor": {
+    efforts: ["low", "medium", "high", "xhigh", "max"],
+    profileUrl: "https://commandcode.ai/models/meta-muse-spark-1.2-contributor",
+  },
+  "meta/muse-spark-1.1": {
+    efforts: ["low", "medium", "high", "xhigh", "max"],
+    profileUrl: "https://commandcode.ai/models/meta-muse-spark-1.1",
+  },
+} as const;
+
+/**
+ * Official Command Code model-profile facts, not a model catalog. Models remain
+ * account-scoped and come exclusively from the authenticated /provider/v1/models endpoint.
+ */
+export const COMMAND_CODE_MODEL_REASONING_EFFORTS: Record<string, string[]> = Object.fromEntries(
+  Object.entries(COMMAND_CODE_MODEL_EFFORTS).map(([id, row]) => [id, [...row.efforts]]),
+);
+
+const refreshedEfforts = new Map<string, string[]>();
+
+function keyFor(modelId: string): string {
+  return modelId.trim().toLowerCase();
+}
+
+export function commandCodeReasoningEfforts(modelId: string): readonly string[] | undefined {
+  const key = keyFor(modelId);
+  const refreshed = refreshedEfforts.get(key);
+  if (refreshed !== undefined) return refreshed;
+  // Case-insensitive: the table keys match the EXACT upstream ids (e.g. `zai-org/GLM-5.3`),
+  // but callers may pass either case.
+  for (const [id, efforts] of Object.entries(COMMAND_CODE_MODEL_REASONING_EFFORTS)) {
+    if (keyFor(id) === key) return efforts;
+  }
+  return undefined;
+}
+
+function parsedProfileEfforts(page: string): string[] | undefined {
+  const match = page.match(/Reasoning efforts\s+([^.;]+?)\s+are supported;\s*([^.]*)/i);
+  if (!match) return undefined;
+  const listed = match[1]!.toLowerCase().match(/\b(?:low|medium|high|xhigh|max)\b/g) ?? [];
+  const mapped = match[2]!.toLowerCase().match(/\b(?:low|medium|high|xhigh|max)\s+maps to\s+(?:low|medium|high|xhigh|max)\b/g) ?? [];
+  const normalized = new Set(listed);
+  for (const mapping of mapped) {
+    const [, source, target] = mapping.match(/(low|medium|high|xhigh|max)\s+maps to\s+(low|medium|high|xhigh|max)/) ?? [];
+    if (source && target) {
+      normalized.delete(source);
+      normalized.add(target);
+    }
+  }
+  return normalized.size > 0 ? [...normalized] : [];
+}
+
+/**
+ * Refresh one stale effort record only after the upstream rejects an effort request.
+ * A failed or unparseable public profile deliberately leaves the known table unchanged.
+ */
+export async function refreshCommandCodeReasoningEfforts(
+  modelId: string,
+  fetchFn: typeof globalThis.fetch = globalThis.fetch,
+): Promise<readonly string[] | undefined> {
+  const key = keyFor(modelId);
+  let profile: { efforts: readonly string[]; profileUrl: string } | undefined;
+  for (const [id, row] of Object.entries(COMMAND_CODE_MODEL_EFFORTS)) {
+    if (keyFor(id) === key) {
+      profile = row;
+      break;
+    }
+  }
+  if (!profile) return undefined;
+  try {
+    const response = await fetchFn(profile.profileUrl, {
+      headers: { Accept: "text/html" },
+      signal: AbortSignal.timeout(10_000),
+    });
+    if (!response.ok) return undefined;
+    // Bound the profile page before parsing: a large or malformed page must not
+    // allocate unbounded memory on the request path.
+    const observed = await readBoundedResponseBody(response, { maxBytes: 256 * 1024 });
+    if (!observed.displaySafe) return undefined;
+    const efforts = parsedProfileEfforts(observed.text);
+    if (efforts === undefined) return undefined;
+    refreshedEfforts.set(key, efforts);
+    return efforts;
+  } catch {
+    return undefined;
+  }
+}
+
+export function resetCommandCodeReasoningEffortsForTest(): void {
+  refreshedEfforts.clear();
+}

package/src/providers/context-cap.ts

@@ -1,4 +1,5 @@
 import type { OcxConfig } from "../types";
+import { deleteConfigTopLevelKey } from "../config/rebase-provenance";
 
 export const DEFAULT_PROVIDER_CONTEXT_CAP = 350_000;
 
@@ -27,25 +28,42 @@ export function applyProviderContextCap(contextWindow: number | undefined, cap:
   return contextWindow > cap ? cap : contextWindow;
 }
 
+/**
+ * 上游没报窗口时，已开启的 Context cap 就是实际窗口。
+ * 128k 只是 Codex 解析器的兼容底线，不能当成“已发现窗口”再拿去和 cap 做 min。
+ */
+export function resolveUnknownRoutedContextWindow(cap: number | undefined): number {
+  const window = isValidContextCap(cap) ? Math.floor(cap) : 0;
+  return window > 0 ? window : 128_000;
+}
+
 /** Effective global cap value: explicit config value, else the built-in default. */
 export function globalContextCapValue(config: Pick<OcxConfig, "contextCapValue">): number {
   const value = config.contextCapValue;
   return isValidContextCap(value) ? Math.floor(value) : DEFAULT_PROVIDER_CONTEXT_CAP;
 }
 
-export function setProviderContextCap(config: OcxConfig, provider: string, enabled: boolean): void {
+export function setProviderContextCap(config: OcxConfig, provider: string, enabled: boolean, value?: number): void {
   const next = providerContextCaps(config);
-  if (enabled) next[provider] = globalContextCapValue(config);
-  else delete next[provider];
+  if (enabled) {
+    next[provider] = isValidContextCap(value) ? Math.floor(value) : globalContextCapValue(config);
+  } else {
+    delete next[provider];
+  }
   if (Object.keys(next).length > 0) config.providerContextCaps = next;
-  else delete config.providerContextCaps;
+  else deleteConfigTopLevelKey(config, "providerContextCaps");
 }
 
-/** Set the global cap value and re-point every already-enabled provider to it. */
-export function setGlobalContextCapValue(config: OcxConfig, value: number): void {
+/**
+ * Set the global cap value (the default used by per-provider toggles and "set all").
+ * Re-points every already-enabled provider only when `applyToAll` is true (the dashboard's
+ * "apply to every routed provider" toggle); otherwise each provider keeps its own cap value.
+ */
+export function setGlobalContextCapValue(config: OcxConfig, value: number, applyToAll: boolean): void {
   if (!isValidContextCap(value)) return;
   const next = Math.floor(value);
   config.contextCapValue = next;
+  if (!applyToAll) return;
   const caps = providerContextCaps(config);
   for (const provider of Object.keys(caps)) caps[provider] = next;
   if (Object.keys(caps).length > 0) config.providerContextCaps = caps;
@@ -54,12 +72,12 @@ export function setGlobalContextCapValue(config: OcxConfig, value: number): void
 /** Enable the cap for every named provider at the current value, or clear all caps. */
 export function setAllProviderContextCaps(config: OcxConfig, providerNames: string[], enabled: boolean): void {
   if (!enabled) {
-    delete config.providerContextCaps;
+    deleteConfigTopLevelKey(config, "providerContextCaps");
     return;
   }
   const value = globalContextCapValue(config);
   const next: Record<string, number> = {};
   for (const name of providerNames) next[name] = value;
   if (Object.keys(next).length > 0) config.providerContextCaps = next;
-  else delete config.providerContextCaps;
+  else deleteConfigTopLevelKey(config, "providerContextCaps");
 }