@opengeni/codex 0.2.3 → 0.2.7

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-K47573CJ.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;
@@ -280,7 +323,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 +426,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 +516,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 +563,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 +576,178 @@ 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 };
+    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 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 };
+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();
 
+// 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;
@@ -538,6 +810,210 @@ 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 +1022,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) {
@@ -566,41 +1046,114 @@ function codexSubscriptionFetch(base = globalThis.fetch) {
       headers.delete("OpenAI-Beta");
       headers.delete("x-api-key");
       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";
@@ -636,14 +1189,18 @@ async function bufferCodexErrorResponse(res) {
   if (errorType === CODEX_USAGE_LIMIT_ERROR_TYPE) {
     headers.set("x-should-retry", "false");
   }
-  return new Response(bodyText, { status: res.status, statusText: res.statusText, headers });
+  return new Response(bodyText, {
+    status: res.status,
+    statusText: res.statusText,
+    headers
+  });
 }
 async function sseToJsonResponse(res) {
   const text = await res.text();
   let final = null;
+  let terminalError = null;
   const items = [];
-  for (const block of text.split("\n\n")) {
-    const data = block.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim()).join("\n");
+  for (const data of sseDataPayloads(text)) {
     if (!data || data === "[DONE]") {
       continue;
     }
@@ -651,12 +1208,64 @@ async function sseToJsonResponse(res) {
       const ev = JSON.parse(data);
       if (ev.type === "response.output_item.done" && ev.item !== void 0) {
         items.push(ev.item);
-      } else if (ev.type === "response.completed" || ev.type === "response.done" || ev.type === "response.incomplete") {
+      } else if (ev.type === "response.failed") {
+        terminalError = codexSseFailureResponse(
+          res,
+          ev.response?.error,
+          "response_failed",
+          "The Codex response failed",
+          {
+            eventType: ev.type,
+            responseId: ev.response?.id,
+            responseStatus: ev.response?.status
+          }
+        );
+      } else if (ev.type === "error" || ev.type === "response.error") {
+        terminalError = codexSseFailureResponse(
+          res,
+          ev.error ?? ev.response?.error ?? ev,
+          "response_error",
+          "The Codex response stream reported an error",
+          {
+            eventType: ev.type,
+            responseId: ev.response?.id,
+            responseStatus: ev.response?.status
+          }
+        );
+      } else if (ev.type === "response.incomplete") {
+        const details = ev.response?.incomplete_details;
+        const reason = details && typeof details === "object" ? details.reason : void 0;
+        terminalError = codexSseFailureResponse(
+          res,
+          {
+            code: "response_incomplete",
+            message: typeof reason === "string" && reason.length > 0 ? `The Codex response was incomplete (${reason})` : "The Codex response was incomplete"
+          },
+          "response_incomplete",
+          "The Codex response was incomplete",
+          {
+            eventType: ev.type,
+            responseId: ev.response?.id,
+            responseStatus: ev.response?.status
+          }
+        );
+      } else if (ev.type === "response.completed" || ev.type === "response.done") {
         final = ev.response ?? null;
       }
     } catch {
     }
   }
+  if (terminalError) {
+    return terminalError;
+  }
+  if (!final) {
+    return codexSseFailureResponse(
+      res,
+      null,
+      "invalid_sse_terminal",
+      "The Codex response stream ended without a terminal response"
+    );
+  }
   if (final && items.length > 0) {
     final = { ...final, output: items };
   }
@@ -668,64 +1277,331 @@ async function sseToJsonResponse(res) {
   const headers = new Headers(res.headers);
   headers.set("content-type", "application/json");
   headers.delete("content-length");
-  return new Response(JSON.stringify(final ?? {}), { status: 200, headers });
+  return new Response(JSON.stringify(final), { status: 200, headers });
+}
+var NON_RETRYABLE_SSE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "bio_policy",
+  "context_length_exceeded",
+  "cyber_policy",
+  "insufficient_quota",
+  "invalid_prompt",
+  "usage_limit_reached"
+]);
+function sseDataPayloads(text) {
+  const payloads = [];
+  let dataLines = [];
+  const dispatch = () => {
+    if (dataLines.length > 0) payloads.push(dataLines.join("\n"));
+    dataLines = [];
+  };
+  for (const line of text.split(/\r\n|\r|\n/)) {
+    if (line === "") {
+      dispatch();
+      continue;
+    }
+    if (line === "data") {
+      dataLines.push("");
+      continue;
+    }
+    if (!line.startsWith("data:")) continue;
+    const value = line.slice(5);
+    dataLines.push(value.startsWith(" ") ? value.slice(1) : value);
+  }
+  dispatch();
+  return payloads;
+}
+var CODEX_TERMINAL_ERROR_FIELD_MAX_BYTES = 256;
+var CODEX_TERMINAL_ERROR_MESSAGE_MAX_BYTES = 4 * 1024;
+var CODEX_TERMINAL_ERROR_TRUNCATION_MARKER = "\u2026 [truncated]";
+function boundedTerminalErrorField(value, maxBytes) {
+  if (typeof value !== "string") return { truncated: false };
+  const encoder = new TextEncoder();
+  const encoded = encoder.encode(value);
+  if (encoded.byteLength <= maxBytes) return { value, truncated: false };
+  const markerBytes = encoder.encode(CODEX_TERMINAL_ERROR_TRUNCATION_MARKER).byteLength;
+  let prefixEnd = Math.max(0, maxBytes - markerBytes);
+  while (prefixEnd > 0 && (encoded[prefixEnd] & 192) === 128) {
+    prefixEnd -= 1;
+  }
+  return {
+    value: `${new TextDecoder().decode(encoded.subarray(0, prefixEnd))}${CODEX_TERMINAL_ERROR_TRUNCATION_MARKER}`,
+    truncated: true
+  };
+}
+function codexSseFailureResponse(source, rawError, fallbackCode, fallbackMessage, metadata = {}) {
+  const projection = codexSseFailureProjection(
+    source,
+    rawError,
+    fallbackCode,
+    fallbackMessage,
+    metadata
+  );
+  return new Response(JSON.stringify({ error: projection.error }), {
+    status: projection.status,
+    headers: projection.headers
+  });
+}
+function codexSseFailureProjection(source, rawError, fallbackCode, fallbackMessage, metadata = {}) {
+  const record = rawError && typeof rawError === "object" && !Array.isArray(rawError) ? rawError : {};
+  const typeField = boundedTerminalErrorField(record.type, CODEX_TERMINAL_ERROR_FIELD_MAX_BYTES);
+  const codeField = boundedTerminalErrorField(record.code, CODEX_TERMINAL_ERROR_FIELD_MAX_BYTES);
+  const messageField = boundedTerminalErrorField(
+    record.message ?? (typeof rawError === "string" ? rawError : void 0),
+    CODEX_TERMINAL_ERROR_MESSAGE_MAX_BYTES
+  );
+  const paramField = boundedTerminalErrorField(record.param, CODEX_TERMINAL_ERROR_FIELD_MAX_BYTES);
+  const eventTypeField = boundedTerminalErrorField(
+    metadata.eventType,
+    CODEX_TERMINAL_ERROR_FIELD_MAX_BYTES
+  );
+  const responseIdField = boundedTerminalErrorField(
+    metadata.responseId,
+    CODEX_TERMINAL_ERROR_FIELD_MAX_BYTES
+  );
+  const responseStatusField = boundedTerminalErrorField(
+    metadata.responseStatus,
+    CODEX_TERMINAL_ERROR_FIELD_MAX_BYTES
+  );
+  const providerType = typeField.value === "error" || typeField.value === "response.error" || typeField.value === "response.failed" ? void 0 : typeField.value;
+  const code = (codeField.value?.length ? codeField.value : void 0) ?? (providerType?.length ? providerType : void 0) ?? fallbackCode;
+  const diagnosticTruncated = typeField.truncated || codeField.truncated || messageField.truncated || paramField.truncated || eventTypeField.truncated || responseIdField.truncated || responseStatusField.truncated || Object.keys(record).some((key) => !["type", "code", "message", "param"].includes(key)) || rawError !== null && rawError !== void 0 && typeof rawError !== "string" && (typeof rawError !== "object" || Array.isArray(rawError));
+  const error = {
+    type: providerType?.length ? providerType : code,
+    code,
+    message: messageField.value?.length ? messageField.value : fallbackMessage,
+    ...paramField.value?.length ? { param: paramField.value } : {},
+    ...eventTypeField.value?.length ? { event_type: eventTypeField.value } : {},
+    ...responseIdField.value?.length ? { response_id: responseIdField.value } : {},
+    ...responseStatusField.value?.length ? { response_status: responseStatusField.value } : {},
+    ...diagnosticTruncated ? { diagnostic_truncated: true } : {}
+  };
+  const status = code === "rate_limit_exceeded" || code === "usage_limit_reached" || code === "insufficient_quota" ? 429 : NON_RETRYABLE_SSE_ERROR_CODES.has(code) ? 400 : 502;
+  const headers = new Headers(source.headers);
+  headers.set("content-type", "application/json");
+  headers.set(CODEX_TRANSPORT_ERROR_HEADER, "1");
+  headers.set("x-should-retry", "false");
+  headers.delete("content-length");
+  headers.delete("content-encoding");
+  return { status, error, headers };
+}
+var CodexStreamingTerminalError = class extends Error {
+  status;
+  code;
+  type;
+  eventType;
+  responseId;
+  responseStatus;
+  headers;
+  error;
+  constructor(projection, publicMessage) {
+    super(publicMessage);
+    this.name = "CodexStreamingTerminalError";
+    this.status = projection.status;
+    this.code = projection.error.code;
+    this.type = projection.error.type;
+    if (projection.error.event_type !== void 0) {
+      this.eventType = projection.error.event_type;
+    }
+    if (projection.error.response_id !== void 0) {
+      this.responseId = projection.error.response_id;
+    }
+    if (projection.error.response_status !== void 0) {
+      this.responseStatus = projection.error.response_status;
+    }
+    this.headers = projection.headers;
+    this.error = {
+      type: projection.error.type,
+      code: projection.error.code,
+      ...projection.error.event_type ? { event_type: projection.error.event_type } : {},
+      ...projection.error.response_id ? { response_id: projection.error.response_id } : {},
+      ...projection.error.response_status ? { response_status: projection.error.response_status } : {},
+      ...projection.error.diagnostic_truncated ? { diagnostic_truncated: true } : {}
+    };
+  }
+};
+function codexSseFailureError(source, rawError, fallbackCode, publicMessage, metadata = {}) {
+  return new CodexStreamingTerminalError(
+    codexSseFailureProjection(source, rawError, fallbackCode, publicMessage, metadata),
+    publicMessage
+  );
 }
 function repairCodexStream(res) {
   if (!res.body) {
-    return res;
+    const error = codexSseFailureError(
+      res,
+      null,
+      "invalid_sse_terminal",
+      "The Codex response stream ended without a terminal response"
+    );
+    const body = new ReadableStream({
+      start(controller) {
+        controller.error(error);
+      }
+    });
+    const headers2 = new Headers(res.headers);
+    headers2.delete("content-length");
+    return new Response(body, {
+      status: res.status,
+      statusText: res.statusText,
+      headers: headers2
+    });
   }
   const items = [];
   const decoder = new TextDecoder();
   const encoder = new TextEncoder();
   let buffer = "";
+  let successfulTerminalSeen = false;
+  const emitCompleteBlocks = (controller, final) => {
+    let boundary = findSseBlockBoundary(buffer, final);
+    while (boundary) {
+      const block = buffer.slice(0, boundary.start);
+      const separator = buffer.slice(boundary.start, boundary.end);
+      buffer = buffer.slice(boundary.end);
+      const patched = patchSseBlock(block, items, res);
+      successfulTerminalSeen ||= patched.successfulTerminal;
+      controller.enqueue(encoder.encode(`${patched.block}${separator}`));
+      boundary = findSseBlockBoundary(buffer, final);
+    }
+  };
   const transform = new TransformStream({
     transform(chunk, controller) {
       buffer += decoder.decode(chunk, { stream: true });
-      let idx = buffer.indexOf("\n\n");
-      while (idx !== -1) {
-        const block = buffer.slice(0, idx);
-        buffer = buffer.slice(idx + 2);
-        controller.enqueue(encoder.encode(`${patchSseBlock(block, items)}
-
-`));
-        idx = buffer.indexOf("\n\n");
-      }
+      emitCompleteBlocks(controller, false);
     },
     flush(controller) {
+      buffer += decoder.decode();
+      emitCompleteBlocks(controller, true);
       if (buffer.length > 0) {
-        controller.enqueue(encoder.encode(patchSseBlock(buffer, items)));
+        const patched = patchSseBlock(buffer, items, res);
+        successfulTerminalSeen ||= patched.successfulTerminal;
+        controller.enqueue(encoder.encode(patched.block));
+        buffer = "";
+      }
+      if (!successfulTerminalSeen) {
+        throw codexSseFailureError(
+          res,
+          null,
+          "invalid_sse_terminal",
+          "The Codex response stream ended without a terminal response"
+        );
       }
     }
   });
   const headers = new Headers(res.headers);
   headers.delete("content-length");
-  return new Response(res.body.pipeThrough(transform), { status: res.status, headers });
+  return new Response(res.body.pipeThrough(transform), {
+    status: res.status,
+    headers
+  });
+}
+function findSseBlockBoundary(value, final) {
+  for (let index = 0; index < value.length; index += 1) {
+    const firstEnd = sseLineEndingEnd(value, index, final);
+    if (firstEnd === null) continue;
+    const secondEnd = sseLineEndingEnd(value, firstEnd, final);
+    if (secondEnd !== null) {
+      return { start: index, end: secondEnd };
+    }
+    index = firstEnd - 1;
+  }
+  return null;
+}
+function sseLineEndingEnd(value, index, final) {
+  const current = value[index];
+  if (current === "\n") return index + 1;
+  if (current !== "\r") return null;
+  if (index + 1 < value.length) {
+    return value[index + 1] === "\n" ? index + 2 : index + 1;
+  }
+  return final ? index + 1 : null;
 }
-function patchSseBlock(block, items) {
-  const lines = block.split("\n");
+function patchSseBlock(block, items, source) {
+  const lines = block.split(/\r\n|\r|\n/);
   const dataStr = lines.filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim()).join("\n");
   if (!dataStr || dataStr === "[DONE]") {
-    return block;
+    return { block, successfulTerminal: false };
   }
   let ev;
   try {
     ev = JSON.parse(dataStr);
   } catch {
-    return block;
+    return { block, successfulTerminal: false };
   }
   if (ev.type === "response.output_item.done" && ev.item !== void 0) {
     items.push(ev.item);
-    return block;
+    return { block, successfulTerminal: false };
+  }
+  if (ev.type === "response.failed") {
+    throw codexSseFailureError(
+      source,
+      ev.response?.error,
+      "response_failed",
+      "The Codex response failed",
+      {
+        eventType: ev.type,
+        responseId: ev.response?.id,
+        responseStatus: ev.response?.status
+      }
+    );
+  }
+  if (ev.type === "error" || ev.type === "response.error") {
+    throw codexSseFailureError(
+      source,
+      ev.error ?? ev.response?.error ?? ev,
+      "response_error",
+      "The Codex response stream reported an error",
+      {
+        eventType: ev.type,
+        responseId: ev.response?.id,
+        responseStatus: ev.response?.status
+      }
+    );
   }
-  if ((ev.type === "response.completed" || ev.type === "response.done" || ev.type === "response.incomplete") && ev.response) {
+  if (ev.type === "response.incomplete") {
+    const details = ev.response?.incomplete_details;
+    const reason = details && typeof details === "object" ? details.reason : void 0;
+    throw codexSseFailureError(
+      source,
+      {
+        code: "response_incomplete",
+        message: typeof reason === "string" && reason.length > 0 ? `The Codex response was incomplete (${reason})` : "The Codex response was incomplete"
+      },
+      "response_incomplete",
+      "The Codex response was incomplete",
+      {
+        eventType: ev.type,
+        responseId: ev.response?.id,
+        responseStatus: ev.response?.status
+      }
+    );
+  }
+  if ((ev.type === "response.completed" || ev.type === "response.done") && ev.response) {
+    if (ev.response.status === "failed" || ev.response.status === "incomplete" || ev.response.error !== null && ev.response.error !== void 0) {
+      throw codexSseFailureError(
+        source,
+        ev.response.error,
+        ev.response.status === "incomplete" ? "response_incomplete" : "response_failed",
+        ev.response.status === "incomplete" ? "The Codex response was incomplete" : "The Codex response failed",
+        {
+          eventType: ev.type,
+          responseId: ev.response.id,
+          responseStatus: ev.response.status
+        }
+      );
+    }
     const out = ev.response.output;
     if ((!Array.isArray(out) || out.length === 0) && items.length > 0) {
       ev.response = { ...ev.response, output: items };
       const nonData = lines.filter((l) => !l.startsWith("data:"));
-      return [...nonData, `data: ${JSON.stringify(ev)}`].join("\n");
+      const lineEnding = block.match(/\r\n|\r|\n/)?.[0] ?? "\n";
+      return {
+        block: [...nonData, `data: ${JSON.stringify(ev)}`].join(lineEnding),
+        successfulTerminal: true
+      };
     }
+    return { block, successfulTerminal: true };
   }
-  return block;
+  return { block, successfulTerminal: false };
 }
 
 // src/mcp-sanitize.ts
@@ -894,6 +1770,412 @@ function codexAppsSanitizingFetch(base = globalThis.fetch, namespaceSink) {
     return new Response(sanitized, { status: res.status, statusText: res.statusText, headers });
   };
 }
+
+// src/oversized-image-card.ts
+var MODEL_TOOL_OUTPUT_OVERSIZED_IMAGE_CARD_DATA_URL = "data:image/png;base64,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";
+
+// src/model-output-truncation.ts
+var CODEX_MODEL_TOOL_OUTPUT_TRUNCATION_TOKENS = 1e4;
+var CODEX_TOOL_OUTPUT_SERIALIZATION_ALLOWANCE = 1.2;
+var DEFAULT_MODEL_TOOL_OUTPUT_TRUNCATION_TOKENS = CODEX_MODEL_TOOL_OUTPUT_TRUNCATION_TOKENS;
+var APPROX_BYTES_PER_TOKEN = 4;
+var TOKEN_TRUNCATION_MARKER = /…\d{1,12} tokens truncated…/u;
+var TOOL_RESULT_TYPES = /* @__PURE__ */ new Set([
+  "function_call_result",
+  "function_call_output",
+  "computer_call_result",
+  "custom_tool_call_output",
+  "shell_call_output",
+  "apply_patch_call_output"
+]);
+var STRUCTURAL_STRING_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "role",
+  "status",
+  "name",
+  "id",
+  "callId",
+  "call_id",
+  "namespace",
+  "detail",
+  "mimeType",
+  "media_type"
+]);
+var MODEL_TOOL_OUTPUT_MAX_DEPTH = 12;
+var MODEL_TOOL_OUTPUT_MAX_CONTAINER_ENTRIES = 255;
+var MODEL_TOOL_OUTPUT_MAX_TOTAL_ENTRIES = 2048;
+var MODEL_TOOL_OUTPUT_MAX_PROPERTY_KEY_BYTES = 256;
+var MODEL_TOOL_OUTPUT_MAX_STRUCTURAL_STRING_TOKENS = 64;
+var MODEL_TOOL_OUTPUT_STRUCTURAL_STRING_BUDGET_TOKENS = 1024;
+var MODEL_TOOL_OUTPUT_OPAQUE_PAYLOAD_MAX_BYTES = 8 * 1024 * 1024;
+var DEPTH_OMISSION_MARKER = "[OpenGeni omitted subtree: maximum structured tool-output depth exceeded]";
+var CYCLE_OMISSION_MARKER = "[OpenGeni omitted subtree: cyclic tool output]";
+var STRUCTURAL_STRING_OMISSION_MARKER = "[OpenGeni omitted structural string: structural budget exhausted]";
+var TEXT_FIELD_OMISSION_MARKER = /^\[omitted text field \d+ \.\.\.\]$/u;
+var TEXT_ITEMS_OMISSION_MARKER = /^\[omitted \d+ text items \.\.\.\]$/u;
+var STRUCTURAL_ENTRIES_OMISSION_MARKER = /^\[OpenGeni omitted \d+ structured (?:array items|object properties)\]$/u;
+var OPAQUE_PAYLOAD_OMISSION_MARKER = /^\[OpenGeni omitted (?:image|file|encrypted) payload: \d+ bytes exceeded the bounded model-input allowance\]$/u;
+var STRUCTURAL_PROPERTIES_MARKER_KEY = "__opengeni_omitted_properties__";
+function modelToolOutputSerializationBudgetTokens(policyTokens = DEFAULT_MODEL_TOOL_OUTPUT_TRUNCATION_TOKENS) {
+  return Math.ceil(Math.max(0, policyTokens) * CODEX_TOOL_OUTPUT_SERIALIZATION_ALLOWANCE);
+}
+function approximateTokenCount(value) {
+  return Math.ceil(Buffer.byteLength(value, "utf8") / APPROX_BYTES_PER_TOKEN);
+}
+function truncateMiddleWithTokenBudget(value, maxTokens) {
+  if (value.length === 0) return value;
+  const maxBytes = Math.max(0, maxTokens) * APPROX_BYTES_PER_TOKEN;
+  const valueBytes = Buffer.byteLength(value, "utf8");
+  if (maxTokens > 0 && valueBytes <= maxBytes) return value;
+  const existingMarker = value.match(TOKEN_TRUNCATION_MARKER)?.[0];
+  if (existingMarker && valueBytes <= maxBytes + Buffer.byteLength(existingMarker, "utf8")) {
+    return value;
+  }
+  if (maxBytes === 0) {
+    return `\u2026${approximateTokenCount(value)} tokens truncated\u2026`;
+  }
+  const leftBudget = Math.floor(maxBytes / 2);
+  const rightBudget = maxBytes - leftBudget;
+  const bytes = Buffer.from(value, "utf8");
+  let leftEnd = Math.min(leftBudget, bytes.length);
+  while (leftEnd > 0 && leftEnd < bytes.length && isUtf8ContinuationByte(bytes[leftEnd])) {
+    leftEnd -= 1;
+  }
+  let rightStart = Math.max(0, bytes.length - rightBudget);
+  while (rightStart < bytes.length && isUtf8ContinuationByte(bytes[rightStart])) {
+    rightStart += 1;
+  }
+  const left = bytes.subarray(0, leftEnd).toString("utf8");
+  const right = bytes.subarray(rightStart).toString("utf8");
+  const removedBytes = Math.max(0, valueBytes - maxBytes);
+  const removedTokens = Math.ceil(removedBytes / APPROX_BYTES_PER_TOKEN);
+  return `${left}\u2026${removedTokens} tokens truncated\u2026${right}`;
+}
+function isUtf8ContinuationByte(value) {
+  return (value & 192) === 128;
+}
+function boundModelToolOutputItem(item, policyTokens = DEFAULT_MODEL_TOOL_OUTPUT_TRUNCATION_TOKENS) {
+  const type = typeof item.type === "string" ? item.type : "";
+  if (!TOOL_RESULT_TYPES.has(type)) return item;
+  const budget = modelToolOutputSerializationBudgetTokens(policyTokens);
+  const boundedOutput = boundToolOutputValue(item.output, budget);
+  return boundedOutput === item.output ? item : { ...item, output: boundedOutput };
+}
+function boundModelToolOutputItems(items, policyTokens = DEFAULT_MODEL_TOOL_OUTPUT_TRUNCATION_TOKENS) {
+  return items.map((item) => boundModelToolOutputItem(item, policyTokens));
+}
+function boundToolOutputValue(output, budgetTokens) {
+  const state = modelOutputBoundState(budgetTokens);
+  if (typeof output === "string") {
+    if (isGeneratedModelOutputMarker(output)) {
+      observeGeneratedMarkerBudget(output, state);
+      return output;
+    }
+    if (isImageDataUrl(output)) return boundOpaqueProtocolString(output, state, "image");
+    return truncateMiddleWithTokenBudget(output, budgetTokens);
+  }
+  if (Array.isArray(output)) {
+    const isProtocolContent = isResponsesProtocolContentPrefix(output);
+    return isProtocolContent ? boundStructuredOutputItems(output, state) : boundTextLeaves(output, state);
+  }
+  if (!output || typeof output !== "object") return output;
+  const record = output;
+  return boundTextLeaves(record, state);
+}
+function modelOutputBoundState(budgetTokens) {
+  return {
+    remaining: Math.max(0, budgetTokens),
+    remainingStructural: MODEL_TOOL_OUTPUT_STRUCTURAL_STRING_BUDGET_TOKENS,
+    remainingEntries: MODEL_TOOL_OUTPUT_MAX_TOTAL_ENTRIES,
+    remainingOpaqueBytes: MODEL_TOOL_OUTPUT_OPAQUE_PAYLOAD_MAX_BYTES,
+    opaqueOmissions: 0,
+    lastOpaqueOmissionMarker: null,
+    omitted: 0,
+    seen: /* @__PURE__ */ new WeakSet()
+  };
+}
+function boundStructuredOutputItems(items, state) {
+  let omitted = 0;
+  let changed = false;
+  const out = [];
+  let processed = 0;
+  const terminalStructuralMarker = items.length <= MODEL_TOOL_OUTPUT_MAX_CONTAINER_ENTRIES + 1 && isTypedStructuralArrayOmissionMarker(items.at(-1)) ? items.at(-1) : null;
+  let preservedTerminalStructuralMarker = false;
+  for (let index = 0; index < items.length; index += 1) {
+    const item = items[index];
+    if (processed >= MODEL_TOOL_OUTPUT_MAX_CONTAINER_ENTRIES || state.remainingEntries <= 0) {
+      if (terminalStructuralMarker && index <= items.length - 1) {
+        out.push(terminalStructuralMarker);
+        preservedTerminalStructuralMarker = true;
+      }
+      break;
+    }
+    processed += 1;
+    state.remainingEntries -= 1;
+    const record = item;
+    if (record.type === "input_text" && isGeneratedModelOutputMarker(record.text)) {
+      const bounded2 = boundTextLeaves(item, state, 1);
+      out.push(bounded2);
+      if (item === terminalStructuralMarker) preservedTerminalStructuralMarker = true;
+      if (bounded2 !== item) changed = true;
+      continue;
+    }
+    if (record.type === "input_text" && state.remaining === 0) {
+      omitted += 1;
+      changed = true;
+      continue;
+    }
+    const bounded = boundResponsesProtocolContentItem(record, state);
+    out.push(bounded);
+    if (item === terminalStructuralMarker) preservedTerminalStructuralMarker = true;
+    if (bounded !== item) changed = true;
+  }
+  if (omitted > 0) {
+    out.push({
+      type: "input_text",
+      text: `[omitted ${omitted} text items ...]`
+    });
+  }
+  const structurallyOmitted = preservedTerminalStructuralMarker ? 0 : items.length - processed;
+  if (structurallyOmitted > 0) {
+    out.push(typedStructuredArrayOmissionMarker(structurallyOmitted));
+    changed = true;
+  }
+  return changed ? out : items;
+}
+function boundResponsesProtocolContentItem(item, state) {
+  const opaqueOmissionsBefore = state.opaqueOmissions;
+  const bounded = boundTextLeaves(item, state, 1);
+  if (item.type === "input_image" && state.opaqueOmissions > opaqueOmissionsBefore) {
+    return {
+      type: "input_image",
+      imageUrl: MODEL_TOOL_OUTPUT_OVERSIZED_IMAGE_CARD_DATA_URL
+    };
+  }
+  if (item.type === "input_file" && state.opaqueOmissions > opaqueOmissionsBefore) {
+    return typedProtocolTextMarker(
+      state.lastOpaqueOmissionMarker ?? "[OpenGeni omitted file payload: 0 bytes exceeded the bounded model-input allowance]"
+    );
+  }
+  return bounded;
+}
+function boundTextLeaves(value, state, depth = 0, opaqueKind = null) {
+  if (typeof value === "string") {
+    if (isGeneratedModelOutputMarker(value)) {
+      observeGeneratedMarkerBudget(value, state);
+      return value;
+    }
+    if (opaqueKind || isImageDataUrl(value)) {
+      return boundOpaqueProtocolString(value, state, opaqueKind ?? "image");
+    }
+    if (state.remaining === 0) {
+      state.omitted += 1;
+      return `[omitted text field ${state.omitted} ...]`;
+    }
+    const cost = approximateTokenCount(value);
+    if (cost <= state.remaining) {
+      state.remaining -= cost;
+      return value;
+    }
+    const bounded = truncateMiddleWithTokenBudget(value, state.remaining);
+    state.remaining = 0;
+    return bounded;
+  }
+  if (!value || typeof value !== "object") return value;
+  if (depth >= MODEL_TOOL_OUTPUT_MAX_DEPTH) return DEPTH_OMISSION_MARKER;
+  if (state.seen.has(value)) return CYCLE_OMISSION_MARKER;
+  state.seen.add(value);
+  if (Array.isArray(value)) {
+    const out2 = [];
+    let processed2 = 0;
+    let changed2 = false;
+    for (let index = 0; index < value.length; index += 1) {
+      const entry = value[index];
+      if (processed2 >= MODEL_TOOL_OUTPUT_MAX_CONTAINER_ENTRIES || state.remainingEntries <= 0) {
+        if (index === value.length - 1 && typeof entry === "string" && STRUCTURAL_ENTRIES_OMISSION_MARKER.test(entry)) {
+          out2.push(entry);
+        }
+        break;
+      }
+      processed2 += 1;
+      state.remainingEntries -= 1;
+      const bounded = boundTextLeaves(entry, state, depth + 1, opaqueKind);
+      out2.push(bounded);
+      if (bounded !== entry) changed2 = true;
+    }
+    const omitted2 = value.length - out2.length;
+    if (omitted2 > 0) {
+      out2.push(structuredEntriesOmissionMarker(omitted2, "array"));
+      changed2 = true;
+    }
+    state.seen.delete(value);
+    return changed2 ? out2 : value;
+  }
+  const record = value;
+  const recordOpaqueKind = nonTextProtocolKind(record.type) ?? opaqueKind;
+  const entries = Object.entries(record);
+  const out = {};
+  let processed = 0;
+  let omitted = 0;
+  let changed = false;
+  for (let index = 0; index < entries.length; index += 1) {
+    const [key, entry] = entries[index];
+    if (processed >= MODEL_TOOL_OUTPUT_MAX_CONTAINER_ENTRIES || state.remainingEntries <= 0) {
+      if (index === entries.length - 1 && isGeneratedStructuralMarkerProperty(key, entry)) {
+        out[key] = entry;
+        break;
+      }
+      omitted += entries.length - index;
+      break;
+    }
+    processed += 1;
+    state.remainingEntries -= 1;
+    if (Buffer.byteLength(key, "utf8") > MODEL_TOOL_OUTPUT_MAX_PROPERTY_KEY_BYTES) {
+      omitted += 1;
+      changed = true;
+      continue;
+    }
+    const childOpaqueKind = opaqueKindForChild(recordOpaqueKind, key);
+    if (typeof entry === "string" && childOpaqueKind) {
+      const bounded2 = boundTextLeaves(entry, state, depth + 1, childOpaqueKind);
+      out[key] = bounded2;
+      if (bounded2 !== entry) changed = true;
+      continue;
+    }
+    if (typeof entry === "string" && STRUCTURAL_STRING_KEYS.has(key)) {
+      const bounded2 = boundStructuralString(entry, state);
+      out[key] = bounded2;
+      if (bounded2 !== entry) changed = true;
+      continue;
+    }
+    const bounded = boundTextLeaves(entry, state, depth + 1, childOpaqueKind);
+    out[key] = bounded;
+    if (bounded !== entry) changed = true;
+  }
+  if (omitted > 0) {
+    out[uniqueStructuralMarkerKey(out)] = structuredEntriesOmissionMarker(omitted, "object");
+    changed = true;
+  }
+  state.seen.delete(value);
+  return changed ? out : value;
+}
+function boundStructuralString(value, state) {
+  if (isGeneratedModelOutputMarker(value)) {
+    observeGeneratedMarkerBudget(value, state);
+    return value;
+  }
+  if (state.remainingStructural === 0) return STRUCTURAL_STRING_OMISSION_MARKER;
+  const cost = approximateTokenCount(value);
+  const allowance = Math.min(
+    MODEL_TOOL_OUTPUT_MAX_STRUCTURAL_STRING_TOKENS,
+    state.remainingStructural
+  );
+  if (cost <= allowance) {
+    state.remainingStructural -= cost;
+    return value;
+  }
+  state.remainingStructural -= allowance;
+  return truncateMiddleWithTokenBudget(value, allowance);
+}
+function boundOpaqueProtocolString(value, state, kind) {
+  if (kind === "image" && value === MODEL_TOOL_OUTPUT_OVERSIZED_IMAGE_CARD_DATA_URL) {
+    state.remainingOpaqueBytes = 0;
+    return value;
+  }
+  const bytes = Buffer.byteLength(value, "utf8");
+  if (bytes <= state.remainingOpaqueBytes) {
+    state.remainingOpaqueBytes -= bytes;
+    return value;
+  }
+  state.remainingOpaqueBytes = 0;
+  if (kind === "image") {
+    state.opaqueOmissions += 1;
+    return MODEL_TOOL_OUTPUT_OVERSIZED_IMAGE_CARD_DATA_URL;
+  }
+  const marker = `[OpenGeni omitted ${kind} payload: ${bytes} bytes exceeded the bounded model-input allowance]`;
+  state.opaqueOmissions += 1;
+  state.lastOpaqueOmissionMarker = marker;
+  return marker;
+}
+function nonTextProtocolKind(value) {
+  if (value === "image" || value === "input_image" || value === "computer_screenshot") {
+    return "image";
+  }
+  if (value === "file" || value === "input_file") return "file";
+  if (value === "encrypted_content") return "encrypted";
+  return null;
+}
+function opaqueKindForChild(kind, key) {
+  if (!kind) return null;
+  const opaqueKeys = kind === "image" ? ["image", "image_url", "imageUrl", "file_id", "fileId", "id", "data", "url", "source"] : kind === "file" ? [
+    "file",
+    "file_data",
+    "fileData",
+    "file_url",
+    "fileUrl",
+    "file_id",
+    "fileId",
+    "id",
+    "data",
+    "url",
+    "content",
+    "source"
+  ] : ["encrypted_content", "content", "data"];
+  return opaqueKeys.includes(key) ? kind : null;
+}
+function structuredEntriesOmissionMarker(count, container) {
+  return `[OpenGeni omitted ${count} structured ${container === "array" ? "array items" : "object properties"}]`;
+}
+function typedProtocolTextMarker(text) {
+  return { type: "input_text", text };
+}
+function typedStructuredArrayOmissionMarker(count) {
+  return typedProtocolTextMarker(structuredEntriesOmissionMarker(count, "array"));
+}
+function isTypedStructuralArrayOmissionMarker(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return record.type === "input_text" && typeof record.text === "string" && STRUCTURAL_ENTRIES_OMISSION_MARKER.test(record.text) && record.text.includes("structured array items");
+}
+function isGeneratedModelOutputMarker(value) {
+  return typeof value === "string" && (value === DEPTH_OMISSION_MARKER || value === CYCLE_OMISSION_MARKER || value === STRUCTURAL_STRING_OMISSION_MARKER || TEXT_FIELD_OMISSION_MARKER.test(value) || TEXT_ITEMS_OMISSION_MARKER.test(value) || STRUCTURAL_ENTRIES_OMISSION_MARKER.test(value) || OPAQUE_PAYLOAD_OMISSION_MARKER.test(value));
+}
+function observeGeneratedMarkerBudget(value, state) {
+  if (TEXT_FIELD_OMISSION_MARKER.test(value) || TEXT_ITEMS_OMISSION_MARKER.test(value)) {
+    state.remaining = 0;
+  }
+  if (value === STRUCTURAL_STRING_OMISSION_MARKER) state.remainingStructural = 0;
+  if (OPAQUE_PAYLOAD_OMISSION_MARKER.test(value)) state.remainingOpaqueBytes = 0;
+}
+function isGeneratedStructuralMarkerProperty(key, value) {
+  return key.startsWith(STRUCTURAL_PROPERTIES_MARKER_KEY) && typeof value === "string" && STRUCTURAL_ENTRIES_OMISSION_MARKER.test(value);
+}
+function uniqueStructuralMarkerKey(record) {
+  let key = STRUCTURAL_PROPERTIES_MARKER_KEY;
+  let suffix = 1;
+  while (Object.hasOwn(record, key)) {
+    key = `${STRUCTURAL_PROPERTIES_MARKER_KEY}_${suffix}`;
+    suffix += 1;
+  }
+  return key;
+}
+function isResponsesProtocolContentPrefix(output) {
+  if (output.length === 0) return false;
+  const retainedPrefixLength = Math.min(output.length, MODEL_TOOL_OUTPUT_MAX_CONTAINER_ENTRIES);
+  for (let index = 0; index < retainedPrefixLength; index += 1) {
+    const item = output[index];
+    if (!item || typeof item !== "object" || Array.isArray(item)) return false;
+    const record = item;
+    if (record.type === "input_text" && typeof record.text === "string") continue;
+    if (record.type === "input_image") continue;
+    if (record.type === "input_file") continue;
+    return false;
+  }
+  return true;
+}
+function isImageDataUrl(value) {
+  return /^data:image\/[a-z0-9.+-]+;base64,/i.test(value);
+}
 export {
   CODEX_APPS_MCP_SERVER_ID,
   CODEX_APPS_MCP_SERVER_NAME,
@@ -915,13 +2197,23 @@ export {
   CODEX_MODEL_CONTEXT_WINDOW_TOKENS,
   CODEX_MODEL_EFFECTIVE_CONTEXT_WINDOW_TOKENS,
   CODEX_MODEL_ID_PREFIX,
+  CODEX_MODEL_TOOL_OUTPUT_TRUNCATION_TOKENS,
   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,
   CODEX_USAGE_LIMIT_ERROR_TYPE,
   CODEX_WEEKLY_WINDOW_SECONDS,
@@ -929,29 +2221,48 @@ 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,
   ToolNameMapper,
   accessTokenExpiry,
+  approximateTokenCount,
+  boundModelToolOutputItem,
+  boundModelToolOutputItems,
   buildCodexUsageWindowFromCache,
   buildModelResolver,
+  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
+  startDeviceCode,
+  truncateMiddleWithTokenBudget
 };
 //# sourceMappingURL=index.js.map