@opengeni/codex 0.2.5 → 0.2.9

package/dist/index.js

@@ -24,9 +24,15 @@ import {
   CODEX_REFRESH_FALLBACK_MS,
   CODEX_REFRESH_WINDOW_MS,
   CODEX_RESPONSES_BASE,
+  CODEX_RESPONSE_HEADERS_TIMEOUT_MS,
+  CODEX_RESPONSE_NO_BYTE_RETRIES,
+  CODEX_RESPONSE_RETRY_BACKOFF_MS,
+  CODEX_RESPONSE_SDK_OUTER_TIMEOUT_MS,
+  CODEX_RESPONSE_STREAM_IDLE_TIMEOUT_MS,
+  CODEX_RESPONSE_WHOLE_TIMEOUT_MS,
   CODEX_TOKEN_URL,
   CODEX_WHAM_BASE
-} from "./chunk-AMRVHBCD.js";
+} from "./chunk-YGKQDUY7.js";
 
 // src/billing.ts
 function isCodexBilledModel(model) {
@@ -107,7 +113,37 @@ async function exchangeDeviceCode(input, fetchImpl = fetch) {
   };
 }
 
+// src/bounded-operation.ts
+async function runBoundedCodexOperation(operation, timeoutMs) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("Codex operation timeout must be positive");
+  }
+  const controller = new AbortController();
+  let timedOut = false;
+  let timeout;
+  const work = operation(controller.signal).then(
+    (value) => ({ ok: true, value }),
+    () => ({
+      ok: false,
+      reason: timedOut || controller.signal.aborted ? "timeout" : "network_error"
+    })
+  );
+  const deadline = new Promise((resolve) => {
+    timeout = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+      resolve({ ok: false, reason: "timeout" });
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([work, deadline]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
 // src/refresh.ts
+var CODEX_REFRESH_TIMEOUT_MS = 5e3;
 var CodexReloginRequired = class extends Error {
   constructor(message) {
     super(message);
@@ -120,17 +156,24 @@ var CodexRefreshTransient = class extends Error {
     this.name = "CodexRefreshTransient";
   }
 };
-async function refreshCodexToken(refreshToken, fetchImpl = fetch) {
-  const res = await fetchImpl(CODEX_TOKEN_URL, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      client_id: CODEX_CLIENT_ID,
-      grant_type: "refresh_token",
-      refresh_token: refreshToken
-    })
-  });
-  const text = await res.text();
+async function refreshCodexToken(refreshToken, fetchImpl = fetch, timeoutMs = CODEX_REFRESH_TIMEOUT_MS) {
+  const fetched = await runBoundedCodexOperation(async (signal) => {
+    const res2 = await fetchImpl(CODEX_TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        client_id: CODEX_CLIENT_ID,
+        grant_type: "refresh_token",
+        refresh_token: refreshToken
+      }),
+      signal
+    });
+    return { res: res2, text: await res2.text() };
+  }, timeoutMs);
+  if (!fetched.ok) {
+    throw new CodexRefreshTransient(`Codex token refresh ${fetched.reason}`);
+  }
+  const { res, text } = fetched.value;
   if (!res.ok) {
     const code = extractRefreshErrorCode(text);
     const msg = code ? PERMANENT_REFRESH_FAILURES[code] : void 0;
@@ -218,7 +261,8 @@ var CODEX_ALLOWED_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "stream",
   "include",
   "prompt_cache_key",
-  "text"
+  "text",
+  "service_tier"
 ]);
 function normalizeCodexRequestBody(body, resolveModel) {
   body.store = false;
@@ -280,7 +324,89 @@ function buildModelResolver(liveSlugs, fallbackSlug) {
 }
 
 // src/usage-normalize.ts
+import * as z2 from "zod/v4";
+
+// src/reset-credits.ts
 import * as z from "zod/v4";
+var CODEX_RATE_LIMIT_RESET_OUTCOMES = [
+  "reset",
+  "nothingToReset",
+  "noCredit",
+  "alreadyRedeemed"
+];
+var nonNegativeInteger = z.number().int().nonnegative();
+var backendTimestamp = z.string().datetime({ offset: true });
+var backendCreditSchema = z.object({
+  id: z.string().min(1),
+  reset_type: z.string().min(1),
+  status: z.string().min(1),
+  granted_at: backendTimestamp,
+  expires_at: backendTimestamp.nullish(),
+  title: z.string().nullish(),
+  description: z.string().nullish()
+}).passthrough();
+var backendDetailsSchema = z.object({
+  credits: z.array(backendCreditSchema),
+  available_count: nonNegativeInteger
+}).passthrough();
+var backendUsageSummarySchema = z.object({
+  rate_limit_reset_credits: z.object({ available_count: nonNegativeInteger }).passthrough().nullish()
+}).passthrough();
+var backendConsumeOutcomes = [
+  "reset",
+  "nothing_to_reset",
+  "no_credit",
+  "already_redeemed"
+];
+var backendConsumeSchema = z.object({
+  code: z.enum(backendConsumeOutcomes),
+  // The app-server intentionally discards this field. OpenGeni also refetches
+  // rather than inferring post-redemption state from it.
+  windows_reset: nonNegativeInteger.default(0)
+}).passthrough();
+function normalizedResetType(value) {
+  return value === "codex_rate_limits" ? "codexRateLimits" : "unknown";
+}
+function normalizedCreditStatus(value) {
+  if (value === "available" || value === "redeeming" || value === "redeemed") {
+    return value;
+  }
+  return "unknown";
+}
+function parseCodexRateLimitResetCreditsDetails(payload) {
+  const parsed = backendDetailsSchema.safeParse(payload);
+  if (!parsed.success) return null;
+  return {
+    availableCount: parsed.data.available_count,
+    credits: parsed.data.credits.map((credit) => ({
+      id: credit.id,
+      resetType: normalizedResetType(credit.reset_type),
+      status: normalizedCreditStatus(credit.status),
+      grantedAt: Math.floor(Date.parse(credit.granted_at) / 1e3),
+      expiresAt: credit.expires_at == null ? null : Math.floor(Date.parse(credit.expires_at) / 1e3),
+      title: credit.title ?? null,
+      description: credit.description ?? null
+    }))
+  };
+}
+function parseCodexRateLimitResetCreditsSummary(payload) {
+  const parsed = backendUsageSummarySchema.safeParse(payload);
+  const availableCount = parsed.success ? parsed.data.rate_limit_reset_credits?.available_count : void 0;
+  return availableCount === void 0 ? null : { availableCount, credits: null };
+}
+function parseCodexRateLimitResetConsumeResponse(payload) {
+  const parsed = backendConsumeSchema.safeParse(payload);
+  if (!parsed.success) return null;
+  const outcomes = {
+    reset: "reset",
+    nothing_to_reset: "nothingToReset",
+    no_credit: "noCredit",
+    already_redeemed: "alreadyRedeemed"
+  };
+  return { outcome: outcomes[parsed.data.code] };
+}
+
+// src/usage-normalize.ts
 var CODEX_FIVE_HOUR_WINDOW_SECONDS = 18e3;
 var CODEX_WEEKLY_WINDOW_SECONDS = 604800;
 function buildCodexUsageWindowFromCache(usedPercent, resetAt, limitWindowSeconds) {
@@ -301,34 +427,34 @@ function buildCodexUsageWindowFromCache(usedPercent, resetAt, limitWindowSeconds
     limitWindowSeconds
   };
 }
-var windowSchema = z.object({
-  used_percent: z.number().optional(),
-  reset_after_seconds: z.number().optional(),
-  reset_at: z.number().optional(),
-  limit_window_seconds: z.number().optional()
+var windowSchema = z2.object({
+  used_percent: z2.number().optional(),
+  reset_after_seconds: z2.number().optional(),
+  reset_at: z2.number().optional(),
+  limit_window_seconds: z2.number().optional()
 }).nullish();
-var rateLimitSchema = z.object({
-  allowed: z.boolean().optional(),
-  limit_reached: z.boolean().optional(),
+var rateLimitSchema = z2.object({
+  allowed: z2.boolean().optional(),
+  limit_reached: z2.boolean().optional(),
   primary_window: windowSchema,
   secondary_window: windowSchema
 }).nullish();
-var additionalLimitSchema = z.object({
-  limit_name: z.string().optional(),
-  metered_feature: z.string().optional(),
+var additionalLimitSchema = z2.object({
+  limit_name: z2.string().optional(),
+  metered_feature: z2.string().optional(),
   primary_window: windowSchema,
   secondary_window: windowSchema
 });
-var creditsSchema = z.object({
-  has_credits: z.boolean().optional(),
-  unlimited: z.boolean().optional(),
-  overage_limit_reached: z.boolean().optional(),
-  balance: z.union([z.string(), z.number()]).optional()
+var creditsSchema = z2.object({
+  has_credits: z2.boolean().optional(),
+  unlimited: z2.boolean().optional(),
+  overage_limit_reached: z2.boolean().optional(),
+  balance: z2.union([z2.string(), z2.number()]).optional()
 }).nullish();
-var usageBodySchema = z.object({
-  plan_type: z.string().nullish(),
+var usageBodySchema = z2.object({
+  plan_type: z2.string().nullish(),
   rate_limit: rateLimitSchema,
-  additional_limits: z.array(additionalLimitSchema).nullish(),
+  additional_limits: z2.array(additionalLimitSchema).nullish(),
   credits: creditsSchema
 });
 function clampPercent(value) {
@@ -391,7 +517,8 @@ function normalizeCodexUsage(httpStatus, rawPayload) {
     fiveHour: null,
     weekly: null,
     limitReached: false,
-    fetchedAt
+    fetchedAt,
+    rateLimitResetCredits: parseCodexRateLimitResetCreditsSummary(rawPayload)
   };
   if (httpStatus >= 400 && httpStatus !== 404 || body == null) {
     return { ...base, status: "error" };
@@ -437,6 +564,9 @@ function normalizeCodexUsage(httpStatus, rawPayload) {
 }
 
 // src/api-client.ts
+var CODEX_READ_TIMEOUT_MS = 5e3;
+var RESET_CREDIT_DETAILS_TIMEOUT_MS = 5e3;
+var RESET_CREDIT_CONSUME_TIMEOUT_MS = 1e4;
 function subscriptionHeaders(a) {
   return {
     Authorization: `Bearer ${a.accessToken}`,
@@ -447,35 +577,183 @@ function subscriptionHeaders(a) {
     ...a.isFedramp ? { "X-OpenAI-Fedramp": "true" } : {}
   };
 }
-async function fetchCodexModels(a, fetchImpl = fetch) {
-  const res = await fetchImpl(
-    `${CODEX_RESPONSES_BASE}/models?client_version=${encodeURIComponent(a.clientVersion)}`,
-    {
+async function fetchCodexModels(a, fetchImpl = fetch, timeoutMs = CODEX_READ_TIMEOUT_MS) {
+  const fetched = await runBoundedCodexOperation(async (signal) => {
+    const res = await fetchImpl(
+      `${CODEX_RESPONSES_BASE}/models?client_version=${encodeURIComponent(a.clientVersion)}`,
+      { method: "GET", headers: subscriptionHeaders(a), signal }
+    );
+    if (!res.ok) {
+      await res.arrayBuffer().catch(() => void 0);
+      return { ok: false, status: res.status, slugs: [] };
+    }
+    const body = await res.json();
+    const slugs = (body.models ?? []).map((model) => model.slug).filter((slug) => typeof slug === "string");
+    return { ok: true, status: res.status, slugs };
+  }, timeoutMs);
+  return fetched.ok ? fetched.value : { ok: false, status: 0, slugs: [] };
+}
+async function fetchCodexUsage(a, fetchImpl = fetch, timeoutMs = CODEX_READ_TIMEOUT_MS) {
+  const fetched = await runBoundedCodexOperation(async (signal) => {
+    const res = await fetchImpl(`${CODEX_WHAM_BASE}/wham/usage`, {
+      method: "GET",
+      headers: subscriptionHeaders(a),
+      signal
+    });
+    const payload = res.ok || res.status === 404 ? await res.json().catch(() => null) : null;
+    if (!res.ok && res.status !== 404) await res.arrayBuffer().catch(() => void 0);
+    return { status: res.status, payload };
+  }, timeoutMs);
+  if (!fetched.ok) throw new Error(`Codex usage request ${fetched.reason}`);
+  return fetched.value;
+}
+async function fetchCodexRateLimitResetCredits(a, fetchImpl = fetch, timeoutMs = RESET_CREDIT_DETAILS_TIMEOUT_MS) {
+  const fetched = await runBoundedCodexOperation(async (signal) => {
+    const res = await fetchImpl(`${CODEX_WHAM_BASE}/wham/rate-limit-reset-credits`, {
       method: "GET",
-      headers: subscriptionHeaders(a)
+      headers: subscriptionHeaders(a),
+      signal
+    });
+    if (!res.ok) {
+      await res.arrayBuffer().catch(() => void 0);
+      return { ok: false, status: res.status, reason: "http_error" };
     }
-  );
-  if (!res.ok) {
-    return { ok: false, status: res.status, slugs: [] };
-  }
-  const body = await res.json();
-  const slugs = (body.models ?? []).map((m) => m.slug).filter((s) => typeof s === "string");
-  return { ok: true, status: res.status, slugs };
-}
-async function fetchCodexUsage(a, fetchImpl = fetch) {
-  const res = await fetchImpl(`${CODEX_WHAM_BASE}/wham/usage`, {
-    method: "GET",
-    headers: subscriptionHeaders(a)
-  });
-  const payload = res.ok || res.status === 404 ? await res.json().catch(() => null) : null;
-  return { status: res.status, payload };
+    const details = parseCodexRateLimitResetCreditsDetails(await res.json().catch(() => null));
+    return details ? { ok: true, status: res.status, details } : { ok: false, status: res.status, reason: "invalid_response" };
+  }, timeoutMs);
+  return fetched.ok ? fetched.value : { ok: false, status: 0, reason: fetched.reason };
+}
+async function consumeCodexRateLimitResetCredit(a, input, fetchImpl = fetch, timeoutMs = RESET_CREDIT_CONSUME_TIMEOUT_MS) {
+  if (input.idempotencyKey.length === 0 || input.creditId === "") {
+    return { ok: false, status: 0, reason: "invalid_request" };
+  }
+  const fetched = await runBoundedCodexOperation(async (signal) => {
+    const res = await fetchImpl(`${CODEX_WHAM_BASE}/wham/rate-limit-reset-credits/consume`, {
+      method: "POST",
+      headers: {
+        ...subscriptionHeaders(a),
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        redeem_request_id: input.idempotencyKey,
+        ...input.creditId ? { credit_id: input.creditId } : {}
+      }),
+      signal
+    });
+    if (!res.ok) {
+      await res.arrayBuffer().catch(() => void 0);
+      return { ok: false, status: res.status, reason: "http_error" };
+    }
+    const result = parseCodexRateLimitResetConsumeResponse(await res.json().catch(() => null));
+    return result ? { ok: true, status: res.status, result } : { ok: false, status: res.status, reason: "invalid_response" };
+  }, timeoutMs);
+  return fetched.ok ? fetched.value : { ok: false, status: 0, reason: fetched.reason };
 }
 
 // src/request-context.ts
 import { AsyncLocalStorage } from "async_hooks";
 var codexRequestStorage = new AsyncLocalStorage();
+function withCodexRequestOverrides(overrides, fn) {
+  const current = codexRequestStorage.getStore();
+  if (!current) return fn();
+  return codexRequestStorage.run({ ...current, ...overrides }, fn);
+}
+
+// src/response-timeout.ts
+var CODEX_RESPONSE_TIMEOUT_ERROR_TYPE = "opengeni_codex_response_timeout";
+var DEFAULT_CODEX_RESPONSE_TIMEOUT_POLICY = Object.freeze({
+  headersTimeoutMs: CODEX_RESPONSE_HEADERS_TIMEOUT_MS,
+  streamIdleTimeoutMs: CODEX_RESPONSE_STREAM_IDLE_TIMEOUT_MS,
+  wholeRequestTimeoutMs: CODEX_RESPONSE_WHOLE_TIMEOUT_MS,
+  noByteRetries: CODEX_RESPONSE_NO_BYTE_RETRIES,
+  retryBackoffMs: CODEX_RESPONSE_RETRY_BACKOFF_MS
+});
+function positiveFinite(value, fallback) {
+  return value !== void 0 && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function resolveCodexResponseTimeoutPolicy(override) {
+  return {
+    headersTimeoutMs: positiveFinite(
+      override?.headersTimeoutMs,
+      DEFAULT_CODEX_RESPONSE_TIMEOUT_POLICY.headersTimeoutMs
+    ),
+    streamIdleTimeoutMs: positiveFinite(
+      override?.streamIdleTimeoutMs,
+      DEFAULT_CODEX_RESPONSE_TIMEOUT_POLICY.streamIdleTimeoutMs
+    ),
+    wholeRequestTimeoutMs: positiveFinite(
+      override?.wholeRequestTimeoutMs,
+      DEFAULT_CODEX_RESPONSE_TIMEOUT_POLICY.wholeRequestTimeoutMs
+    ),
+    // Automatic replay is fail-closed until the provider operation can be
+    // durably read/reconciled. Keep the field for policy/event compatibility,
+    // but never let a caller opt back into an unproved retry.
+    noByteRetries: 0,
+    retryBackoffMs: override?.retryBackoffMs !== void 0 && Number.isFinite(override.retryBackoffMs) && override.retryBackoffMs >= 0 ? override.retryBackoffMs : DEFAULT_CODEX_RESPONSE_TIMEOUT_POLICY.retryBackoffMs
+  };
+}
+var CodexResponseTimeoutError = class extends Error {
+  constructor(timeoutClass, requestId, responseObserved, message = `Codex response ${timeoutClass.replaceAll("_", " ")} timed out`) {
+    super(message);
+    this.timeoutClass = timeoutClass;
+    this.requestId = requestId;
+    this.responseObserved = responseObserved;
+    this.name = "CodexResponseTimeoutError";
+  }
+  code = CODEX_RESPONSE_TIMEOUT_ERROR_TYPE;
+  type = CODEX_RESPONSE_TIMEOUT_ERROR_TYPE;
+};
+function parseTimeoutClass(value) {
+  return value === "connect" || value === "headers" || value === "idle_stream" || value === "whole_request" ? value : null;
+}
+function classifyCodexResponseTimeoutError(error, options = {}) {
+  let current = error;
+  for (let depth = 0; depth < 8 && current && typeof current === "object"; depth += 1) {
+    const value = current;
+    const nested = value.error && typeof value.error === "object" ? value.error : void 0;
+    const type = (typeof value.type === "string" ? value.type : void 0) ?? (typeof value.code === "string" ? value.code : void 0) ?? (typeof nested?.type === "string" ? nested.type : void 0) ?? (typeof nested?.code === "string" ? nested.code : void 0);
+    if (type === CODEX_RESPONSE_TIMEOUT_ERROR_TYPE || value.name === "CodexResponseTimeoutError") {
+      const klass = parseTimeoutClass(value.timeoutClass) ?? parseTimeoutClass(nested?.timeout_class) ?? "headers";
+      return {
+        timeoutClass: klass,
+        requestId: (typeof value.requestId === "string" ? value.requestId : void 0) ?? (typeof nested?.request_id === "string" ? nested.request_id : null),
+        responseObserved: typeof value.responseObserved === "boolean" ? value.responseObserved : nested?.response_observed === true,
+        message: (typeof value.message === "string" ? value.message : void 0) ?? (typeof nested?.message === "string" ? nested.message : "Codex response timed out")
+      };
+    }
+    current = value.cause;
+  }
+  if (options.allowLegacyRequestTimeout && error && typeof error === "object") {
+    const value = error;
+    if (value.name === "APIConnectionTimeoutError" || value.message === "Request timed out." && value.name === "Error") {
+      return {
+        timeoutClass: "headers",
+        requestId: null,
+        responseObserved: false,
+        message: String(value.message ?? "Request timed out.")
+      };
+    }
+  }
+  return null;
+}
+function isPreHeadersTimeoutError(error) {
+  const structured = classifyCodexResponseTimeoutError(error);
+  if (structured && !structured.responseObserved) {
+    return structured.timeoutClass;
+  }
+  if (!error || typeof error !== "object") return null;
+  const value = error;
+  const code = typeof value.code === "string" ? value.code : "";
+  const name = typeof value.name === "string" ? value.name : "";
+  const message = typeof value.message === "string" ? value.message : String(error);
+  if (/^(?:ETIMEDOUT|UND_ERR_CONNECT_TIMEOUT)$/i.test(code) || /ConnectTimeout/i.test(name)) {
+    return "connect";
+  }
+  return /connect(?:ion)?[^.]*timed?\s*out/i.test(`${name} ${message}`) ? "connect" : null;
+}
 
 // src/fetch.ts
+import { randomUUID } from "crypto";
 var CODEX_TRANSPORT_ERROR_HEADER = "x-opengeni-codex-transport-error";
 function headersCarryCodexTransportMarker(headers) {
   if (!headers || typeof headers !== "object") return false;
@@ -495,6 +773,31 @@ function isCodexTransportError(error) {
   }
   return false;
 }
+function classifyCodexEncryptedArtifactRejection(error) {
+  if (!isCodexTransportError(error)) return null;
+  let current = error;
+  for (let depth = 0; depth < 6 && current && typeof current === "object"; depth += 1) {
+    const value = current;
+    const body = value.error && typeof value.error === "object" ? value.error : null;
+    const status = Number(value.status ?? body?.status);
+    const message = [
+      typeof value.message === "string" ? value.message : "",
+      typeof body?.message === "string" ? body.message : "",
+      typeof value.code === "string" ? value.code : "",
+      typeof body?.code === "string" ? body.code : "",
+      typeof value.type === "string" ? value.type : "",
+      typeof body?.type === "string" ? body.type : ""
+    ].join(" ").toLowerCase();
+    const unsupportedFieldShape = /(?:invalid value|supported values?|unsupported|unknown (?:field|parameter|value))/.test(
+      message
+    );
+    if (status === 400 && !unsupportedFieldShape && /(?:encrypted[_ ]content|encrypted reasoning|reasoning artifact)/.test(message) && /(?:decrypt(?:ed|ion)?|could not be parsed|cannot be parsed|failed to parse)/.test(message)) {
+      return { status: 400, kind: "encrypted_content_rejected" };
+    }
+    current = value.cause;
+  }
+  return null;
+}
 function parseIntHeader(value) {
   if (value === null) {
     return null;
@@ -538,6 +841,216 @@ function parseCodexUsageHeaders(headers) {
     checkedAt: new Date(nowMs)
   };
 }
+async function emitRequestEvent(audit, event) {
+  await audit.ctx.onModelRequestEvent?.({
+    requestId: audit.requestId,
+    transportAttempt: audit.transportAttempt,
+    ...audit.model ? { model: audit.model } : {},
+    durationMs: Math.max(0, Date.now() - audit.attemptStartedAt),
+    timeoutPolicy: audit.policy,
+    ...event
+  });
+}
+function providerRequestId(headers) {
+  return headers.get("x-request-id") ?? headers.get("request-id") ?? void 0;
+}
+async function fetchBeforeHeaders(base, input, init, audit) {
+  const elapsed = Date.now() - audit.logicalStartedAt;
+  const wholeRemainingMs = audit.policy.wholeRequestTimeoutMs - elapsed;
+  const timeoutClass = wholeRemainingMs <= audit.policy.headersTimeoutMs ? "whole_request" : "headers";
+  const deadlineMs = Math.max(1, Math.min(audit.policy.headersTimeoutMs, wholeRemainingMs));
+  if (wholeRemainingMs <= 0) {
+    throw new CodexResponseTimeoutError("whole_request", audit.requestId, false);
+  }
+  const externalSignal = init.signal;
+  if (externalSignal?.aborted) throw externalSignal.reason;
+  const controller = new AbortController();
+  const forwardAbort = () => controller.abort(externalSignal?.reason);
+  externalSignal?.addEventListener("abort", forwardAbort, { once: true });
+  const basePromise = base(input, { ...init, signal: controller.signal });
+  let deadlineError = null;
+  let timer;
+  const deadline = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
+      deadlineError = new CodexResponseTimeoutError(timeoutClass, audit.requestId, false);
+      reject(deadlineError);
+    }, deadlineMs);
+  });
+  try {
+    return await Promise.race([basePromise, deadline]);
+  } catch (error) {
+    if (deadlineError) {
+      controller.abort(deadlineError);
+      void basePromise.then((late) => late.body?.cancel(deadlineError ?? void 0)).catch(() => void 0);
+      throw deadlineError;
+    }
+    throw error;
+  } finally {
+    if (timer) clearTimeout(timer);
+    externalSignal?.removeEventListener("abort", forwardAbort);
+  }
+}
+async function observedResponse(res, audit, externalSignal) {
+  const requestId = providerRequestId(res.headers);
+  if (!res.body) {
+    await emitRequestEvent(audit, {
+      phase: res.ok ? "completed" : "failed",
+      responseObserved: true,
+      status: res.status,
+      ...requestId ? { providerRequestId: requestId } : {}
+    });
+    return res;
+  }
+  const reader = res.body.getReader();
+  let terminal = false;
+  let firstByte = false;
+  let idleTimer;
+  let wholeTimer;
+  let armIdle = () => void 0;
+  let abortFromOutside;
+  const clearTimers = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    if (wholeTimer) clearTimeout(wholeTimer);
+    if (abortFromOutside) externalSignal?.removeEventListener("abort", abortFromOutside);
+  };
+  const body = new ReadableStream({
+    start(controller) {
+      const timeOut = (klass) => {
+        if (terminal) return;
+        terminal = true;
+        clearTimers();
+        const error = new CodexResponseTimeoutError(klass, audit.requestId, true);
+        void reader.cancel(error).catch(() => void 0);
+        void emitRequestEvent(audit, {
+          phase: "timed_out",
+          responseObserved: true,
+          timeoutClass: klass,
+          status: res.status,
+          ...requestId ? { providerRequestId: requestId } : {}
+        }).then(
+          () => controller.error(error),
+          () => controller.error(error)
+        );
+      };
+      armIdle = () => {
+        if (idleTimer) clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => timeOut("idle_stream"), audit.policy.streamIdleTimeoutMs);
+      };
+      armIdle();
+      const wholeRemaining = Math.max(
+        1,
+        audit.policy.wholeRequestTimeoutMs - (Date.now() - audit.logicalStartedAt)
+      );
+      wholeTimer = setTimeout(() => timeOut("whole_request"), wholeRemaining);
+      abortFromOutside = () => {
+        if (terminal) return;
+        terminal = true;
+        clearTimers();
+        const reason = externalSignal?.reason ?? new DOMException("Aborted", "AbortError");
+        void reader.cancel(reason).catch(() => void 0);
+        void emitRequestEvent(audit, {
+          phase: "failed",
+          responseObserved: true,
+          status: res.status,
+          ...requestId ? { providerRequestId: requestId } : {}
+        }).then(
+          () => controller.error(reason),
+          () => controller.error(reason)
+        );
+      };
+      if (externalSignal?.aborted) {
+        abortFromOutside();
+      } else {
+        externalSignal?.addEventListener("abort", abortFromOutside, {
+          once: true
+        });
+      }
+    },
+    async pull(controller) {
+      if (terminal) return;
+      try {
+        const chunk = await reader.read();
+        if (terminal) return;
+        if (chunk.done) {
+          terminal = true;
+          clearTimers();
+          await emitRequestEvent(audit, {
+            phase: res.ok ? "completed" : "failed",
+            responseObserved: true,
+            status: res.status,
+            ...requestId ? { providerRequestId: requestId } : {}
+          });
+          controller.close();
+          return;
+        }
+        armIdle();
+        if (!firstByte) {
+          firstByte = true;
+          await emitRequestEvent(audit, {
+            phase: "first_byte",
+            responseObserved: true,
+            status: res.status,
+            ...requestId ? { providerRequestId: requestId } : {}
+          });
+        }
+        controller.enqueue(chunk.value);
+      } catch (error) {
+        if (terminal) return;
+        terminal = true;
+        clearTimers();
+        await emitRequestEvent(audit, {
+          phase: "failed",
+          responseObserved: true,
+          status: res.status,
+          ...requestId ? { providerRequestId: requestId } : {}
+        });
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      if (!terminal) {
+        terminal = true;
+        clearTimers();
+        await emitRequestEvent(audit, {
+          phase: "failed",
+          responseObserved: true,
+          status: res.status,
+          ...requestId ? { providerRequestId: requestId } : {}
+        }).catch(() => void 0);
+      }
+      await reader.cancel(reason).catch(() => void 0);
+    }
+  });
+  const headers = new Headers(res.headers);
+  headers.delete("content-length");
+  return new Response(body, {
+    status: res.status,
+    statusText: res.statusText,
+    headers
+  });
+}
+function timeoutErrorResponse(info) {
+  return new Response(
+    JSON.stringify({
+      error: {
+        type: CODEX_RESPONSE_TIMEOUT_ERROR_TYPE,
+        code: CODEX_RESPONSE_TIMEOUT_ERROR_TYPE,
+        message: info.message,
+        timeout_class: info.timeoutClass,
+        response_observed: info.responseObserved,
+        request_id: info.requestId
+      }
+    }),
+    {
+      status: 504,
+      headers: {
+        "content-type": "application/json",
+        "x-should-retry": "false",
+        [CODEX_TRANSPORT_ERROR_HEADER]: "1"
+      }
+    }
+  );
+}
 function codexSubscriptionFetch(base = globalThis.fetch) {
   return async (input, init) => {
     const ctx = codexRequestStorage.getStore();
@@ -546,7 +1059,11 @@ function codexSubscriptionFetch(base = globalThis.fetch) {
     }
     const rawUrl = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
     const rewritten = rawUrl.replace(/(?<!\/codex)\/responses(\b|$)/, "/codex/responses$1");
-    const attempt = async (auth) => {
+    const policy = resolveCodexResponseTimeoutPolicy(ctx.responseTimeoutPolicy);
+    const requestId = ctx.nextRequestId?.() ?? randomUUID();
+    const logicalStartedAt = Date.now();
+    let transportAttempt = 0;
+    const attempt = async (auth, authenticationAttempt) => {
       const headers = new Headers(init?.headers);
       headers.set("Authorization", `Bearer ${auth.accessToken}`);
       if (auth.chatgptAccountId) {
@@ -565,42 +1082,121 @@ function codexSubscriptionFetch(base = globalThis.fetch) {
       }
       headers.delete("OpenAI-Beta");
       headers.delete("x-api-key");
+      if (ctx.betaFeatures && ctx.betaFeatures.length > 0) {
+        headers.set("x-codex-beta-features", ctx.betaFeatures.join(","));
+      }
+      if (ctx.turnMetadata && Object.keys(ctx.turnMetadata).length > 0) {
+        headers.set("x-codex-turn-metadata", JSON.stringify(ctx.turnMetadata));
+      }
       let callerWantsStream = true;
+      let model;
       const nextInit = { ...init, headers };
       if (typeof init?.body === "string") {
         try {
           const parsed = JSON.parse(init.body);
           callerWantsStream = parsed.stream === true;
-          nextInit.body = JSON.stringify(normalizeCodexRequestBody(parsed, ctx.resolveModel));
+          const normalized = normalizeCodexRequestBody(parsed, ctx.resolveModel);
+          model = typeof normalized.model === "string" ? normalized.model : void 0;
+          nextInit.body = JSON.stringify(normalized);
         } catch {
         }
       }
+      headers.set(
+        "Idempotency-Key",
+        authenticationAttempt === 0 ? requestId : `${requestId}:auth-${authenticationAttempt}`
+      );
       if (process.env.CODEX_DEBUG) {
-        const keys = typeof nextInit.body === "string" ? Object.keys(JSON.parse(nextInit.body)) : [];
+        let keys = [];
+        if (typeof nextInit.body === "string") {
+          try {
+            keys = Object.keys(JSON.parse(nextInit.body));
+          } catch {
+          }
+        }
         console.error(
           `[codex-debug] POST ${rewritten} stream=${callerWantsStream} bodyKeys=[${keys.join(",")}]`
         );
       }
-      const res2 = await base(rewritten, nextInit);
-      const usage = parseCodexUsageHeaders(res2.headers);
+      let res;
+      transportAttempt += 1;
+      const audit = {
+        ctx,
+        requestId,
+        transportAttempt,
+        ...model ? { model } : {},
+        logicalStartedAt,
+        attemptStartedAt: Date.now(),
+        policy
+      };
+      await emitRequestEvent(audit, {
+        phase: "started",
+        responseObserved: false
+      });
+      try {
+        res = await fetchBeforeHeaders(base, rewritten, nextInit, audit);
+        const upstreamRequestId = providerRequestId(res.headers);
+        await emitRequestEvent(audit, {
+          phase: "headers",
+          responseObserved: true,
+          status: res.status,
+          ...upstreamRequestId ? { providerRequestId: upstreamRequestId } : {}
+        });
+        const observed = await observedResponse(res, audit, nextInit.signal);
+        res = observed;
+      } catch (error) {
+        if (nextInit.signal?.aborted) {
+          await emitRequestEvent(audit, {
+            phase: "failed",
+            responseObserved: false
+          }).catch(() => void 0);
+          throw error;
+        }
+        const klass = isPreHeadersTimeoutError(error);
+        if (!klass) {
+          await emitRequestEvent(audit, {
+            phase: "failed",
+            responseObserved: false
+          });
+          throw error;
+        }
+        await emitRequestEvent(audit, {
+          phase: "timed_out",
+          responseObserved: false,
+          timeoutClass: klass,
+          willRetry: false
+        }).catch(() => void 0);
+        throw new CodexResponseTimeoutError(klass, requestId, false);
+      }
+      const usage = parseCodexUsageHeaders(res.headers);
       if (usage) {
         ctx.onUsageHeaders?.(usage);
       }
-      if (process.env.CODEX_DEBUG && !res2.ok) {
+      if (process.env.CODEX_DEBUG && !res.ok) {
         console.error(
-          `[codex-debug] <- ${res2.status} requestId=${res2.headers.get("x-request-id") ?? "unknown"}`
+          `[codex-debug] <- ${res.status} requestId=${res.headers.get("x-request-id") ?? "unknown"}`
         );
       }
-      if (!res2.ok) {
-        return await bufferCodexErrorResponse(res2);
+      if (!res.ok) {
+        return await bufferCodexErrorResponse(res);
       }
-      return callerWantsStream ? repairCodexStream(res2) : await sseToJsonResponse(res2);
+      return callerWantsStream ? repairCodexStream(res) : await sseToJsonResponse(res);
     };
-    let res = await attempt(await ctx.getToken());
-    if (res.status === 401) {
-      res = await attempt(await ctx.refresh());
+    try {
+      let res = await attempt(await ctx.getToken(), 0);
+      if (res.status === 401) {
+        res = await attempt(await ctx.refresh(), 1);
+      }
+      return res;
+    } catch (error) {
+      const timeout = classifyCodexResponseTimeoutError(error);
+      if (!timeout) throw error;
+      return timeoutErrorResponse({
+        timeoutClass: timeout.timeoutClass,
+        requestId: timeout.requestId ?? requestId,
+        responseObserved: timeout.responseObserved,
+        message: timeout.message
+      });
     }
-    return res;
   };
 }
 var CODEX_USAGE_LIMIT_ERROR_TYPE = "usage_limit_reached";
@@ -1648,9 +2244,17 @@ export {
   CODEX_ORIGINATOR,
   CODEX_PROVIDER_BASE_URL,
   CODEX_PROVIDER_ID,
+  CODEX_RATE_LIMIT_RESET_OUTCOMES,
   CODEX_REFRESH_FALLBACK_MS,
   CODEX_REFRESH_WINDOW_MS,
   CODEX_RESPONSES_BASE,
+  CODEX_RESPONSE_HEADERS_TIMEOUT_MS,
+  CODEX_RESPONSE_NO_BYTE_RETRIES,
+  CODEX_RESPONSE_RETRY_BACKOFF_MS,
+  CODEX_RESPONSE_SDK_OUTER_TIMEOUT_MS,
+  CODEX_RESPONSE_STREAM_IDLE_TIMEOUT_MS,
+  CODEX_RESPONSE_TIMEOUT_ERROR_TYPE,
+  CODEX_RESPONSE_WHOLE_TIMEOUT_MS,
   CODEX_TOKEN_URL,
   CODEX_TOOL_OUTPUT_SERIALIZATION_ALLOWANCE,
   CODEX_TRANSPORT_ERROR_HEADER,
@@ -1660,7 +2264,9 @@ export {
   CodexDeviceError,
   CodexRefreshTransient,
   CodexReloginRequired,
+  CodexResponseTimeoutError,
   CodexStreamingTerminalError,
+  DEFAULT_CODEX_RESPONSE_TIMEOUT_POLICY,
   DEFAULT_MODEL_TOOL_OUTPUT_TRUNCATION_TOKENS,
   MODEL_TOOL_OUTPUT_OPAQUE_PAYLOAD_MAX_BYTES,
   MODEL_TOOL_OUTPUT_OVERSIZED_IMAGE_CARD_DATA_URL,
@@ -1671,27 +2277,37 @@ export {
   boundModelToolOutputItems,
   buildCodexUsageWindowFromCache,
   buildModelResolver,
+  classifyCodexEncryptedArtifactRejection,
+  classifyCodexResponseTimeoutError,
   classifyCodexUsageLimitError,
   codexAppsSanitizingFetch,
   codexRequestStorage,
   codexSubscriptionFetch,
+  consumeCodexRateLimitResetCredit,
   decodeJwtPayload,
   exchangeDeviceCode,
   fetchCodexModels,
+  fetchCodexRateLimitResetCredits,
   fetchCodexUsage,
   isCodexBilledModel,
   isCodexTransportError,
+  isPreHeadersTimeoutError,
   modelToolOutputSerializationBudgetTokens,
   normalizeCodexRequestBody,
   normalizeCodexUsage,
+  parseCodexRateLimitResetConsumeResponse,
+  parseCodexRateLimitResetCreditsDetails,
+  parseCodexRateLimitResetCreditsSummary,
   parseCodexUsageHeaders,
   parseIdToken,
   pollDeviceCode,
   refreshCodexToken,
   remapToolCallRequestBody,
+  resolveCodexResponseTimeoutPolicy,
   sanitizeMcpJsonBody,
   sanitizeMcpSseBody,
   startDeviceCode,
-  truncateMiddleWithTokenBudget
+  truncateMiddleWithTokenBudget,
+  withCodexRequestOverrides
 };
 //# sourceMappingURL=index.js.map