@demicodes/provider-codex 0.1.0 → 0.2.1

package/README.md

@@ -1,11 +1,31 @@
 # @demicodes/provider-codex
 
-A Demi provider backed by Codex (CLI/OAuth transport). Exposes
+A Demi provider backed by Codex (ChatGPT / Responses transport). Exposes
 `createCodexProvider()`.
 
 ```ts
 import { createCodexProvider } from '@demicodes/provider-codex'
+
+const provider = createCodexProvider()
+// provider.auth, provider.quota, provider.credentials (multi-account pool by default)
 ```
 
+## Auth and credentials
+
+- Default material: `~/.codex/auth.json` (or `$CODEX_HOME`).
+- Multi-credential pool under `$DEMI_HOME/credentials/codex/` with global
+  `provider.credentials.setActive(id)`.
+- Lifecycle: `beginLogin` → vendor `codex login` → `importDefault` → `setActive`.
+
+See [docs/provider-global-credentials.md](../../docs/provider-global-credentials.md).
+
+## Quota
+
+- **probe** (cost: `minimal_request`): tiny streamed Responses call; reads
+  `x-codex-primary-*` / `x-codex-secondary-*` headers.
+- **observe**: same headers on live inference responses (preferred steady-state).
+
+See [docs/provider-quota.md](../../docs/provider-quota.md).
+
 Implements the [`@demicodes/provider`](../provider/README.md) contract. Part of
 [Demi](../../README.md). Apache-2.0.

package/dist/index.d.mts

