openai-codex-oauth 1.0.0 → 1.0.1

package/dist/index.js

@@ -1,25 +1,605 @@
-import {
-  DEFAULT_CLIENT_ID,
-  DEFAULT_CODEX_BASE_URL,
-  DEFAULT_ISSUER,
-  OpenAIOAuthError,
-  createCodexOAuthClient,
-  createCodexOAuthFetch,
-  createMemoryTokenStore,
-  createOpenAIOAuthProxy,
-  normalizeCodexResponsesBody,
-  refreshOpenAITokens,
-  startOpenAIDeviceFlow
-} from "./chunk-GI2K7JPK.js";
-import {
-  deriveAccountId,
-  deriveExpiresAt,
-  parseJwtClaims
-} from "./chunk-SCKIRN2D.js";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_CLIENT_ID: () => DEFAULT_CLIENT_ID,
+  DEFAULT_CODEX_BASE_URL: () => DEFAULT_CODEX_BASE_URL,
+  DEFAULT_ISSUER: () => DEFAULT_ISSUER,
+  OpenAIOAuthError: () => OpenAIOAuthError,
+  createCodexOAuthClient: () => createCodexOAuthClient,
+  createCodexOAuthFetch: () => createCodexOAuthFetch,
+  createMemoryTokenStore: () => createMemoryTokenStore,
+  createOpenAIOAuth: () => createOpenAIOAuth,
+  createOpenAIOAuthProxy: () => createOpenAIOAuthProxy,
+  deriveAccountId: () => deriveAccountId,
+  deriveExpiresAt: () => deriveExpiresAt,
+  normalizeCodexResponsesBody: () => normalizeCodexResponsesBody,
+  parseJwtClaims: () => parseJwtClaims,
+  refreshOpenAITokens: () => refreshOpenAITokens,
+  startOpenAIDeviceFlow: () => startOpenAIDeviceFlow
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/jwt.ts
+function decodeBase64Url(value) {
+  try {
+    const base64 = value.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+    if (typeof globalThis.atob === "function") {
+      const binary = globalThis.atob(padded);
+      const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+      return new TextDecoder().decode(bytes);
+    }
+    return Buffer.from(padded, "base64").toString("utf8");
+  } catch {
+    return void 0;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJwtClaims(token) {
+  if (!token?.includes(".")) {
+    return void 0;
+  }
+  const parts = token.split(".");
+  if (parts.length !== 3 || !parts[1]) {
+    return void 0;
+  }
+  const payload = decodeBase64Url(parts[1]);
+  if (!payload) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(payload);
+    return isRecord(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function deriveAccountId(...tokens) {
+  for (const token of tokens) {
+    const claims = parseJwtClaims(token);
+    const auth = claims?.["https://api.openai.com/auth"];
+    if (isRecord(auth) && typeof auth.chatgpt_account_id === "string" && auth.chatgpt_account_id.length > 0) {
+      return auth.chatgpt_account_id;
+    }
+  }
+  return void 0;
+}
+function deriveExpiresAt(token) {
+  const claims = parseJwtClaims(token);
+  return typeof claims?.exp === "number" ? claims.exp * 1e3 : void 0;
+}
+
+// src/types.ts
+var OpenAIOAuthError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "OpenAIOAuthError";
+    this.code = code;
+  }
+};
+
+// src/device-flow.ts
+var DEFAULT_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+var DEFAULT_ISSUER = "https://auth.openai.com";
+var POLL_BUFFER_MS = 3e3;
+function pickFetch(customFetch) {
+  if (typeof customFetch === "function") {
+    return customFetch;
+  }
+  if (typeof globalThis.fetch === "function") {
+    return globalThis.fetch.bind(globalThis);
+  }
+  throw new OpenAIOAuthError("fetch_required", "A fetch implementation is required for OpenAI OAuth.");
+}
+async function startOpenAIDeviceFlow(options = {}) {
+  const fetch = pickFetch(options.fetch);
+  const issuer = (options.issuer ?? DEFAULT_ISSUER).replace(/\/$/, "");
+  const clientId = options.clientId ?? DEFAULT_CLIENT_ID;
+  const now = options.now ?? (() => Date.now());
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const codeResponse = await fetch(`${issuer}/api/accounts/deviceauth/usercode`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ client_id: clientId })
+  });
+  if (!codeResponse.ok) {
+    throw new OpenAIOAuthError("auth_failed", "Failed to initiate OpenAI authorization.");
+  }
+  const device = await codeResponse.json();
+  if (!device.device_auth_id || !device.user_code) {
+    throw new OpenAIOAuthError("auth_failed", "OpenAI authorization response did not include a device code.");
+  }
+  const intervalSeconds = typeof device.interval === "number" ? device.interval : parseInt(device.interval ?? "5", 10);
+  const intervalMs = Math.max(Number.isFinite(intervalSeconds) ? intervalSeconds : 5, 1) * 1e3;
+  return {
+    providerId: "openai",
+    url: `${issuer}/codex/device`,
+    code: device.user_code,
+    instructions: `Enter code: ${device.user_code}`,
+    async complete() {
+      while (true) {
+        const poll = await fetch(`${issuer}/api/accounts/deviceauth/token`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            device_auth_id: device.device_auth_id,
+            user_code: device.user_code
+          })
+        });
+        if (poll.ok) {
+          const grant = await poll.json();
+          if (!grant.authorization_code || !grant.code_verifier) {
+            throw new OpenAIOAuthError("auth_failed", "OpenAI authorization grant was incomplete.");
+          }
+          const tokens = await exchangeAuthorizationCode({
+            fetch,
+            issuer,
+            clientId,
+            authorizationCode: grant.authorization_code,
+            codeVerifier: grant.code_verifier,
+            now
+          });
+          await options.tokenStore?.save(tokens);
+          return tokens;
+        }
+        if (poll.status !== 403 && poll.status !== 404) {
+          throw new OpenAIOAuthError("auth_failed", "OpenAI OAuth authorization failed.");
+        }
+        await sleep(intervalMs + POLL_BUFFER_MS);
+      }
+    }
+  };
+}
+async function exchangeAuthorizationCode({
+  fetch,
+  issuer,
+  clientId,
+  authorizationCode,
+  codeVerifier,
+  now
+}) {
+  const response = await fetch(`${issuer}/oauth/token`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code: authorizationCode,
+      redirect_uri: `${issuer}/deviceauth/callback`,
+      client_id: clientId,
+      code_verifier: codeVerifier
+    }).toString()
+  });
+  if (!response.ok) {
+    throw new OpenAIOAuthError("auth_failed", "OpenAI token exchange failed.");
+  }
+  const token = await response.json();
+  if (!token.access_token) {
+    throw new OpenAIOAuthError("auth_failed", "OpenAI token exchange did not return an access token.");
+  }
+  return {
+    refreshToken: token.refresh_token,
+    accessToken: token.access_token,
+    idToken: token.id_token,
+    expiresAt: now() + (token.expires_in ?? 3600) * 1e3,
+    accountId: deriveAccountId(token.id_token, token.access_token)
+  };
+}
+async function refreshOpenAITokens({
+  tokens,
+  fetch,
+  clientId = DEFAULT_CLIENT_ID,
+  issuer = DEFAULT_ISSUER,
+  tokenUrl,
+  now = () => Date.now()
+}) {
+  if (!tokens.refreshToken) {
+    return void 0;
+  }
+  const resolvedIssuer = issuer.replace(/\/$/, "");
+  const response = await fetch(tokenUrl ?? `${resolvedIssuer}/oauth/token`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: tokens.refreshToken,
+      client_id: clientId,
+      scope: "openid profile email offline_access"
+    }).toString()
+  });
+  if (!response.ok) {
+    return void 0;
+  }
+  const payload = await response.json();
+  if (!payload.access_token) {
+    return void 0;
+  }
+  const next = {
+    accessToken: payload.access_token,
+    refreshToken: payload.refresh_token ?? tokens.refreshToken,
+    idToken: payload.id_token ?? tokens.idToken,
+    expiresAt: now() + (payload.expires_in ?? 3600) * 1e3
+  };
+  next.accountId = deriveAccountId(next.idToken, next.accessToken) ?? tokens.accountId;
+  return next;
+}
+
+// src/memory-token-store.ts
+function createMemoryTokenStore(initial) {
+  let current = initial;
+  return {
+    async load() {
+      return current;
+    },
+    async save(tokens) {
+      current = tokens;
+    }
+  };
+}
+
+// src/codex-fetch.ts
+var DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex";
+var DEFAULT_BROWSER_PROXY_BASE_URL = "/api/proxy/openai/codex";
+var DEFAULT_REFRESH_MARGIN_MS = 5 * 60 * 1e3;
+var DEFAULT_INSTRUCTIONS = "";
+var DEFAULT_ORIGINATOR = "openai-codex-oauth";
+function pickFetch2(customFetch) {
+  if (typeof customFetch === "function") {
+    return customFetch;
+  }
+  if (typeof globalThis.fetch === "function") {
+    return globalThis.fetch.bind(globalThis);
+  }
+  throw new OpenAIOAuthError("fetch_required", "A fetch implementation is required for OpenAI OAuth.");
+}
+function withoutTrailingSlash(value) {
+  return value.replace(/\/$/, "");
+}
+function resolveBaseURL(baseURL) {
+  return withoutTrailingSlash(baseURL ?? DEFAULT_CODEX_BASE_URL);
+}
+function createStore(settings) {
+  if (settings.tokenStore) {
+    return settings.tokenStore;
+  }
+  if (settings.tokens) {
+    return createMemoryTokenStore(settings.tokens);
+  }
+  throw new OpenAIOAuthError(
+    "tokens_required",
+    "OpenAI OAuth tokens are required. Pass `tokens`, `tokenStore`, or use `createCodexAuthFileStore` from `@tolksyn/openai-oauth/node`."
+  );
+}
+function needsRefresh(tokens, now, marginMs) {
+  const expiresAt = tokens.expiresAt ?? deriveExpiresAt(tokens.accessToken);
+  if (!tokens.accessToken) {
+    return true;
+  }
+  if (expiresAt == null || expiresAt <= 0) {
+    return false;
+  }
+  return expiresAt <= now + marginMs;
+}
+function hasExpired(tokens, now) {
+  const expiresAt = tokens.expiresAt ?? deriveExpiresAt(tokens.accessToken);
+  return expiresAt != null && expiresAt > 0 && expiresAt <= now;
+}
+var TokenManager = class {
+  constructor(settings, store, fetch) {
+    this.settings = settings;
+    this.store = store;
+    this.fetch = fetch;
+  }
+  settings;
+  store;
+  fetch;
+  /** Promise for an in-flight token refresh to coalesce concurrent requests. */
+  inflight;
+  /** Cached current tokens to avoid redundant store loads. */
+  current;
+  /**
+   * Gets valid OAuth tokens, triggering refresh if needed.
+   * Coalesces concurrent requests to avoid duplicate refresh calls.
+   */
+  async get() {
+    if (this.inflight) {
+      return this.inflight;
+    }
+    this.inflight = this.loadFresh().then((tokens) => {
+      this.current = tokens;
+      this.inflight = void 0;
+      return tokens;
+    }).catch((error) => {
+      this.inflight = void 0;
+      throw error;
+    });
+    return this.inflight;
+  }
+  /**
+   * Loads fresh tokens, optionally refreshing if expired or near expiry.
+   * Derives account ID from JWT claims if not explicitly provided.
+   */
+  async loadFresh() {
+    let tokens = this.current ?? await this.store.load();
+    if (!tokens?.accessToken) {
+      throw new OpenAIOAuthError("auth_failed", "OpenAI OAuth access token is missing.");
+    }
+    const now = this.settings.now?.() ?? Date.now();
+    const refreshMarginMs = this.settings.refreshMarginMs ?? DEFAULT_REFRESH_MARGIN_MS;
+    if (needsRefresh(tokens, now, refreshMarginMs)) {
+      const refreshed = await refreshOpenAITokens({
+        tokens,
+        fetch: this.fetch,
+        clientId: this.settings.clientId,
+        issuer: this.settings.issuer,
+        tokenUrl: this.settings.tokenUrl,
+        now: this.settings.now
+      });
+      if (refreshed) {
+        tokens = refreshed;
+        await this.store.save(tokens);
+        await this.settings.onTokens?.(tokens);
+      } else if (hasExpired(tokens, now)) {
+        throw new OpenAIOAuthError("auth_failed", "OpenAI OAuth access token expired and refresh failed.");
+      }
+    }
+    const accountId = tokens.accountId ?? deriveAccountId(tokens.idToken, tokens.accessToken);
+    if (!accountId) {
+      throw new OpenAIOAuthError(
+        "account_id_missing",
+        "OpenAI OAuth account id is missing. Store `accountId` with the tokens or include an id_token with the ChatGPT account claim."
+      );
+    }
+    return {
+      ...tokens,
+      accountId
+    };
+  }
+};
+function resolveTargetUrl(input, baseURL) {
+  const base = new URL(baseURL);
+  const parsed = /^https?:\/\//.test(input) ? new URL(input) : new URL(input, "https://codex.invalid");
+  let pathname = parsed.pathname;
+  const basePath = withoutTrailingSlash(base.pathname);
+  if (pathname === basePath) {
+    pathname = "/";
+  } else if (basePath && pathname.startsWith(`${basePath}/`)) {
+    pathname = pathname.slice(basePath.length);
+  }
+  if (pathname === "/v1") {
+    pathname = "/";
+  } else if (pathname.startsWith("/v1/")) {
+    pathname = pathname.slice(3);
+  }
+  if (!pathname.startsWith("/")) {
+    pathname = `/${pathname}`;
+  }
+  return `${base.origin}${basePath}${pathname}${parsed.search}`;
+}
+function browserOrigin() {
+  const maybeWindow = globalThis.window;
+  return typeof maybeWindow?.location?.origin === "string" ? maybeWindow.location.origin.replace(/\/$/, "") : void 0;
+}
+function resolveBrowserProxyUrl(target, baseURL, settings) {
+  const origin = browserOrigin();
+  if (!origin || settings.browserProxyBaseUrl === false) {
+    return void 0;
+  }
+  const proxyBase = settings.browserProxyBaseUrl ?? DEFAULT_BROWSER_PROXY_BASE_URL;
+  const absoluteProxyBase = /^https?:\/\//.test(proxyBase) ? proxyBase.replace(/\/$/, "") : `${origin}${proxyBase.startsWith("/") ? "" : "/"}${proxyBase}`.replace(/\/$/, "");
+  const upstreamBasePath = withoutTrailingSlash(new URL(baseURL).pathname);
+  let pathname = target.pathname;
+  if (upstreamBasePath && pathname.startsWith(`${upstreamBasePath}/`)) {
+    pathname = pathname.slice(upstreamBasePath.length);
+  }
+  return `${absoluteProxyBase}${pathname}${target.search}`;
+}
+async function readRequestParts(input, init) {
+  if (input instanceof Request) {
+    const headers = new Headers(input.headers);
+    if (init?.headers) {
+      new Headers(init.headers).forEach((value, key) => headers.set(key, value));
+    }
+    return {
+      url: input.url,
+      method: init?.method ?? input.method,
+      headers,
+      body: init?.body ?? (input.body == null ? void 0 : await input.clone().text()),
+      signal: init?.signal ?? input.signal
+    };
+  }
+  return {
+    url: String(input),
+    method: init?.method,
+    headers: new Headers(init?.headers),
+    body: init?.body,
+    signal: init?.signal
+  };
+}
+async function decodeBody(body) {
+  if (body == null) {
+    return void 0;
+  }
+  if (typeof body === "string") {
+    return body;
+  }
+  if (body instanceof URLSearchParams || body instanceof FormData || body instanceof ReadableStream) {
+    return void 0;
+  }
+  if (body instanceof Blob) {
+    return body.text();
+  }
+  if (body instanceof ArrayBuffer) {
+    return new TextDecoder().decode(body);
+  }
+  if (ArrayBuffer.isView(body)) {
+    return new TextDecoder().decode(body);
+  }
+  return void 0;
+}
+function normalizeCodexResponsesBody(body, options = {}) {
+  const normalized = { ...body };
+  if (typeof normalized.instructions !== "string") {
+    normalized.instructions = options.instructions ?? DEFAULT_INSTRUCTIONS;
+  }
+  if (normalized.store === void 0) {
+    normalized.store = options.store ?? false;
+  }
+  delete normalized.max_output_tokens;
+  return normalized;
+}
+async function prepareBody(pathname, headers, body, settings) {
+  if (!pathname.endsWith("/responses")) {
+    return body;
+  }
+  const contentType = headers.get("content-type");
+  if (contentType && !contentType.includes("application/json")) {
+    return body;
+  }
+  const bodyText = await decodeBody(body);
+  if (typeof bodyText !== "string") {
+    return body;
+  }
+  try {
+    const parsed = JSON.parse(bodyText);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return body;
+    }
+    return JSON.stringify(normalizeCodexResponsesBody(parsed, settings));
+  } catch {
+    return body;
+  }
+}
+function createCodexOAuthFetch(settings = {}) {
+  const fetch = pickFetch2(settings.fetch);
+  const store = createStore(settings);
+  const manager = new TokenManager(settings, store, fetch);
+  const baseURL = resolveBaseURL(settings.baseURL);
+  return async (input, init) => {
+    const request = await readRequestParts(input, init);
+    const targetUrl = resolveTargetUrl(request.url, baseURL);
+    const target = new URL(targetUrl);
+    const tokens = await manager.get();
+    const headers = new Headers(settings.headers);
+    request.headers.forEach((value, key) => headers.set(key, value));
+    headers.delete("authorization");
+    headers.delete("chatgpt-account-id");
+    headers.delete("openai-beta");
+    headers.set("Authorization", `Bearer ${tokens.accessToken}`);
+    headers.set("ChatGPT-Account-Id", tokens.accountId);
+    headers.set("OpenAI-Beta", "responses=experimental");
+    if (settings.originator !== false && !headers.has("originator")) {
+      headers.set("originator", settings.originator ?? DEFAULT_ORIGINATOR);
+    }
+    const body = await prepareBody(target.pathname, headers, request.body, settings);
+    return fetch(resolveBrowserProxyUrl(target, baseURL, settings) ?? target.toString(), {
+      method: request.method ?? init?.method,
+      headers,
+      body,
+      signal: request.signal ?? void 0
+    });
+  };
+}
+function createCodexOAuthClient(settings = {}) {
+  const baseURL = resolveBaseURL(settings.baseURL);
+  const fetch = createCodexOAuthFetch(settings);
+  return {
+    baseURL,
+    fetch,
+    request: (path, init) => fetch(resolveTargetUrl(path, baseURL), init)
+  };
+}
+
+// src/proxy.ts
+function pickFetch3(customFetch) {
+  if (typeof customFetch === "function") return customFetch;
+  if (typeof globalThis.fetch === "function") return globalThis.fetch.bind(globalThis);
+  throw new Error("A fetch implementation is required for OpenAI Codex proxy handlers.");
+}
+function noStoreText(text, status) {
+  return new Response(text, {
+    status,
+    headers: {
+      "Content-Type": "text/plain; charset=utf-8",
+      "Cache-Control": "no-store"
+    }
+  });
+}
+async function requestBody(request, options) {
+  const text = await request.text();
+  if (!text.trim()) return text;
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return text;
+    return JSON.stringify(normalizeCodexResponsesBody(parsed, options));
+  } catch {
+    return text;
+  }
+}
+function createOpenAIOAuthProxy(options = {}) {
+  const fetch = pickFetch3(options.fetch);
+  const baseURL = (options.baseURL ?? DEFAULT_CODEX_BASE_URL).replace(/\/$/, "");
+  return {
+    async responses(request) {
+      const authorization = request.headers.get("authorization") ?? "";
+      const accountId = request.headers.get("chatgpt-account-id") ?? "";
+      if (!authorization.trim() || !accountId.trim()) {
+        return noStoreText("Missing OpenAI OAuth credentials.", 401);
+      }
+      const upstream = await fetch(`${baseURL}/responses${new URL(request.url).search}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: authorization,
+          "ChatGPT-Account-Id": accountId,
+          "OpenAI-Beta": "responses=experimental",
+          ...options.originator === false ? {} : { originator: options.originator ?? "openai-codex-oauth" }
+        },
+        body: await requestBody(request, options)
+      });
+      return new Response(upstream.body, {
+        status: upstream.status,
+        headers: {
+          "Content-Type": upstream.headers.get("Content-Type") ?? "application/json",
+          "Cache-Control": upstream.headers.get("Cache-Control") ?? "no-store"
+        }
+      });
+    }
+  };
+}
 
 // src/provider.ts
-import { createOpenAI } from "@ai-sdk/openai";
-import { NoSuchModelError } from "@ai-sdk/provider";
+var import_openai = require("@ai-sdk/openai");
+var import_provider = require("@ai-sdk/provider");
 
 // src/stream-to-generate.ts
 var emptyUsage = () => ({
@@ -203,7 +783,7 @@ var StreamOnlyLanguageModel = class {
 function createOpenAIOAuth(settings = {}) {
   const providerName = settings.name ?? "openai-oauth";
   const oauthFetch = createCodexOAuthFetch(settings);
-  const openai = createOpenAI({
+  const openai = (0, import_openai.createOpenAI)({
     apiKey: "oauth",
     baseURL: settings.baseURL ?? DEFAULT_CODEX_BASE_URL,
     name: providerName,
@@ -215,14 +795,15 @@ function createOpenAIOAuth(settings = {}) {
   provider.languageModel = createLanguageModel;
   provider.responses = createLanguageModel;
   provider.embeddingModel = (modelId) => {
-    throw new NoSuchModelError({ modelId, modelType: "embeddingModel" });
+    throw new import_provider.NoSuchModelError({ modelId, modelType: "embeddingModel" });
   };
   provider.imageModel = (modelId) => {
-    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
+    throw new import_provider.NoSuchModelError({ modelId, modelType: "imageModel" });
   };
   return provider;
 }
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   DEFAULT_CLIENT_ID,
   DEFAULT_CODEX_BASE_URL,
   DEFAULT_ISSUER,
@@ -238,5 +819,5 @@ export {
   parseJwtClaims,
   refreshOpenAITokens,
   startOpenAIDeviceFlow
-};
+});
 //# sourceMappingURL=index.js.map