openai-oauth 0.0.1 → 1.0.1

package/README.md

@@ -1,5 +1,7 @@
 # openai-oauth
 
+[GitHub](https://github.com/EvanZhouDev/openai-oauth) | [Legal](#legal)
+
 OpenAI-compatible local endpoint backed by your ChatGPT account.
 
 ## Usage
@@ -13,6 +15,7 @@ When startup succeeds, the CLI prints:
 ```text
 OpenAI-compatible endpoint ready at http://127.0.0.1:10531/v1
 Use this as your OpenAI base URL. No API key is required.
+Available Models: gpt-5.4, gpt-5.3-codex, ...
 ```
 
 If no auth file is available, it fails early and tells you to run:
@@ -23,15 +26,16 @@ npx @openai/codex login
 
 ## Configuration
 
-| Config | CLI | Default | Description |
-| --- | --- | --- | --- |
-| Host binding | `--host` | `127.0.0.1` | Host interface the local proxy binds to. |
-| Port | `--port` | `10531` | Port the local proxy binds to. |
-| Model allowlist | `--models` | `gpt-5.4`, `gpt-5.3-codex`, `gpt-5.3-codex-spark`, `gpt-5.2`, `gpt-5.1`, `gpt-5.1-codex`, `gpt-5.1-codex-max` | Comma-separated list of model ids exposed by `/v1/models`. |
-| Upstream base URL | `--base-url` | `https://chatgpt.com/backend-api/codex` | Override the upstream Codex base URL. |
-| OAuth client id | `--oauth-client-id` | `app_EMoamEEZ73f0CkXaXp7hrann` | Override the OAuth client id used for refresh. |
-| OAuth token URL | `--oauth-token-url` | `https://auth.openai.com/oauth/token` | Override the OAuth token URL used for refresh. |
-| Auth file path | `--oauth-file` | `--oauth-file` path if provided, otherwise `$CHATGPT_LOCAL_HOME/auth.json`, `$CODEX_HOME/auth.json`, `~/.chatgpt-local/auth.json`, `~/.codex/auth.json` | Override where the local OAuth auth file is discovered. |
+| Config            | CLI                 | Default                                                                                                                                                 | Description                                                                                                                        |
+| ----------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
+| Host binding      | `--host`            | `127.0.0.1`                                                                                                                                             | Host interface the local proxy binds to.                                                                                           |
+| Port              | `--port`            | `10531`                                                                                                                                                 | Port the local proxy binds to.                                                                                                     |
+| Model allowlist   | `--models`          | Account-specific Codex models discovered from ChatGPT                                                                                                   | Comma-separated list of model ids exposed by `/v1/models`. When omitted, the CLI mirrors the models your account can actually use. |
+| Codex API version | `--codex-version`   | Local `codex --version`, then `@openai/codex` latest from npm, then `0.111.0`                                                                          | Override the Codex API client version used for model discovery.                                                                    |
+| Upstream base URL | `--base-url`        | `https://chatgpt.com/backend-api/codex`                                                                                                                 | Override the upstream Codex base URL.                                                                                              |
+| OAuth client id   | `--oauth-client-id` | `app_EMoamEEZ73f0CkXaXp7hrann`                                                                                                                          | Override the OAuth client id used for refresh.                                                                                     |
+| OAuth token URL   | `--oauth-token-url` | `https://auth.openai.com/oauth/token`                                                                                                                   | Override the OAuth token URL used for refresh.                                                                                     |
+| Auth file path    | `--oauth-file`      | `--oauth-file` path if provided, otherwise `$CHATGPT_LOCAL_HOME/auth.json`, `$CODEX_HOME/auth.json`, `~/.chatgpt-local/auth.json`, `~/.codex/auth.json` | Override where the local OAuth auth file is discovered.                                                                            |
 
 ## Features
 
@@ -40,7 +44,7 @@ What currently works:
 - Working Endpoints:
   - `/v1/responses`
   - `/v1/chat/completions`
-  - `/v1/models` (with configurable model allowlist)
+  - `/v1/models` (account-aware by default, or overridden with `--models`)
 - Streaming Responses
 - Toolcalls
 - Reasoning Traces
@@ -57,4 +61,16 @@ What is intentionally not there yet:
 
 OpenAI's Codex CLI uses a special endpoint at `chatgpt.com/backend-api/codex/responses` to let you use special OpenAI rate limits tied to your ChatGPT account.
 
-By using the same Oauth tokens as Codex, we can effectively use OpenAI's API through Oauth instead of buying API credits.
+By using the same Oauth tokens as Codex, we can effectively use OpenAI's API through Oauth instead of buying API credits.
+
+## Legal
+
+This is an unofficial, community-maintained project and is not affiliated with, endorsed by, or sponsored by OpenAI, Inc.
+
+It uses your local Codex/ChatGPT authentication cache (auth.json, e.g. `~/.codex/auth.json`) and should be treated like password-equivalent credentials.
+
+Use only for personal, local experimentation on trusted machines; do not run as a hosted service, do not share access, and do not pool or redistribute tokens.
+
+You are solely responsible for complying with OpenAI’s Terms, policies, and any applicable agreements; misuse may result in rate limits, suspension, or termination.
+
+Provided “as is” with no warranties; you assume all risk for data exposure, costs, and account actions.

package/dist/{chunk-VZQM4BY4.js → chunk-WDJBHN6N.js}

@@ -21790,19 +21790,6 @@ import { jsonSchema as jsonSchema2, tool as tool2 } from "ai";
 
 // src/shared.ts
 import { Buffer as Buffer2 } from "buffer";
-
-// src/types.ts
-var defaultOpenAIOAuthModels = [
-  "gpt-5.4",
-  "gpt-5.3-codex",
-  "gpt-5.3-codex-spark",
-  "gpt-5.2",
-  "gpt-5.1",
-  "gpt-5.1-codex",
-  "gpt-5.1-codex-max"
-];
-
-// src/shared.ts
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 10531;
 var jsonHeaders = {
@@ -21893,16 +21880,6 @@ var usesServerReplayState = (value) => {
     (item) => isRecord5(item) && item.type === "item_reference" && typeof item.id === "string"
   );
 };
-var resolveModels = (models) => {
-  if (Array.isArray(models) && models.length > 0) {
-    return models;
-  }
-  const envModels = process.env.CODEX_OPENAI_MODEL_IDS;
-  if (typeof envModels === "string" && envModels.trim().length > 0) {
-    return envModels.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
-  }
-  return [...defaultOpenAIOAuthModels];
-};
 var copyUpstreamResponse = (response) => {
   const headers = new Headers(response.headers);
   for (const [key, value] of Object.entries(corsHeaders)) {
@@ -22463,6 +22440,176 @@ var handleChatCompletionsRequest = async (request, provider, logger) => {
   }
 };
 
+// src/models.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var MODELS_CACHE_TTL_MS = 5 * 60 * 1e3;
+var CODEX_VERSION_CACHE_TTL_MS = 60 * 60 * 1e3;
+var REGISTRY_URL = "https://registry.npmjs.org/@openai/codex/latest";
+var FALLBACK_CODEX_CLIENT_VERSION = "0.111.0";
+var execFileAsync = promisify(execFile);
+var isRecord6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var uniqueStrings = (values) => {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const value of values) {
+    if (!seen.has(value)) {
+      seen.add(value);
+      result.push(value);
+    }
+  }
+  return result;
+};
+var normalizeVersion = (value) => {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const match = value.trim().match(/\b\d+\.\d+\.\d+\b/);
+  return match?.[0];
+};
+var cachedCodexClientVersion;
+var codexClientVersionCacheExpiresAt = 0;
+var inflightCodexClientVersion;
+var resolveLocalCodexClientVersion = async (runCommand) => {
+  try {
+    const { stdout, stderr } = await runCommand("codex", ["--version"]);
+    return normalizeVersion(stdout) ?? normalizeVersion(stderr);
+  } catch {
+    return void 0;
+  }
+};
+var resolveRemoteCodexClientVersion = async (fetchImpl) => {
+  try {
+    const response = await fetchImpl(REGISTRY_URL, {
+      headers: {
+        accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      return void 0;
+    }
+    const parsed = await response.json();
+    return typeof parsed.version === "string" ? normalizeVersion(parsed.version) : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var resolveCodexClientVersion = async (dependencies = {}) => {
+  if (typeof dependencies.codexVersion === "string" && dependencies.codexVersion.trim().length > 0) {
+    return dependencies.codexVersion.trim();
+  }
+  const now = Date.now();
+  if (cachedCodexClientVersion && now < codexClientVersionCacheExpiresAt) {
+    return cachedCodexClientVersion;
+  }
+  if (inflightCodexClientVersion) {
+    return inflightCodexClientVersion;
+  }
+  const runCommand = dependencies.runCommand ?? execFileAsync;
+  const fetchImpl = dependencies.fetchImpl ?? globalThis.fetch;
+  inflightCodexClientVersion = (async () => {
+    const localVersion = await resolveLocalCodexClientVersion(runCommand);
+    if (localVersion) {
+      cachedCodexClientVersion = localVersion;
+      codexClientVersionCacheExpiresAt = Date.now() + CODEX_VERSION_CACHE_TTL_MS;
+      inflightCodexClientVersion = void 0;
+      return localVersion;
+    }
+    const remoteVersion = await resolveRemoteCodexClientVersion(fetchImpl);
+    if (remoteVersion) {
+      cachedCodexClientVersion = remoteVersion;
+      codexClientVersionCacheExpiresAt = Date.now() + CODEX_VERSION_CACHE_TTL_MS;
+      inflightCodexClientVersion = void 0;
+      return remoteVersion;
+    }
+    cachedCodexClientVersion = FALLBACK_CODEX_CLIENT_VERSION;
+    codexClientVersionCacheExpiresAt = Date.now() + CODEX_VERSION_CACHE_TTL_MS;
+    dependencies.onWarning?.(
+      `Could not determine the Codex API version automatically. Falling back to ${FALLBACK_CODEX_CLIENT_VERSION}. Pass a version explicitly with --codex-version if you need to override it.`
+    );
+    inflightCodexClientVersion = void 0;
+    return FALLBACK_CODEX_CLIENT_VERSION;
+  })().catch((error40) => {
+    inflightCodexClientVersion = void 0;
+    throw error40;
+  });
+  return inflightCodexClientVersion;
+};
+var toUpstreamErrorMessage = (bodyText) => {
+  if (typeof bodyText !== "string" || bodyText.length === 0) {
+    return "Failed to load models from Codex.";
+  }
+  try {
+    const parsed = JSON.parse(bodyText);
+    if (typeof parsed.detail === "string" && parsed.detail.length > 0) {
+      return parsed.detail;
+    }
+    if (isRecord6(parsed.error) && typeof parsed.error.message === "string") {
+      return parsed.error.message;
+    }
+  } catch {
+  }
+  return bodyText;
+};
+var fetchAvailableModels = async (client, dependencies = {}) => {
+  const clientVersion = await resolveCodexClientVersion(dependencies);
+  const response = await client.request(
+    `/models?client_version=${encodeURIComponent(clientVersion)}`
+  );
+  const bodyText = await response.text();
+  if (!response.ok) {
+    throw new Error(toUpstreamErrorMessage(bodyText));
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(bodyText);
+  } catch {
+    throw new Error("Codex returned an invalid models response.");
+  }
+  if (!Array.isArray(parsed.models)) {
+    throw new Error("Codex returned a malformed models response.");
+  }
+  const models = uniqueStrings(
+    parsed.models.map((model) => model.slug).filter(
+      (slug) => typeof slug === "string" && slug.length > 0
+    )
+  );
+  if (models.length === 0) {
+    throw new Error("Codex returned an empty models list.");
+  }
+  return models;
+};
+var resolveOpenAIOAuthModels = async (client, configuredModels, dependencies = {}) => {
+  if (Array.isArray(configuredModels) && configuredModels.length > 0) {
+    return uniqueStrings(configuredModels);
+  }
+  return fetchAvailableModels(client, dependencies);
+};
+var createModelResolver = (client, configuredModels, dependencies = {}) => {
+  let cachedModels;
+  let cacheExpiresAt = 0;
+  let inflight;
+  return async () => {
+    const now = Date.now();
+    if (cachedModels && now < cacheExpiresAt) {
+      return [...cachedModels];
+    }
+    if (inflight) {
+      return [...await inflight];
+    }
+    inflight = resolveOpenAIOAuthModels(client, configuredModels, dependencies).then((models) => {
+      cachedModels = models;
+      cacheExpiresAt = Date.now() + MODELS_CACHE_TTL_MS;
+      inflight = void 0;
+      return models;
+    }).catch((error40) => {
+      inflight = void 0;
+      throw error40;
+    });
+    return [...await inflight];
+  };
+};
+
 // src/responses.ts
 var handleResponsesRequest = async (request, settings, client) => {
   const body = await request.json();
@@ -22507,7 +22654,7 @@ var handleResponsesRequest = async (request, settings, client) => {
 };
 
 // src/server.ts
-var handleRoutes = async (request, settings, provider, client, models, requestLogger) => {
+var handleRoutes = async (request, settings, provider, client, resolveModels, requestLogger) => {
   if (request.method === "OPTIONS") {
     return new Response(null, {
       status: 204,
@@ -22522,15 +22669,24 @@ var handleRoutes = async (request, settings, provider, client, models, requestLo
     });
   }
   if (request.method === "GET" && url2.pathname === "/v1/models") {
-    return toJsonResponse({
-      object: "list",
-      data: models.map((id) => ({
-        id,
-        object: "model",
-        created: 0,
-        owned_by: "codex-oauth"
-      }))
-    });
+    try {
+      const models = await resolveModels();
+      return toJsonResponse({
+        object: "list",
+        data: models.map((id) => ({
+          id,
+          object: "model",
+          created: 0,
+          owned_by: "codex-oauth"
+        }))
+      });
+    } catch (error40) {
+      return toErrorResponse(
+        error40 instanceof Error ? error40.message : "Failed to load models.",
+        502,
+        "upstream_error"
+      );
+    }
   }
   if (request.method === "POST" && url2.pathname === "/v1/responses") {
     return handleResponsesRequest(request, settings, client);
@@ -22541,13 +22697,15 @@ var handleRoutes = async (request, settings, provider, client, models, requestLo
   return toErrorResponse("Route not found.", 404, "not_found_error");
 };
 var createOpenAIOAuthFetchHandler = (settings = {}) => {
-  const models = resolveModels(settings.models);
   const sharedSettings = {
     ...settings,
     responsesState: false
   };
   const client = createCodexOAuthClient(sharedSettings);
   const provider = createOpenAIOAuth(sharedSettings);
+  const resolveModels = createModelResolver(client, settings.models, {
+    codexVersion: settings.codexVersion
+  });
   const requestLogger = createRequestLogger(settings);
   return async (request) => {
     try {
@@ -22556,7 +22714,7 @@ var createOpenAIOAuthFetchHandler = (settings = {}) => {
         settings,
         provider,
         client,
-        models,
+        resolveModels,
         requestLogger
       );
     } catch (error40) {
@@ -22578,6 +22736,10 @@ var startOpenAIOAuthServer = async (settings = {}) => {
       const response = await handler(request);
       await writeWebResponse(res, response);
     } catch (error40) {
+      if (res.headersSent || res.writableEnded) {
+        res.destroy(error40 instanceof Error ? error40 : void 0);
+        return;
+      }
       const message = error40 instanceof Error ? error40.message : "Unexpected server error.";
       await writeWebResponse(res, toErrorResponse(message, 500, "server_error"));
     }
@@ -22607,10 +22769,23 @@ var startOpenAIOAuthServer = async (settings = {}) => {
   };
 };
 
+// src/types.ts
+var defaultOpenAIOAuthModels = [
+  "gpt-5.4",
+  "gpt-5.3-codex",
+  "gpt-5.3-codex-spark",
+  "gpt-5.2",
+  "gpt-5.1",
+  "gpt-5.1-codex",
+  "gpt-5.1-codex-max"
+];
+
 export {
   resolveAuthFileCandidates,
-  defaultOpenAIOAuthModels,
+  createCodexOAuthClient,
   DEFAULT_PORT,
+  resolveOpenAIOAuthModels,
   createOpenAIOAuthFetchHandler,
-  startOpenAIOAuthServer
+  startOpenAIOAuthServer,
+  defaultOpenAIOAuthModels
 };

package/dist/cli.js

@@ -1,14 +1,188 @@
 #!/usr/bin/env node
 import {
   DEFAULT_PORT,
+  createCodexOAuthClient,
   resolveAuthFileCandidates,
+  resolveOpenAIOAuthModels,
   startOpenAIOAuthServer
-} from "./chunk-VZQM4BY4.js";
+} from "./chunk-WDJBHN6N.js";
 
 // src/cli-app.ts
 import { access } from "fs/promises";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
+
+// package.json
+var package_default = {
+  name: "openai-oauth",
+  version: "1.0.1",
+  description: "Free OpenAI API access with your ChatGPT account.",
+  type: "module",
+  bin: {
+    "openai-oauth": "./dist/cli.js"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      default: "./dist/index.js"
+    }
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "tsup src/index.ts src/cli.ts --format esm --dts --outDir dist --clean",
+    dev: "bun ./src/cli.ts",
+    prepublishOnly: "bun run build",
+    typecheck: "tsc --noEmit",
+    test: "vitest run",
+    "test:live": "LIVE_CODEX_E2E=1 vitest run test/live.e2e.test.ts"
+  },
+  dependencies: {
+    ai: "6.0.116",
+    yargs: "^17.7.2"
+  },
+  devDependencies: {
+    "@ai-sdk/openai": "3.0.41",
+    "@types/node": "20.17.24",
+    "@types/yargs": "^17.0.33",
+    "openai-oauth-core": "workspace:*",
+    "openai-oauth-provider": "workspace:*",
+    typescript: "latest",
+    vitest: "latest",
+    zod: "^3.25.76"
+  },
+  author: "EvanZhouDev",
+  license: "AGPL-3.0-only",
+  bugs: {
+    url: "https://github.com/EvanZhouDev/openai-oauth/issues"
+  },
+  homepage: "https://github.com/EvanZhouDev/openai-oauth#readme"
+};
+
+// src/cli-logging.ts
+var ansi = {
+  dim: "\x1B[2m",
+  reset: "\x1B[0m",
+  underline: "\x1B[4m"
+};
+var formatWarningMessage = (warning, provider, model) => {
+  const prefix = `openai-oauth Warning (${provider} / ${model}):`;
+  switch (warning.type) {
+    case "unsupported": {
+      let message = `${prefix} The feature "${warning.feature}" is not supported.`;
+      if (warning.details) {
+        message += ` ${warning.details}`;
+      }
+      return message;
+    }
+    case "compatibility": {
+      let message = `${prefix} The feature "${warning.feature}" is used in a compatibility mode.`;
+      if (warning.details) {
+        message += ` ${warning.details}`;
+      }
+      return message;
+    }
+    case "other":
+      return `${prefix} ${warning.message ?? "Unknown warning."}`;
+    default:
+      return `${prefix} ${JSON.stringify(warning, null, 2)}`;
+  }
+};
+var withAnsi = (text, code, options) => {
+  if (!options?.useColor) {
+    return text;
+  }
+  return `${code}${text}${ansi.reset}`;
+};
+var underline = (text, options) => withAnsi(text, ansi.underline, options);
+var dim = (text, options) => withAnsi(text, ansi.dim, options);
+var toStartupMessage = (baseUrl, availableModels, options) => [
+  `OpenAI-compatible endpoint ready at ${underline(baseUrl, options)}`,
+  dim("Use this as your OpenAI base URL. No API key is required.", options),
+  "",
+  `Available Models: ${availableModels.join(", ")}`
+].join("\n");
+var installCliWarningLogger = () => {
+  let hasLoggedWarningSystemMessage = false;
+  globalThis.AI_SDK_LOG_WARNINGS = ({ warnings, provider, model }) => {
+    if (warnings.length === 0) {
+      return;
+    }
+    if (!hasLoggedWarningSystemMessage) {
+      hasLoggedWarningSystemMessage = true;
+      console.info("");
+      console.info(
+        "openai-oauth Warning System: To turn off warning logging, set the AI_SDK_LOG_WARNINGS global to false."
+      );
+    }
+    for (const warning of warnings) {
+      console.warn(formatWarningMessage(warning, provider, model));
+    }
+  };
+};
+
+// src/update-check.ts
+var REGISTRY_URL = "https://registry.npmjs.org/openai-oauth/latest";
+var normalizeVersion = (value) => {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const match = value.trim().match(/^\d+\.\d+\.\d+$/);
+  return match?.[0];
+};
+var compareSemver = (left, right) => {
+  const leftParts = left.split(".").map(Number);
+  const rightParts = right.split(".").map(Number);
+  for (let index = 0; index < 3; index += 1) {
+    const leftPart = leftParts[index] ?? 0;
+    const rightPart = rightParts[index] ?? 0;
+    if (leftPart < rightPart) {
+      return -1;
+    }
+    if (leftPart > rightPart) {
+      return 1;
+    }
+  }
+  return 0;
+};
+var fetchLatestVersion = async (fetchImpl) => {
+  try {
+    const response = await fetchImpl(REGISTRY_URL, {
+      headers: {
+        accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      return void 0;
+    }
+    const parsed = await response.json();
+    return typeof parsed.version === "string" ? normalizeVersion(parsed.version) : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var checkForOpenAIOAuthUpdates = async (currentVersion, dependencies = {}) => {
+  const normalizedCurrentVersion = normalizeVersion(currentVersion);
+  if (normalizedCurrentVersion == null) {
+    return;
+  }
+  const latestVersion = await fetchLatestVersion(
+    dependencies.fetchImpl ?? globalThis.fetch
+  );
+  if (latestVersion == null) {
+    return;
+  }
+  if (compareSemver(normalizedCurrentVersion, latestVersion) >= 0) {
+    return;
+  }
+  dependencies.onWarning?.(
+    `A newer version of openai-oauth is available: ${normalizedCurrentVersion} -> ${latestVersion}.
+Run \`npx openai-oauth@latest\` to use the newest version.`
+  );
+};
+
+// src/cli-app.ts
 var parseModels = (value) => {
   if (typeof value !== "string") {
     return void 0;
@@ -16,34 +190,66 @@ var parseModels = (value) => {
   const models = value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
   return models.length > 0 ? models : void 0;
 };
+var helpLines = [
+  "Free OpenAI API access with your ChatGPT account.",
+  "",
+  "Usage",
+  "  npx openai-oauth@latest [options]",
+  "",
+  "Options",
+  "  --host <host>              Host interface to bind to.",
+  "  --port <port>              Port to listen on. Default: 10531",
+  "  --models <ids>             Comma-separated model ids to expose from /v1/models.",
+  "  --codex-version <version>  Codex API version to use for model discovery.",
+  "  --base-url <url>           Override the upstream Codex base URL.",
+  "  --oauth-client-id <id>     Override the OAuth client id used for refresh.",
+  "  --oauth-token-url <url>    Override the OAuth token URL used for refresh.",
+  "  --oauth-file <path>        Path to the local auth.json file.",
+  "",
+  "Flags",
+  "  --help                     Show help",
+  `  --version                  Show version (${package_default.version})`,
+  "",
+  "Notes",
+  "  If no auth file is found, run: npx @openai/codex login",
+  "  By default, available models are discovered from your account."
+];
+var createCliParser = (argv) => yargs(argv).scriptName("openai-oauth").strict().help(false).version(false).option("host", {
+  type: "string",
+  describe: "Host interface to bind to."
+}).option("port", {
+  type: "number",
+  describe: "Port to listen on. Default: 10531"
+}).option("models", {
+  type: "string",
+  describe: "Comma-separated model ids to expose from /v1/models.",
+  coerce: parseModels
+}).option("codex-version", {
+  type: "string",
+  describe: "Codex API version to use for model discovery."
+}).option("base-url", {
+  type: "string",
+  describe: "Override the upstream Codex base URL."
+}).option("oauth-client-id", {
+  type: "string",
+  describe: "Override the OAuth client id used for refresh."
+}).option("oauth-token-url", {
+  type: "string",
+  describe: "Override the OAuth token URL used for refresh."
+}).option("oauth-file", {
+  type: "string",
+  describe: "Path to the local auth.json file."
+});
+var isHelpFlag = (argv) => argv.includes("--help") || argv.includes("-h");
+var isVersionFlag = (argv) => argv.includes("--version");
+var toHelpMessage = () => helpLines.join("\n");
 var parseCliArgs = (argv) => {
-  const parsed = yargs(argv).scriptName("openai-oauth").strict().help().option("host", {
-    type: "string",
-    describe: "Host interface to bind the local proxy to."
-  }).option("port", {
-    type: "number",
-    describe: "Port to bind the local proxy to."
-  }).option("models", {
-    type: "string",
-    describe: "Comma-separated list of models exposed by /v1/models.",
-    coerce: parseModels
-  }).option("base-url", {
-    type: "string",
-    describe: "Override the upstream Codex responses base URL."
-  }).option("oauth-client-id", {
-    type: "string",
-    describe: "Override the OAuth client id used for token refresh."
-  }).option("oauth-token-url", {
-    type: "string",
-    describe: "Override the OAuth token URL used for token refresh."
-  }).option("oauth-file", {
-    type: "string",
-    describe: "Override the auth.json file path used for local OAuth tokens."
-  }).parseSync();
+  const parsed = createCliParser(argv).parseSync();
   return {
     host: parsed.host,
     port: parsed.port,
     models: parsed.models,
+    codexVersion: parsed.codexVersion,
     baseURL: parsed.baseUrl,
     clientId: parsed.oauthClientId,
     tokenUrl: parsed.oauthTokenUrl,
@@ -51,9 +257,10 @@ var parseCliArgs = (argv) => {
   };
 };
 var toServerOptions = (args) => ({
-  host: args.host ?? process.env.HOST,
-  port: args.port ?? Number(process.env.PORT ?? String(DEFAULT_PORT)),
+  host: args.host,
+  port: args.port ?? DEFAULT_PORT,
   models: args.models,
+  codexVersion: args.codexVersion,
   baseURL: args.baseURL,
   clientId: args.clientId,
   tokenUrl: args.tokenUrl,
@@ -82,28 +289,51 @@ var toMissingAuthFileMessage = (authFilePath) => {
     "Run `npx @openai/codex login` and try again."
   ].join("\n");
 };
-var toStartupMessage = (options) => {
-  const baseUrl = `http://${options.host ?? "127.0.0.1"}:${options.port ?? DEFAULT_PORT}/v1`;
-  return [
-    `OpenAI-compatible endpoint ready at ${baseUrl}`,
-    "Use this as your OpenAI base URL. No API key is required."
-  ].join("\n");
-};
 var runCli = async (argv = hideBin(process.argv)) => {
+  if (isHelpFlag(argv)) {
+    console.log(toHelpMessage());
+    return;
+  }
+  if (isVersionFlag(argv)) {
+    console.log(package_default.version);
+    return;
+  }
+  installCliWarningLogger();
   const args = parseCliArgs(argv);
   const options = toServerOptions(args);
   const existingAuthFile = await findExistingAuthFile(options.authFilePath);
   if (!existingAuthFile) {
     throw new Error(toMissingAuthFileMessage(options.authFilePath));
   }
+  const client = createCodexOAuthClient({
+    ...options,
+    responsesState: false
+  });
+  const availableModels = await resolveOpenAIOAuthModels(
+    client,
+    options.models,
+    {
+      codexVersion: options.codexVersion,
+      onWarning: (message) => {
+        console.error(message);
+      }
+    }
+  );
   const server = await startOpenAIOAuthServer(options);
   console.log(
-    toStartupMessage({
-      ...options,
-      host: server.host,
-      port: server.port
-    })
+    toStartupMessage(
+      `http://${server.host}:${server.port}/v1`,
+      availableModels,
+      {
+        useColor: process.stdout.isTTY
+      }
+    )
   );
+  void checkForOpenAIOAuthUpdates(package_default.version, {
+    onWarning: (message) => {
+      console.error(message);
+    }
+  });
   const shutdown = async () => {
     await server.close();
     process.exit(0);

package/dist/index.d.ts

@@ -45,6 +45,7 @@ declare class CodexResponsesState {
 
 type CodexOAuthSettings = Omit<AuthLoaderOptions, "fetch"> & {
     baseURL?: string;
+    codexVersion?: string;
     fetch?: FetchFunction;
     headers?: Record<string, string>;
     instructions?: string;
@@ -137,6 +138,7 @@ type OpenAIOAuthServerOptions = Omit<CodexOAuthSettings, "responsesState"> & {
     host?: string;
     port?: number;
     models?: string[];
+    codexVersion?: string;
     requestLogger?: (event: OpenAIOAuthServerLogEvent) => void;
 };
 type RunningOpenAIOAuthServer = {

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   createOpenAIOAuthFetchHandler,
   defaultOpenAIOAuthModels,
   startOpenAIOAuthServer
-} from "./chunk-VZQM4BY4.js";
+} from "./chunk-WDJBHN6N.js";
 export {
   createOpenAIOAuthFetchHandler,
   defaultOpenAIOAuthModels,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "openai-oauth",
-	"version": "0.0.1",
+	"version": "1.0.1",
 	"description": "Free OpenAI API access with your ChatGPT account.",
 	"type": "module",
 	"bin": {
@@ -18,16 +18,17 @@
 	"scripts": {
 		"build": "tsup src/index.ts src/cli.ts --format esm --dts --outDir dist --clean",
 		"dev": "bun ./src/cli.ts",
+		"prepublishOnly": "bun run build",
 		"typecheck": "tsc --noEmit",
 		"test": "vitest run",
 		"test:live": "LIVE_CODEX_E2E=1 vitest run test/live.e2e.test.ts"
 	},
 	"dependencies": {
-		"ai": "6.0.0-beta.138",
+		"ai": "6.0.116",
 		"yargs": "^17.7.2"
 	},
 	"devDependencies": {
-		"@ai-sdk/openai": "3.0.0-beta.87",
+		"@ai-sdk/openai": "3.0.41",
 		"@types/node": "20.17.24",
 		"@types/yargs": "^17.0.33",
 		"openai-oauth-core": "workspace:*",