@@ -1,4 +1,6 @@
-import { ModelPolicy, Provider, ProviderAuthState, ProviderModelList } from "@demicodes/provider";
+import { ModelPolicy, Provider, ProviderAuthState, ProviderCredentials, ProviderModelList, ProviderQuota, ProviderQuotaProbeResult } from "@demicodes/provider";
+import { FileCredentialPool } from "@demicodes/provider/credentials-pool";
+import "@demicodes/core";
 //#region src/auth.d.ts
 type CodexResolvedAuth = {
   kind: 'chatgpt';
@@ -38,6 +40,8 @@ interface CodexAuthStore {
 declare function codexAuthStatus(options?: FileCodexAuthStoreOptions): Promise<ProviderAuthState>;
 interface FileCodexAuthStoreOptions {
   codexHome?: string;
+  /** Override auth.json path (e.g. demi credential pool entry). */
+  authFile?: string;
   refresh?: CodexTokenRefresh;
   now?: () => Date;
   lockRetryDelayMs?: number;
@@ -85,7 +89,66 @@ interface CodexProviderOptions extends CodexProviderConfig {
   id?: string;
   displayName?: string;
   models?: ModelPolicy;
+  authStore?: CodexAuthStore;
+  /** Demi state root for credential pool (`$DEMI_HOME` / `~/.demi`). */
+  stateDir?: string;
+  /**
+   * When true (default if `authStore` is not provided), attach multi-credential
+   * pool + global switch under `provider.credentials`.
+   */
+  credentials?: boolean;
 }
 declare function createCodexProvider(options?: CodexProviderOptions): Provider;
 //#endregion
-export { type CodexModelCatalogOptions, type CodexProviderOptions, type CodexTransportMode, type FileCodexAuthStoreOptions, codexAuthStatus, createCodexProvider, listCodexModels };
+//#region src/quota.d.ts
+interface CodexQuotaOptions {
+  providerId?: string;
+  codexHome?: string;
+  baseUrl?: string;
+  authStore?: CodexAuthStore;
+  /** Model id for the minimal probe request (must be accepted by the backend). */
+  probeModelId?: string;
+  fetch?: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+  userAgent?: string;
+}
+/**
+ * Codex consumer rate windows come from Responses headers:
+ * x-codex-{primary,secondary}-used-percent / -window-minutes / -reset-at
+ *
+ * probe() issues a minimal streamed Responses request and cancels the body
+ * (probeCost: minimal_request). observeResponse can parse the same headers
+ * from any live Responses call without an extra request.
+ */
+declare function createCodexQuota(options?: CodexQuotaOptions): ProviderQuota;
+declare function mapCodexRateLimitHeaders(headers: Headers | undefined): ProviderQuotaProbeResult | null;
+//#endregion
+//#region src/credentials.d.ts
+/**
+ * Auth store that prefers the demi pool active entry; falls back to vendor ~/.codex.
+ */
+declare class PoolAwareCodexAuthStore implements CodexAuthStore {
+  private readonly pool;
+  private readonly vendorHome;
+  private readonly fileAuthOptions;
+  constructor(pool: FileCredentialPool, options?: {
+    codexHome?: string;
+    fileAuthOptions?: Omit<FileCodexAuthStoreOptions, 'codexHome' | 'authFile'>;
+  });
+  status(): Promise<import("@demicodes/provider").ProviderAuthState>;
+  resolveAuth(options?: {
+    forceRefresh?: boolean;
+  }): Promise<CodexResolvedAuth>;
+  private currentStore;
+}
+declare function createCodexCredentials(pool: FileCredentialPool, authStore: CodexAuthStore, options?: {
+  codexHome?: string;
+  loginCommand?: string;
+  loginArgs?: string[];
+  quota?: ProviderQuota | null;
+  onActiveChange?: () => void;
+}): ProviderCredentials;
+declare function openCodexCredentialPool(options?: {
+  stateDir?: string;
+}): FileCredentialPool;
+//#endregion
+export { type CodexModelCatalogOptions, type CodexProviderOptions, type CodexQuotaOptions, type CodexResolvedAuth, type CodexTransportMode, type FileCodexAuthStoreOptions, PoolAwareCodexAuthStore, codexAuthStatus, createCodexCredentials, createCodexProvider, createCodexQuota, listCodexModels, mapCodexRateLimitHeaders, openCodexCredentialPool };

package/dist/index.mjs

@@ -1,13 +1,20 @@
-import { delay, errorMessage, isRecord, nonEmptyString, numberOrNull, numberOrZero, parseJsonObject, parseJsonOrString, shortHash, stringOrNull } from "@demicodes/utils";
+import { delay, errorCode, errorMessage, isRecord, nonEmptyString, numberOrNull, numberOrZero, parseJsonObject, parseJsonOrString, shortHash, stringOrNull } from "@demicodes/utils";
 import { Buffer } from "node:buffer";
 import { chmod, mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { applyModelPolicy, clampPromptCacheKey, defineProvider, httpErrorCode } from "@demicodes/provider";
+import { applyModelPolicy, clampPromptCacheKey, clampUsedPercent, createProviderQuota, defineProvider, httpErrorCode, numberHeader, redactCredentialText, severityFromUsedPercent, unixSecondsToIso } from "@demicodes/provider";
+import { FileCredentialPool, credentialIdFromIdentity, runVendorLoginCommand } from "@demicodes/provider/credentials-pool";
+import { randomUUID } from "node:crypto";
 //#region src/auth.ts
 async function codexAuthStatus(options = {}) {
 	return new FileCodexAuthStore(options).status();
 }
+/** Codex error text may embed the env-provided API key by name; redact it alongside the standard fields. */
+const SECRET_FIELD_PATTERNS = ["OPENAI_API_KEY"];
+function redactCodexSecretText(text) {
+	return redactCredentialText(text, SECRET_FIELD_PATTERNS);
+}
 const TOKEN_REFRESH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
 const TOKEN_REFRESH_URL = "https://auth.openai.com/oauth/token";
 const REFRESH_EXPIRY_SKEW_MS = 300 * 1e3;
@@ -21,7 +28,7 @@ var FileCodexAuthStore = class {
 	lockTimeoutMs;
 	constructor(options = {}) {
 		this.codexHome = options.codexHome ?? defaultCodexHome();
-		this.authFile = join(this.codexHome, "auth.json");
+		this.authFile = options.authFile ?? join(this.codexHome, "auth.json");
 		this.refreshImpl = options.refresh ?? refreshCodexToken;
 		this.now = options.now ?? (() => /* @__PURE__ */ new Date());
 		this.lockRetryDelayMs = options.lockRetryDelayMs ?? 25;
@@ -57,7 +64,7 @@ var FileCodexAuthStore = class {
 			};
 			return {
 				status: "error",
-				message: redactSecretText(error instanceof Error ? error.message : String(error))
+				message: redactCodexSecretText(error instanceof Error ? error.message : String(error))
 			};
 		}
 	}
@@ -137,8 +144,8 @@ var FileCodexAuthStore = class {
 		try {
 			return JSON.parse(await readFile(this.authFile, "utf8"));
 		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") throw new CodexAuthError("auth_missing", `Codex auth file not found: ${this.authFile}`);
-			throw new CodexAuthError("auth_invalid", `Failed to read Codex auth file ${this.authFile}: ${redactSecretText(errorMessage(error))}`);
+			if (errorCode(error) === "ENOENT") throw new CodexAuthError("auth_missing", `Codex auth file not found: ${this.authFile}`);
+			throw new CodexAuthError("auth_invalid", `Failed to read Codex auth file ${this.authFile}: ${redactCodexSecretText(errorMessage(error))}`);
 		}
 	}
 	async withAuthFileLock(fn) {
@@ -149,7 +156,7 @@ var FileCodexAuthStore = class {
 		while (!handle) try {
 			handle = await open(lockFile, "wx", 384);
 		} catch (error) {
-			if (!isNodeError(error) || error.code !== "EEXIST" || Date.now() - started > this.lockTimeoutMs) throw new CodexAuthError("auth_lock_failed", `Failed to lock Codex auth file: ${redactSecretText(errorMessage(error))}`);
+			if (errorCode(error) !== "EEXIST" || Date.now() - started > this.lockTimeoutMs) throw new CodexAuthError("auth_lock_failed", `Failed to lock Codex auth file: ${redactCodexSecretText(errorMessage(error))}`);
 			await delay(this.lockRetryDelayMs);
 		}
 		try {
@@ -220,9 +227,6 @@ async function refreshCodexToken(refreshToken, signal) {
 	if (!response.ok) throw new CodexAuthError("auth_refresh_failed", `Codex token refresh failed with HTTP ${response.status}`);
 	return await response.json();
 }
-function redactSecretText(text) {
-	return text.replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/g, "Bearer [REDACTED]").replace(/(access_token|refresh_token|id_token|OPENAI_API_KEY)["'=:\s]+[A-Za-z0-9._~+/=-]+/gi, "$1=[REDACTED]");
-}
 function resolveChatGptAuthFromFile(auth, authFile) {
 	const tokens = auth.tokens;
 	if (!tokens || typeof tokens !== "object") throw new CodexAuthError("auth_missing", `No ChatGPT tokens found in ${authFile}`);
@@ -288,9 +292,6 @@ function parseDate(value) {
 	const ms = Date.parse(value);
 	return Number.isFinite(ms) ? new Date(ms) : null;
 }
-function isNodeError(error) {
-	return error instanceof Error && "code" in error;
-}
 //#endregion
 //#region src/models.ts
 const DEFAULT_CHATGPT_CODEX_BASE_URL$1 = "https://chatgpt.com/backend-api";
@@ -491,7 +492,7 @@ function isAuthCatalogError(error) {
 var CodexModelCatalogHttpError = class extends Error {
 	status;
 	constructor(status, message) {
-		super(redactSecretText(message));
+		super(redactCodexSecretText(message));
 		this.status = status;
 		this.name = "CodexModelCatalogHttpError";
 	}
@@ -500,6 +501,291 @@ function defaultModelCatalogUserAgent() {
 	return `demi-provider-codex/0.0.0`;
 }
 //#endregion
+//#region src/credentials.ts
+/**
+* Auth store that prefers the demi pool active entry; falls back to vendor ~/.codex.
+*/
+var PoolAwareCodexAuthStore = class {
+	pool;
+	vendorHome;
+	fileAuthOptions;
+	constructor(pool, options = {}) {
+		this.pool = pool;
+		this.vendorHome = options.codexHome ?? defaultCodexHome();
+		this.fileAuthOptions = options.fileAuthOptions ?? {};
+	}
+	async status() {
+		return this.currentStore().then((s) => s.status());
+	}
+	async resolveAuth(options) {
+		return this.currentStore().then((s) => s.resolveAuth(options));
+	}
+	async currentStore() {
+		await this.pool.ensureActivePointer();
+		const activeId = await this.pool.getActiveId();
+		if (activeId) return new FileCodexAuthStore({
+			...this.fileAuthOptions,
+			authFile: this.pool.secretPath(activeId),
+			codexHome: this.pool.entryDir(activeId)
+		});
+		return new FileCodexAuthStore({
+			...this.fileAuthOptions,
+			codexHome: this.vendorHome
+		});
+	}
+};
+function createCodexCredentials(pool, authStore, options = {}) {
+	const vendorHome = options.codexHome ?? defaultCodexHome();
+	const loginCommand = options.loginCommand ?? "codex";
+	const loginArgs = options.loginArgs ?? ["login"];
+	const capability = () => ({
+		mode: "supported",
+		canBeginLogin: true,
+		canImportDefault: true,
+		canAdd: true,
+		multi: true
+	});
+	const getActive = async () => {
+		await pool.ensureActivePointer();
+		return {
+			credentialId: await pool.getActiveId(),
+			status: await authStore.status()
+		};
+	};
+	const setActive = async (credentialId) => {
+		await pool.setActiveId(credentialId);
+		options.quota?.clearLatest?.();
+		options.onActiveChange?.();
+		return getActive();
+	};
+	const importFromAuthJson = async (authText, source) => {
+		let auth;
+		try {
+			auth = JSON.parse(authText);
+		} catch {
+			throw new CodexAuthError("auth_invalid", "Codex auth material is not valid JSON");
+		}
+		if (!isRecord(auth)) throw new CodexAuthError("auth_invalid", "Codex auth material is not an object");
+		const { label, identityKey, detail } = labelFromCodexAuth(auth);
+		const id = (identityKey ? await pool.findByIdentityKey(identityKey) : null)?.id ?? credentialIdFromIdentity(identityKey, label);
+		const meta = {
+			id,
+			label,
+			detail,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			source,
+			identityKey
+		};
+		await pool.writeEntry(meta, `${JSON.stringify(auth, null, 2)}\n`);
+		if (!await pool.getActiveId()) await pool.setActiveId(id);
+		options.quota?.clearLatest?.();
+		options.onActiveChange?.();
+		return {
+			id: meta.id,
+			label: meta.label,
+			detail: meta.detail,
+			updatedAt: meta.updatedAt
+		};
+	};
+	return {
+		capability,
+		list: () => pool.list(),
+		getActive,
+		setActive,
+		beginLogin: async (loginOptions) => {
+			const result = await runVendorLoginCommand(loginCommand, loginArgs, { signal: loginOptions?.signal });
+			if (result.status === "completed") return { status: "completed" };
+			if (result.status === "cancelled") return { status: "cancelled" };
+			if (result.status === "unavailable") return {
+				status: "unavailable",
+				message: result.message ?? "Login unavailable"
+			};
+			return {
+				status: "failed",
+				message: result.message ?? "Login failed"
+			};
+		},
+		importDefault: async () => {
+			const authFile = join(vendorHome, "auth.json");
+			let text;
+			try {
+				text = await readFile(authFile, "utf8");
+			} catch {
+				throw new CodexAuthError("auth_missing", `No Codex auth at ${authFile}. Run codex login or beginLogin first.`);
+			}
+			return importFromAuthJson(text, `vendor:${authFile}`);
+		},
+		add: async (input) => {
+			if (typeof input.authJsonText === "string") return importFromAuthJson(input.authJsonText, "add:authJsonText");
+			if (typeof input.authFile === "string") {
+				const text = await readFile(input.authFile, "utf8");
+				return importFromAuthJson(text, `add:authFile:${input.authFile}`);
+			}
+			if (isRecord(input.auth) || isRecord(input.authJson)) {
+				const obj = input.auth ?? input.authJson;
+				return importFromAuthJson(`${JSON.stringify(obj, null, 2)}\n`, "add:auth");
+			}
+			throw new Error("Codex credentials.add expects authJsonText, authFile, or auth/authJson object");
+		},
+		remove: async (credentialId) => {
+			await pool.remove(credentialId);
+			options.quota?.clearLatest?.();
+			options.onActiveChange?.();
+		}
+	};
+}
+function openCodexCredentialPool(options = {}) {
+	return new FileCredentialPool({
+		stateDir: options.stateDir,
+		providerKey: "codex",
+		secretFileName: "auth.json"
+	});
+}
+function labelFromCodexAuth(auth) {
+	if (nonEmptyString(auth.OPENAI_API_KEY)) return {
+		label: "OPENAI_API_KEY",
+		identityKey: "apiKey",
+		detail: "apiKey"
+	};
+	const pat = nonEmptyString(auth.personal_access_token);
+	if (pat) {
+		const claims = parseChatGptClaims(pat);
+		const label = claims.email ?? claims.accountId ?? "personal access token";
+		return {
+			label,
+			identityKey: claims.accountId ?? label,
+			detail: "personalAccessToken"
+		};
+	}
+	const tokens = auth.tokens;
+	if (tokens && typeof tokens === "object") {
+		const access = nonEmptyString(tokens.access_token);
+		const idClaims = parseIdTokenClaims(tokens.id_token);
+		const accessClaims = access ? parseChatGptClaims(access) : {
+			accountId: null,
+			email: null,
+			isFedrampAccount: false
+		};
+		const accountId = nonEmptyString(tokens.account_id) ?? idClaims.accountId ?? accessClaims.accountId;
+		const email = idClaims.email ?? accessClaims.email;
+		return {
+			label: email ?? accountId ?? "chatgpt",
+			identityKey: accountId ?? email,
+			detail: "chatgpt"
+		};
+	}
+	return {
+		label: "codex",
+		identityKey: null,
+		detail: null
+	};
+}
+//#endregion
+//#region src/quota.ts
+const DEFAULT_PROBE_MODEL = "gpt-5.4";
+/**
+* Codex consumer rate windows come from Responses headers:
+* x-codex-{primary,secondary}-used-percent / -window-minutes / -reset-at
+*
+* probe() issues a minimal streamed Responses request and cancels the body
+* (probeCost: minimal_request). observeResponse can parse the same headers
+* from any live Responses call without an extra request.
+*/
+function createCodexQuota(options = {}) {
+	const providerId = options.providerId ?? "codex";
+	const authStore = options.authStore ?? new FileCodexAuthStore({ codexHome: options.codexHome });
+	const fetchImpl = options.fetch ?? fetch;
+	const probeModelId = options.probeModelId ?? DEFAULT_PROBE_MODEL;
+	return createProviderQuota({
+		providerId,
+		canProbe: true,
+		canObserve: true,
+		probeCost: "minimal_request",
+		staleAfterMs: 5 * 6e4,
+		probe: async ({ signal } = {}) => {
+			const auth = await authStore.resolveAuth();
+			const status = await authStore.status();
+			const accountLabel = status.status === "authenticated" ? status.accountLabel ?? null : null;
+			const headers = buildCodexHeaders(auth, {
+				sessionId: "demi-codex-quota-probe",
+				requestId: randomUUID()
+			}, { userAgent: options.userAgent });
+			const body = {
+				model: probeModelId,
+				instructions: "Reply with pong.",
+				input: [{
+					type: "message",
+					role: "user",
+					content: [{
+						type: "input_text",
+						text: "ping"
+					}]
+				}],
+				tools: [],
+				tool_choice: "auto",
+				parallel_tool_calls: true,
+				store: false,
+				stream: true,
+				include: [],
+				prompt_cache_key: "demi-codex-quota-probe",
+				text: { verbosity: "low" }
+			};
+			const response = await fetchImpl(responsesUrlForAuth(auth, options.baseUrl), {
+				method: "POST",
+				headers,
+				body: JSON.stringify(body),
+				signal
+			});
+			const partial = mapCodexRateLimitHeaders(response.headers);
+			await response.body?.cancel().catch(() => {});
+			if (!partial || partial.windows.length === 0) throw new Error(`Codex quota probe got no rate-limit headers (HTTP ${response.status})`);
+			return {
+				...partial,
+				accountLabel,
+				raw: {
+					...isRecord(partial.raw) ? partial.raw : {},
+					httpStatus: response.status,
+					authKind: auth.kind
+				}
+			};
+		},
+		observe: ({ headers }) => mapCodexRateLimitHeaders(headers)
+	});
+}
+function mapCodexRateLimitHeaders(headers) {
+	if (!headers) return null;
+	const windows = [parseCodexWindow(headers, "primary"), parseCodexWindow(headers, "secondary")].filter((w) => w !== null);
+	if (windows.length === 0) return null;
+	return {
+		windows,
+		raw: {
+			primary: headerBag(headers, "primary"),
+			secondary: headerBag(headers, "secondary")
+		}
+	};
+}
+function parseCodexWindow(headers, kind) {
+	const usedPercent = clampUsedPercent(numberHeader(headers, `x-codex-${kind}-used-percent`));
+	if (usedPercent == null && !headers.has(`x-codex-${kind}-used-percent`)) return null;
+	const windowMinutes = numberHeader(headers, `x-codex-${kind}-window-minutes`);
+	const resetAt = unixSecondsToIso(numberHeader(headers, `x-codex-${kind}-reset-at`));
+	return {
+		id: kind,
+		label: kind === "primary" ? windowMinutes != null ? `Primary (${windowMinutes}m)` : "Primary" : windowMinutes != null ? `Secondary (${windowMinutes}m)` : "Secondary",
+		usedPercent,
+		unit: "percent",
+		resetsAt: resetAt,
+		severity: severityFromUsedPercent(usedPercent)
+	};
+}
+function headerBag(headers, kind) {
+	return {
+		usedPercent: headers.get(`x-codex-${kind}-used-percent`),
+		windowMinutes: headers.get(`x-codex-${kind}-window-minutes`),
+		resetAt: headers.get(`x-codex-${kind}-reset-at`)
+	};
+}
+//#endregion
 //#region src/responses.ts
 function buildCodexResponsesRequestBody(request) {
 	const body = {
@@ -877,7 +1163,13 @@ var FetchCodexResponsesTransport = class {
 			headerTimeout.clear();
 			combined.cleanup();
 		}
-		if (!response.ok) throw new CodexHttpError(response.status, response.statusText, await response.text());
+		try {
+			request.onHttpResponse?.({
+				headers: response.headers,
+				status: response.status
+			});
+		} catch {}
+		if (!response.ok) throw new CodexHttpError(response.status, response.statusText, await response.text(), response.headers);
 		if (!response.body) throw new Error("Codex response did not include a body");
 		yield* parseSseResponseStream(response.body);
 	}
@@ -989,10 +1281,12 @@ var AutoCodexResponsesTransport = class {
 var CodexHttpError = class extends Error {
 	status;
 	responseText;
-	constructor(status, statusText, responseText) {
+	headers;
+	constructor(status, statusText, responseText, headers = new Headers()) {
 		super(codexHttpErrorMessage(status, statusText, responseText));
 		this.status = status;
 		this.responseText = responseText;
+		this.headers = headers;
 		this.name = "CodexHttpError";
 	}
 };
@@ -1133,6 +1427,7 @@ var CodexProvider = class {
 	config;
 	authStore;
 	transport;
+	quota;
 	constructor(options = {}) {
 		this.config = {
 			codexHome: options.codexHome,
@@ -1149,6 +1444,7 @@ var CodexProvider = class {
 		};
 		this.authStore = options.authStore ?? new FileCodexAuthStore({ codexHome: options.codexHome });
 		this.transport = options.transportImpl ?? createCodexTransport(this.config.transport);
+		this.quota = options.quota ?? null;
 	}
 	async *run(request) {
 		const body = buildCodexResponsesRequestBody(request);
@@ -1166,10 +1462,20 @@ var CodexProvider = class {
 				signal: request.cancel,
 				headerTimeoutMs: this.config.headerTimeoutMs,
 				websocketConnectTimeoutMs: this.config.websocketConnectTimeoutMs,
-				streamIdleTimeoutMs: this.config.streamIdleTimeoutMs || void 0
+				streamIdleTimeoutMs: this.config.streamIdleTimeoutMs || void 0,
+				onHttpResponse: (response) => {
+					this.observeQuotaResponse({
+						headers: response.headers,
+						status: response.status
+					});
+				}
 			}));
 			return;
 		} catch (error) {
+			if (error instanceof CodexHttpError) this.observeQuotaResponse({
+				headers: error.headers,
+				status: error.status
+			});
 			if (request.cancel.aborted) {
 				yield { type: "abort" };
 				return;
@@ -1187,11 +1493,20 @@ var CodexProvider = class {
 			return;
 		}
 	}
+	observeQuotaResponse(input) {
+		try {
+			this.quota?.observeResponse?.(input);
+		} catch {}
+	}
 };
 function createCodexProvider(options = {}) {
 	const id = options.id ?? "codex";
 	const displayName = options.displayName ?? "Codex";
+	const enableCredentials = options.credentials ?? options.authStore === void 0;
+	const pool = !options.authStore && enableCredentials ? openCodexCredentialPool({ stateDir: options.stateDir }) : null;
+	const authStore = options.authStore ?? (pool ? new PoolAwareCodexAuthStore(pool, { codexHome: options.codexHome }) : new FileCodexAuthStore({ codexHome: options.codexHome }));
 	const runtimeOptions = {
+		authStore,
 		codexHome: options.codexHome,
 		baseUrl: options.baseUrl,
 		transport: options.transport,
@@ -1204,13 +1519,27 @@ function createCodexProvider(options = {}) {
 		streamIdleTimeoutMs: options.streamIdleTimeoutMs,
 		clientVersion: options.clientVersion
 	};
+	const quota = createCodexQuota({
+		providerId: id,
+		codexHome: options.codexHome,
+		baseUrl: options.baseUrl,
+		authStore,
+		userAgent: options.userAgent
+	});
+	runtimeOptions.quota = quota;
+	const credentialsApi = pool ? createCodexCredentials(pool, authStore, {
+		codexHome: options.codexHome,
+		quota
+	}) : void 0;
 	return defineProvider({
 		id,
 		displayName,
-		auth: { status: () => new FileCodexAuthStore({ codexHome: options.codexHome }).status() },
+		auth: { status: () => authStore.status() },
+		quota,
+		...credentialsApi ? { credentials: credentialsApi } : {},
 		state: () => ({
 			status: "ready",
-			message: "Uses official Codex auth storage"
+			message: credentialsApi ? "Uses Codex auth + demi credential pool" : "Uses official Codex auth storage"
 		}),
 		listModels: async () => {
 			return applyModelPolicy(await listCodexModels(runtimeOptions), id, options.models);
@@ -1245,17 +1574,17 @@ function openAiResponsesUrl(baseUrl) {
 function providerErrorFromUnknown(error) {
 	if (error instanceof CodexAuthError) return {
 		type: "error",
-		message: redactSecretText(error.message),
+		message: redactCodexSecretText(error.message),
 		code: error.code
 	};
 	if (error instanceof CodexHttpError) return {
 		type: "error",
-		message: redactSecretText(error.message),
+		message: redactCodexSecretText(error.message),
 		code: httpErrorCode(error.status, error.message)
 	};
 	return {
 		type: "error",
-		message: redactSecretText(error instanceof Error ? error.message : String(error)),
+		message: redactCodexSecretText(error instanceof Error ? error.message : String(error)),
 		code: null
 	};
 }
@@ -1276,4 +1605,4 @@ function sleep(ms, signal) {
 	});
 }
 //#endregion
-export { codexAuthStatus, createCodexProvider, listCodexModels };
+export { PoolAwareCodexAuthStore, codexAuthStatus, createCodexCredentials, createCodexProvider, createCodexQuota, listCodexModels, mapCodexRateLimitHeaders, openCodexCredentialPool };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@demicodes/provider-codex",
   "description": "Codex provider adapter for Demi.",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "private": false,
   "type": "module",
   "exports": {
@@ -12,13 +12,13 @@
     }
   },
   "dependencies": {
-    "@demicodes/core": "workspace:*",
-    "@demicodes/provider": "workspace:*",
-    "@demicodes/utils": "workspace:*"
+    "@demicodes/core": "^0.2.1",
+    "@demicodes/provider": "^0.2.1",
+    "@demicodes/utils": "^0.2.1"
   },
   "devDependencies": {
-    "@demicodes/agent": "workspace:*",
-    "@demicodes/shell": "workspace:*"
+    "@demicodes/agent": "^0.2.1",
+    "@demicodes/shell": "^0.2.1"
   },
   "license": "Apache-2.0",
   "main": "./dist/index.mjs",