@bitkyc08/opencodex 2.36.0-preview.20260829 → 2.36.0

package/src/codex/data/upstream-models.json

@@ -21,6 +21,10 @@
       "multi_agent_version": "v2",
       "use_responses_lite": true,
       "include_skills_usage_instructions": false,
+      "node_repl_disabled": false,
+      "node_repl_auto_review_required": false,
+      "include_plugin_usage_instructions": true,
+      "include_apps_usage_instructions": true,
       "auto_review_model_override": null,
       "context_window": 372000,
       "max_context_window": 372000,
@@ -57,7 +61,7 @@
           "description": "Maximum reasoning with automatic task delegation"
         }
       ],
-      "shell_type": "shell_command",
+      "shell_type": "unified_exec",
       "visibility": "list",
       "minimal_client_version": "0.142.2",
       "supported_in_api": true,
@@ -135,6 +139,10 @@
       "multi_agent_version": "v2",
       "use_responses_lite": true,
       "include_skills_usage_instructions": false,
+      "node_repl_disabled": false,
+      "node_repl_auto_review_required": false,
+      "include_plugin_usage_instructions": true,
+      "include_apps_usage_instructions": true,
       "auto_review_model_override": null,
       "context_window": 372000,
       "max_context_window": 372000,
@@ -171,7 +179,7 @@
           "description": "Maximum reasoning with automatic task delegation"
         }
       ],
-      "shell_type": "shell_command",
+      "shell_type": "unified_exec",
       "visibility": "list",
       "minimal_client_version": "0.142.2",
       "supported_in_api": true,
@@ -247,6 +255,10 @@
       "multi_agent_version": "v1",
       "use_responses_lite": true,
       "include_skills_usage_instructions": false,
+      "node_repl_disabled": false,
+      "node_repl_auto_review_required": false,
+      "include_plugin_usage_instructions": true,
+      "include_apps_usage_instructions": true,
       "auto_review_model_override": null,
       "context_window": 372000,
       "max_context_window": 372000,
@@ -279,7 +291,7 @@
           "description": "Maximum reasoning depth for the hardest problems"
         }
       ],
-      "shell_type": "shell_command",
+      "shell_type": "unified_exec",
       "visibility": "list",
       "minimal_client_version": "0.142.2",
       "supported_in_api": true,
@@ -355,6 +367,10 @@
       "multi_agent_version": null,
       "use_responses_lite": false,
       "include_skills_usage_instructions": true,
+      "node_repl_disabled": false,
+      "node_repl_auto_review_required": false,
+      "include_plugin_usage_instructions": true,
+      "include_apps_usage_instructions": true,
       "auto_review_model_override": null,
       "context_window": 272000,
       "max_context_window": 272000,
@@ -383,7 +399,7 @@
           "description": "Extra high reasoning depth for complex problems"
         }
       ],
-      "shell_type": "shell_command",
+      "shell_type": "unified_exec",
       "visibility": "list",
       "minimal_client_version": "0.124.0",
       "supported_in_api": true,
@@ -461,6 +477,10 @@
       "multi_agent_version": null,
       "use_responses_lite": false,
       "include_skills_usage_instructions": false,
+      "node_repl_disabled": false,
+      "node_repl_auto_review_required": false,
+      "include_plugin_usage_instructions": true,
+      "include_apps_usage_instructions": true,
       "auto_review_model_override": null,
       "context_window": 272000,
       "max_context_window": 1000000,
@@ -489,7 +509,7 @@
           "description": "Extra high reasoning depth for complex problems"
         }
       ],
-      "shell_type": "shell_command",
+      "shell_type": "unified_exec",
       "visibility": "list",
       "minimal_client_version": "0.98.0",
       "supported_in_api": true,
@@ -562,6 +582,10 @@
       "multi_agent_version": null,
       "use_responses_lite": false,
       "include_skills_usage_instructions": false,
+      "node_repl_disabled": false,
+      "node_repl_auto_review_required": false,
+      "include_plugin_usage_instructions": true,
+      "include_apps_usage_instructions": true,
       "auto_review_model_override": null,
       "context_window": 272000,
       "max_context_window": 272000,
@@ -590,7 +614,7 @@
           "description": "Extra high reasoning depth for complex problems"
         }
       ],
