@bitkyc08/opencodex 2.40.0 → 2.41.0

package/src/server/index.ts

@@ -227,6 +227,9 @@ import { detectInstall } from "../update/index";
 import { readyProtocolMetadata } from "../remote/protocol";
 import { modelCapabilityFields } from "./models-capabilities";
 import { recordCursorSeen } from "../integrations/cursor-seen";
+import { detectCursorInstalls } from "../integrations/cursor-detect";
+import { loadCursorEffortTable } from "../integrations/cursor-effort-table";
+import { expandCursorEffortRow, knownEffortRowIds } from "./effort-row";
 
 export const MAX_WS_FRAME_BYTES = 50 * 1024 * 1024;
 const WEBSOCKET_IDLE_TIMEOUT_SECONDS = 0;
@@ -1354,7 +1357,7 @@ export function startServer(port?: number, deps: StartServerDeps = {}): Server<W
           }
           throw error;
         }
-        const { accountBoundNativeOpenAiSlugsBySelector, applyNativeVisibility, buildCatalogEntries, configuredNativeAliasSlugs, desktopAllowlistSuppressedNativeSlugs, disabledNativeSlugs, exactComboCatalogSlugs, loadCatalogTemplate, NATIVE_OPENAI_MODELS, nativeContextLimits, nativeInputModalities, nativeOpenAiContextWindow, nativeOpenAiContextTier, nativeOpenAiSlugs, nativeReasoningEfforts, nativeDefaultReasoningEffort, orderForSubagents, filterCatalogVisibleModels, shouldIncludeAccountBoundNativeOpenAi, shouldIncludeNativeOpenAi, uniqueCatalogModelsForRawPublicList, visibleCodexAccountSelectors, visibleNativeSlugs, desktopVisibleNativeSlugs } = await import("../codex/catalog");
+        const { accountBoundNativeOpenAiSlugsBySelector, applyNativeVisibility, buildCatalogEntries, configuredNativeAliasSlugs, desktopAllowlistSuppressedNativeSlugs, disabledNativeSlugs, exactComboCatalogSlugs, loadCatalogTemplate, NATIVE_OPENAI_MODELS, nativeContextLimits, nativeInputModalities, nativeOpenAiContextWindow, nativeOpenAiMaxOutputTokens, nativeOpenAiContextTier, nativeOpenAiSlugs, nativeReasoningEfforts, nativeDefaultReasoningEffort, orderForSubagents, filterCatalogVisibleModels, shouldIncludeAccountBoundNativeOpenAi, shouldIncludeNativeOpenAi, uniqueCatalogModelsForRawPublicList, visibleCodexAccountSelectors, visibleNativeSlugs, desktopVisibleNativeSlugs } = await import("../codex/catalog");
         const { ACCOUNT_GATED_NATIVE_OPENAI_MODELS } = await import("../codex/catalog/native-models");
         const includeNativeOpenAi = shouldIncludeNativeOpenAi(config);
         const includeAccountBoundNativeOpenAi = shouldIncludeAccountBoundNativeOpenAi(config);
@@ -1533,6 +1536,7 @@ export function startServer(port?: number, deps: StartServerDeps = {}): Server<W
               // GPT-5.6) so the client can pick per request; without a tier, the effective
               // window is the only value.
               ...nativeContextInput(metadataId),
+              maxOutputTokens: nativeOpenAiMaxOutputTokens(metadataId),
               inputModalities: nativeInputModalities(metadataId),
             }),
           });
@@ -1565,44 +1569,69 @@ export function startServer(port?: number, deps: StartServerDeps = {}): Server<W
             return disabledModels.has(id) ? [] : [{ id, metadataId }];
           })
         );
