@opengeni/codex 0.2.0

package/dist/chunk-2ESTGQ57.js

@@ -0,0 +1,54 @@
+// src/constants.ts
+var CODEX_ISSUER = "https://auth.openai.com";
+var CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+var CODEX_AUTH_BASE = `${CODEX_ISSUER}/api/accounts`;
+var CODEX_TOKEN_URL = `${CODEX_ISSUER}/oauth/token`;
+var CODEX_DEVICE_VERIFICATION_URL = `${CODEX_ISSUER}/codex/device`;
+var CODEX_DEVICE_REDIRECT_URI = `${CODEX_ISSUER}/deviceauth/callback`;
+var CODEX_RESPONSES_BASE = "https://chatgpt.com/backend-api/codex";
+var CODEX_WHAM_BASE = "https://chatgpt.com/backend-api";
+var CODEX_ORIGINATOR = "codex_cli_rs";
+var CODEX_ID_TOKEN_AUTH_CLAIM = "https://api.openai.com/auth";
+var CODEX_PROVIDER_ID = "codex-subscription";
+var CODEX_PROVIDER_BASE_URL = "https://chatgpt.com/backend-api";
+var CODEX_MODEL_ID_PREFIX = "codex/";
+var CODEX_FALLBACK_MODEL_SLUGS = [
+  "gpt-5.5",
+  "gpt-5.4",
+  "gpt-5.4-mini",
+  "gpt-5.3-codex-spark"
+];
+var CODEX_CLIENT_VERSION = "0.142.4";
+var CODEX_REFRESH_WINDOW_MS = 5 * 60 * 1e3;
+var CODEX_REFRESH_FALLBACK_MS = 8 * 24 * 60 * 60 * 1e3;
+var CODEX_APPS_MCP_SERVER_ID = "codex_apps";
+var CODEX_APPS_MCP_SERVER_NAME = "codex_apps";
+var CODEX_APPS_MCP_URL = "https://chatgpt.com/backend-api/ps/mcp";
+var CODEX_APPS_STARTUP_TIMEOUT_MS = 3e4;
+var CODEX_APPS_REQUIRED_SCOPES = ["api.connectors.read", "api.connectors.invoke"];
+
+export {
+  CODEX_ISSUER,
+  CODEX_CLIENT_ID,
+  CODEX_AUTH_BASE,
+  CODEX_TOKEN_URL,
+  CODEX_DEVICE_VERIFICATION_URL,
+  CODEX_DEVICE_REDIRECT_URI,
+  CODEX_RESPONSES_BASE,
+  CODEX_WHAM_BASE,
+  CODEX_ORIGINATOR,
+  CODEX_ID_TOKEN_AUTH_CLAIM,
+  CODEX_PROVIDER_ID,
+  CODEX_PROVIDER_BASE_URL,
+  CODEX_MODEL_ID_PREFIX,
+  CODEX_FALLBACK_MODEL_SLUGS,
+  CODEX_CLIENT_VERSION,
+  CODEX_REFRESH_WINDOW_MS,
+  CODEX_REFRESH_FALLBACK_MS,
+  CODEX_APPS_MCP_SERVER_ID,
+  CODEX_APPS_MCP_SERVER_NAME,
+  CODEX_APPS_MCP_URL,
+  CODEX_APPS_STARTUP_TIMEOUT_MS,
+  CODEX_APPS_REQUIRED_SCOPES
+};
+//# sourceMappingURL=chunk-2ESTGQ57.js.map