-      "shell_type": "shell_command",
+      "shell_type": "unified_exec",
       "visibility": "list",
       "minimal_client_version": "0.98.0",
       "supported_in_api": true,
@@ -658,6 +682,10 @@
       "multi_agent_version": null,
       "use_responses_lite": false,
       "include_skills_usage_instructions": false,
+      "node_repl_disabled": false,
+      "node_repl_auto_review_required": false,
+      "include_plugin_usage_instructions": true,
+      "include_apps_usage_instructions": true,
       "auto_review_model_override": null,
       "context_window": 272000,
       "max_context_window": 272000,
@@ -686,7 +714,7 @@
           "description": "Extra high reasoning for complex problems"
         }
       ],
-      "shell_type": "shell_command",
+      "shell_type": "unified_exec",
       "visibility": "list",
       "minimal_client_version": "0.0.1",
       "supported_in_api": true,
@@ -754,6 +782,10 @@
       "multi_agent_version": null,
       "use_responses_lite": false,
       "include_skills_usage_instructions": false,
+      "node_repl_disabled": false,
+      "node_repl_auto_review_required": false,
+      "include_plugin_usage_instructions": true,
+      "include_apps_usage_instructions": true,
       "auto_review_model_override": null,
       "context_window": 272000,
       "max_context_window": 1000000,
@@ -782,7 +814,7 @@
           "description": "Extra high reasoning depth for complex problems"
         }
       ],
-      "shell_type": "shell_command",
+      "shell_type": "unified_exec",
       "visibility": "hide",
       "minimal_client_version": "0.98.0",
       "supported_in_api": true,

package/src/codex/inject-coordination.ts