+        // The projection is opt-in. Keep the default path free of Cursor install detection,
+        // and resolve the bundle table once for the whole list rather than once per row.
+        const effortRowsEnabled = config.cursorEffortRows === true;
+        const effortRowKnownIds = effortRowsEnabled ? knownEffortRowIds(config) : undefined;
+        const privateInference = effortRowsEnabled
+          ? detectCursorInstalls().find(install => install.build === "private-inference")
+          : undefined;
+        const cursorEffortTable = effortRowsEnabled
+          ? (deps.managementApi?.loadCursorEffortTable ?? loadCursorEffortTable)(privateInference)
+          : null;
+        const expandedNativeModelRow = (id: string, metadataId = id) => {
+          const reasoningEfforts = nativeReasoningEfforts(metadataId);
+          return expandCursorEffortRow(nativeModelRow(id, metadataId), reasoningEfforts, config, {
+            knownIds: effortRowKnownIds,
+            table: cursorEffortTable,
+            supportsReasoning: reasoningEfforts.length > 0,
+          });
+        };
+        const routedRows = await Promise.all(uniqueCatalogModelsForRawPublicList(goOrdered).map(async m => {
+          // Same rule as the anthropic branch: with the global fast switch on, a client
+          // that has no Fast toggle is offered the fast identity directly. An operator
+          // alias is an explicit decision and still wins.
+          const fastModelId = cursorFastIdForListing?.(m.id, m.provider);
+          const publicId = m.alias ?? `${m.provider}/${fastModelId ?? m.id}`;
+          const isCombo = m.provider === "combo" && exactComboSlugs.has(publicId);
+          const provider = config.providers[m.provider];
+          const effective = provider
+            ? (await import("../providers/default-aliases")).effectiveModelAliases(
+                config,
+                provider,
+                knownModelIdsForProvider(m.provider, provider, config),
+              ).get(m.id)
+            : undefined;
+          const row = {
+            id: publicId,
+            object: "model",
+            created: 0,
+            // This endpoint is an OpenAI-compatible inbound contract. Some clients use
+            // owned_by as an adapter selector, so a virtual combo must name that wire
+            // adapter rather than the internal catalog authority marker.
+            owned_by: isCombo ? "openai" : (m.owned_by ?? m.provider),
+            ...(isCombo ? { is_combo: true } : {}),
+            ...(effective ? { alias_of: `${provider?.alias || m.provider}/${effective.alias}` } : {}),
+            ...grokEffortFields(m.reasoningEfforts ?? [], m.defaultReasoningEffort),
+            ...modelCapabilityFields({
+              reasoningEfforts: m.reasoningEfforts,
+              // contextWindow is already the post-cap effective value; contextCap is the raw
+              // operator knob and over-reports models whose real window sits below it.
+              contextWindow: m.contextWindow,
+              maxOutputTokens: m.maxOutputTokens,
+              inputModalities: m.inputModalities,
+            }),
+          };
+          return expandCursorEffortRow(row, m.reasoningEfforts, config, {
+            knownIds: effortRowKnownIds,
+            table: cursorEffortTable,
+            supportsReasoning: (m.reasoningEfforts ?? []).length > 0,
+          });
+        }));
         const data = [
-          ...visibleNatives.map(id => nativeModelRow(id)),
-          ...visibleAccountNatives.map(({ id, metadataId }) => nativeModelRow(id, metadataId)),
-          ...await Promise.all(uniqueCatalogModelsForRawPublicList(goOrdered).map(async m => {
-            // Same rule as the anthropic branch: with the global fast switch on, a client
-            // that has no Fast toggle is offered the fast identity directly. An operator
-            // alias is an explicit decision and still wins.
-            const fastModelId = cursorFastIdForListing?.(m.id, m.provider);
-            const publicId = m.alias ?? `${m.provider}/${fastModelId ?? m.id}`;
-            const isCombo = m.provider === "combo" && exactComboSlugs.has(publicId);
-            const provider = config.providers[m.provider];
-            const effective = provider
-              ? (await import("../providers/default-aliases")).effectiveModelAliases(
-                  config,
-                  provider,
-                  knownModelIdsForProvider(m.provider, provider, config),
-                ).get(m.id)
-              : undefined;
-            return {
-              id: publicId,
-              object: "model",
-              created: 0,
-              // This endpoint is an OpenAI-compatible inbound contract. Some clients use
-              // owned_by as an adapter selector, so a virtual combo must name that wire
-              // adapter rather than the internal catalog authority marker.
-              owned_by: isCombo ? "openai" : (m.owned_by ?? m.provider),
-              ...(isCombo ? { is_combo: true } : {}),
-              ...(effective ? { alias_of: `${provider?.alias || m.provider}/${effective.alias}` } : {}),
-              ...grokEffortFields(m.reasoningEfforts ?? [], m.defaultReasoningEffort),
-              ...modelCapabilityFields({
-                reasoningEfforts: m.reasoningEfforts,
-                // contextWindow is already the post-cap effective value; contextCap is the raw
-                // operator knob and over-reports models whose real window sits below it.
-                contextWindow: m.contextWindow,
-                inputModalities: m.inputModalities,
-              }),
-            };
-          })),
+          ...visibleNatives.flatMap(id => expandedNativeModelRow(id)),
+          ...visibleAccountNatives.flatMap(({ id, metadataId }) => expandedNativeModelRow(id, metadataId)),
+          ...routedRows.flat(),
         ];
         return jsonResponse({ object: "list", data }, 200, req, policy);
       }

