@alvin0/ai-agent-sdk-provider-codex 0.1.0

package/dist/index.js

@@ -0,0 +1,996 @@
+import { AgentSdkError, MISSING_CREDENTIAL_CODE, ReasoningEffortId, waitForSettlement } from "@alvin0/ai-agent-sdk-core";
+import { AgentSdkError as AgentSdkError$1, CREDENTIAL_CAPABILITY_API_VERSION, defineCredentialStore, defineModelProviderPlugin } from "@alvin0/ai-agent-sdk-core/provider";
+import { createHttpProvider, createRuntimeHttpProvider, observeCredentialOperation } from "@alvin0/ai-agent-sdk-provider-http";
+import { openAiResponsesProtocol, openAiResponsesProtocol as openAiResponsesProtocol$1 } from "@alvin0/ai-agent-sdk-protocol-responses";
+
+//#region src/auth.ts
+/**
+* Universal Codex credential contracts and JWT helpers.
+*
+* Storage is injected. Filesystem/path/environment ownership belongs to the
+* Node auth package, never this Universal provider.
+*/
+/** An in-memory {@link CodexAuthStore}, for tests. */
+function memoryCodexAuthStore(initial) {
+	let current = initial;
+	return {
+		location: "<memory>",
+		read: () => Promise.resolve(current),
+		write: (file) => {
+			current = file;
+			return Promise.resolve();
+		}
+	};
+}
+/** In-memory compare-and-swap store for deterministic runtime/tests. */
+function memoryCodexCredentialStore(initial) {
+	let current = initial === void 0 ? void 0 : structuredClone(initial);
+	let revision = 0;
+	return defineCredentialStore({
+		id: "codex-memory-credentials",
+		label: "<memory>",
+		async read({ signal }) {
+			signal.throwIfAborted();
+			return current === void 0 ? void 0 : {
+				value: structuredClone(current),
+				revision: String(revision)
+			};
+		},
+		async commit(input, { signal }) {
+			signal.throwIfAborted();
+			const expected = current === void 0 ? null : String(revision);
+			if (input.expectedRevision !== expected) throw new AgentSdkError("Codex credential revision changed before commit", "CODEX_CREDENTIAL_REVISION_CONFLICT");
+			current = structuredClone(input.value);
+			revision++;
+			return { revision: String(revision) };
+		}
+	});
+}
+/** The custom claim namespace OpenAI puts its ChatGPT account fields under. */
+const AUTH_CLAIM_NAMESPACE = "https://api.openai.com/auth";
+/** Decode a base64url segment without requiring Node's Buffer. */
+function decodeBase64Url(segment) {
+	const padded = segment.replace(/-/g, "+").replace(/_/g, "/") + "=".repeat((4 - segment.length % 4) % 4);
+	const binary = atob(padded);
+	const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+	return new TextDecoder().decode(bytes);
+}
+/**
+* Read the claims this SDK cares about out of a JWT.
+*
+* The signature is NOT verified, and does not need to be: this token is being
+* read to decide which account id to send and whether to refresh, not to grant
+* anything. The issuer verifies it.
+* @param jwt - a compact-serialization JWT.
+* @returns the claims, or `undefined` when the token is unreadable.
+*/
+function readJwtClaims(jwt) {
+	const parts = jwt.split(".");
+	const payload = parts.length === 3 ? parts[1] : void 0;
+	if (payload === void 0 || payload.length === 0) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(decodeBase64Url(payload));
+	} catch {
+		return;
+	}
+	const auth = parsed[AUTH_CLAIM_NAMESPACE];
+	const authClaims = typeof auth === "object" && auth !== null ? auth : {};
+	const exp = parsed.exp;
+	const email = parsed.email;
+	const accountId = authClaims.chatgpt_account_id;
+	const planType = authClaims.chatgpt_plan_type;
+	return {
+		...typeof exp === "number" ? { exp } : {},
+		...typeof email === "string" ? { email } : {},
+		...typeof accountId === "string" ? { accountId } : {},
+		...typeof planType === "string" ? { planType } : {},
+		isFedramp: authClaims.chatgpt_account_is_fedramp === true
+	};
+}
+/**
+* Resolve the account id to send as `ChatGPT-Account-ID`.
+*
+* Prefers the stored value and falls back to the `id_token` claim, because the
+* stored field is legitimately null for personal accounts.
+* @param tokens - the stored tokens.
+* @returns the account id, or `undefined` when neither source has one.
+*/
+function resolveAccountId(tokens) {
+	const stored = tokens.account_id;
+	if (typeof stored === "string" && stored.length > 0) return stored;
+	return readJwtClaims(tokens.id_token)?.accountId;
+}
+/** Whether this account must be routed through the FedRAMP edge. */
+function isFedrampAccount(tokens) {
+	return readJwtClaims(tokens.id_token)?.isFedramp === true;
+}
+/** Refresh this long before the access token actually expires. */
+const ACCESS_TOKEN_REFRESH_WINDOW_MS = 3e5;
+/** Fallback staleness bound, used only when `exp` cannot be read. */
+const LAST_REFRESH_MAX_AGE_MS = 6912e5;
+/**
+* Whether the access token should be refreshed before the next request.
+*
+* Primary signal is the token's own `exp`, with a five-minute margin so a request
+* cannot expire in flight. The `last_refresh` age is only a fallback for a token
+* whose `exp` is unreadable — matching how the Codex CLI decides.
+* @param file - the credential file.
+* @param now - current time in epoch milliseconds; injectable for tests.
+* @returns true when a refresh is due.
+*/
+function shouldRefresh(file, now = Date.now()) {
+	const tokens = file.tokens;
+	if (tokens === void 0 || tokens === null) return false;
+	const exp = readJwtClaims(tokens.access_token)?.exp;
+	if (exp !== void 0) return exp * 1e3 <= now + ACCESS_TOKEN_REFRESH_WINDOW_MS;
+	const lastRefresh = file.last_refresh;
+	if (lastRefresh === void 0 || lastRefresh === null) return false;
+	const at = Date.parse(lastRefresh);
+	return Number.isFinite(at) && at < now - 6912e5;
+}
+/**
+* Require usable ChatGPT tokens, with a message that says how to get them.
+* @param file - the credential file, or `undefined` when absent.
+* @param location - the path checked, named in the diagnostic.
+* @returns the tokens.
+*/
+function requireTokens(file, location) {
+	const tokens = file?.tokens;
+	if (tokens === void 0 || tokens === null || typeof tokens.access_token !== "string" || tokens.access_token.length === 0) throw new AgentSdkError(`no Codex credentials at ${location}; run \`npm run provider:codex:login-device\` to sign in`, MISSING_CREDENTIAL_CODE);
+	return tokens;
+}
+
+//#endregion
+//#region src/common/store-capture.ts
+/** Capture store identity and methods without invoking accessors or doing storage I/O. */
+function captureCodexStore(value) {
+	try {
+		if (value === null || typeof value !== "object") throw new TypeError("store must be an object");
+		const marker = dataValue(value, "kind", false);
+		if (marker === void 0) return captureLegacy(value);
+		if (marker !== "credential-store" || dataValue(value, "apiVersion") !== CREDENTIAL_CAPABILITY_API_VERSION) throw new TypeError("unsupported credential-store marker");
+		const id = boundedString(dataValue(value, "id"), 128, "credential store id");
+		const label = boundedString(dataValue(value, "label"), 256, "credential store label");
+		const read = capturedMethod(value, "read");
+		const commit = capturedMethod(value, "commit");
+		return Object.freeze({
+			kind: "versioned",
+			label,
+			store: Object.freeze({
+				kind: "credential-store",
+				apiVersion: CREDENTIAL_CAPABILITY_API_VERSION,
+				id,
+				label,
+				read,
+				commit
+			})
+		});
+	} catch (error) {
+		throw new AgentSdkError$1("Codex authStore credential store is invalid", "CREDENTIAL_STORE_INVALID", { cause: error });
+	}
+}
+function captureLegacy(source) {
+	const location = boundedString(dataValue(source, "location"), 1024, "Codex auth store location");
+	const read = capturedMethod(source, "read");
+	const write = capturedMethod(source, "write");
+	return Object.freeze({
+		kind: "legacy",
+		label: location,
+		store: Object.freeze({
+			location,
+			read,
+			write
+		})
+	});
+}
+function capturedMethod(source, key) {
+	const method = dataValue(source, key);
+	if (typeof method !== "function") throw new TypeError(`${String(key)} must be a function`);
+	return (...args) => Reflect.apply(method, source, args);
+}
+function dataValue(source, key, required = true) {
+	let owner = source;
+	while (owner !== null) {
+		const descriptor = Object.getOwnPropertyDescriptor(owner, key);
+		if (descriptor !== void 0) {
+			if (!("value" in descriptor)) throw new TypeError(`${String(key)} must not be an accessor`);
+			return descriptor.value;
+		}
+		owner = Object.getPrototypeOf(owner);
+	}
+	if (!required) return void 0;
+	throw new TypeError(`missing ${String(key)}`);
+}
+function boundedString(value, maxLength, label) {
+	if (typeof value !== "string" || value.length === 0 || value.length > maxLength) throw new TypeError(`${label} must be a bounded non-empty string`);
+	return value;
+}
+
+//#endregion
+//#region src/common/no-follow.ts
+/** Reject every redirect shape exposed by Web fetch before any second request. */
+async function rejectCodexRedirect(response, requestedUrl, operation, teardownTimeoutMs) {
+	const redirectStatus = response.status >= 300 && response.status < 400;
+	const responseUrlChanged = response.url.length > 0 && response.url !== requestedUrl;
+	if (response.type !== "opaqueredirect" && response.redirected !== true && !redirectStatus && !responseUrlChanged) return;
+	if (response.body !== null) await waitForSettlement(response.body.cancel().catch(() => void 0), teardownTimeoutMs);
+	throw new TypeError(`Codex ${operation} rejected a redirect before following it`);
+}
+
+//#endregion
+//#region src/oauth.ts
+/**
+* The OAuth flows behind the Codex credential file: device-code sign-in and
+* refresh-token rotation.
+*
+* Device code rather than a browser redirect because this SDK has no business
+* binding a localhost port: the flow works over SSH, in containers, and in CI,
+* and it needs no callback server.
+*
+* One surprise worth flagging: in this flow the SERVER generates the PKCE pair
+* and returns both the verifier and the challenge alongside the authorization
+* code. That inverts normal PKCE, where the client generates the verifier and
+* never transmits it. It is what the endpoint does, so it is what this
+* implements — but it means the device-code leg is only as safe as the TLS
+* channel, and it is why the user-facing prompt carries a phishing warning.
+*
+* @module ai-agent-sdk/providers/codex/oauth
+*/
+const NEVER_ABORTED_SIGNAL = new AbortController().signal;
+const NULL_LOGGER$1 = Object.freeze({
+	child: () => NULL_LOGGER$1,
+	trace: () => void 0,
+	debug: () => void 0,
+	info: () => void 0,
+	warn: () => void 0,
+	error: () => void 0,
+	fatal: () => void 0
+});
+/** OpenAI's auth issuer. */
+const DEFAULT_CODEX_ISSUER = "https://auth.openai.com";
+/** The public OAuth client id the Codex CLI uses; not a secret. */
+const CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+/** The device code expires server-side after this long. */
+const DEVICE_CODE_MAX_WAIT_MS = 9e5;
+/** Used when the server does not state a polling interval. */
+const DEFAULT_POLL_INTERVAL_SECONDS = 5;
+function issuerOf(options) {
+	const url = new URL(options.issuer ?? "https://auth.openai.com");
+	if (url.username.length > 0 || url.password.length > 0) throw new TypeError("Codex OAuth issuer must not contain credentials");
+	if (url.protocol !== "https:" && !(options.allowInsecureIssuer === true && url.protocol === "http:")) throw new TypeError("Codex OAuth issuer must use https");
+	return url.href.replace(/\/+$/, "");
+}
+function clientIdOf(options) {
+	return options.clientId ?? "app_EMoamEEZ73f0CkXaXp7hrann";
+}
+async function oauthFetch(options, input, init) {
+	const issuer = new URL(issuerOf(options));
+	const url = new URL(input);
+	if (url.origin !== issuer.origin) throw new TypeError(`Codex OAuth endpoint origin '${url.origin}' is not allowed`);
+	const timeoutMs = positiveSafeInteger$1(options.requestTimeoutMs ?? 3e4, "requestTimeoutMs");
+	const timeout = AbortSignal.timeout(timeoutMs);
+	const signal = options.signal === void 0 ? timeout : AbortSignal.any([options.signal, timeout]);
+	const fetchImpl = options.fetch ?? globalThis.fetch;
+	if (typeof fetchImpl !== "function") throw new TypeError("Codex OAuth requires fetch");
+	const response = await raceAbort$1(Promise.resolve(fetchImpl(url, {
+		...init,
+		signal,
+		redirect: "manual"
+	})), signal);
+	await rejectCodexRedirect(response, url.href, "OAuth", 3e4);
+	return response;
+}
+async function readResponseText(response, options) {
+	const maxBytes = positiveSafeInteger$1(options.maxResponseBytes ?? 1048576, "maxResponseBytes");
+	const maxChunks = positiveSafeInteger$1(options.maxResponseChunks ?? 1e4, "maxResponseChunks");
+	const declared = Number(response.headers.get("content-length"));
+	if (Number.isFinite(declared) && declared > maxBytes) {
+		if (response.body !== null) await waitForSettlement(response.body.cancel().catch(() => void 0), 3e4);
+		throw new RangeError(`Codex OAuth response exceeds the ${maxBytes}-byte limit`);
+	}
+	if (response.body === null) return "";
+	const timeout = AbortSignal.timeout(positiveSafeInteger$1(options.requestTimeoutMs ?? 3e4, "requestTimeoutMs"));
+	const signal = options.signal === void 0 ? timeout : AbortSignal.any([options.signal, timeout]);
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let bytes = 0;
+	let chunks = 0;
+	let result = "";
+	try {
+		while (true) {
+			const next = await raceAbort$1(reader.read(), signal);
+			if (next.done) return result + decoder.decode();
+			if (next.value === void 0) continue;
+			chunks++;
+			bytes += next.value.byteLength;
+			if (chunks > maxChunks || bytes > maxBytes) {
+				await waitForSettlement(reader.cancel().catch(() => void 0), 3e4);
+				throw new RangeError(`Codex OAuth response exceeds its configured resource limit`);
+			}
+			result += decoder.decode(next.value, { stream: true });
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+function raceAbort$1(pending, signal) {
+	if (signal.aborted) return Promise.reject(signal.reason ?? /* @__PURE__ */ new Error("Codex OAuth operation aborted"));
+	return new Promise((resolve, reject) => {
+		const abort = () => {
+			cleanup();
+			reject(signal.reason ?? /* @__PURE__ */ new Error("Codex OAuth operation aborted"));
+		};
+		const cleanup = () => signal.removeEventListener("abort", abort);
+		signal.addEventListener("abort", abort, { once: true });
+		pending.then((value) => {
+			cleanup();
+			resolve(value);
+		}, (error) => {
+			cleanup();
+			reject(error);
+		});
+	});
+}
+function positiveSafeInteger$1(value, field) {
+	if (!Number.isSafeInteger(value) || value < 1) throw new RangeError(`Codex OAuth ${field} must be a positive safe integer`);
+	return value;
+}
+/** Read a JSON body, failing with the status when it is not JSON. */
+async function readJson(response, what, options) {
+	const raw = await readResponseText(response, options);
+	try {
+		return JSON.parse(raw);
+	} catch (error) {
+		throw new AgentSdkError(`${what} returned a non-JSON response (HTTP ${response.status})`, "CODEX_AUTH_MALFORMED", { cause: error });
+	}
+}
+function requireString(source, key, what) {
+	const value = source[key];
+	if (typeof value !== "string" || value.length === 0) throw new AgentSdkError(`${what} omitted "${key}"`, "CODEX_AUTH_MALFORMED");
+	return value;
+}
+/**
+* Start a device authorization.
+* @param options - issuer, client id, cancellation.
+* @returns the code and URL to show the user.
+*/
+async function requestDeviceCode(options = {}) {
+	const issuer = issuerOf(options);
+	const response = await oauthFetch(options, `${issuer}/api/accounts/deviceauth/usercode`, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({ client_id: clientIdOf(options) })
+	});
+	if (response.status === 404) throw new AgentSdkError(`device-code login is not available at ${issuer}; check the issuer URL`, "CODEX_AUTH_UNAVAILABLE");
+	if (!response.ok) throw new AgentSdkError(`device-code request failed (HTTP ${response.status})`, "CODEX_AUTH_FAILED", { cause: new Error(await readResponseText(response, options)) });
+	const body = await readJson(response, "the device-code endpoint", options);
+	const rawInterval = body.interval;
+	const parsed = typeof rawInterval === "string" ? Number.parseInt(rawInterval.trim(), 10) : typeof rawInterval === "number" ? rawInterval : NaN;
+	return {
+		verificationUrl: `${issuer}/codex/device`,
+		userCode: requireString(body, "user_code", "the device-code endpoint"),
+		deviceAuthId: requireString(body, "device_auth_id", "the device-code endpoint"),
+		intervalSeconds: Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_POLL_INTERVAL_SECONDS
+	};
+}
+function sleep(ms, signal) {
+	if (signal?.aborted === true) return Promise.reject(new AgentSdkError("device-code login cancelled", "ABORTED"));
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(new AgentSdkError("device-code login cancelled", "ABORTED"));
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* Poll until the user approves the code, or the authorization expires.
+*
+* `403` and `404` both mean "not approved yet" here, which is unusual — most
+* device flows use a `authorization_pending` error code — so anything else is
+* treated as a real failure rather than retried.
+* @param code - the pending authorization.
+* @param options - issuer, client id, cancellation.
+* @param progress - poll notifications.
+* @returns the authorization code and its server-issued PKCE verifier.
+*/
+async function pollForAuthorization(code, options, progress) {
+	const url = `${issuerOf(options)}/api/accounts/deviceauth/token`;
+	const startedAt = Date.now();
+	while (true) {
+		const elapsed = Date.now() - startedAt;
+		try {
+			progress.onPoll?.(elapsed);
+		} catch {}
+		const response = await oauthFetch(options, url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				device_auth_id: code.deviceAuthId,
+				user_code: code.userCode
+			})
+		});
+		if (response.ok) {
+			const body = await readJson(response, "the device-token endpoint", options);
+			return {
+				authorizationCode: requireString(body, "authorization_code", "the device-token endpoint"),
+				codeVerifier: requireString(body, "code_verifier", "the device-token endpoint")
+			};
+		}
+		if (response.status === 403 || response.status === 404) {
+			const remaining = DEVICE_CODE_MAX_WAIT_MS - (Date.now() - startedAt);
+			if (remaining <= 0) throw new AgentSdkError("device-code login timed out after 15 minutes without approval", "CODEX_AUTH_TIMEOUT");
+			await sleep(Math.min(code.intervalSeconds * 1e3, remaining), options.signal);
+			continue;
+		}
+		throw new AgentSdkError(`device-code polling failed (HTTP ${response.status})`, "CODEX_AUTH_FAILED", { cause: new Error(await readResponseText(response, options)) });
+	}
+}
+/**
+* Exchange an approved authorization code for tokens.
+*
+* Form-encoded, not JSON — the token endpoint differs from the device-auth
+* endpoints in this respect, and sending JSON here fails.
+*/
+async function exchangeCodeForTokens(grant, options) {
+	const issuer = issuerOf(options);
+	const body = new URLSearchParams({
+		grant_type: "authorization_code",
+		code: grant.authorizationCode,
+		redirect_uri: `${issuer}/deviceauth/callback`,
+		client_id: clientIdOf(options),
+		code_verifier: grant.codeVerifier
+	});
+	const response = await oauthFetch(options, `${issuer}/oauth/token`, {
+		method: "POST",
+		headers: { "content-type": "application/x-www-form-urlencoded" },
+		body: body.toString()
+	});
+	if (!response.ok) throw new AgentSdkError(`token exchange failed (HTTP ${response.status})`, "CODEX_AUTH_FAILED", { cause: new Error(await readResponseText(response, options)) });
+	const parsed = await readJson(response, "the token endpoint", options);
+	return {
+		id_token: requireString(parsed, "id_token", "the token endpoint"),
+		access_token: requireString(parsed, "access_token", "the token endpoint"),
+		refresh_token: requireString(parsed, "refresh_token", "the token endpoint")
+	};
+}
+/** Build the credential file for a freshly issued token set. */
+function authFileFor(tokens) {
+	const accountId = resolveAccountId(tokens);
+	return {
+		auth_mode: "chatgpt",
+		OPENAI_API_KEY: null,
+		tokens: {
+			...tokens,
+			account_id: accountId ?? null
+		},
+		last_refresh: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+async function runDeviceCodeLogin(store, options = {}, progress = {}) {
+	const captured = captureCodexStore(store);
+	const operation = credentialOperation(options.signal);
+	const initial = await readStore(captured, operation);
+	const code = await requestDeviceCode(options);
+	try {
+		progress.onPrompt?.(code);
+	} catch {}
+	const tokens = await exchangeCodeForTokens(await pollForAuthorization(code, options, progress), options);
+	const file = authFileFor(tokens);
+	await commitStore(captured, file, initial.revision, operation);
+	const claims = readJwtClaims(tokens.id_token);
+	return {
+		location: storeLabel(captured),
+		email: claims?.email,
+		accountId: file.tokens?.account_id ?? void 0,
+		planType: claims?.planType
+	};
+}
+/** A refresh that did not succeed. */
+var CodexRefreshError = class extends AgentSdkError {
+	kind;
+	constructor(message, kind, options) {
+		super(message, kind === "permanent" ? "CODEX_REAUTH_REQUIRED" : "CODEX_REFRESH_TRANSIENT", options);
+		this.kind = kind;
+	}
+};
+/** Error codes that mean the refresh token is gone for good. */
+const PERMANENT_REFRESH_CODES = /* @__PURE__ */ new Set([
+	"refresh_token_expired",
+	"refresh_token_reused",
+	"refresh_token_invalidated",
+	"invalid_grant"
+]);
+/** Pull an OAuth error code out of either body shape the endpoint uses. */
+function refreshErrorCode(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		const error = parsed.error;
+		if (typeof error === "string") return error;
+		if (typeof error === "object" && error !== null) {
+			const code = error.code;
+			if (typeof code === "string") return code;
+		}
+		const code = parsed.code;
+		return typeof code === "string" ? code : void 0;
+	} catch {
+		return;
+	}
+}
+async function refreshCodexTokens(store, options = {}) {
+	return await refreshCodexTokensWithOperation(store, options, credentialOperation(options.signal));
+}
+/** Internal runtime path that preserves the caller's bound credential logger. */
+async function refreshCodexTokensWithOperation(store, options, operation) {
+	const captured = captureCodexStore(store);
+	const snapshot = await readStore(captured, operation);
+	const file = snapshot.file;
+	const current = file?.tokens;
+	if (current === void 0 || current === null || current.refresh_token.length === 0) throw new CodexRefreshError(`no refresh token at ${storeLabel(captured)}; run \`npm run provider:codex:login-device\``, "permanent");
+	const issuer = issuerOf(options);
+	let response;
+	try {
+		response = await oauthFetch(options, `${issuer}/oauth/token`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				client_id: clientIdOf(options),
+				grant_type: "refresh_token",
+				refresh_token: current.refresh_token
+			})
+		});
+	} catch (error) {
+		throw new CodexRefreshError("token refresh could not reach the auth service", "transient", { cause: error });
+	}
+	if (!response.ok) {
+		const raw = await readResponseText(response, options);
+		const code = refreshErrorCode(raw);
+		const permanent = response.status === 401 || code !== void 0 && PERMANENT_REFRESH_CODES.has(code.toLowerCase());
+		throw new CodexRefreshError(permanent ? `Codex credentials are no longer valid (${code ?? `HTTP ${response.status}`}); run \`npm run provider:codex:login-device\` to sign in again` : `token refresh failed (HTTP ${response.status})`, permanent ? "permanent" : "transient", { cause: new Error(raw) });
+	}
+	const parsed = await readJson(response, "the token endpoint", options);
+	const next = {
+		id_token: typeof parsed.id_token === "string" ? parsed.id_token : current.id_token,
+		access_token: typeof parsed.access_token === "string" ? parsed.access_token : current.access_token,
+		refresh_token: typeof parsed.refresh_token === "string" ? parsed.refresh_token : current.refresh_token
+	};
+	const accountId = resolveAccountId(next);
+	const updated = {
+		...next,
+		account_id: accountId ?? null
+	};
+	const nextFile = {
+		...file,
+		auth_mode: file?.auth_mode ?? "chatgpt",
+		tokens: updated,
+		last_refresh: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	try {
+		await commitStore(captured, nextFile, snapshot.revision, operation);
+	} catch (error) {
+		if (!isRevisionConflict(error) || captured.kind !== "versioned") throw error;
+		const winner = await readStore(captured, operation);
+		const winnerTokens = winner.file?.tokens;
+		if (winner.revision === snapshot.revision || winnerTokens === void 0 || winnerTokens === null) throw error;
+		return requireRefreshTokens(winnerTokens, storeLabel(captured));
+	}
+	return updated;
+}
+function credentialOperation(signal) {
+	return {
+		signal: signal ?? NEVER_ABORTED_SIGNAL,
+		logger: NULL_LOGGER$1
+	};
+}
+async function readStore(captured, operation) {
+	if (captured.kind === "versioned") {
+		const record = await captured.store.read(operation);
+		return record === void 0 ? {
+			file: void 0,
+			revision: null
+		} : {
+			file: record.value,
+			revision: record.revision
+		};
+	}
+	return {
+		file: await captured.store.read(),
+		revision: null
+	};
+}
+async function commitStore(captured, file, expectedRevision, operation) {
+	if (captured.kind === "versioned") {
+		await captured.store.commit({
+			value: file,
+			expectedRevision
+		}, operation);
+		return;
+	}
+	await captured.store.write(file);
+}
+function storeLabel(captured) {
+	return captured.label;
+}
+function isRevisionConflict(error) {
+	if (error === null || typeof error !== "object") return false;
+	const descriptor = Object.getOwnPropertyDescriptor(error, "code");
+	return descriptor !== void 0 && "value" in descriptor && descriptor.value === "CODEX_CREDENTIAL_REVISION_CONFLICT";
+}
+function requireRefreshTokens(tokens, location) {
+	if (typeof tokens.access_token !== "string" || tokens.access_token.length === 0 || typeof tokens.refresh_token !== "string" || tokens.refresh_token.length === 0) throw new CodexRefreshError(`refreshed credentials at ${location} are incomplete`, "permanent");
+	return tokens;
+}
+
+//#endregion
+//#region src/common/response-media.ts
+/**
+* Contain the official ChatGPT Codex endpoint's missing SSE media-type header.
+* Generic HTTP providers and custom Codex gateways remain strict.
+*/
+function codexResponseMediaFetch(options) {
+	const officialEndpoint = endpoint(options.officialBaseUrl);
+	const configuredEndpoint = endpoint(options.baseUrl);
+	const official = configuredEndpoint !== void 0 && configuredEndpoint === officialEndpoint;
+	return async (input, init) => {
+		const response = await (options.fetch ?? globalThis.fetch)(input, init);
+		if (typeof input !== "string") return response;
+		const requestedUrl = input;
+		if (!official || requestedUrl !== configuredEndpoint || response.status !== 200 || response.body === null || response.headers.get("content-type") !== null || response.redirected || response.type === "opaqueredirect" || response.url.length > 0 && response.url !== requestedUrl) return response;
+		const headers = new Headers(response.headers);
+		headers.set("content-type", "text/event-stream");
+		return new Response(response.body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers
+		});
+	};
+}
+function endpoint(value) {
+	try {
+		const url = new URL(value);
+		if (url.search.length > 0 || url.hash.length > 0) return void 0;
+		return `${url.href.replace(/\/+$/u, "")}/responses`;
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+//#region src/adapter.ts
+/** The ChatGPT-backed Codex API base. */
+const CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex";
+/** Client identifier this endpoint expects. See the module note. */
+const CODEX_ORIGINATOR = "codex_cli_rs";
+/**
+* Client version sent when listing models.
+*
+* NOT cosmetic: the model catalog is gated on it, and an older value returns a
+* shorter list or an empty one. Verified against a live account — `0.45.0` returns
+* `{"models":[]}` while `1.0.0` returns the full set.
+*/
+const CODEX_CLIENT_VERSION = "1.0.0";
+function randomId() {
+	return globalThis.crypto?.randomUUID?.() ?? `sdk-${Date.now().toString(36)}`;
+}
+/** Read `/models`, which requires — and is gated on — a client version. */
+async function discoverCodexModels(context, clientVersion, limits, fetchImpl) {
+	const url = `${context.baseUrl}/models?client_version=${encodeURIComponent(clientVersion)}`;
+	const timeout = AbortSignal.timeout(limits.timeoutMs);
+	const signal = context.signal === void 0 ? timeout : AbortSignal.any([context.signal, timeout]);
+	const response = await fetchImpl(url, {
+		headers: context.headers,
+		signal,
+		redirect: "manual"
+	});
+	await rejectCodexRedirect(response, url, "model catalog", 3e4);
+	if (!response.ok) return [];
+	const body = await readCatalogJson(response, limits.maxBytes, limits.maxChunks, signal);
+	const models = Array.isArray(body.models) ? body.models : [];
+	if (models.length > limits.maxModels) throw new RangeError(`Codex model catalog exceeds the ${limits.maxModels}-model limit`);
+	return models.flatMap((entry) => {
+		if (typeof entry.slug !== "string" || entry.slug.length === 0) return [];
+		const modalities = (entry.input_modalities ?? []).filter((value) => value === "text" || value === "image");
+		const outputModalities = (entry.output_modalities ?? []).filter((value) => value === "text" || value === "image");
+		const efforts = (entry.supported_reasoning_levels ?? []).flatMap((candidate) => {
+			if (typeof candidate.effort !== "string" || candidate.effort.length === 0) return [];
+			return [{
+				id: ReasoningEffortId(candidate.effort),
+				name: candidate.effort,
+				...candidate.description === void 0 ? {} : { description: candidate.description }
+			}];
+		});
+		const defaultEffort = typeof entry.default_reasoning_level === "string" && efforts.some((effort) => effort.id === entry.default_reasoning_level) ? ReasoningEffortId(entry.default_reasoning_level) : void 0;
+		return [{
+			id: entry.slug,
+			...entry.display_name === void 0 ? {} : { name: entry.display_name },
+			...entry.description === void 0 ? {} : { description: entry.description },
+			...modalities.length > 0 ? { inputModalities: modalities } : {},
+			...outputModalities.length > 0 ? { outputModalities } : {},
+			...typeof entry.context_window === "number" && Number.isSafeInteger(entry.context_window) && entry.context_window > 0 ? { contextWindow: entry.context_window } : {},
+			...efforts.length === 0 ? {} : { reasoning: {
+				efforts,
+				...defaultEffort === void 0 ? {} : { defaultEffort }
+			} }
+		}];
+	});
+}
+function codexAdapter(options) {
+	const captured = captureCodexStore(options?.authStore);
+	return captured.kind === "versioned" ? runtimeCodexAdapter(options, captured) : legacyCodexAdapter(options, captured);
+}
+function legacyCodexAdapter(options, captured = captureCodexStore(options?.authStore)) {
+	if (captured.kind !== "legacy") throw new TypeError("Codex legacy adapter requires a read/write auth store");
+	const store = captured.store;
+	const promptCacheKey = options.promptCacheKey ?? randomId();
+	const clientVersion = options.clientVersion ?? "1.0.0";
+	const catalogLimits = Object.freeze({
+		maxBytes: positiveSafeInteger(options.maxCatalogBytes ?? 4194304, "maxCatalogBytes"),
+		maxModels: positiveSafeInteger(options.maxCatalogModels ?? 2048, "maxCatalogModels"),
+		maxChunks: positiveSafeInteger(options.maxCatalogChunks ?? 1e4, "maxCatalogChunks"),
+		timeoutMs: positiveSafeInteger(options.catalogTimeoutMs ?? 3e4, "catalogTimeoutMs")
+	});
+	/**
+	* The Codex request schema has no `temperature`, `top_p`, or
+	* `max_output_tokens`, so those knobs are turned off rather than sent and
+	* rejected.
+	*/
+	const dialect = {
+		sampling: false,
+		maxOutputTokens: false,
+		structuredOutputs: true,
+		store: false,
+		messagePhase: true,
+		promptCacheKey
+	};
+	return createHttpProvider({
+		displayName: "Codex",
+		protocol: openAiResponsesProtocol$1,
+		baseUrl: options.baseUrl ?? "https://chatgpt.com/backend-api/codex",
+		dialect,
+		/**
+		* Resolved per operation, which is what lets OAuth live in configuration.
+		*
+		* Refresh happens HERE, proactively, keyed on the access token's own `exp`
+		* with a five-minute margin. Doing it before the request rather than reacting
+		* to a 401 keeps `AUTH` correctly non-retryable: by the time a 401 does
+		* arrive, the credentials really are dead and the fix is re-login.
+		*/
+		auth: {
+			kind: "dynamic",
+			resolve: async (_signal, context) => {
+				const file = await store.read();
+				let tokens = requireTokens(file, store.location);
+				if (file !== void 0 && shouldRefresh(file)) tokens = await observeCredentialOperation(context, "codex", "refresh", async () => await refreshCodexTokens(store, options.oauth ?? {}));
+				const accountId = resolveAccountId(tokens);
+				return {
+					"authorization": `Bearer ${tokens.access_token}`,
+					"originator": options.originator ?? "codex_cli_rs",
+					...accountId === void 0 ? {} : { "chatgpt-account-id": accountId },
+					...isFedrampAccount(tokens) ? { "x-openai-fedramp": "true" } : {},
+					"session-id": promptCacheKey
+				};
+			}
+		},
+		...options.models === void 0 ? { discoverModels: (context) => discoverCodexModels(context, clientVersion, catalogLimits, options.fetch ?? globalThis.fetch) } : { models: options.models },
+		defaultMaxTokens: options.defaultMaxTokens ?? 32e3,
+		defaultContextWindow: options.defaultContextWindow ?? 272e3,
+		...options.streamIdleTimeoutMs === void 0 ? {} : { streamIdleTimeoutMs: options.streamIdleTimeoutMs },
+		...options.catalogTtlMs === void 0 ? {} : { catalogTtlMs: options.catalogTtlMs },
+		...options.catalogStaleTtlMs === void 0 ? {} : { catalogStaleTtlMs: options.catalogStaleTtlMs },
+		...options.catalogFailureBackoffMs === void 0 ? {} : { catalogFailureBackoffMs: options.catalogFailureBackoffMs },
+		...transportLimits(options),
+		...options.retryPolicy === void 0 ? {} : { retryPolicy: options.retryPolicy },
+		...options.requestLogger === void 0 ? {} : { requestLogger: options.requestLogger }
+	});
+}
+const NULL_LOGGER = Object.freeze({
+	child: () => NULL_LOGGER,
+	trace: () => void 0,
+	debug: () => void 0,
+	info: () => void 0,
+	warn: () => void 0,
+	error: () => void 0,
+	fatal: () => void 0
+});
+function runtimeCodexAdapter(options, captured = captureCodexStore(options.authStore)) {
+	if (captured.kind !== "versioned") throw new TypeError("Codex runtime authStore must be a versioned credential store");
+	const store = captured.store;
+	const promptCacheKey = options.promptCacheKey ?? randomId();
+	const clientVersion = options.clientVersion ?? "1.0.0";
+	const catalogLimits = Object.freeze({
+		maxBytes: positiveSafeInteger(options.maxCatalogBytes ?? 4194304, "maxCatalogBytes"),
+		maxModels: positiveSafeInteger(options.maxCatalogModels ?? 2048, "maxCatalogModels"),
+		maxChunks: positiveSafeInteger(options.maxCatalogChunks ?? 1e4, "maxCatalogChunks"),
+		timeoutMs: positiveSafeInteger(options.catalogTimeoutMs ?? 3e4, "catalogTimeoutMs")
+	});
+	const dialect = {
+		sampling: false,
+		maxOutputTokens: false,
+		structuredOutputs: true,
+		store: false,
+		messagePhase: true,
+		promptCacheKey
+	};
+	return createRuntimeHttpProvider({
+		displayName: "Codex",
+		protocol: openAiResponsesProtocol$1,
+		baseUrl: options.baseUrl ?? "https://chatgpt.com/backend-api/codex",
+		dialect,
+		auth: {
+			kind: "dynamic",
+			resolve: async ({ provider, signal, context }) => {
+				const operation = {
+					signal,
+					logger: context?.logger ?? NULL_LOGGER
+				};
+				const file = (await store.read(operation))?.value;
+				let tokens = requireTokens(file, store.label);
+				if (file !== void 0 && shouldRefresh(file)) tokens = await observeCredentialOperation(context, provider, "refresh", async () => await refreshCodexTokensWithOperation(store, {
+					...options.oauth ?? {},
+					signal
+				}, operation));
+				const accountId = resolveAccountId(tokens);
+				return {
+					authorization: `Bearer ${tokens.access_token}`,
+					originator: options.originator ?? "codex_cli_rs",
+					...accountId === void 0 ? {} : { "chatgpt-account-id": accountId },
+					...isFedrampAccount(tokens) ? { "x-openai-fedramp": "true" } : {},
+					"session-id": promptCacheKey
+				};
+			}
+		},
+		...options.models === void 0 ? { discoverModels: (context) => discoverCodexModels({
+			baseUrl: context.baseUrl.href.replace(/\/+$/, ""),
+			headers: context.headers,
+			signal: context.signal,
+			provider: context.provider,
+			...context.context === void 0 ? {} : { context: context.context }
+		}, clientVersion, catalogLimits, options.fetch ?? globalThis.fetch) } : { models: options.models },
+		...options.catalogTtlMs === void 0 ? {} : { catalogTtlMs: options.catalogTtlMs },
+		...options.catalogStaleTtlMs === void 0 ? {} : { catalogStaleTtlMs: options.catalogStaleTtlMs },
+		...options.catalogFailureBackoffMs === void 0 ? {} : { catalogFailureBackoffMs: options.catalogFailureBackoffMs },
+		defaultMaxTokens: options.defaultMaxTokens ?? 32e3,
+		defaultContextWindow: options.defaultContextWindow ?? 272e3,
+		...options.streamIdleTimeoutMs === void 0 ? {} : { streamIdleTimeoutMs: options.streamIdleTimeoutMs },
+		...transportLimits(options),
+		...options.retryPolicy === void 0 ? {} : { retryPolicy: options.retryPolicy },
+		...options.requestLogger === void 0 ? {} : { requestLogger: options.requestLogger }
+	});
+}
+function codexPlugin(options) {
+	if (isVersionedStoreInput(options.authStore)) {
+		const id = "id" in options && options.id !== void 0 ? options.id : "codex";
+		const routes = Object.freeze([...options.routes ?? [id]]);
+		return defineModelProviderPlugin({
+			id,
+			family: "codex",
+			displayName: "Codex",
+			routes,
+			...runtimeDefaultModel("defaultModel" in options ? options.defaultModel : void 0, routes),
+			setup(registrar) {
+				const adapter = runtimeCodexAdapter(options);
+				const remove = registrar.registerAdapter(adapter);
+				return () => {
+					remove();
+				};
+			}
+		});
+	}
+	return legacyCodexPlugin(options);
+}
+/** Marker inspection only; full store capture stays deferred to preferred setup. */
+function isVersionedStoreInput(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const kind = Object.getOwnPropertyDescriptor(value, "kind");
+	return kind !== void 0 && "value" in kind && kind.value === "credential-store";
+}
+function legacyCodexPlugin(options, captured) {
+	const routes = Object.freeze([...options.routes ?? ["codex"]]);
+	const adapter = legacyCodexAdapter(options, captured);
+	return Object.freeze({
+		id: "codex",
+		displayName: "Codex",
+		setup(registrar) {
+			registrar.registerAdapter(routes, adapter);
+		}
+	});
+}
+function runtimeDefaultModel(value, routes) {
+	if (value === void 0) return {};
+	if (typeof value !== "string") return { defaultModel: value };
+	if (routes.length !== 1) throw new TypeError("A string defaultModel requires exactly one Codex route");
+	return { defaultModel: Object.freeze({
+		provider: routes[0],
+		id: value
+	}) };
+}
+async function readCatalogJson(response, maxBytes, maxChunks, signal) {
+	const declared = Number(response.headers.get("content-length"));
+	if (Number.isFinite(declared) && declared > maxBytes) {
+		if (response.body !== null) await waitForSettlement(response.body.cancel().catch(() => void 0), 3e4);
+		throw new RangeError(`Codex model catalog exceeds the ${maxBytes}-byte limit`);
+	}
+	if (response.body === null) throw new TypeError("Codex model catalog returned no body");
+	const reader = response.body.getReader();
+	const chunks = [];
+	let bytes = 0;
+	let chunkCount = 0;
+	try {
+		while (true) {
+			const next = await raceAbort(reader.read(), signal);
+			if (next.done) break;
+			if (next.value === void 0) continue;
+			chunkCount++;
+			if (chunkCount > maxChunks) {
+				await waitForSettlement(reader.cancel().catch(() => void 0), 3e4);
+				throw new RangeError(`Codex model catalog exceeds the ${maxChunks}-chunk limit`);
+			}
+			bytes += next.value.byteLength;
+			if (bytes > maxBytes) {
+				await waitForSettlement(reader.cancel().catch(() => void 0), 3e4);
+				throw new RangeError(`Codex model catalog exceeds the ${maxBytes}-byte limit`);
+			}
+			chunks.push(next.value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const merged = new Uint8Array(bytes);
+	let offset = 0;
+	for (const chunk of chunks) {
+		merged.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	const parsed = JSON.parse(new TextDecoder().decode(merged));
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new TypeError("Codex model catalog must be a JSON object");
+	return parsed;
+}
+function raceAbort(pending, signal) {
+	if (signal.aborted) return Promise.reject(signal.reason ?? /* @__PURE__ */ new Error("Codex catalog request aborted"));
+	return new Promise((resolve, reject) => {
+		const abort = () => {
+			cleanup();
+			reject(signal.reason ?? /* @__PURE__ */ new Error("Codex catalog request aborted"));
+		};
+		const cleanup = () => signal.removeEventListener("abort", abort);
+		signal.addEventListener("abort", abort, { once: true });
+		pending.then((value) => {
+			cleanup();
+			resolve(value);
+		}, (error) => {
+			cleanup();
+			reject(error);
+		});
+	});
+}
+function positiveSafeInteger(value, field) {
+	if (!Number.isSafeInteger(value) || value < 1) throw new RangeError(`Codex ${field} must be a positive safe integer`);
+	return value;
+}
+function transportLimits(options) {
+	const fetch = codexResponseMediaFetch({
+		baseUrl: options.baseUrl ?? "https://chatgpt.com/backend-api/codex",
+		officialBaseUrl: CODEX_BASE_URL,
+		...options.fetch === void 0 ? {} : { fetch: options.fetch }
+	});
+	return {
+		...options.requestTimeoutMs === void 0 ? {} : { requestTimeoutMs: options.requestTimeoutMs },
+		...options.maxRequestBytes === void 0 ? {} : { maxRequestBytes: options.maxRequestBytes },
+		...options.maxResponseBytes === void 0 ? {} : { maxResponseBytes: options.maxResponseBytes },
+		...options.maxResponseChunks === void 0 ? {} : { maxResponseChunks: options.maxResponseChunks },
+		...options.maxSseEvents === void 0 ? {} : { maxSseEvents: options.maxSseEvents },
+		...options.maxSseEventChars === void 0 ? {} : { maxSseEventChars: options.maxSseEventChars },
+		...options.maxErrorBodyBytes === void 0 ? {} : { maxErrorBodyBytes: options.maxErrorBodyBytes },
+		...options.requestLoggerTimeoutMs === void 0 ? {} : { requestLoggerTimeoutMs: options.requestLoggerTimeoutMs },
+		fetch
+	};
+}
+
+//#endregion
+export { ACCESS_TOKEN_REFRESH_WINDOW_MS, CODEX_BASE_URL, CODEX_CLIENT_ID, CODEX_CLIENT_VERSION, CODEX_ORIGINATOR, CodexRefreshError, DEFAULT_CODEX_ISSUER, LAST_REFRESH_MAX_AGE_MS, codexAdapter, codexPlugin, isFedrampAccount, memoryCodexAuthStore, memoryCodexCredentialStore, openAiResponsesProtocol, readJwtClaims, refreshCodexTokens, requestDeviceCode, requireTokens, resolveAccountId, runDeviceCodeLogin, shouldRefresh };
+//# sourceMappingURL=index.js.map