package/dist/chunk-2ESTGQ57.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/constants.ts"],"sourcesContent":["// Wire constants for the ChatGPT/Codex subscription backend.\n// Source: CODEX-SUBSCRIPTION-SPEC.md (verified against openai/codex codex-rs).\n\nexport const CODEX_ISSUER = \"https://auth.openai.com\";\nexport const CODEX_CLIENT_ID = \"app_EMoamEEZ73f0CkXaXp7hrann\"; // spec §1.1 (manager.rs:1444)\nexport const CODEX_AUTH_BASE = `${CODEX_ISSUER}/api/accounts`; // device endpoints (device_code_auth.rs:164)\nexport const CODEX_TOKEN_URL = `${CODEX_ISSUER}/oauth/token`; // exchange (form) + refresh (json)\nexport const CODEX_DEVICE_VERIFICATION_URL = `${CODEX_ISSUER}/codex/device`;\nexport const CODEX_DEVICE_REDIRECT_URI = `${CODEX_ISSUER}/deviceauth/callback`;\n\n// Model requests: base already includes /codex; client appends /responses, /models.\nexport const CODEX_RESPONSES_BASE = \"https://chatgpt.com/backend-api/codex\";\n// Usage lives on the WHAM base — NOT under /codex (verified, spec §1.8a).\nexport const CODEX_WHAM_BASE = \"https://chatgpt.com/backend-api\";\n\nexport const CODEX_ORIGINATOR = \"codex_cli_rs\"; // whitelisted originator (spec §1.2)\nexport const CODEX_ID_TOKEN_AUTH_CLAIM = \"https://api.openai.com/auth\";\n\n// Synthetic registry-provider identity. The provider's baseURL is the bare\n// /backend-api (NOT /codex) — codexSubscriptionFetch rewrites /responses ->\n// /codex/responses. Codex model ids are namespaced `codex/<slug>` so they never\n// collide with the built-in OpenAI provider's model ids; the fetch's resolveModel\n// strips the prefix before the slug reaches the backend.\nexport const CODEX_PROVIDER_ID = \"codex-subscription\";\nexport const CODEX_PROVIDER_BASE_URL = \"https://chatgpt.com/backend-api\";\nexport const CODEX_MODEL_ID_PREFIX = \"codex/\";\n\n// Offline fallback catalog. The live catalog from GET /models supersedes this\n// when wired; until then these are the selectable codex models and the\n// longest-prefix resolution targets. Confirmed live (2026-06) against a pro plan:\n// GET /codex/models returned exactly these (plus the internal codex-auto-review).\nexport const CODEX_FALLBACK_MODEL_SLUGS = [\n  \"gpt-5.5\",\n  \"gpt-5.4\",\n  \"gpt-5.4-mini\",\n  \"gpt-5.3-codex-spark\",\n] as const;\n\n// Sent as the `version` header and inside the User-Agent. Confirmed live: the\n// backend accepts the current codex CLI version; an older value risks /models\n// min_client_version filtering. Keep in step with the codex CLI releases.\nexport const CODEX_CLIENT_VERSION = \"0.142.4\";\n\nexport const CODEX_REFRESH_WINDOW_MS = 5 * 60 * 1000; // proactive refresh when within 5 min of exp (spec §1.1)\nexport const CODEX_REFRESH_FALLBACK_MS = 8 * 24 * 60 * 60 * 1000; // 8 days when exp is unparseable\n\n// ── Apps / connectors MCP (spec §1.10, §E) ───────────────────────────────────\n// One server-side MCP exposes ALL the user's ChatGPT/Codex connectors\n// (gmail/github/linear/slack/sentry/drive/calendar/…). Streamable HTTP, always.\nexport const CODEX_APPS_MCP_SERVER_ID = \"codex_apps\";        // tools surface as mcp__codex_apps__<tool>\nexport const CODEX_APPS_MCP_SERVER_NAME = \"codex_apps\";      // MCP `name` — MUST equal the id so the SDK namespaces tools as mcp__codex_apps__*\nexport const CODEX_APPS_MCP_URL = \"https://chatgpt.com/backend-api/ps/mcp\"; // live URL (NOT /codex, NOT the legacy /wham/apps)\nexport const CODEX_APPS_STARTUP_TIMEOUT_MS = 30_000;         // startup_timeout 30s (spec §1.10) — maps to timeoutMs on this server only\n// Connector scopes that the apps MCP requires. Present ONLY when granted at\n// browser-authorize time; the device-code path CANNOT be confirmed to grant\n// them, so treat connector availability as runtime-discovered (spec §1.10 / §E).\nexport const CODEX_APPS_REQUIRED_SCOPES = [\"api.connectors.read\", \"api.connectors.invoke\"] as const;\n"],"mappings":";AAGO,IAAM,eAAe;AACrB,IAAM,kBAAkB;AACxB,IAAM,kBAAkB,GAAG,YAAY;AACvC,IAAM,kBAAkB,GAAG,YAAY;AACvC,IAAM,gCAAgC,GAAG,YAAY;AACrD,IAAM,4BAA4B,GAAG,YAAY;AAGjD,IAAM,uBAAuB;AAE7B,IAAM,kBAAkB;AAExB,IAAM,mBAAmB;AACzB,IAAM,4BAA4B;AAOlC,IAAM,oBAAoB;AAC1B,IAAM,0BAA0B;AAChC,IAAM,wBAAwB;AAM9B,IAAM,6BAA6B;AAAA,EACxC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAKO,IAAM,uBAAuB;AAE7B,IAAM,0BAA0B,IAAI,KAAK;AACzC,IAAM,4BAA4B,IAAI,KAAK,KAAK,KAAK;AAKrD,IAAM,2BAA2B;AACjC,IAAM,6BAA6B;AACnC,IAAM,qBAAqB;AAC3B,IAAM,gCAAgC;AAItC,IAAM,6BAA6B,CAAC,uBAAuB,uBAAuB;","names":[]}