package/src/server/management/api-key-rotation.ts

@@ -7,6 +7,7 @@ export type ApiKeyRotationStart = {
   id: string;
   name: string;
   key: string;
+  createdAt: string;
   rotationId: string;
   expiresAt: string;
 };
@@ -44,7 +45,7 @@ export function startApiKeyRotation(
   const createdAt = new Date(now).toISOString();
   const expiresAt = new Date(now + API_KEY_ROTATION_TTL_MS).toISOString();
   entry.pendingRotation = { id: rotationId, key, createdAt, expiresAt };
-  return { id: entry.id, name: entry.name, key, rotationId, expiresAt };
+  return { id: entry.id, name: entry.name, key, createdAt, rotationId, expiresAt };
 }
 
 export function commitApiKeyRotation(

package/src/server/management/api-key-usage.ts

@@ -1,9 +1,9 @@
 import {
   currentUsageLogRevision,
-  readUsageSnapshotForManagement,
   usageLogIdentityKey,
   type PersistedUsageEntry,
 } from "../../usage/log";
+import { scanUsageLedgerCooperatively } from "../../usage/ledger-scanner";
 
 /**
  * Per-key usage as the API tab renders it.
@@ -29,6 +29,11 @@ export interface ApiKeyUsageSnapshot {
   attributionSince?: string;
 }
 
+export interface ApiKeyUsageAccumulator {
+  add(entry: PersistedUsageEntry): void;
+  snapshot(): ApiKeyUsageSnapshot;
+}
+
 const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
 
 /**
@@ -58,6 +63,21 @@ export function rollupApiKeyUsage(
   configuredIds: string[],
   now: number = Date.now(),
 ): ApiKeyUsageSnapshot {
+  const accumulator = createApiKeyUsageAccumulator(configuredIds, now);
+  for (const entry of entries) accumulator.add(entry);
+  return accumulator.snapshot();
+}
+
+/**
+ * Constant-memory fold for API-key attribution while the usage ledger streams.
+ *
+ * Only configured IDs are retained, so a hand-edited ledger containing an
+ * unbounded set of arbitrary `apiKeyId` values cannot grow this accumulator.
+ */
+export function createApiKeyUsageAccumulator(
+  configuredIds: string[],
+  now: number = Date.now(),
+): ApiKeyUsageAccumulator {
   const duplicated = new Set<string>();
   const seen = new Set<string>();
   for (const id of configuredIds) {
@@ -69,37 +89,40 @@ export function rollupApiKeyUsage(
   let attributionSince: number | undefined;
   const cutoff = now - SEVEN_DAYS_MS;
 
-  for (const entry of entries) {
-    if (!entry.admissionKind) continue;
-    const timestamp = usableTimestamp(entry.timestamp);
-    if (timestamp !== null && (attributionSince === undefined || timestamp < attributionSince)) {
-      attributionSince = timestamp;
-    }
-    if (entry.admissionKind !== "configured" || !entry.apiKeyId) continue;
-
-    const bucket = totals.get(entry.apiKeyId) ?? { requests7d: 0, totalRequests: 0 };
-    // The request happened even if its clock reading is unusable, so it still
-    // counts toward the total; only the time-based fields are skipped.
-    bucket.totalRequests += 1;
-    if (timestamp !== null) {
-      if (timestamp >= cutoff) bucket.requests7d += 1;
-      const iso = new Date(timestamp).toISOString();
-      if (!bucket.lastUsedAt || iso > bucket.lastUsedAt) bucket.lastUsedAt = iso;
-    }
-    totals.set(entry.apiKeyId, bucket);
-  }
-
-  const rollup = new Map<string, ApiKeyUsage>();
-  for (const id of configuredIds) {
-    if (duplicated.has(id)) {
-      rollup.set(id, { ambiguous: true });
-      continue;
-    }
-    rollup.set(id, totals.get(id) ?? { requests7d: 0, totalRequests: 0 });
-  }
   return {
-    rollup,
-    ...(attributionSince !== undefined ? { attributionSince: new Date(attributionSince).toISOString() } : {}),
+    add(entry) {
+      if (!entry.admissionKind) return;
+      const timestamp = usableTimestamp(entry.timestamp);
+      if (timestamp !== null && (attributionSince === undefined || timestamp < attributionSince)) {
+        attributionSince = timestamp;
+      }
+      if (entry.admissionKind !== "configured" || !entry.apiKeyId || !seen.has(entry.apiKeyId)) return;
+
+      const bucket = totals.get(entry.apiKeyId) ?? { requests7d: 0, totalRequests: 0 };
+      // The request happened even if its clock reading is unusable, so it still
+      // counts toward the total; only the time-based fields are skipped.
+      bucket.totalRequests += 1;
+      if (timestamp !== null) {
+        if (timestamp >= cutoff) bucket.requests7d += 1;
+        const iso = new Date(timestamp).toISOString();
+        if (!bucket.lastUsedAt || iso > bucket.lastUsedAt) bucket.lastUsedAt = iso;
+      }
+      totals.set(entry.apiKeyId, bucket);
+    },
+    snapshot() {
+      const rollup = new Map<string, ApiKeyUsage>();
+      for (const id of configuredIds) {
+        if (duplicated.has(id)) {
+          rollup.set(id, { ambiguous: true });
+          continue;
+        }
+        rollup.set(id, totals.get(id) ?? { requests7d: 0, totalRequests: 0 });
+      }
+      return {
+        rollup,
+        ...(attributionSince !== undefined ? { attributionSince: new Date(attributionSince).toISOString() } : {}),
+      };
+    },
   };
 }
 
@@ -111,6 +134,7 @@ export function rollupApiKeyUsage(
  * caching it costs nothing; a new row changes the revision and invalidates it.
  */
 let rollupCache: { revisionKey: string; expiresAt: number; lastSeenSize?: number; snapshot: ApiKeyUsageSnapshot } | null = null;
+const rollupFlights = new Map<string, Promise<ApiKeyUsageSnapshot>>();
 
 /**
  * The rollup is a function of the log AND of the clock: a request ages out of
@@ -127,6 +151,7 @@ const ROLLUP_CACHE_TTL_MS = 60_000;
 /** Test seam: the cache is module state and would otherwise leak between cases. */
 export function clearApiKeyUsageCacheForTests(): void {
   rollupCache = null;
+  rollupFlights.clear();
 }
 
 /**
@@ -159,6 +184,25 @@ export function cacheApiKeyUsageFromSnapshot(
   return rolled;
 }
 
+/** Seed the API-key cache from the accumulator already fed by `/api/usage`. */
+export function cacheApiKeyUsageFromRollup(
+  snapshot: ApiKeyUsageSnapshot,
+  configuredIds: string[],
+  identityKey: string,
+  lastSeenSize: number,
+  maxReadBytes: number | undefined,
+  now: number = Date.now(),
+): ApiKeyUsageSnapshot {
+  const idsKey = JSON.stringify([configuredIds, maxReadBytes]);
+  rollupCache = {
+    revisionKey: `${identityKey}|${idsKey}`,
+    expiresAt: now + ROLLUP_CACHE_TTL_MS,
+    lastSeenSize,
+    snapshot,
+  };
+  return snapshot;
+}
+
 export async function readApiKeyUsageRollup(configuredIds: string[], maxReadBytes?: number): Promise<ApiKeyUsageSnapshot> {
   // JSON rather than a joined string: ids are only validated as non-empty
   // strings, so `["a\0b","c"]` and `["a","b\0c"]` join to the same value and one
@@ -173,18 +217,28 @@ export async function readApiKeyUsageRollup(configuredIds: string[], maxReadByte
       return rollupCache.snapshot;
     }
 
-    const snapshot = await readUsageSnapshotForManagement(maxReadBytes);
-    const rolled = {
-      ...rollupApiKeyUsage(snapshot.entries, configuredIds, now),
-      ...(snapshot.truncatedPrefixBytes > 0 || snapshot.entriesTruncated ? { historyTruncated: true as const } : {}),
-    };
-    rollupCache = {
-      revisionKey: `${usageLogIdentityKey(snapshot.revision)}|${idsKey}`,
-      expiresAt: now + ROLLUP_CACHE_TTL_MS,
-      lastSeenSize: snapshot.revision?.size ?? 0,
-      snapshot: rolled,
-    };
-    return rolled;
+    const existing = rollupFlights.get(idsKey);
+    if (existing) return await existing;
+
+    const flight = (async (): Promise<ApiKeyUsageSnapshot> => {
+      const accumulator = createApiKeyUsageAccumulator(configuredIds, now);
+      const scan = await scanUsageLedgerCooperatively({ onEntry: entry => accumulator.add(entry) });
+      if (scan.oversizedRows > 0) throw new Error("usage ledger contains an oversized row");
+      return cacheApiKeyUsageFromRollup(
+        accumulator.snapshot(),
+        configuredIds,
+        usageLogIdentityKey(scan.revision),
+        scan.revision?.size ?? 0,
+        maxReadBytes,
+        now,
+      );
+    })();
+    rollupFlights.set(idsKey, flight);
+    try {
+      return await flight;
+    } finally {
+      if (rollupFlights.get(idsKey) === flight) rollupFlights.delete(idsKey);
+    }
   } catch {
     const rollup = new Map<string, ApiKeyUsage>();
     for (const id of configuredIds) rollup.set(id, { requests7d: 0, totalRequests: 0 });

package/src/server/management/context.ts

@@ -11,6 +11,8 @@ import type { injectGrokConfig } from "../../grok/inject";
 import type { removeDesktop3pStandardPivot, writeDesktop3pConfig } from "../../claude/desktop-3p";
 import type { probeClaudeDesktopPolicy } from "../../claude/desktop-policy";
 import type { RuntimePortState } from "../../config/process-state";
+import type { CursorInstall } from "../../integrations/cursor-detect";
+import type { CursorEffortTable } from "../../integrations/cursor-effort-table";
 import type { CatalogDisposition, ConvergeCodex } from "../../codex/convergence-types";
 import type {
   performCodexRestart,
@@ -58,6 +60,7 @@ export interface ManagementApiDeps {
    * on the developer's real runtime state file.
    */
   readRuntimePort?: (pid: number) => RuntimePortState | null;
+  loadCursorEffortTable?: (install: CursorInstall | undefined) => CursorEffortTable | null;
   clearThreadAccountMap?: () => void;
   clearProviderQuotaCache?: () => void;
   primeCodexPoolQuotas?: (config: OcxConfig, reason: string) => Promise<void> | void;

package/src/server/management/cursor-integration-routes.ts

@@ -9,12 +9,14 @@
  * started — plus which active models will show Cursor's Reasoning and Context controls.
  */
 import { readRuntimePort } from "../../config/process-state";
-import { filterCatalogVisibleModels, nativeContextLimits, nativeOpenAiContextTier, uniqueCatalogModelsForRawPublicList, visibleNativeSlugs } from "../../codex/catalog";
+import { filterCatalogVisibleModels, nativeContextLimits, nativeOpenAiContextTier, nativeReasoningEfforts, uniqueCatalogModelsForRawPublicList, visibleNativeSlugs } from "../../codex/catalog";
 import { cursorLastSeen, type CursorSeen } from "../../integrations/cursor-seen";
 import { detectCursorInstalls, type CursorInstall } from "../../integrations/cursor-detect";
+import { loadCursorEffortTable } from "../../integrations/cursor-effort-table";
 import { configuredApiAuthToken, isApiAuthRequired, jsonResponse } from "../auth-cors";
 import { fetchAllModels } from "../management-api";
-import { cursorEffortFamily } from "../models-capabilities";
+import { predictCursorEffort } from "../models-capabilities";
+import { expandCursorEffortRow, knownEffortRowIds } from "../effort-row";
 import type { ManagementContext } from "./context";
 
 export const CURSOR_GATEWAY_PLACEHOLDER_KEY = "opencodex-loopback";
@@ -25,9 +27,13 @@ export interface CursorIntegrationStatus {
   regularCursor: { installed: boolean; path: string | null };
   gateway: { baseUrl: string; apiKeyMode: "credential" | "placeholder"; placeholder: string };
   lastSeen: CursorSeen | null;
+  effortTable: { source: "bundle" | "static"; version: string | null; families: number | null };
   models: Array<{
     id: string;
     reasoning: string[] | null;
+    family: string | null;
+    tableLess: boolean;
+    effortRows: string[];
     context: { defaultWindow: number; longWindow: number } | null;
   }>;
   guideUrl: string;
@@ -58,18 +64,40 @@ export async function buildCursorIntegrationStatus(
   // Same visibility rules as the raw /v1/models list Cursor will read: disabled models and
   // provider allowlists drop out here too, or the prediction shows rows Cursor never gets.
   const goModels = filterCatalogVisibleModels(await fetchAllModels(config), config);
-  const ids = [
-    ...visibleNativeSlugs(config),
-    ...uniqueCatalogModelsForRawPublicList(goModels).map(model => model.alias ?? `${model.provider}/${model.id}`),
+  // supportsReasoning mirrors what the /v1/models row advertises (a non-empty ladder); the
+  // gemini family withholds its control when it is false.
+  const ids: Array<{ id: string; supportsReasoning: boolean; reasoningEfforts: readonly string[] }> = [
+    ...visibleNativeSlugs(config).map(id => {
+      const reasoningEfforts = nativeReasoningEfforts(id);
+      return { id, supportsReasoning: reasoningEfforts.length > 0, reasoningEfforts };
+    }),
+    ...uniqueCatalogModelsForRawPublicList(goModels).map(model => ({
+      id: model.alias ?? `${model.provider}/${model.id}`,
+      supportsReasoning: (model.reasoningEfforts ?? []).length > 0,
+      reasoningEfforts: model.reasoningEfforts ?? [],
+    })),
   ];
-  const models = ids.map(id => {
+  const table = (deps.loadCursorEffortTable ?? loadCursorEffortTable)(privateInference);
+  const effortRowKnownIds = config.cursorEffortRows === true ? knownEffortRowIds(config) : undefined;
+  const models = ids.map(({ id, supportsReasoning, reasoningEfforts }) => {
     const tier = nativeOpenAiContextTier(id, limits);
+    const predicted = predictCursorEffort(id, table, supportsReasoning);
     return {
       id,
-      reasoning: cursorEffortFamily(id),
+      reasoning: predicted.ladder,
+      family: predicted.family,
+      tableLess: predicted.ladder === null,
+      effortRows: expandCursorEffortRow({ id }, reasoningEfforts, config, {
+        knownIds: effortRowKnownIds,
+        table,
+        supportsReasoning,
+      }).slice(1).map(row => row.id),
       context: tier ? { defaultWindow: tier.defaultWindow, longWindow: tier.longWindow } : null,
     };
   });
+  const effortTable = table
+    ? { source: "bundle" as const, version: table.version, families: table.families.length }
+    : { source: "static" as const, version: null, families: null };
 
   return {
     privateInference: {
@@ -84,6 +112,7 @@ export async function buildCursorIntegrationStatus(
       placeholder: CURSOR_GATEWAY_PLACEHOLDER_KEY,
     },
     lastSeen: cursorLastSeen(),
+    effortTable,
     models,
     guideUrl: CURSOR_GUIDE_URL,
   };