@@ -16,6 +16,7 @@ import { CODEX_CONFIG_PATH, CODEX_PROFILE_PATH } from "./paths";
 import type {
   CodexArtifactId,
   CodexProvenanceEntry,
+  CodexProvenanceLedger,
 } from "./convergence-types";
 import {
   codexWriteCoordination,
@@ -196,6 +197,41 @@ export function captureCodexPreImages(): CodexPreImages {
  */
 export const CODEX_PROVENANCE_MAX_TRANSACTIONS = 16;
 
+/**
+ * How many serialized bytes of evidence the ledger keeps.
+ *
+ * The transaction window alone bounds the ledger only if each transaction is small, and a
+ * baseline embeds the artifact's exact bytes. Those artifacts sit outside this proxy's trust
+ * boundary: a native `config.toml` grown to hundreds of megabytes is copied into the record as
+ * base64 and re-serialized on every append, so a single oversized file turns a 16-transaction
+ * window into a multi-gigabyte write.
+ *
+ * The size is derived from the window above rather than picked: the 25 KB `config.toml` that
+ * comment describes measures 100.8 KiB per transaction, so a full 16-transaction window is
+ * 1.58 MiB. 4 MiB leaves that ordinary window untouched with room to spare while still refusing
+ * the pathological case, and a regression test pins the ordinary window so the two cannot drift
+ * apart silently.
+ */
+export const CODEX_PROVENANCE_MAX_BYTES = 4 * 1024 * 1024;
+
+/**
+ * Measure the representation the integration-record writer actually emits.
+ *
+ * The minimal wrapper reproduces the final indentation depth of `provenance.entries`, including
+ * structured unknown extension fields preserved from older records. Its fixed wrapper makes this
+ * slightly conservative as a ledger-only ceiling, which is preferable to admitting an entry that
+ * expands past the limit when `JSON.stringify(record, null, 2)` writes it.
+ */
+function serializedProvenanceBytes(
+  entries: readonly CodexProvenanceEntry[],
+  ledger: CodexProvenanceLedger | undefined,
+): number {
+  return Buffer.byteLength(`${JSON.stringify({
+    version: 1,
+    provenance: { ...ledger, entries },
+  }, null, 2)}\n`, "utf-8");
+}
+
 function provenanceBaseline(bytes: string | null): CodexProvenanceEntry["baseline"] {
   if (bytes === null) return { kind: "absent" };
   return {
@@ -214,21 +250,66 @@ function provenancePostImage(path: string): string | null {
 }
 
 /**
- * Keep the newest `CODEX_PROVENANCE_MAX_TRANSACTIONS` transactions, whole.
+ * Keep the newest transactions that fit both the transaction window and the byte ceiling, whole.
  *
  * Trimming by ENTRY count would cut a transaction in half and leave evidence that says a
  * transaction touched two artifacts when it touched three — worse than dropping it outright,
- * because a partial record still reads as complete. Order is preserved; only whole leading
- * transactions are removed.
+ * because a partial record still reads as complete. Order is preserved; only whole transactions
+ * are removed.
+ *
+ * The byte ceiling applies the same rule: a transaction that does not fit is omitted whole,
+ * including the newest one — a record silently truncated to fit would be read as a faithful
+ * pre-image. An oversized transaction is skipped rather than ending the scan, so one pathological
+ * artifact cannot erase the smaller transactions that still fit and are still diagnosable.
  */
 export function boundProvenanceEntries(
   entries: readonly CodexProvenanceEntry[],
   maxTransactions = CODEX_PROVENANCE_MAX_TRANSACTIONS,
+  maxBytes = CODEX_PROVENANCE_MAX_BYTES,
+  ledger?: CodexProvenanceLedger,
 ): readonly CodexProvenanceEntry[] {
-  const order: string[] = [];
-  for (const entry of entries) if (!order.includes(entry.txId)) order.push(entry.txId);
-  if (order.length <= maxTransactions) return entries;
-  const keep = new Set(order.slice(order.length - maxTransactions));
+  const transactions = new Map<string, CodexProvenanceEntry[]>();
+  for (const entry of entries) {
+    const transaction = transactions.get(entry.txId);
+    if (transaction) transaction.push(entry);
+    else transactions.set(entry.txId, [entry]);
+  }
+  const order = [...transactions.keys()];
+  if (order.length <= maxTransactions) {
+    const baselineBytes = entries.reduce(
+      (total, entry) => total + (entry.baseline.kind === "present" ? entry.baseline.bytesBase64.length : 0),
+      0,
+    );
+    if (
+      baselineBytes <= maxBytes
+      && serializedProvenanceBytes(entries, ledger) <= maxBytes
+    ) return entries;
+  }
+  // Newest first, so the transactions anyone diagnoses against are the ones that fit.
+  const keep = new Set<string>();
+  let baselineBytes = 0;
+  for (let i = order.length - 1; i >= 0 && keep.size < maxTransactions; i--) {
+    const txId = order[i]!;
+    const txEntries = transactions.get(txId)!;
+    // Measure the embedded pre-images first: a pathological baseline is refused without
+    // serializing it, so the ceiling does not itself allocate the payload it exists to reject.
+    const transactionBaselineBytes = txEntries.reduce(
+      (total, entry) => total + (entry.baseline.kind === "present" ? entry.baseline.bytesBase64.length : 0),
+      0,
+    );
+    if (baselineBytes + transactionBaselineBytes > maxBytes) continue;
+    const candidateKeep = new Set(keep);
+    candidateKeep.add(txId);
+    // Reuse the already-grouped transactions: this avoids another full-ledger filter on each
+    // iteration while preserving the original transaction and entry order.
+    const candidateEntries = order.flatMap(id =>
+      candidateKeep.has(id) ? transactions.get(id)! : []
+    );
+    if (serializedProvenanceBytes(candidateEntries, ledger) > maxBytes) continue;
+    baselineBytes += transactionBaselineBytes;
+    keep.add(txId);
+  }
+  if (keep.size === order.length) return entries;
   return entries.filter(entry => keep.has(entry.txId));
 }
 
@@ -250,13 +331,29 @@ export function recordCodexNativeTransactionProvenance(
     txId,
     at,
   }));
-  return updateIntegrationRecord(record => ({
-    ...record,
-    provenance: {
-      ...record.provenance,
-      entries: boundProvenanceEntries([...(record.provenance?.entries ?? []), ...entries]),
-    },
-  }));
+  return updateIntegrationRecord(record => {
+    const previousLedger = record.provenance;
+    // Unknown ledger extensions are forward-compatible and must be preserved. If those fixed
+    // fields alone exceed the ceiling, no entry selection can make the write compliant. Keep the
+    // existing record byte-for-byte instead of deleting all known evidence and rewriting the
+    // same oversized extension on every native transaction.
+    if (
+      previousLedger
+      && serializedProvenanceBytes([], previousLedger) > CODEX_PROVENANCE_MAX_BYTES
+    ) return record;
+    return {
+      ...record,
+      provenance: {
+        ...previousLedger,
+        entries: boundProvenanceEntries(
+          [...(previousLedger?.entries ?? []), ...entries],
+          CODEX_PROVENANCE_MAX_TRANSACTIONS,
+          CODEX_PROVENANCE_MAX_BYTES,
+          previousLedger,
+        ),
+      },
+    };
+  });
 }
 
 /**

package/src/codex/integration-record.ts

@@ -204,12 +204,17 @@ function mergeEntry(previous: CodexProvenanceEntry, next: CodexProvenanceEntry):
 function mergeLedger(previous: CodexProvenanceLedger, next: CodexProvenanceLedger): CodexProvenanceLedger {
   const unused = new Set(previous.entries.map((_, index) => index));
   const entries = next.entries.map((entry, nextIndex) => {
-    let previousIndex = previous.entries.findIndex((candidate, index) =>
+    // Extensions follow provenance identity, never position. A bounded ledger may drop an
+    // oversized transaction, shifting an unrelated entry into that slot, and even within one
+    // transaction and timestamp the artifact may differ. Since this search already requires
+    // txId, timestamp, and artifact identity, any remaining positional match is by definition
+    // a different artifact, so preserving its unknown entry/artifact/baseline fields would
+    // attach false evidence and could regrow the record past the measured byte ceiling.
+    const previousIndex = previous.entries.findIndex((candidate, index) =>
       unused.has(index)
       && candidate.txId === entry.txId
       && candidate.at === entry.at
       && knownArtifactIdentity(candidate.artifact) === knownArtifactIdentity(entry.artifact));
-    if (previousIndex < 0 && unused.has(nextIndex)) previousIndex = nextIndex;
     if (previousIndex < 0) return entry;
     unused.delete(previousIndex);
     return mergeEntry(previous.entries[previousIndex]!, entry);
@@ -245,6 +250,11 @@ export const updateIntegrationRecord = (
       if (read.kind === "invalid") return read;
       const previous: CodexIntegrationRecord = read.kind === "ready" ? read.record : { version: 1 };
       const proposed = mutate(previous);
+      // The mutator can explicitly decline an update by returning the exact record it received.
+      // This matters when a preserved forward-compatible extension already exceeds a caller's
+      // write budget: rewriting the same oversized bytes would amplify I/O while deleting known
+      // entries cannot make that irreducible overhead fit.
+      if (proposed === previous) return { kind: "updated" as const, record: previous };
       if (!validateRecord(proposed)) {
         return { kind: "invalid", message: "Codex integration record update produced a malformed v1 shape" };
       }

package/src/codex/main-account.ts

@@ -1,7 +1,23 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import { readCodexTokens } from "./auth-collision";
-import { decodeJwtPayload } from "../oauth/chatgpt";
+import {
+  decodeJwtPayload,
+  extractAccountId,
+  refreshChatGPTToken,
+} from "../oauth/chatgpt";
+import type { OAuthCredentials } from "../oauth/types";
 import { extractChatgptPlanType } from "./plan";
 import { MAIN_CODEX_ACCOUNT_ID } from "./account-id";
+import {
+  refreshGrantFingerprintForToken,
+  withCodexRefreshFileLock,
+} from "./account-store";
+import { atomicWriteFile, resolveWriteTarget } from "../config/atomic-write";
+import { resolveCodexHomeDir } from "./home";
+import { assertNotRealCodexHomeUnderTest } from "../lib/test-home-guard";
+import { clearAccountNeedsReauth } from "./account-runtime-state";
 
 export { MAIN_CODEX_ACCOUNT_ID } from "./account-id";
 
@@ -12,6 +28,214 @@ export { MAIN_CODEX_ACCOUNT_ID } from "./account-id";
  */
 let mainAccountPlan: string | null = null;
 let jwtPlanAttempted = false;
+const MAIN_TOKEN_REFRESH_SKEW_MS = 60_000;
+let beforeMainAuthJsonRenameForTests: (() => void) | null = null;
+
+type MainAuthJsonCredential = {
+  path: string;
+  rawSha256: string;
+  root: Record<string, unknown>;
+  tokens: Record<string, unknown>;
+  accessToken?: string;
+  refreshToken?: string;
+  chatgptAccountId: string;
+};
+
+export interface NativeMainRefreshDependencies {
+  refreshToken?: (refreshToken: string, options: { signal: AbortSignal }) => Promise<OAuthCredentials>;
+  signal?: AbortSignal;
+}
+
+export class MainAuthJsonChangedDuringRefreshError extends Error {
+  constructor() {
+    super("Codex auth.json changed while its token was refreshing");
+    this.name = "MainAuthJsonChangedDuringRefreshError";
+  }
+}
+
+export class MainAccountTokenRefreshError extends Error {
+  constructor(readonly reason: "reauth" | "transient", options?: ErrorOptions) {
+    super(reason === "reauth"
+      ? "Codex main account needs reauthentication"
+      : "Codex main token refresh did not complete", options);
+    this.name = "MainAccountTokenRefreshError";
+  }
+}
+
+function nonEmptyString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+
+function sha256(value: string): string {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+function readMainAuthJsonCredential(): MainAuthJsonCredential | null {
+  const path = resolveWriteTarget(join(resolveCodexHomeDir(), "auth.json"));
+  let raw: string;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    const root = parsed as Record<string, unknown>;
+    const tokenValue = root.tokens;
+    if (!tokenValue || typeof tokenValue !== "object" || Array.isArray(tokenValue)) return null;
+    const tokens = tokenValue as Record<string, unknown>;
+    const accessToken = nonEmptyString(tokens.access_token);
+    const refreshToken = nonEmptyString(tokens.refresh_token);
+    if (!accessToken && !refreshToken) return null;
+    const idToken = nonEmptyString(tokens.id_token);
+    const chatgptAccountId = extractAccountId(idToken, accessToken)
+      ?? nonEmptyString(tokens.account_id)
+      ?? "";
+    return {
+      path,
+      rawSha256: sha256(raw),
+      root,
+      tokens,
+      ...(accessToken ? { accessToken } : {}),
+      ...(refreshToken ? { refreshToken } : {}),
+      chatgptAccountId,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function mainAccessTokenFresh(accessToken: string | undefined, now: number, skewMs: number): boolean {
+  if (!accessToken) return false;
+  const payload = decodeJwtPayload(accessToken);
+  const exp = typeof payload?.exp === "number" ? payload.exp * 1000 : undefined;
+  return exp === undefined || exp > now + skewMs;
+}
+
+/** A refresh grant makes native main routeable even when the current access token is expired. */
+export function isMainAccountCredentialUsable(now = Date.now()): boolean {
+  const current = readMainAuthJsonCredential();
+  return !!current?.refreshToken || mainAccessTokenFresh(current?.accessToken, now, 0);
+}
+
+export function hasMainAccountRefreshGrant(): boolean {
+  return !!readMainAuthJsonCredential()?.refreshToken;
+}
+
+function assertMainAuthJsonSnapshotUnchanged(expected: MainAuthJsonCredential): void {
+  const current = readMainAuthJsonCredential();
+  if (!current || current.path !== expected.path || current.rawSha256 !== expected.rawSha256) {
+    throw new MainAuthJsonChangedDuringRefreshError();
+  }
+}
+
+function persistRefreshedMainAuthJson(
+  expected: MainAuthJsonCredential,
+  refreshed: OAuthCredentials,
+): { accessToken: string; chatgptAccountId: string } {
+  assertNotRealCodexHomeUnderTest(resolveCodexHomeDir());
+  const accessToken = refreshed.access;
+  const refreshToken = refreshed.refresh || expected.refreshToken!;
+  const chatgptAccountId = refreshed.accountId
+    ?? extractAccountId(undefined, accessToken)
+    ?? expected.chatgptAccountId;
+  const tokens = {
+    ...expected.tokens,
+    access_token: accessToken,
+    refresh_token: refreshToken,
+    account_id: chatgptAccountId,
+  };
+  atomicWriteFile(
+    expected.path,
+    JSON.stringify({ ...expected.root, tokens }, null, 2) + "\n",
+    undefined,
+    {
+      beforeRename: () => {
+        assertMainAuthJsonSnapshotUnchanged(expected);
+        const hook = beforeMainAuthJsonRenameForTests;
+        beforeMainAuthJsonRenameForTests = null;
+        hook?.();
+      },
+      validateBeforeRename: () => assertMainAuthJsonSnapshotUnchanged(expected),
+    },
+  );
+  return { accessToken, chatgptAccountId };
+}
+
+export function setMainAuthJsonBeforeRenameHookForTests(hook: (() => void) | null): void {
+  beforeMainAuthJsonRenameForTests = hook;
+}
+
+async function resolveMainAccountToken(
+  dependencies: NativeMainRefreshDependencies = {},
+  rejectedAccessToken?: string,
+): Promise<{ accessToken: string; chatgptAccountId: string } | null> {
+  const initial = readMainAuthJsonCredential();
+  if (!initial) return null;
+  const now = Date.now();
+  if (initial.accessToken !== rejectedAccessToken
+    && mainAccessTokenFresh(initial.accessToken, now, MAIN_TOKEN_REFRESH_SKEW_MS)) {
+    return { accessToken: initial.accessToken!, chatgptAccountId: initial.chatgptAccountId };
+  }
+  if (!initial.refreshToken) {
+    return initial.accessToken !== rejectedAccessToken
+      && mainAccessTokenFresh(initial.accessToken, now, 0)
+      ? { accessToken: initial.accessToken!, chatgptAccountId: initial.chatgptAccountId }
+      : null;
+  }
+
+  const signal = dependencies.signal
+    ? AbortSignal.any([dependencies.signal, AbortSignal.timeout(30_000)])
+    : AbortSignal.timeout(30_000);
+  const lockKey = refreshGrantFingerprintForToken(initial.refreshToken);
+  return withCodexRefreshFileLock(lockKey, signal, async () => {
+    const locked = readMainAuthJsonCredential();
+    if (!locked) throw new MainAuthJsonChangedDuringRefreshError();
+    if (!locked.refreshToken
+      || refreshGrantFingerprintForToken(locked.refreshToken) !== lockKey) {
+      if (locked.accessToken !== rejectedAccessToken
+        && mainAccessTokenFresh(locked.accessToken, Date.now(), 0)) {
+        return { accessToken: locked.accessToken!, chatgptAccountId: locked.chatgptAccountId };
+      }
+      throw new MainAuthJsonChangedDuringRefreshError();
+    }
+    if (locked.accessToken !== rejectedAccessToken
+      && mainAccessTokenFresh(locked.accessToken, Date.now(), MAIN_TOKEN_REFRESH_SKEW_MS)) {
+      return { accessToken: locked.accessToken!, chatgptAccountId: locked.chatgptAccountId };
+    }
+    const refresh = dependencies.refreshToken
+      ?? ((refreshToken: string, options: { signal: AbortSignal }) => refreshChatGPTToken(refreshToken, options));
+    let refreshed: OAuthCredentials;
+    try {
+      refreshed = await refresh(locked.refreshToken, { signal });
+    } catch (cause) {
+      const message = cause instanceof Error ? cause.message.toLowerCase() : "";
+      const reason = /invalid_grant|invalidated|revoked|expired/.test(message)
+        ? "reauth" as const
+        : "transient" as const;
+      throw new MainAccountTokenRefreshError(reason, { cause });
+    }
+    const result = persistRefreshedMainAuthJson(locked, refreshed);
+    clearAccountNeedsReauth(MAIN_CODEX_ACCOUNT_ID);
+    return result;
+  });
+}
+
+/** Refresh the CLI-owned native credential before upstream I/O and publish it atomically. */
+export function getValidMainAccountToken(
+  dependencies: NativeMainRefreshDependencies = {},
+): Promise<{ accessToken: string; chatgptAccountId: string } | null> {
+  return resolveMainAccountToken(dependencies);
+}
+
+/** Force refresh after upstream rejected this exact bearer once. */
+export function forceRefreshMainAccountToken(
+  rejectedAccessToken: string,
+  dependencies: NativeMainRefreshDependencies = {},
+): Promise<{ accessToken: string; chatgptAccountId: string } | null> {
+  return resolveMainAccountToken(dependencies, rejectedAccessToken);
+}
 
 export function setMainAccountPlan(plan: string | null): void {
   mainAccountPlan = plan;