package/dist/constants.d.ts

@@ -0,0 +1,24 @@
+declare const CODEX_ISSUER = "https://auth.openai.com";
+declare const CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+declare const CODEX_AUTH_BASE = "https://auth.openai.com/api/accounts";
+declare const CODEX_TOKEN_URL = "https://auth.openai.com/oauth/token";
+declare const CODEX_DEVICE_VERIFICATION_URL = "https://auth.openai.com/codex/device";
+declare const CODEX_DEVICE_REDIRECT_URI = "https://auth.openai.com/deviceauth/callback";
+declare const CODEX_RESPONSES_BASE = "https://chatgpt.com/backend-api/codex";
+declare const CODEX_WHAM_BASE = "https://chatgpt.com/backend-api";
+declare const CODEX_ORIGINATOR = "codex_cli_rs";
+declare const CODEX_ID_TOKEN_AUTH_CLAIM = "https://api.openai.com/auth";
+declare const CODEX_PROVIDER_ID = "codex-subscription";
+declare const CODEX_PROVIDER_BASE_URL = "https://chatgpt.com/backend-api";
+declare const CODEX_MODEL_ID_PREFIX = "codex/";
+declare const CODEX_FALLBACK_MODEL_SLUGS: readonly ["gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex-spark"];
+declare const CODEX_CLIENT_VERSION = "0.142.4";
+declare const CODEX_REFRESH_WINDOW_MS: number;
+declare const CODEX_REFRESH_FALLBACK_MS: number;
+declare const CODEX_APPS_MCP_SERVER_ID = "codex_apps";
+declare const CODEX_APPS_MCP_SERVER_NAME = "codex_apps";
+declare const CODEX_APPS_MCP_URL = "https://chatgpt.com/backend-api/ps/mcp";
+declare const CODEX_APPS_STARTUP_TIMEOUT_MS = 30000;
+declare const CODEX_APPS_REQUIRED_SCOPES: readonly ["api.connectors.read", "api.connectors.invoke"];
+
+export { CODEX_APPS_MCP_SERVER_ID, CODEX_APPS_MCP_SERVER_NAME, CODEX_APPS_MCP_URL, CODEX_APPS_REQUIRED_SCOPES, CODEX_APPS_STARTUP_TIMEOUT_MS, CODEX_AUTH_BASE, CODEX_CLIENT_ID, CODEX_CLIENT_VERSION, CODEX_DEVICE_REDIRECT_URI, CODEX_DEVICE_VERIFICATION_URL, CODEX_FALLBACK_MODEL_SLUGS, CODEX_ID_TOKEN_AUTH_CLAIM, CODEX_ISSUER, CODEX_MODEL_ID_PREFIX, CODEX_ORIGINATOR, CODEX_PROVIDER_BASE_URL, CODEX_PROVIDER_ID, CODEX_REFRESH_FALLBACK_MS, CODEX_REFRESH_WINDOW_MS, CODEX_RESPONSES_BASE, CODEX_TOKEN_URL, CODEX_WHAM_BASE };

