@organizaone/o1-code 0.10.4 → 0.12.0

package/chunks/chunk-TC2TJAOF.js

@@ -0,0 +1,1365 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  redactProxyCredentials
+} from "./chunk-HDGYCLNB.js";
+import {
+  createDebugLogger
+} from "./chunk-UK2KIU2V.js";
+import {
+  getErrorMessage,
+  getErrorStatus,
+  isAbortError
+} from "./chunk-JAQAGKIV.js";
+import {
+  init_esbuild_shims
+} from "./chunk-S2467S6L.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/utils/fetch.ts
+init_esbuild_shims();
+
+// packages/core/src/utils/retry.ts
+init_esbuild_shims();
+
+// packages/core/src/utils/quotaErrorDetection.ts
+init_esbuild_shims();
+function isApiError(error) {
+  return typeof error === "object" && error !== null && "error" in error && typeof error.error === "object" && error.error !== null && "message" in error.error;
+}
+__name(isApiError, "isApiError");
+function isStructuredError(error) {
+  return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
+}
+__name(isStructuredError, "isStructuredError");
+var QUOTA_EXHAUSTED_PREFIX = "Quota exhausted: ";
+function getQuotaMessage(error) {
+  let message = null;
+  if (typeof error === "string") message = error;
+  else if (isStructuredError(error)) message = error.message;
+  else if (isApiError(error)) message = error.error.message;
+  if (message === null) return null;
+  const start = message.indexOf("{");
+  if (start !== -1) {
+    try {
+      const parsed = JSON.parse(message.substring(start));
+      if (isApiError(parsed)) return parsed.error.message;
+    } catch {
+    }
+  }
+  return message;
+}
+__name(getQuotaMessage, "getQuotaMessage");
+function isQuotaExhaustedError(error) {
+  const message = getQuotaMessage(error);
+  if (!message) return false;
+  const lower = message.toLowerCase();
+  return lower.includes("quota") && (lower.includes("exhausted") || lower.includes("exceeded")) && (lower.includes("will reset") || lower.includes("reset at"));
+}
+__name(isQuotaExhaustedError, "isQuotaExhaustedError");
+function formatQuotaExhaustedMessage(error) {
+  const raw = getQuotaMessage(error) ?? "";
+  if (raw.startsWith(QUOTA_EXHAUSTED_PREFIX)) return raw;
+  const stripped = raw.replace(/^\d{3}\s+/, "").trim() || "quota has been exhausted";
+  return `${QUOTA_EXHAUSTED_PREFIX}${stripped}
+
+Please retry after the reset time, or switch to another API key / auth method.`;
+}
+__name(formatQuotaExhaustedMessage, "formatQuotaExhaustedMessage");
+
+// packages/core/src/utils/proxy-waits.ts
+init_esbuild_shims();
+
+// packages/core/src/utils/rateLimit.ts
+init_esbuild_shims();
+
+// packages/core/src/utils/retryPolicy.ts
+init_esbuild_shims();
+var MAX_TIMEOUT_MS = 2147483647;
+function getRetryDelayMs(options) {
+  const normalizedAttempt = Math.max(1, options.attempt);
+  const delayCeilingMs = Math.min(options.maxDelayMs, MAX_TIMEOUT_MS);
+  const exponent = Math.min(normalizedAttempt - 1, 31);
+  const cappedExponentialDelayMs = Math.min(
+    options.initialDelayMs * Math.pow(2, exponent),
+    delayCeilingMs
+  );
+  const retryAfterMode = options.retryAfterMode ?? "ignore";
+  const retryAfterMs = retryAfterMode === "ignore" ? null : getRetryAfterDelayMs(options.error);
+  if (retryAfterMs !== null && retryAfterMs > 0) {
+    const retryAfterCapMs = Math.min(
+      options.retryAfterMaxDelayMs ?? options.maxDelayMs,
+      MAX_TIMEOUT_MS
+    );
+    const cappedRetryAfterMs = Math.min(retryAfterMs, retryAfterCapMs);
+    return Math.max(cappedExponentialDelayMs, cappedRetryAfterMs);
+  }
+  const jitterRatio = options.jitterRatio ?? 0;
+  if (jitterRatio <= 0) return cappedExponentialDelayMs;
+  const random = options.random ?? Math.random;
+  const jitter = cappedExponentialDelayMs * jitterRatio * (random() * 2 - 1);
+  return Math.min(
+    Math.max(0, cappedExponentialDelayMs + jitter),
+    delayCeilingMs
+  );
+}
+__name(getRetryDelayMs, "getRetryDelayMs");
+function getRetryAfterDelayMs(error) {
+  const millis = getHeaderValue(error, "retry-after-ms") ?? getResponseHeaderValue(error, "retry-after-ms");
+  if (millis !== null && /^\d+(\.\d+)?$/.test(millis.trim())) {
+    const value2 = Number(millis);
+    if (Number.isFinite(value2)) return Math.min(value2, MAX_TIMEOUT_MS);
+  }
+  const value = getHeaderValue(error, "retry-after") ?? getResponseHeaderValue(error, "retry-after");
+  if (value === null) return null;
+  const trimmed = value.trim();
+  if (/^\d+(\.\d+)?$/.test(trimmed)) {
+    const seconds = Number(trimmed);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+      return Math.min(seconds * 1e3, MAX_TIMEOUT_MS);
+    }
+  }
+  const retryAtMs = Date.parse(trimmed);
+  if (!Number.isFinite(retryAtMs)) return null;
+  const delayMs = retryAtMs - Date.now();
+  return delayMs > 0 ? Math.min(delayMs, MAX_TIMEOUT_MS) : 0;
+}
+__name(getRetryAfterDelayMs, "getRetryAfterDelayMs");
+function getErrorHeader(error, headerName) {
+  return getHeaderValue(error, headerName) ?? getResponseHeaderValue(error, headerName);
+}
+__name(getErrorHeader, "getErrorHeader");
+function getHeaderValue(error, headerName) {
+  if (!hasHeaders(error)) return null;
+  const { headers } = error;
+  if (typeof headers.get === "function") {
+    const value = headers.get(headerName);
+    return typeof value === "string" ? value : null;
+  }
+  if (typeof headers !== "object" || headers === null) return null;
+  const lowerHeaderName = headerName.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() !== lowerHeaderName) continue;
+    return typeof value === "string" ? value : null;
+  }
+  return null;
+}
+__name(getHeaderValue, "getHeaderValue");
+function getResponseHeaderValue(error, headerName) {
+  if (!hasResponseHeaders(error)) return null;
+  return getHeaderValue(error.response, headerName);
+}
+__name(getResponseHeaderValue, "getResponseHeaderValue");
+function hasHeaders(error) {
+  return typeof error === "object" && error !== null && "headers" in error && error.headers != null;
+}
+__name(hasHeaders, "hasHeaders");
+function hasResponseHeaders(error) {
+  return typeof error === "object" && error !== null && "response" in error && typeof error.response === "object" && error.response !== null && "headers" in error.response && error.response.headers != null;
+}
+__name(hasResponseHeaders, "hasResponseHeaders");
+
+// packages/core/src/utils/rateLimit.ts
+var RATE_LIMIT_ERROR_CODES = /* @__PURE__ */ new Set([429, 503, 1302, 1305]);
+function isRateLimitError(error, extraCodes) {
+  const code = getErrorCode(error);
+  if (code === null) return isStatuslessThrottle(error);
+  if (RATE_LIMIT_ERROR_CODES.has(code)) return true;
+  if (extraCodes && extraCodes.includes(code)) return true;
+  return false;
+}
+__name(isRateLimitError, "isRateLimitError");
+function isStatuslessThrottle(error) {
+  for (const payload of [error, ...getJsonPayloads(error)]) {
+    const selected = providerErrorSource(payload);
+    if (!selected) continue;
+    const { source } = selected;
+    const { type, message } = source;
+    if (type === "rate_limit_error" || type === "overloaded_error") return true;
+    if (type !== "invalid_request_error" || typeof message !== "string")
+      continue;
+    const detail = decodeProviderMessage(message)?.["message"] ?? message;
+    if (typeof detail === "string" && /^too many requests\b/i.test(detail.trim()) && /\b(?:wait|try(?:ing)? again)\b/i.test(detail)) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(isStatuslessThrottle, "isStatuslessThrottle");
+function providerErrorSource(payload) {
+  if (typeof payload !== "object" || payload === null) return null;
+  const direct = payload;
+  const nested = direct["error"];
+  const source = typeof nested === "object" && nested !== null ? nested : direct;
+  return { source, direct };
+}
+__name(providerErrorSource, "providerErrorSource");
+function decodeProviderMessage(message) {
+  try {
+    const selected = providerErrorSource(JSON.parse(message));
+    if (!selected || typeof selected.source["message"] !== "string") {
+      return null;
+    }
+    return { ...selected.direct, ...selected.source };
+  } catch {
+    return null;
+  }
+}
+__name(decodeProviderMessage, "decodeProviderMessage");
+function getRateLimitErrorDetails(error) {
+  const statusCode = getErrorStatus(error);
+  const payload = getProviderErrorPayload(error);
+  const message = getRawErrorMessage(error);
+  const transport = message?.includes("event:error") || message?.includes("HTTP_STATUS/") ? "sse" : statusCode !== void 0 ? "http" : "unknown";
+  return {
+    ...statusCode !== void 0 ? { statusCode } : {},
+    ...payload?.code !== void 0 || payload?.type !== void 0 ? { providerCode: String(payload.code ?? payload.type) } : {},
+    ...payload?.type !== void 0 ? { providerType: payload.type } : {},
+    ...payload?.message !== void 0 ? { providerMessage: payload.message } : {},
+    ...payload?.requestId !== void 0 ? { requestId: payload.requestId } : {},
+    transport
+  };
+}
+__name(getRateLimitErrorDetails, "getRateLimitErrorDetails");
+function getRateLimitRetryDelayMs(attempt, options) {
+  return getRetryDelayMs({
+    attempt,
+    initialDelayMs: options.initialDelayMs,
+    maxDelayMs: options.maxDelayMs,
+    retryAfterMode: "minimum",
+    retryAfterMaxDelayMs: options.maxDelayMs,
+    error: options.error
+  });
+}
+__name(getRateLimitRetryDelayMs, "getRateLimitRetryDelayMs");
+function getErrorCode(error) {
+  if (isApiError(error)) {
+    const n = Number(error.error.code);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  const msg = error instanceof Error ? error.message : typeof error === "string" ? error : null;
+  if (msg) {
+    const i = msg.indexOf("{");
+    if (i !== -1) {
+      try {
+        const p = JSON.parse(msg.substring(i));
+        if (isApiError(p)) {
+          const n = Number(p.error.code);
+          if (Number.isFinite(n) && n > 0) return n;
+        }
+      } catch {
+      }
+    }
+  }
+  if (isStructuredError(error) && typeof error.status === "number") {
+    return error.status;
+  }
+  if (error instanceof Error && "status" in error) {
+    const s = error.status;
+    if (typeof s === "number") return s;
+  }
+  return getErrorStatus(error) ?? null;
+}
+__name(getErrorCode, "getErrorCode");
+function getProviderErrorPayload(error) {
+  for (const payload of getJsonPayloads(error)) {
+    const selected = providerErrorSource(payload);
+    if (!selected) continue;
+    const { source, direct } = selected;
+    const decoded = typeof source["message"] === "string" ? decodeProviderMessage(source["message"]) : null;
+    const code = typeof source["code"] === "string" || typeof source["code"] === "number" ? source["code"] : typeof decoded?.["code"] === "string" || typeof decoded?.["code"] === "number" ? decoded["code"] : void 0;
+    const type = typeof source["type"] === "string" ? source["type"] : typeof decoded?.["type"] === "string" ? decoded["type"] : void 0;
+    const message = typeof decoded?.["message"] === "string" ? decoded["message"] : typeof source["message"] === "string" ? source["message"] : void 0;
+    const requestId = typeof source["request_id"] === "string" ? source["request_id"] : typeof source["requestId"] === "string" ? source["requestId"] : typeof direct["request_id"] === "string" ? direct["request_id"] : typeof direct["requestId"] === "string" ? direct["requestId"] : typeof decoded?.["request_id"] === "string" ? decoded["request_id"] : typeof decoded?.["requestId"] === "string" ? decoded["requestId"] : void 0;
+    if (code !== void 0 || type !== void 0 || message !== void 0 || requestId !== void 0) {
+      return { code, type, message, requestId };
+    }
+  }
+  if (isApiError(error)) {
+    const decoded = decodeProviderMessage(error.error.message);
+    return {
+      code: error.error.code,
+      ...typeof decoded?.["type"] === "string" ? { type: decoded["type"] } : {},
+      message: typeof decoded?.["message"] === "string" ? decoded["message"] : error.error.message
+    };
+  }
+  return null;
+}
+__name(getProviderErrorPayload, "getProviderErrorPayload");
+function getJsonPayloads(error) {
+  const message = getRawErrorMessage(error);
+  if (!message) return [];
+  const payloads = [];
+  for (const line of message.split(/\r?\n/)) {
+    if (!line.startsWith("data:")) continue;
+    const data = line.slice("data:".length).trim();
+    if (!data || data === "[DONE]") continue;
+    try {
+      payloads.push(JSON.parse(data));
+    } catch {
+    }
+  }
+  if (payloads.length > 0) return payloads;
+  const jsonStart = message.indexOf("{");
+  const jsonEnd = message.lastIndexOf("}");
+  if (jsonStart !== -1 && jsonEnd > jsonStart) {
+    try {
+      payloads.push(
+        JSON.parse(message.slice(jsonStart, jsonEnd + 1))
+      );
+    } catch {
+    }
+  }
+  return payloads;
+}
+__name(getJsonPayloads, "getJsonPayloads");
+function getRawErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  return null;
+}
+__name(getRawErrorMessage, "getRawErrorMessage");
+
+// packages/core/src/utils/proxy-waits.ts
+var PROXY_LONG_WAIT_MS = 5 * 6e4;
+var PROXY_WAIT_CODES = /* @__PURE__ */ new Set([
+  "account_limit_exceeded",
+  // The cap the person set on their own credentials (contract §3.5).
+  "own_limit",
+  "upstream_rate_limited",
+  "provider_unavailable",
+  "limits_unavailable"
+]);
+function readProxyWait(error, now = Date.now()) {
+  const status = getErrorStatus(error);
+  if (status !== 429 && status !== 503) return null;
+  const details = getRateLimitErrorDetails(error);
+  const limit = getErrorHeader(error, "x-o1gw-limit") ?? void 0;
+  const ours = limit !== void 0 || details.providerCode !== void 0 && PROXY_WAIT_CODES.has(details.providerCode) || /usage limit is reached/i.test(details.providerMessage ?? "");
+  if (!ours) return null;
+  const resetHeader = getErrorHeader(error, "x-o1gw-limit-reset");
+  const resetFromHeader = resetHeader ? Date.parse(resetHeader) : NaN;
+  const retryAfterMs = getRetryAfterDelayMs(error);
+  const waitMs = retryAfterMs ?? (Number.isFinite(resetFromHeader) ? Math.max(0, resetFromHeader - now) : 0);
+  const resetAt = new Date(
+    Number.isFinite(resetFromHeader) ? resetFromHeader : now + waitMs
+  );
+  return {
+    ...limit ? { limit } : {},
+    resetAt,
+    waitMs,
+    ...details.providerMessage ? { message: details.providerMessage } : {}
+  };
+}
+__name(readProxyWait, "readProxyWait");
+function isLongProxyWait(error, now) {
+  const wait = readProxyWait(error, now);
+  return wait !== null && wait.waitMs > PROXY_LONG_WAIT_MS;
+}
+__name(isLongProxyWait, "isLongProxyWait");
+function formatDuration(ms) {
+  const minutes = Math.max(1, Math.round(ms / 6e4));
+  const hours = Math.floor(minutes / 60);
+  const rest = minutes % 60;
+  if (hours === 0) return `${minutes} min`;
+  return rest === 0 ? `${hours} h` : `${hours} h ${rest} min`;
+}
+__name(formatDuration, "formatDuration");
+function formatProxyWaitMessage(error, now = Date.now()) {
+  const wait = readProxyWait(error, now);
+  const reason = wait?.message?.replace(/^\d{3}\s+/, "").trim() || (wait?.limit ? `The account limit ${wait.limit} is reached.` : "The provider asks to wait.");
+  const when = wait ? `Try again at ${wait.resetAt.toLocaleTimeString([], {
+    hour: "2-digit",
+    minute: "2-digit"
+  })} (in ${formatDuration(wait.waitMs)}).` : "";
+  return `${QUOTA_EXHAUSTED_PREFIX}${reason}
+
+${when} The request was not retried; send it again then, or switch to another model or provider.`.trim();
+}
+__name(formatProxyWaitMessage, "formatProxyWaitMessage");
+
+// packages/core/src/utils/retryErrorClassification.ts
+init_esbuild_shims();
+
+// packages/core/src/utils/responses-http-error.ts
+init_esbuild_shims();
+var ResponsesHttpError = class extends Error {
+  constructor(status, body, responseHeaders, secrets = []) {
+    const sanitize = /* @__PURE__ */ __name((value) => {
+      let text = redactProxyCredentials(value);
+      for (const secret of secrets) {
+        if (secret) text = text.split(secret).join("<redacted>");
+      }
+      return text;
+    }, "sanitize");
+    const headers = new Headers();
+    for (const name of [
+      "x-request-id",
+      "retry-after",
+      "retry-after-ms",
+      "x-should-retry"
+    ]) {
+      const value = responseHeaders?.get(name);
+      if (value) headers.set(name, sanitize(value));
+    }
+    let envelope;
+    try {
+      envelope = record(JSON.parse(body));
+    } catch {
+    }
+    const upstream = record(envelope?.["error"]);
+    const error = {};
+    for (const name of ["message", "code", "type", "param"]) {
+      const value = upstream?.[name];
+      if (typeof value === "string" || typeof value === "number") {
+        error[name] = sanitize(String(value));
+      }
+    }
+    const requestId = headers.get("x-request-id") ?? void 0;
+    const diagnostic = {
+      ...Object.keys(error).length ? { error } : {},
+      ...requestId ? { request_id: requestId } : {}
+    };
+    const excerpt = Object.keys(error).length ? JSON.stringify(diagnostic) : sanitize(body).substring(0, 500);
+    super(
+      `Responses API error ${status}: ${excerpt}` + (!Object.keys(error).length && requestId ? ` (request_id: ${requestId})` : "")
+    );
+    this.status = status;
+    this.name = "ResponsesHttpError";
+    this.headers = headers;
+    this.requestId = requestId;
+    this.error = Object.keys(error).length ? error : void 0;
+    this.code = error["code"];
+    this.type = error["type"];
+    this.param = error["param"];
+  }
+  static {
+    __name(this, "ResponsesHttpError");
+  }
+  headers;
+  requestId;
+  code;
+  type;
+  param;
+  error;
+  shouldRetry(extraRetryErrorCodes) {
+    const directive = this.headers.get("x-should-retry");
+    if (directive === "true") return true;
+    if (directive === "false") return false;
+    return this.status === 408 || this.status === 409 || this.status === 429 || this.status >= 500 && this.status < 600 || (extraRetryErrorCodes?.includes(this.status) ?? false);
+  }
+};
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+__name(record, "record");
+
+// packages/core/src/utils/retryErrorClassification.ts
+function classifyRetryError(error, context = {}) {
+  if (isRetryAbortError(error)) {
+    return {
+      kind: "abort",
+      diagnosis: "fail-fast",
+      reason: "aborted"
+    };
+  }
+  const details = getRateLimitErrorDetails(error);
+  const statusCode = details.statusCode;
+  const providerFields = getProviderFields(error);
+  const providerCode = details.providerCode ?? providerFields.providerCode;
+  const providerMessage = details.providerMessage ?? providerFields.providerMessage;
+  const requestId = details.requestId || providerFields.requestId;
+  const common = {
+    ...statusCode !== void 0 ? { statusCode } : {},
+    ...providerCode !== void 0 ? { providerCode } : {},
+    ...providerMessage !== void 0 ? { providerMessage } : {},
+    ...requestId !== void 0 ? { requestId } : {}
+  };
+  if (isAllocatedQuotaExceeded(providerCode)) {
+    return {
+      kind: "provider-business",
+      diagnosis: "fail-fast",
+      reason: "allocated-quota-exceeded",
+      ...common
+    };
+  }
+  if (error instanceof ResponsesHttpError && (error.headers.has("x-should-retry") || statusCode === 408 || statusCode === 409)) {
+    return {
+      kind: "http",
+      diagnosis: error.shouldRetry(context.extraRetryErrorCodes) ? "retryable" : "fail-fast",
+      reason: "responses-http-retry-policy",
+      ...common
+    };
+  }
+  if (isRateLimitError(error, context.extraRetryErrorCodes)) {
+    const kind = details.transport === "sse" ? "sse-provider" : statusCode !== void 0 ? "http" : "provider";
+    return {
+      kind,
+      diagnosis: "retryable",
+      reason: "rate-limit",
+      ...common
+    };
+  }
+  const transportCode = getTransportCode(error);
+  if (transportCode !== void 0 && (statusCode === void 0 || statusCode >= 500)) {
+    return {
+      kind: "transport",
+      diagnosis: "retryable",
+      reason: "transport-error",
+      transportCode,
+      ...statusCode !== void 0 ? { statusCode } : {}
+    };
+  }
+  if (statusCode !== void 0) {
+    const kind = details.transport === "sse" ? "sse-provider" : "http";
+    if (statusCode === 529) {
+      return {
+        kind,
+        diagnosis: "retryable",
+        reason: "capacity-overload",
+        ...common
+      };
+    }
+    if (statusCode === 401 || statusCode === 403) {
+      return {
+        kind,
+        diagnosis: "fail-fast",
+        reason: "auth-error",
+        ...common
+      };
+    }
+    if (statusCode >= 400 && statusCode < 500) {
+      if (providerCode === void 0 && providerMessage === void 0 && hasNetworkFailureCause(error)) {
+        return {
+          kind: "transport",
+          diagnosis: "retryable",
+          reason: "network-error",
+          ...common
+        };
+      }
+      return {
+        kind,
+        diagnosis: "fail-fast",
+        reason: "client-error",
+        ...common
+      };
+    }
+    if (statusCode === 502 && providerCode === "upstream_redirected") {
+      return {
+        kind,
+        diagnosis: "fail-fast",
+        reason: "permanent-provider-code",
+        ...common
+      };
+    }
+    if (statusCode >= 500 && statusCode < 600) {
+      return {
+        kind,
+        diagnosis: "retryable",
+        reason: "server-error",
+        ...common
+      };
+    }
+    return {
+      kind,
+      diagnosis: "unknown",
+      reason: "http-status",
+      ...common
+    };
+  }
+  const statuslessKind = details.transport === "sse" ? "sse-provider" : "provider";
+  if (isPermanentProviderCode(providerCode) || isPermanentProviderCode(providerFields.providerType) || isPermanentProviderCode(details.providerType)) {
+    return {
+      kind: statuslessKind,
+      diagnosis: "fail-fast",
+      reason: "permanent-provider-code",
+      ...common
+    };
+  }
+  if (requestId !== void 0) {
+    return {
+      kind: statuslessKind,
+      diagnosis: "retryable",
+      reason: "upstream-error-without-status",
+      ...common
+    };
+  }
+  return {
+    kind: "unknown",
+    diagnosis: "unknown",
+    reason: "unclassified",
+    ...common
+  };
+}
+__name(classifyRetryError, "classifyRetryError");
+function isRetryAbortError(error) {
+  if (isAbortError(error)) {
+    return true;
+  }
+  return error instanceof Error && error.name === "CanceledError";
+}
+__name(isRetryAbortError, "isRetryAbortError");
+var MAX_TRANSPORT_CAUSE_DEPTH = 4;
+function getTransportCode(error) {
+  let current = error;
+  for (let depth = 0; depth <= MAX_TRANSPORT_CAUSE_DEPTH; depth++) {
+    if (typeof current !== "object" || current === null) {
+      return void 0;
+    }
+    const code = current.code;
+    if (typeof code === "string" && isTransportCode(code)) {
+      return code;
+    }
+    current = current instanceof Error ? current.cause : void 0;
+  }
+  return void 0;
+}
+__name(getTransportCode, "getTransportCode");
+function isTransportCode(code) {
+  return TRANSPORT_ERROR_CODES.has(code);
+}
+__name(isTransportCode, "isTransportCode");
+var NETWORK_FAILURE_MESSAGE_RE = /network error for request /i;
+function hasNetworkFailureCause(error) {
+  let current = error;
+  for (let depth = 0; depth <= MAX_TRANSPORT_CAUSE_DEPTH; depth++) {
+    if (typeof current !== "object" || current === null) return false;
+    const message = current.message;
+    if (typeof message === "string" && NETWORK_FAILURE_MESSAGE_RE.test(message)) {
+      return true;
+    }
+    current = current instanceof Error ? current.cause : void 0;
+  }
+  return false;
+}
+__name(hasNetworkFailureCause, "hasNetworkFailureCause");
+var TRANSPORT_ERROR_CODES = /* @__PURE__ */ new Set([
+  "EAI_AGAIN",
+  "ECONNABORTED",
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "ENOTFOUND",
+  "EPIPE",
+  "ETIMEDOUT",
+  "UND_ERR_BODY_TIMEOUT",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_SOCKET"
+]);
+function isAllocatedQuotaExceeded(providerCode) {
+  return providerCode === "Throttling.AllocationQuota";
+}
+__name(isAllocatedQuotaExceeded, "isAllocatedQuotaExceeded");
+var PERMANENT_PROVIDER_CODE_PATTERN = /^(?:response[_-]?data[_-]?inspection[_-]?failed|data[_-]?inspection[_-]?failed|content[_-]?filter|invalid[_-]?api[_-]?key|arrearage|insufficient[_-]?quota|model[._-]?access[_-]?denied|invalid[_-]?request[_-]?error|authentication[_-]?error|permission[_-]?error|not[_-]?found[_-]?error|billing[_-]?error|invalid[_-]?parameter(?:[_-]?error)?|context[_-]?length[_-]?exceeded|request[_-]?too[_-]?large)$/i;
+function isPermanentProviderCode(providerCode) {
+  return providerCode !== void 0 && PERMANENT_PROVIDER_CODE_PATTERN.test(providerCode);
+}
+__name(isPermanentProviderCode, "isPermanentProviderCode");
+function getProviderFields(error) {
+  if (typeof error !== "object" || error === null) {
+    return {};
+  }
+  const source = error;
+  const rawCode = typeof source.code === "string" || typeof source.code === "number" ? String(source.code) : void 0;
+  const isHttpStatusEcho = typeof source.code === "number" && source.code >= 100 && source.code < 600;
+  const providerCode = error instanceof Error && rawCode?.startsWith("ERR_") || isHttpStatusEcho ? void 0 : rawCode;
+  const requestId = firstNonEmptyString(
+    source.request_id,
+    source.requestId,
+    source.requestID
+  );
+  const providerMessage = typeof source.message === "string" && (!(error instanceof Error) || providerCode !== void 0 || requestId !== void 0) ? source.message : void 0;
+  const providerType = firstNonEmptyString(source.type);
+  return {
+    ...providerCode !== void 0 ? { providerCode } : {},
+    ...providerType !== void 0 ? { providerType } : {},
+    ...providerMessage !== void 0 ? { providerMessage } : {},
+    ...requestId !== void 0 ? { requestId } : {}
+  };
+}
+__name(getProviderFields, "getProviderFields");
+var FALLBACK_ELIGIBLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 503, 529]);
+function isFallbackEligible(classification) {
+  return classification.kind !== "transport" && classification.statusCode !== void 0 && FALLBACK_ELIGIBLE_STATUS_CODES.has(classification.statusCode) && classification.diagnosis !== "fail-fast" && classification.diagnosis !== "unknown";
+}
+__name(isFallbackEligible, "isFallbackEligible");
+function isRetryableUpstreamError(error, extraRetryErrorCodes) {
+  return isRateLimitError(error, extraRetryErrorCodes) || classifyRetryError(error, { extraRetryErrorCodes }).diagnosis === "retryable";
+}
+__name(isRetryableUpstreamError, "isRetryableUpstreamError");
+function firstNonEmptyString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value) {
+      return value;
+    }
+  }
+  return void 0;
+}
+__name(firstNonEmptyString, "firstNonEmptyString");
+
+// packages/core/src/utils/retryContext.ts
+init_esbuild_shims();
+import { AsyncLocalStorage } from "node:async_hooks";
+var retryContext = new AsyncLocalStorage();
+
+// packages/core/src/utils/retry.ts
+var debugLogger = createDebugLogger("RETRY");
+var PERSISTENT_MAX_BACKOFF_MS = 5 * 60 * 1e3;
+var PERSISTENT_CAP_MS = 6 * 60 * 60 * 1e3;
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var DEFAULT_RETRY_OPTIONS = {
+  maxAttempts: 7,
+  initialDelayMs: 1500,
+  maxDelayMs: 3e4,
+  // 30 seconds
+  shouldRetryOnError: defaultShouldRetry
+};
+function defaultShouldRetry(error, extraRetryErrorCodes) {
+  if (error instanceof ResponsesHttpError) {
+    return error.shouldRetry(extraRetryErrorCodes);
+  }
+  const status = getErrorStatus(error);
+  if (status !== void 0 && status >= 500 && status < 600) {
+    return true;
+  }
+  return isRetryableUpstreamError(error, extraRetryErrorCodes);
+}
+__name(defaultShouldRetry, "defaultShouldRetry");
+function hasRetryAfterStatus(status) {
+  return status === 429 || status === 503;
+}
+__name(hasRetryAfterStatus, "hasRetryAfterStatus");
+function isTransientCapacityError(error) {
+  const status = getErrorStatus(error);
+  return status === 429 || status === 529;
+}
+__name(isTransientCapacityError, "isTransientCapacityError");
+function isUnattendedMode() {
+  const val = process.env["O1CODE_UNATTENDED_RETRY"];
+  return val === "true" || val === "1";
+}
+__name(isUnattendedMode, "isUnattendedMode");
+function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      return reject(new Error("Retry aborted by signal"));
+    }
+    const cleanup = /* @__PURE__ */ __name(() => {
+      signal?.removeEventListener("abort", onAbort);
+    }, "cleanup");
+    function onAbort() {
+      clearTimeout(timeout);
+      cleanup();
+      reject(new Error("Retry aborted by signal"));
+    }
+    __name(onAbort, "onAbort");
+    const timeout = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) {
+      clearTimeout(timeout);
+      cleanup();
+      reject(new Error("Retry aborted by signal"));
+    }
+  });
+}
+__name(delay, "delay");
+async function sleepWithHeartbeat(totalMs, ctx) {
+  let remaining = totalMs;
+  while (remaining > 0) {
+    if (ctx.signal?.aborted) {
+      throw new Error("Retry aborted by signal");
+    }
+    const chunk = Math.max(1, Math.min(remaining, ctx.heartbeatInterval));
+    await delay(chunk, ctx.signal);
+    remaining -= chunk;
+    if (remaining > 0 && ctx.heartbeatFn) {
+      ctx.heartbeatFn({
+        attempt: ctx.attempt,
+        remainingMs: remaining,
+        error: ctx.error
+      });
+    }
+  }
+}
+__name(sleepWithHeartbeat, "sleepWithHeartbeat");
+async function retryWithBackoff(fn, options) {
+  if (options?.maxAttempts !== void 0 && options.maxAttempts <= 0) {
+    throw new Error("maxAttempts must be a positive number.");
+  }
+  const cleanOptions = options ? Object.fromEntries(Object.entries(options).filter(([_, v]) => v != null)) : {};
+  const {
+    maxAttempts,
+    initialDelayMs,
+    maxDelayMs,
+    authType,
+    extraRetryErrorCodes,
+    shouldRetryOnError,
+    shouldRetryOnContent,
+    persistentMode,
+    persistentMaxBackoffMs,
+    persistentCapMs,
+    heartbeatIntervalMs,
+    heartbeatFn,
+    signal,
+    onRetry
+  } = {
+    ...DEFAULT_RETRY_OPTIONS,
+    ...cleanOptions
+  };
+  const hasCustomShouldRetryOnError = typeof options?.shouldRetryOnError === "function";
+  const persistent = persistentMode ?? false;
+  const maxBackoff = persistentMaxBackoffMs ?? PERSISTENT_MAX_BACKOFF_MS;
+  const capMs = persistentCapMs ?? PERSISTENT_CAP_MS;
+  const heartbeatInterval = heartbeatIntervalMs ?? HEARTBEAT_INTERVAL_MS;
+  let attempt = 0;
+  let persistentAttempt = 0;
+  let currentDelay = initialDelayMs;
+  const requestEntryTime = Date.now();
+  let iterationCount = 0;
+  let retryTotalDelayMs = 0;
+  let lastContentResult;
+  let hadContentRetry = false;
+  while (attempt < maxAttempts) {
+    attempt++;
+    iterationCount++;
+    const requestSetupMs = Date.now() - requestEntryTime;
+    try {
+      const result = await retryContext.run(
+        { attempt: iterationCount, retryTotalDelayMs, requestSetupMs },
+        () => fn()
+      );
+      if (shouldRetryOnContent && shouldRetryOnContent(result)) {
+        lastContentResult = result;
+        hadContentRetry = true;
+        const delayMs = getRetryDelayMs({
+          // attempt: 1 — currentDelay already tracks exponential growth;
+          // getRetryDelayMs is called here only for jitter calculation.
+          attempt: 1,
+          initialDelayMs: currentDelay,
+          maxDelayMs,
+          jitterRatio: 0.3
+        });
+        debugLogger.warn(
+          `Attempt ${iterationCount}: response rejected by content check. Retrying with backoff in ${Math.ceil(delayMs / 1e3)}s...`
+        );
+        await delay(delayMs, signal);
+        retryTotalDelayMs += delayMs;
+        currentDelay = Math.min(maxDelayMs, currentDelay * 2);
+        continue;
+      }
+      return result;
+    } catch (error) {
+      const errorStatus = getErrorStatus(error);
+      const retryDiagnostics = classifyRetryError(error, {
+        authType,
+        extraRetryErrorCodes
+      });
+      if (retryDiagnostics.kind === "abort") {
+        throw error;
+      }
+      if (isQuotaExhaustedError(error)) {
+        debugLogger.error(
+          "Quota exhausted, fast-failing",
+          retryDiagnostics,
+          error
+        );
+        throw new Error(formatQuotaExhaustedMessage(error), { cause: error });
+      }
+      if (isLongProxyWait(error)) {
+        debugLogger.error("Proxy asks for a long wait, fast-failing", error);
+        throw new Error(formatProxyWaitMessage(error), { cause: error });
+      }
+      const isTransient = isTransientCapacityError(error);
+      const callerAllowsRetry = hasCustomShouldRetryOnError ? shouldRetryOnError(error) : defaultShouldRetry(error, extraRetryErrorCodes);
+      const isFailFast = retryDiagnostics.diagnosis === "fail-fast";
+      const shouldPersist = persistent && isTransient && callerAllowsRetry && !isFailFast;
+      if (!shouldPersist) {
+        if (attempt >= maxAttempts || !callerAllowsRetry) {
+          throw error;
+        }
+      }
+      let delayMs;
+      if (shouldPersist) {
+        persistentAttempt++;
+        const retryAfterMs = hasRetryAfterStatus(errorStatus) || error instanceof ResponsesHttpError ? getRetryAfterDelayMs(error) : null;
+        if (retryAfterMs !== null && retryAfterMs > 0) {
+          delayMs = Math.min(retryAfterMs, capMs);
+        } else {
+          delayMs = getRetryDelayMs({
+            attempt: persistentAttempt,
+            initialDelayMs,
+            maxDelayMs: Math.min(maxBackoff, capMs),
+            jitterRatio: 0.25
+          });
+        }
+        const reportedAttempt = persistentAttempt;
+        debugLogger.warn(
+          `[Persistent] Attempt ${reportedAttempt} failed with status ${errorStatus ?? "unknown"}. Retrying in ${Math.ceil(delayMs / 1e3)}s...`,
+          retryDiagnostics,
+          error
+        );
+        if (!signal?.aborted) {
+          try {
+            onRetry?.({
+              attempt: iterationCount,
+              error,
+              errorStatus,
+              delayMs
+            });
+          } catch (cbError) {
+            debugLogger.warn(
+              `onRetry callback threw (swallowed): ${cbError instanceof Error ? cbError.message : String(cbError)}`
+            );
+          }
+        }
+        await sleepWithHeartbeat(delayMs, {
+          attempt: reportedAttempt,
+          error,
+          heartbeatInterval,
+          heartbeatFn,
+          signal
+        });
+        retryTotalDelayMs += delayMs;
+        if (attempt >= maxAttempts) {
+          attempt = maxAttempts - 1;
+        }
+      } else {
+        const retryAfterMs = hasRetryAfterStatus(errorStatus) || error instanceof ResponsesHttpError ? getRetryAfterDelayMs(error) : null;
+        let actualDelayMs;
+        if (retryAfterMs !== null && retryAfterMs > 0) {
+          actualDelayMs = retryAfterMs;
+          currentDelay = initialDelayMs;
+          logRetryAtStatusLevel(
+            `Attempt ${attempt} failed with status ${errorStatus ?? "unknown"}. Retrying after explicit delay of ${retryAfterMs}ms...`,
+            retryDiagnostics,
+            error,
+            errorStatus
+          );
+        } else {
+          actualDelayMs = getRetryDelayMs({
+            // attempt: 1 — currentDelay already tracks exponential growth;
+            // getRetryDelayMs is called here only for jitter calculation.
+            attempt: 1,
+            initialDelayMs: currentDelay,
+            maxDelayMs,
+            jitterRatio: 0.3
+          });
+          currentDelay = Math.min(maxDelayMs, currentDelay * 2);
+          logRetryAttempt(
+            attempt,
+            error,
+            retryDiagnostics,
+            errorStatus,
+            actualDelayMs
+          );
+        }
+        if (!signal?.aborted) {
+          try {
+            onRetry?.({
+              attempt: iterationCount,
+              error,
+              errorStatus,
+              delayMs: actualDelayMs
+            });
+          } catch (cbError) {
+            debugLogger.warn(
+              `onRetry callback threw (swallowed): ${cbError instanceof Error ? cbError.message : String(cbError)}`
+            );
+          }
+        }
+        await delay(actualDelayMs, signal);
+        retryTotalDelayMs += actualDelayMs;
+      }
+    }
+  }
+  if (hadContentRetry) {
+    return lastContentResult;
+  }
+  throw new Error("Retry attempts exhausted");
+}
+__name(retryWithBackoff, "retryWithBackoff");
+function logRetryAttempt(attempt, error, retryDiagnostics, errorStatus, delayMs) {
+  const backoff = delayMs !== void 0 ? `Retrying with backoff in ${Math.ceil(delayMs / 1e3)}s...` : "Retrying with backoff...";
+  const message = errorStatus ? `Attempt ${attempt} failed with status ${errorStatus}. ${backoff}` : `Attempt ${attempt} failed. ${backoff}`;
+  logRetryAtStatusLevel(message, retryDiagnostics, error, errorStatus);
+}
+__name(logRetryAttempt, "logRetryAttempt");
+function logRetryAtStatusLevel(message, retryDiagnostics, error, errorStatus) {
+  if (errorStatus !== void 0 && errorStatus >= 500 && errorStatus < 600) {
+    debugLogger.error(message, retryDiagnostics, error);
+  } else {
+    debugLogger.warn(message, retryDiagnostics, error);
+  }
+}
+__name(logRetryAtStatusLevel, "logRetryAtStatusLevel");
+
+// packages/core/src/utils/fetch.ts
+import { URL } from "node:url";
+var PRIVATE_IP_RANGES = [
+  /^10\./,
+  /^127\./,
+  /^172\.(1[6-9]|2[0-9]|3[0-1])\./,
+  /^192\.168\./,
+  // IPv4 link-local (incl. cloud metadata endpoints) and CGNAT 100.64.0.0/10.
+  /^169\.254\./,
+  /^100\.(6[4-9]|[7-9][0-9]|1[01][0-9]|12[0-7])\./,
+  /^0\.0\.0\.0$/,
+  /^::1$/,
+  /^::$/,
+  // ULA fc00::/7 covers fc00: through fdff: (fd00: is the common prefix in
+  // practice); link-local fe80::/10 covers fe80: through febf:.
+  /^f[cd][0-9a-f]{2}:/i,
+  /^fe[89ab][0-9a-f]:/i
+];
+var TLS_ERROR_CODES = /* @__PURE__ */ new Set([
+  "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+  "SELF_SIGNED_CERT_IN_CHAIN",
+  "DEPTH_ZERO_SELF_SIGNED_CERT",
+  "CERT_HAS_EXPIRED",
+  "ERR_TLS_CERT_ALTNAME_INVALID"
+]);
+var FETCH_TROUBLESHOOTING_ERROR_CODES = /* @__PURE__ */ new Set([
+  ...TLS_ERROR_CODES,
+  "ECONNRESET",
+  "ETIMEDOUT",
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "EHOSTUNREACH",
+  "ENETUNREACH"
+]);
+var FetchError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "FetchError";
+  }
+  static {
+    __name(this, "FetchError");
+  }
+};
+var CONNECTION_LEVEL_ERROR_CODES = /* @__PURE__ */ new Set([
+  ...TLS_ERROR_CODES,
+  "ECONNREFUSED",
+  "EPROTO",
+  "ERR_SSL_WRONG_VERSION_NUMBER",
+  // Servers that don't speak TLS on 443 often reset during the handshake
+  // rather than refusing the connection. Safe to include: the http fallback
+  // only ever fires for URLs the caller requested as http.
+  "ECONNRESET",
+  "UND_ERR_SOCKET",
+  // Filtered port 443 (silent drop): undici's own bounded connect timeout.
+  // Deliberately NOT the full-budget ETIMEDOUT — that can fire mid-body on
+  // a healthy https server, and a fallback there would double a worst-case
+  // 60s wait for an ambiguous gain.
+  "UND_ERR_CONNECT_TIMEOUT",
+  // No route to the host or network on 443: the network layer refused
+  // before any TLS, as a filtered port does.
+  "EHOSTUNREACH",
+  "ENETUNREACH"
+]);
+function isConnectionLevelError(error) {
+  return error instanceof FetchError && error.code !== void 0 && CONNECTION_LEVEL_ERROR_CODES.has(error.code);
+}
+__name(isConnectionLevelError, "isConnectionLevelError");
+function mappedIpv4(hostname) {
+  const match = /^::ffff:(.+)$/i.exec(hostname);
+  if (!match) return void 0;
+  const tail = match[1];
+  if (tail.includes(".")) return tail;
+  const groups = tail.split(":");
+  if (groups.length !== 2) return void 0;
+  const hi = Number.parseInt(groups[0], 16);
+  const lo = Number.parseInt(groups[1], 16);
+  if (Number.isNaN(hi) || Number.isNaN(lo)) return void 0;
+  return `${hi >> 8}.${hi & 255}.${lo >> 8}.${lo & 255}`;
+}
+__name(mappedIpv4, "mappedIpv4");
+function isPrivateAddress(address) {
+  const bare = address.replace(/^\[|\]$/g, "");
+  const target = mappedIpv4(bare) ?? bare;
+  return PRIVATE_IP_RANGES.some((range) => range.test(target));
+}
+__name(isPrivateAddress, "isPrivateAddress");
+function isPrivateIp(url) {
+  try {
+    return isPrivateAddress(new URL(url).hostname);
+  } catch (_e) {
+    return false;
+  }
+}
+__name(isPrivateIp, "isPrivateIp");
+var INTERNAL_HOST_SUFFIXES = [".local", ".internal", ".lan", ".home.arpa"];
+function isPrivateHost(url) {
+  try {
+    const hostname = new URL(url).hostname.toLowerCase();
+    return hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "host.docker.internal" || // Single-label hostnames (intranet, ci, printserver) are never public.
+    // IPv6 literals are bracketed and dot-free but CAN be public — they
+    // are classified by isPrivateIp below, not by this heuristic.
+    !hostname.includes(".") && !hostname.startsWith("[") || INTERNAL_HOST_SUFFIXES.some((suffix) => hostname.endsWith(suffix)) || isPrivateIp(url);
+  } catch {
+    return false;
+  }
+}
+__name(isPrivateHost, "isPrivateHost");
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+function isPermittedRedirect(originalUrl, redirectUrl) {
+  try {
+    const original = new URL(originalUrl);
+    const redirect = new URL(redirectUrl);
+    if (redirect.protocol !== original.protocol) return false;
+    if (redirect.port !== original.port) return false;
+    if (redirect.username || redirect.password) return false;
+    const stripWww = /* @__PURE__ */ __name((hostname) => hostname.replace(/^www\./, ""), "stripWww");
+    return stripWww(original.hostname) === stripWww(redirect.hostname);
+  } catch {
+    return false;
+  }
+}
+__name(isPermittedRedirect, "isPermittedRedirect");
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([403, 429]);
+var RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ECONNRESET",
+  "EAI_AGAIN",
+  "UND_ERR_SOCKET"
+]);
+var RETRY_DELAY_MS = 500;
+async function fetchWithPolicy(url, options) {
+  const timeoutSignal = AbortSignal.timeout(options.timeoutMs);
+  const signal = options.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal;
+  const abortError = /* @__PURE__ */ __name(() => {
+    if (options.signal?.aborted) {
+      return options.signal.reason instanceof Error ? options.signal.reason : new FetchError("Request aborted", "ABORT_ERR");
+    }
+    if (timeoutSignal.aborted) {
+      return new FetchError(
+        `Request timed out after ${options.timeoutMs}ms`,
+        "ETIMEDOUT"
+      );
+    }
+    return void 0;
+  }, "abortError");
+  let first;
+  try {
+    first = await fetchPolicyAttempt(url, options, signal, timeoutSignal);
+  } catch (error) {
+    if (error instanceof FetchError && error.code !== void 0 && RETRYABLE_ERROR_CODES.has(error.code) && !signal.aborted) {
+      try {
+        await delay(RETRY_DELAY_MS, signal);
+      } catch {
+        throw abortError() ?? error;
+      }
+      return fetchPolicyAttempt(url, options, signal, timeoutSignal);
+    }
+    throw error;
+  }
+  if (first.kind === "response" && RETRYABLE_STATUSES.has(first.status) && !signal.aborted) {
+    try {
+      await delay(RETRY_DELAY_MS, signal);
+      return await fetchPolicyAttempt(url, options, signal, timeoutSignal);
+    } catch {
+      const aborted = abortError();
+      if (aborted) throw aborted;
+      return first;
+    }
+  }
+  return first;
+}
+__name(fetchWithPolicy, "fetchWithPolicy");
+async function fetchPolicyAttempt(url, options, signal, timeoutSignal) {
+  const wrapAbort = /* @__PURE__ */ __name((error) => {
+    if (options.signal?.aborted) {
+      throw options.signal.reason instanceof Error ? options.signal.reason : new FetchError("Request aborted", "ABORT_ERR");
+    }
+    if (timeoutSignal.aborted) {
+      throw new FetchError(
+        `Request timed out after ${options.timeoutMs}ms`,
+        "ETIMEDOUT"
+      );
+    }
+    if (error instanceof FetchError) throw error;
+    throw new FetchError(getErrorMessage(error), classifyErrorCode(error));
+  }, "wrapAbort");
+  let currentUrl = url;
+  for (let hop = 0; hop <= options.maxRedirects; hop++) {
+    let response;
+    try {
+      response = await fetch(currentUrl, {
+        signal,
+        headers: options.headers,
+        redirect: "manual"
+      });
+    } catch (error) {
+      return wrapAbort(error);
+    }
+    if (REDIRECT_STATUSES.has(response.status)) {
+      const location = response.headers.get("location");
+      await response.body?.cancel().catch(() => {
+      });
+      if (!location) {
+        throw new FetchError("Redirect response missing Location header");
+      }
+      let redirectUrl;
+      try {
+        redirectUrl = new URL(location, currentUrl).toString();
+      } catch {
+        throw new FetchError(
+          `Redirect response has a malformed Location header: ${location}`
+        );
+      }
+      if (!isPermittedRedirect(currentUrl, redirectUrl)) {
+        return {
+          kind: "cross-host-redirect",
+          originalUrl: currentUrl,
+          redirectUrl,
+          status: response.status
+        };
+      }
+      currentUrl = redirectUrl;
+      continue;
+    }
+    if (response.status < 200 || response.status >= 300) {
+      await response.body?.cancel().catch(() => {
+      });
+      return {
+        kind: "response",
+        status: response.status,
+        statusText: response.statusText,
+        contentType: response.headers.get("content-type") ?? "",
+        contentDisposition: response.headers.get("content-disposition") ?? "",
+        body: Buffer.alloc(0),
+        finalUrl: currentUrl
+      };
+    }
+    const contentLength = Number(response.headers.get("content-length"));
+    if (Number.isFinite(contentLength) && contentLength > options.maxBytes) {
+      await response.body?.cancel().catch(() => {
+      });
+      throw new FetchError(
+        `Response too large: ${contentLength} bytes exceeds the ${options.maxBytes}-byte limit`,
+        "EMSGSIZE"
+      );
+    }
+    const chunks = [];
+    let total = 0;
+    if (response.body) {
+      const reader = response.body.getReader();
+      try {
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          total += value.byteLength;
+          if (total > options.maxBytes) {
+            throw new FetchError(
+              `Response too large: exceeded the ${options.maxBytes}-byte limit while streaming`,
+              "EMSGSIZE"
+            );
+          }
+          chunks.push(value);
+        }
+      } catch (error) {
+        await reader.cancel().catch(() => {
+        });
+        if (error instanceof FetchError) throw error;
+        return wrapAbort(error);
+      } finally {
+        reader.releaseLock();
+      }
+    }
+    return {
+      kind: "response",
+      status: response.status,
+      statusText: response.statusText,
+      contentType: response.headers.get("content-type") ?? "",
+      contentDisposition: response.headers.get("content-disposition") ?? "",
+      body: Buffer.concat(chunks, total),
+      finalUrl: currentUrl
+    };
+  }
+  throw new FetchError(
+    `Too many redirects (exceeded ${options.maxRedirects})`,
+    "EMAXREDIRECTS"
+  );
+}
+__name(fetchPolicyAttempt, "fetchPolicyAttempt");
+function classifyErrorCode(error) {
+  const cause = error instanceof Error ? error.cause : void 0;
+  const attempts = [error, cause].flatMap((candidate) => {
+    const errors = candidate?.errors;
+    return Array.isArray(errors) ? errors : [];
+  });
+  const connectionLevel = attempts.map(getErrorCode2).find(
+    (code) => code !== void 0 && CONNECTION_LEVEL_ERROR_CODES.has(code)
+  );
+  return connectionLevel ?? getErrorCode2(error) ?? getErrorCode2(cause);
+}
+__name(classifyErrorCode, "classifyErrorCode");
+function getErrorCode2(error) {
+  if (!error || typeof error !== "object") {
+    return void 0;
+  }
+  if ("code" in error && typeof error["code"] === "string") {
+    return error["code"];
+  }
+  return void 0;
+}
+__name(getErrorCode2, "getErrorCode");
+
+export {
+  isApiError,
+  isStructuredError,
+  QUOTA_EXHAUSTED_PREFIX,
+  isQuotaExhaustedError,
+  formatQuotaExhaustedMessage,
+  getErrorHeader,
+  isRateLimitError,
+  getRateLimitErrorDetails,
+  getRateLimitRetryDelayMs,
+  ResponsesHttpError,
+  classifyRetryError,
+  getTransportCode,
+  isFallbackEligible,
+  isRetryableUpstreamError,
+  retryContext,
+  isUnattendedMode,
+  delay,
+  retryWithBackoff,
+  isConnectionLevelError,
+  isPrivateHost,
+  isPermittedRedirect,
+  fetchWithPolicy
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 o1-code contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * Modified by the o1-code project; see NOTICE.
+ * SPDX-License-Identifier: Apache-2.0
+ */