package/dist/constants.js

@@ -0,0 +1,49 @@
+import {
+  CODEX_APPS_MCP_SERVER_ID,
+  CODEX_APPS_MCP_SERVER_NAME,
+  CODEX_APPS_MCP_URL,
+  CODEX_APPS_REQUIRED_SCOPES,
+  CODEX_APPS_STARTUP_TIMEOUT_MS,
+  CODEX_AUTH_BASE,
+  CODEX_CLIENT_ID,
+  CODEX_CLIENT_VERSION,
+  CODEX_DEVICE_REDIRECT_URI,
+  CODEX_DEVICE_VERIFICATION_URL,
+  CODEX_FALLBACK_MODEL_SLUGS,
+  CODEX_ID_TOKEN_AUTH_CLAIM,
+  CODEX_ISSUER,
+  CODEX_MODEL_ID_PREFIX,
+  CODEX_ORIGINATOR,
+  CODEX_PROVIDER_BASE_URL,
+  CODEX_PROVIDER_ID,
+  CODEX_REFRESH_FALLBACK_MS,
+  CODEX_REFRESH_WINDOW_MS,
+  CODEX_RESPONSES_BASE,
+  CODEX_TOKEN_URL,
+  CODEX_WHAM_BASE
+} from "./chunk-2ESTGQ57.js";
+export {
+  CODEX_APPS_MCP_SERVER_ID,
+  CODEX_APPS_MCP_SERVER_NAME,
+  CODEX_APPS_MCP_URL,
+  CODEX_APPS_REQUIRED_SCOPES,
+  CODEX_APPS_STARTUP_TIMEOUT_MS,
+  CODEX_AUTH_BASE,
+  CODEX_CLIENT_ID,
+  CODEX_CLIENT_VERSION,
+  CODEX_DEVICE_REDIRECT_URI,
+  CODEX_DEVICE_VERIFICATION_URL,
+  CODEX_FALLBACK_MODEL_SLUGS,
+  CODEX_ID_TOKEN_AUTH_CLAIM,
+  CODEX_ISSUER,
+  CODEX_MODEL_ID_PREFIX,
+  CODEX_ORIGINATOR,
+  CODEX_PROVIDER_BASE_URL,
+  CODEX_PROVIDER_ID,
+  CODEX_REFRESH_FALLBACK_MS,
+  CODEX_REFRESH_WINDOW_MS,
+  CODEX_RESPONSES_BASE,
+  CODEX_TOKEN_URL,
+  CODEX_WHAM_BASE
+};
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,267 @@
+export { CODEX_APPS_MCP_SERVER_ID, CODEX_APPS_MCP_SERVER_NAME, CODEX_APPS_MCP_URL, CODEX_APPS_REQUIRED_SCOPES, CODEX_APPS_STARTUP_TIMEOUT_MS, CODEX_AUTH_BASE, CODEX_CLIENT_ID, CODEX_CLIENT_VERSION, CODEX_DEVICE_REDIRECT_URI, CODEX_DEVICE_VERIFICATION_URL, CODEX_FALLBACK_MODEL_SLUGS, CODEX_ID_TOKEN_AUTH_CLAIM, CODEX_ISSUER, CODEX_MODEL_ID_PREFIX, CODEX_ORIGINATOR, CODEX_PROVIDER_BASE_URL, CODEX_PROVIDER_ID, CODEX_REFRESH_FALLBACK_MS, CODEX_REFRESH_WINDOW_MS, CODEX_RESPONSES_BASE, CODEX_TOKEN_URL, CODEX_WHAM_BASE } from './constants.js';
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+/**
+ * Pure NECESSARY condition for a Codex-billed turn: the model id is namespaced
+ * for the Codex subscription provider (`codex/<slug>`).
+ *
+ * This is NOT sufficient to bypass billing — an active, connected workspace
+ * credential and the deployment flag (`settings.codexSubscriptionEnabled`) are
+ * ALSO required (see `isCodexBilledTurn`/`workspaceCodexSubscriptionActive` in
+ * `@opengeni/db`). Used only as a cheap, synchronous short-circuit so the common
+ * non-codex path never issues a credential read.
+ */
+declare function isCodexBilledModel(model: string | null | undefined): boolean;
+
+type CodexFetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
+type CodexDeviceStart = {
+    deviceAuthId: string;
+    userCode: string;
+    verificationUri: string;
+    intervalSeconds: number;
+};
+type CodexTokens = {
+    idToken: string;
+    accessToken: string;
+    refreshToken: string;
+};
+type CodexPollResult = {
+    status: "pending";
+} | {
+    status: "expired";
+} | {
+    status: "authorized";
+    authorizationCode: string;
+    codeVerifier: string;
+};
+declare class CodexDeviceError extends Error {
+    constructor(message: string);
+}
+/** Step 1: POST {auth}/deviceauth/usercode {client_id}. device_code_auth.rs:67-95 */
+declare function startDeviceCode(fetchImpl?: CodexFetch): Promise<CodexDeviceStart>;
+/** Step 3 (single, non-blocking): POST {auth}/deviceauth/token. 403/404 => pending. device_code_auth.rs:106-145 */
+declare function pollDeviceCode(input: {
+    deviceAuthId: string;
+    userCode: string;
+}, fetchImpl?: CodexFetch): Promise<CodexPollResult>;
+/** Step 4: POST {issuer}/oauth/token form-encoded grant_type=authorization_code. server.rs:732-766 */
+declare function exchangeDeviceCode(input: {
+    authorizationCode: string;
+    codeVerifier: string;
+}, fetchImpl?: CodexFetch): Promise<CodexTokens>;
+
+/** Permanent — the workspace must reconnect (status => needs_relogin). */
+declare class CodexReloginRequired extends Error {
+    constructor(message: string);
+}
+/** Transient — safe to retry later. */
+declare class CodexRefreshTransient extends Error {
+    constructor(message: string);
+}
+/** Only present fields are returned (the server may rotate any subset). */
+type CodexRefreshTokens = {
+    idToken?: string | undefined;
+    accessToken?: string | undefined;
+    refreshToken?: string | undefined;
+};
+/** POST {issuer}/oauth/token JSON {client_id, grant_type:"refresh_token", refresh_token}. manager.rs:1336-1340 */
+declare function refreshCodexToken(refreshToken: string, fetchImpl?: CodexFetch): Promise<CodexRefreshTokens>;
+/** Decode a JWT payload (base64url, no signature check). */
+declare function decodeJwtPayload(jwt: string): Record<string, unknown> | null;
+/** access-token `exp` claim -> Date | null. token_data.rs:101-105 */
+declare function accessTokenExpiry(accessToken: string): Date | null;
+/** id_token -> {chatgptAccountId, planType, isFedramp}. server.rs:827-832; token_data.rs:71-99 */
+declare function parseIdToken(idToken: string): {
+    chatgptAccountId: string | null;
+    planType: string | null;
+    isFedramp: boolean;
+    email: string | null;
+};
+
+/** Mutates a parsed Responses request body in place and returns it. Pure + synchronous + unit-testable. */
+declare function normalizeCodexRequestBody(body: Record<string, unknown>, resolveModel: (slug: string) => string): Record<string, unknown>;
+/**
+ * Build a longest-prefix model resolver. Catalog slugs come from GET /models
+ * (api-client.ts). One leading `namespace/` segment is stripped first; an
+ * unknown slug returns the fallback (caller should log — spec §1.4 step 4).
+ */
+declare function buildModelResolver(liveSlugs: readonly string[], fallbackSlug: string): (slug: string) => string;
+
+/** The 5-hour (primary) window's `limit_window_seconds`. */
+declare const CODEX_FIVE_HOUR_WINDOW_SECONDS = 18000;
+/** The weekly (secondary) window's `limit_window_seconds`. */
+declare const CODEX_WEEKLY_WINDOW_SECONDS = 604800;
+/** One normalized usage window (applied to BOTH primary_window and secondary_window). */
+type CodexUsageWindow = {
+    used: number;
+    limit: number;
+    remaining: number;
+    percent: number;
+    resetAt: string | null;
+    resetAfterSeconds: number | null;
+    limitWindowSeconds: number;
+};
+/** One additional (per-feature) limit (forward-compat; P2 renders nothing from it). */
+type CodexAdditionalLimit = {
+    limitName: string;
+    meteredFeature: string;
+    fiveHour: CodexUsageWindow | null;
+    weekly: CodexUsageWindow | null;
+};
+type CodexUsageStatus = "ok" | "limit_reached" | "error" | "no-data";
+/** The normalized usage payload — the P2/P3 contract. */
+type CodexUsagePayload = {
+    status: CodexUsageStatus;
+    planType: string | null;
+    fiveHour: CodexUsageWindow | null;
+    weekly: CodexUsageWindow | null;
+    limitReached: boolean;
+    fetchedAt: string;
+    /** Present only on a refresh/auth failure path; carries the precise reason. */
+    reason?: "needs_relogin" | undefined;
+    additionalLimits?: CodexAdditionalLimit[] | undefined;
+    credits?: {
+        hasCredits: boolean;
+        unlimited: boolean;
+        overageLimitReached: boolean;
+        balance: string;
+    } | undefined;
+};
+/**
+ * Build a normalized window from the PERSISTED cache columns (used_percent +
+ * absolute reset timestamp). The same 0–100 synthesis as the live path, with the
+ * skew-free countdown derived from `resetAt − now` at read time. Returns null when
+ * there is no cached percent yet. `limitWindowSeconds` is the constant that
+ * identifies the window (18000 ⇒ 5h, 604800 ⇒ weekly).
+ */
+declare function buildCodexUsageWindowFromCache(usedPercent: number | null | undefined, resetAt: Date | string | null | undefined, limitWindowSeconds: number): CodexUsageWindow | null;
+/**
+ * Normalize a /wham/usage fetch result into the P2/P3 contract.
+ *
+ * @param httpStatus the HTTP status from fetchCodexUsage (404 ⇒ a limit body)
+ * @param rawPayload the parsed JSON body (or null when the body was unreadable)
+ */
+declare function normalizeCodexUsage(httpStatus: number, rawPayload: unknown): CodexUsagePayload;
+
+type CodexAuthHeaders = {
+    accessToken: string;
+    chatgptAccountId: string | null;
+    isFedramp: boolean;
+    clientVersion: string;
+};
+/** GET /codex/models — login-check + live catalog. A 200 means the token is accepted. spec §1.4/§F */
+declare function fetchCodexModels(a: CodexAuthHeaders, fetchImpl?: CodexFetch): Promise<{
+    ok: boolean;
+    status: number;
+    slugs: string[];
+}>;
+/** GET /wham/usage — authoritative limits. NB the WHAM base is /backend-api, NOT /codex (spec §1.8a). */
+declare function fetchCodexUsage(a: CodexAuthHeaders, fetchImpl?: CodexFetch): Promise<{
+    status: number;
+    payload: unknown;
+}>;
+
+type CodexTokenSnapshot = {
+    accessToken: string;
+    chatgptAccountId: string | null;
+    isFedramp: boolean;
+};
+/**
+ * Multi-account P4 (Part A): a full usage snapshot scraped FOR FREE from the
+ * `x-codex-primary-*` / `x-codex-secondary-*` response headers the codex backend
+ * stamps on every `/codex/responses` turn (success AND 429 hard-cap). Integer-
+ * identical to GET /wham/usage but with zero extra round-trip. parseCodexUsageHeaders
+ * returns this only when BOTH windows parse, so a write is always a full 5-column
+ * snapshot (no partial-window clobber). Shape mirrors db's CodexAccountUsageSnapshot
+ * (non-null here: a partial read is filtered to null upstream, never half-written).
+ */
+type CodexUsageHeaderSnapshot = {
+    primaryUsedPercent: number;
+    primaryResetAt: Date;
+    secondaryUsedPercent: number;
+    secondaryResetAt: Date;
+    checkedAt: Date;
+};
+type CodexRequestContext = {
+    clientVersion: string;
+    /** Worker-supplied: proactive refresh + single-flight + db persist. */
+    getToken: () => Promise<CodexTokenSnapshot>;
+    /** Forced refresh used for the 401 retry. */
+    refresh: () => Promise<CodexTokenSnapshot>;
+    /** Model-slug resolver (longest-prefix against the live catalog). */
+    resolveModel: (slug: string) => string;
+    /**
+     * Multi-account P4 (Part A): fire-and-forget usage-header sink. Called by
+     * codexSubscriptionFetch on EVERY response (sync, non-throwing, never awaited)
+     * with the parsed full-window snapshot. The worker records the latest into the
+     * P2 usage cache once per turn in its `finally` — packages/codex stays db-free.
+     */
+    onUsageHeaders?: (snapshot: CodexUsageHeaderSnapshot) => void;
+};
+declare const codexRequestStorage: AsyncLocalStorage<CodexRequestContext>;
+
+type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+/**
+ * Multi-account P4 (Part A): scrape the full usage snapshot the codex backend
+ * stamps on every `/codex/responses` response in `x-codex-primary-*` /
+ * `x-codex-secondary-*` headers (integer-identical to GET /wham/usage, for free).
+ *
+ * CRITICAL clobber-fix: return null unless BOTH windows expose a valid used-percent
+ * integer. recordCodexAccountUsage writes all five columns unconditionally, so a
+ * primary-only snapshot would null the weekly column. Both windows are always
+ * emitted together on `/codex/responses`; gating on both makes every write a full
+ * 5-column snapshot byte-identical to the poll path, and a malformed/absent header
+ * set simply no-ops (the /wham/usage poll fallback still covers it).
+ */
+declare function parseCodexUsageHeaders(headers: Headers): CodexUsageHeaderSnapshot | null;
+declare function codexSubscriptionFetch(base?: FetchLike): FetchLike;
+/** The codex backend's hard-cap error type (ChatGPT/Codex usage limit reached). */
+declare const CODEX_USAGE_LIMIT_ERROR_TYPE = "usage_limit_reached";
+type CodexUsageLimitInfo = {
+    /** Seconds until the usage cap resets, when the backend reported it. */
+    resetsInSeconds: number | null;
+};
+/**
+ * Classify a thrown error as a ChatGPT/Codex usage-cap (429 usage_limit_reached)
+ * and extract the reset window. The SDK surfaces the codex backend's 429 as an
+ * OpenAI APIError whose `.type` (and `.error.type`) is `usage_limit_reached` and
+ * whose `.error.resets_in_seconds` carries the cap reset. Walks the cause chain
+ * and tolerates the message-only shape so it survives any SDK re-wrapping.
+ * Returns null for anything that is not a usage cap.
+ */
+declare function classifyCodexUsageLimitError(error: unknown): CodexUsageLimitInfo | null;
+
+/**
+ * Maps connector tool names to a Responses-API-legal charset and back. One
+ * instance per codex_apps transport (i.e. per turn): tools/list populates it,
+ * tools/call reads it. Idempotent across repeat listings.
+ */
+declare class ToolNameMapper {
+    private readonly sanitizedToOriginal;
+    private readonly used;
+    /** Return a legal, unique name (<= EFFECTIVE_MAX_TOOL_NAME_LEN, so `<prefix>__name` <= 64) for `original`, recording the reverse mapping. */
+    sanitize(original: string): string;
+    /** Reverse a sanitized name back to the MCP server's original, if known. */
+    toOriginal(sanitized: string): string | undefined;
+}
+/** Sanitize a single JSON body (application/json MCP response). */
+declare function sanitizeMcpJsonBody(text: string, mapper?: ToolNameMapper, namespaceSink?: Set<string>): string;
+/** Sanitize an SSE body: each JSON-RPC message rides on a `data:` line. */
+declare function sanitizeMcpSseBody(text: string, mapper?: ToolNameMapper, namespaceSink?: Set<string>): string;
+/** Reverse a sanitized tools/call name back to the original; returns null if no rewrite is needed. */
+declare function remapToolCallRequestBody(body: string, mapper: ToolNameMapper): string | null;
+/**
+ * Wrap a base fetch so the codex_apps MCP transport is Responses-API-compatible:
+ * tools/list responses get their names sanitized + bad outputSchemas dropped (and
+ * the name mapping recorded), and tools/call requests get their name reversed back
+ * to the MCP server's original. Only the POST request/response is buffered; the
+ * long-lived GET notification SSE stream is passed through untouched.
+ *
+ * P4 (Part B.1): an optional `namespaceSink` Set accumulates the ORIGINAL-dotted
+ * connector namespaces seen across every tools/list this turn (captured before the
+ * dot is sanitized away). The worker reads the (live, by-reference) Set after the
+ * turn to cache the serving account's connector set — packages/codex stays db-free.
+ */
+declare function codexAppsSanitizingFetch(base?: FetchLike, namespaceSink?: Set<string>): FetchLike;
+
+export { CODEX_FIVE_HOUR_WINDOW_SECONDS, CODEX_USAGE_LIMIT_ERROR_TYPE, CODEX_WEEKLY_WINDOW_SECONDS, type CodexAdditionalLimit, type CodexAuthHeaders, CodexDeviceError, type CodexDeviceStart, type CodexFetch, type CodexPollResult, type CodexRefreshTokens, CodexRefreshTransient, CodexReloginRequired, type CodexRequestContext, type CodexTokenSnapshot, type CodexTokens, type CodexUsageHeaderSnapshot, type CodexUsageLimitInfo, type CodexUsagePayload, type CodexUsageStatus, type CodexUsageWindow, type FetchLike, ToolNameMapper, accessTokenExpiry, buildCodexUsageWindowFromCache, buildModelResolver, classifyCodexUsageLimitError, codexAppsSanitizingFetch, codexRequestStorage, codexSubscriptionFetch, decodeJwtPayload, exchangeDeviceCode, fetchCodexModels, fetchCodexUsage, isCodexBilledModel, normalizeCodexRequestBody, normalizeCodexUsage, parseCodexUsageHeaders, parseIdToken, pollDeviceCode, refreshCodexToken, remapToolCallRequestBody, sanitizeMcpJsonBody, sanitizeMcpSseBody, startDeviceCode };