@bman654/clodex 2.8.5 → 2.10.0

package/dist/cli.js

@@ -382,7 +382,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.8.5",
+  version: "2.10.0",
   publishConfig: {
     access: "public"
   },
@@ -3423,7 +3423,7 @@ function savedStopsAfter(current, assignments) {
 }
 
 // src/patch-transforms.ts
-var PATCH_TRANSFORMS_VERSION = 11;
+var PATCH_TRANSFORMS_VERSION = 12;
 var NATIVE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 var BASE_EFFORT_LEVELS = ["low", "medium", "high"];
 function projectNativeEffort(effort) {
@@ -3812,7 +3812,7 @@ function applyClodexPatches(source, config) {
     }
     applyOnce(
       patchName,
-      /(function [\w$]+\(\)\{)(let (?:[^;{}]|\{[^;{}]*\})*?[\w$]+\(process\.env\.CLAUDE_CODE_REMOTE\)\?(?:(?!\}\s*function )[\s\S])*?\)return process\.env;let ([\w$]+)=\{(?:(?!\}\s*function )[\s\S])*?return \3)(\})/,
+      /(function [\w$]+\(\)\{)(let[ {[](?:[^;{}]|\{[^;{}]*\})*?(?:\{[^;{}]*)?(?:getAgentProxyEnv|[\w$]+\(process\.env\.CLAUDE_CODE_REMOTE\)\?)(?:(?!\}\s*function )[\s\S])*?\)return process\.env;let ([\w$]+)=\{(?:(?!\}\s*function )[\s\S])*?return \3)(\})/,
       (match, head, body, _copyVar, tail) => {
         const at = js.indexOf(match);
         const closingBrace = at < 0 ? -1 : blockEndIndex(js, at + head.length - 1);
@@ -8009,6 +8009,369 @@ function sanitizeToolInput(input, requiredProps) {
   return out;
 }
 
+// src/upstream-retry.ts
+var UPSTREAM_MAX_RETRIES_ENV = "CLODEX_UPSTREAM_MAX_RETRIES";
+var UPSTREAM_IDLE_TIMEOUT_ENV = "CLODEX_UPSTREAM_IDLE_TIMEOUT_MS";
+var UPSTREAM_TOTAL_TIMEOUT_ENV = "CLODEX_UPSTREAM_TOTAL_TIMEOUT_MS";
+var DEFAULT_UPSTREAM_IDLE_TIMEOUT_MS = 12e4;
+var DEFAULT_UPSTREAM_TOTAL_TIMEOUT_MS = 10 * 6e4;
+var MIN_UPSTREAM_IDLE_TIMEOUT_MS = 1e4;
+var MAX_UPSTREAM_IDLE_TIMEOUT_MS = 60 * 6e4;
+var MIN_UPSTREAM_TOTAL_TIMEOUT_MS = 6e4;
+var MAX_UPSTREAM_TOTAL_TIMEOUT_MS = 6 * 60 * 6e4;
+var SDK_INITIAL_RETRY_DELAY_MS = 2e3;
+var reportedValues = /* @__PURE__ */ new Set();
+var defaultWarn = (message) => emitParentNotice(`clodex: ${message}`);
+function reportOnce(key, message, warn) {
+  if (reportedValues.has(key)) return;
+  reportedValues.add(key);
+  try {
+    warn(message);
+  } catch {
+  }
+}
+function timeoutSetting(env, envName, fallback, min, max, warn) {
+  const raw = env[envName]?.trim();
+  if (raw === void 0 || raw === "") return { value: fallback, explicit: false };
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value <= 0) {
+    reportOnce(
+      `${envName}=${raw}`,
+      `ignoring ${envName}=${raw} (expected a positive integer number of milliseconds)`,
+      warn
+    );
+    return { value: fallback, explicit: false };
+  }
+  if (value < min || value > max) {
+    const clamped = Math.min(max, Math.max(min, value));
+    reportOnce(
+      `${envName}=${raw}`,
+      `clamping ${envName}=${raw} to ${clamped}ms (supported range is ${min}-${max}ms)`,
+      warn
+    );
+    return { value: clamped, explicit: true };
+  }
+  return { value, explicit: true };
+}
+function maxRetriesForIdleTimeout(idleTimeoutMs) {
+  let retries = 0;
+  let elapsedMs = 0;
+  let delayMs = SDK_INITIAL_RETRY_DELAY_MS;
+  while (elapsedMs + delayMs < idleTimeoutMs) {
+    elapsedMs += delayMs;
+    delayMs *= 2;
+    retries += 1;
+  }
+  return retries;
+}
+var MAX_UPSTREAM_MAX_RETRIES = maxRetriesForIdleTimeout(
+  DEFAULT_UPSTREAM_IDLE_TIMEOUT_MS
+);
+var DEFAULT_UPSTREAM_MAX_RETRIES = MAX_UPSTREAM_MAX_RETRIES;
+function configuredUpstreamMaxRetries(env, warn) {
+  const raw = env[UPSTREAM_MAX_RETRIES_ENV]?.trim();
+  if (raw === void 0 || raw === "") return void 0;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 0) {
+    reportOnce(
+      `${UPSTREAM_MAX_RETRIES_ENV}=${raw}`,
+      `ignoring ${UPSTREAM_MAX_RETRIES_ENV}=${raw} (expected a non-negative integer)`,
+      warn
+    );
+    return void 0;
+  }
+  return value;
+}
+function resolveUpstreamMaxRetries(env, warn, idleTimeoutMs) {
+  const ceiling = maxRetriesForIdleTimeout(idleTimeoutMs);
+  const defaultRetries = Math.min(DEFAULT_UPSTREAM_MAX_RETRIES, ceiling);
+  const value = configuredUpstreamMaxRetries(env, warn);
+  if (value === void 0) return defaultRetries;
+  if (value > ceiling) {
+    reportOnce(
+      `${UPSTREAM_MAX_RETRIES_ENV}=${value}:idle=${idleTimeoutMs}`,
+      `clamping ${UPSTREAM_MAX_RETRIES_ENV}=${value} to ${ceiling} (estimated from the SDK fallback backoff and resolved ${idleTimeoutMs}ms idle timeout; provider delays may allow fewer retries)`,
+      warn
+    );
+    return ceiling;
+  }
+  return value;
+}
+function upstreamRequestBudget(options = {}) {
+  const env = options.env ?? process.env;
+  const warn = options.warn ?? defaultWarn;
+  const hasIdleOverride = options.idleTimeoutMs !== void 0;
+  const configuredIdle = options.idleTimeoutMs !== void 0 ? { value: options.idleTimeoutMs, explicit: false } : timeoutSetting(
+    env,
+    UPSTREAM_IDLE_TIMEOUT_ENV,
+    DEFAULT_UPSTREAM_IDLE_TIMEOUT_MS,
+    MIN_UPSTREAM_IDLE_TIMEOUT_MS,
+    MAX_UPSTREAM_IDLE_TIMEOUT_MS,
+    warn
+  );
+  const configuredTotal = timeoutSetting(
+    env,
+    UPSTREAM_TOTAL_TIMEOUT_ENV,
+    DEFAULT_UPSTREAM_TOTAL_TIMEOUT_MS,
+    MIN_UPSTREAM_TOTAL_TIMEOUT_MS,
+    MAX_UPSTREAM_TOTAL_TIMEOUT_MS,
+    warn
+  );
+  let idleTimeoutMs = configuredIdle.value;
+  let totalTimeoutMs = configuredTotal.value;
+  if (totalTimeoutMs < idleTimeoutMs) {
+    if (hasIdleOverride) {
+      idleTimeoutMs = totalTimeoutMs;
+    } else if (configuredIdle.explicit && !configuredTotal.explicit) {
+      reportOnce(
+        `timeout-pair:raise-total:${idleTimeoutMs}:${totalTimeoutMs}`,
+        `raising the resolved total timeout from ${totalTimeoutMs}ms to ${idleTimeoutMs}ms so it is not shorter than ${UPSTREAM_IDLE_TIMEOUT_ENV}`,
+        warn
+      );
+      totalTimeoutMs = idleTimeoutMs;
+    } else {
+      reportOnce(
+        `timeout-pair:lower-idle:${idleTimeoutMs}:${totalTimeoutMs}`,
+        `lowering the resolved idle timeout from ${idleTimeoutMs}ms to ${totalTimeoutMs}ms because it cannot exceed ${UPSTREAM_TOTAL_TIMEOUT_ENV}`,
+        warn
+      );
+      idleTimeoutMs = totalTimeoutMs;
+    }
+  }
+  return {
+    idleTimeoutMs,
+    totalTimeoutMs,
+    maxRetries: resolveUpstreamMaxRetries(env, warn, idleTimeoutMs)
+  };
+}
+var CLIENT_MAX_RETRIES_ENV = "CLAUDE_CODE_MAX_RETRIES";
+var DEFAULT_PASSTHROUGH_RETRIES = 1;
+function passthroughUpstreamRetries(env = process.env, warn = defaultWarn) {
+  const explicit = configuredUpstreamMaxRetries(env, warn);
+  if (explicit !== void 0) {
+    if (explicit <= MAX_UPSTREAM_MAX_RETRIES) return explicit;
+    reportOnce(
+      `${UPSTREAM_MAX_RETRIES_ENV}=${explicit}:passthrough`,
+      `clamping ${UPSTREAM_MAX_RETRIES_ENV}=${explicit} to ${MAX_UPSTREAM_MAX_RETRIES} (the raw HTTP MITM path supports at most this many replays)`,
+      warn
+    );
+    return MAX_UPSTREAM_MAX_RETRIES;
+  }
+  const raw = env[CLIENT_MAX_RETRIES_ENV]?.trim();
+  if (raw !== void 0 && raw !== "") {
+    const clientRetries = Number(raw);
+    if (Number.isFinite(clientRetries) && clientRetries === 0) return 0;
+  }
+  return DEFAULT_PASSTHROUGH_RETRIES;
+}
+
+// src/oauth/ws-upgrade-pacer.ts
+var WS_NEW_CONNECTIONS_PER_MIN_ENV = "CLODEX_WS_MAX_NEW_CONNECTIONS_PER_MIN";
+var DEFAULT_WS_NEW_CONNECTIONS_PER_MIN = 60;
+var MAX_WS_NEW_CONNECTIONS_PER_MIN = 600;
+var WS_NEW_CONNECTION_BURST = 10;
+var WS_NEW_CONNECTION_MAX_WAIT_CEILING_MS = 15e3;
+function resolvedPacingBudget() {
+  const { idleTimeoutMs, maxRetries } = upstreamRequestBudget();
+  return { idleTimeoutMs, maxRetries };
+}
+var SDK_INITIAL_BACKOFF_MS = 2e3;
+function wsNewConnectionMaxWaitMs(idleTimeoutMs, maxRetries) {
+  if (!Number.isFinite(idleTimeoutMs) || !Number.isFinite(maxRetries) || idleTimeoutMs <= 0 || maxRetries < 0) {
+    return 0;
+  }
+  const attempts = maxRetries + 1;
+  const totalBackoffMs = SDK_INITIAL_BACKOFF_MS * (2 ** maxRetries - 1);
+  const shareableMs = Math.max(0, idleTimeoutMs - totalBackoffMs) / 2;
+  const bound = Math.floor(shareableMs / attempts);
+  return Number.isFinite(bound) ? Math.min(WS_NEW_CONNECTION_MAX_WAIT_CEILING_MS, Math.max(0, bound)) : 0;
+}
+function pacedRetryAfterSeconds(requiredWaitMs, maxWaitMs) {
+  const capSeconds = Number.isFinite(maxWaitMs) ? Math.max(1, Math.floor(maxWaitMs / 1e3)) : 1;
+  const wantSeconds = Number.isFinite(requiredWaitMs) ? Math.max(1, Math.ceil(requiredWaitMs / 1e3)) : 1;
+  return Math.min(wantSeconds, capSeconds);
+}
+function refusalScheduleMs(maxWaitMs, maxRetries) {
+  if (!Number.isFinite(maxRetries) || maxRetries <= 0) return 0;
+  return maxRetries * pacedRetryAfterSeconds(Number.MAX_SAFE_INTEGER, maxWaitMs) * 1e3;
+}
+function canRefuseAtRate(maxWaitMs, maxRetries, ratePerMinute) {
+  if (!Number.isFinite(ratePerMinute) || ratePerMinute <= 0) return false;
+  const refillIntervalMs = 6e4 / ratePerMinute;
+  return refusalScheduleMs(maxWaitMs, maxRetries) >= refillIntervalMs;
+}
+function defaultSchedule(ms, fire) {
+  const timer = setTimeout(fire, ms);
+  return () => clearTimeout(timer);
+}
+function abortError(signal) {
+  if (signal?.reason instanceof Error) return signal.reason;
+  const error = new Error(
+    typeof signal?.reason === "string" ? signal.reason : "WebSocket connection pacing aborted"
+  );
+  error.name = "AbortError";
+  return error;
+}
+var reportedNotices = /* @__PURE__ */ new Set();
+function reportOnce2(key, message, warn) {
+  if (reportedNotices.has(key)) return;
+  reportedNotices.add(key);
+  try {
+    warn(message);
+  } catch {
+  }
+}
+var WsUpgradePacer = class {
+  /** Longest any one request will be queued. Derived; exposed for diagnostics. */
+  maxWaitMs;
+  enabled;
+  refillPerMs;
+  capacity;
+  canRefuse;
+  maxDebt;
+  now;
+  schedule;
+  tokens;
+  lastRefillAt;
+  constructor(options = {}) {
+    const ratePerMinute = options.ratePerMinute ?? DEFAULT_WS_NEW_CONNECTIONS_PER_MIN;
+    const burst = options.burst ?? WS_NEW_CONNECTION_BURST;
+    const budget = options.idleTimeoutMs === void 0 || options.maxRetries === void 0 ? resolvedPacingBudget() : { idleTimeoutMs: options.idleTimeoutMs, maxRetries: options.maxRetries };
+    const idleTimeoutMs = options.idleTimeoutMs ?? budget.idleTimeoutMs;
+    const maxRetries = options.maxRetries ?? budget.maxRetries;
+    this.maxWaitMs = wsNewConnectionMaxWaitMs(idleTimeoutMs, maxRetries);
+    const rateRequested = Number.isFinite(ratePerMinute) && ratePerMinute > 0;
+    this.enabled = rateRequested && this.maxWaitMs > 0;
+    if (rateRequested && !this.enabled) {
+      reportOnce2(
+        `disabled:${maxRetries}:${idleTimeoutMs}`,
+        `not pacing new OpenAI connections: a ${maxRetries}-retry budget leaves no room to queue inside the resolved ${idleTimeoutMs}ms request deadline`,
+        (message) => emitParentNotice(`clodex: ${message}`)
+      );
+    }
+    this.canRefuse = maxRetries > 0 && canRefuseAtRate(this.maxWaitMs, maxRetries, ratePerMinute);
+    if (this.enabled && maxRetries > 0 && !this.canRefuse) {
+      reportOnce2(
+        `norefuse:${ratePerMinute}:${maxRetries}:${this.maxWaitMs}`,
+        `pacing new OpenAI connections at ${ratePerMinute}/minute without refusing overflow: a ${maxRetries}-retry schedule spans only ${refusalScheduleMs(this.maxWaitMs, maxRetries)}ms, which cannot outlast the ${Math.round(6e4 / ratePerMinute)}ms wait for a free connection slot, so clodex shapes the opening burst and then admits remaining overflow instead of failing it`,
+        (message) => emitParentNotice(`clodex: ${message}`)
+      );
+    }
+    this.refillPerMs = this.enabled ? ratePerMinute / 6e4 : 0;
+    this.capacity = Number.isFinite(burst) ? Math.max(1, burst) : WS_NEW_CONNECTION_BURST;
+    this.maxDebt = this.maxWaitMs * this.refillPerMs;
+    this.now = options.now ?? Date.now;
+    this.schedule = options.schedule ?? defaultSchedule;
+    this.tokens = this.capacity;
+    this.lastRefillAt = this.now();
+  }
+  /**
+   * Resolves when this request may open a new connection, or resolves to a
+   * refusal the caller must report as a retryable rate limit. Callers that
+   * reuse an existing connection must not call this at all.
+   */
+  async admit(signal) {
+    if (!this.enabled) return { kind: "admitted", waitedMs: 0 };
+    if (signal?.aborted) throw abortError(signal);
+    const reservation = this.reserve(this.now());
+    if (!reservation.admitted) {
+      return {
+        kind: "refused",
+        requiredWaitMs: reservation.requiredWaitMs,
+        // Capped at the bound: the SDK substitutes this hint for its own
+        // backoff rung, so an uncapped one would overrun the deadline the
+        // bound was derived to fit. See `pacedRetryAfterSeconds`.
+        retryAfterSeconds: clampRetryAfterSeconds(
+          pacedRetryAfterSeconds(reservation.requiredWaitMs, this.maxWaitMs)
+        )
+      };
+    }
+    if (reservation.waitMs <= 0) return { kind: "admitted", waitedMs: 0 };
+    const startedAt = this.now();
+    try {
+      await this.sleep(reservation.waitMs, signal);
+    } catch (error) {
+      this.refund(reservation.consumed);
+      throw error;
+    }
+    return { kind: "admitted", waitedMs: Math.max(0, this.now() - startedAt) };
+  }
+  reserve(now) {
+    const elapsed = Math.max(0, now - this.lastRefillAt);
+    this.tokens = Math.min(this.capacity, this.tokens + elapsed * this.refillPerMs);
+    this.lastRefillAt = now;
+    const waitMs = this.tokens >= 1 ? 0 : Math.ceil((1 - this.tokens) / this.refillPerMs);
+    if (waitMs > this.maxWaitMs) {
+      if (this.canRefuse) return { admitted: false, requiredWaitMs: waitMs };
+      const before = this.tokens;
+      this.tokens = Math.max(-this.maxDebt, this.tokens - 1);
+      const consumed = before - this.tokens;
+      return { admitted: true, waitMs: consumed > 0 ? this.maxWaitMs : 0, consumed };
+    }
+    this.tokens -= 1;
+    return { admitted: true, waitMs, consumed: 1 };
+  }
+  refund(consumed) {
+    this.tokens = Math.min(this.capacity, this.tokens + consumed);
+  }
+  /**
+   * INVARIANT REQUIRED OF FUTURE EDITS: `admit` must reject an aborted signal
+   * before reaching here, and nothing may be awaited between that check and
+   * this call. An abort arriving in such a window would leave the request
+   * parked on a listener an already-aborted signal never fires, and it would
+   * wait out the full duration. There is deliberately no second check here to
+   * catch that, because an untested guard is not a guarantee.
+   */
+  sleep(ms, signal) {
+    return new Promise((resolve3, reject) => {
+      let settled = false;
+      let cancelTimer;
+      const onAbort = () => {
+        if (settled) return;
+        settled = true;
+        cancelTimer?.();
+        reject(abortError(signal));
+      };
+      const fire = () => {
+        if (settled) return;
+        settled = true;
+        signal?.removeEventListener("abort", onAbort);
+        resolve3();
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      cancelTimer = this.schedule(ms, fire);
+      if (settled) cancelTimer();
+    });
+  }
+};
+function wsNewConnectionsPerMinute(env = process.env, warn = (message) => emitParentNotice(`clodex: ${message}`)) {
+  const raw = env[WS_NEW_CONNECTIONS_PER_MIN_ENV]?.trim();
+  if (raw === void 0 || raw === "") return DEFAULT_WS_NEW_CONNECTIONS_PER_MIN;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 0) {
+    reportOnce2(
+      `rate:${raw}`,
+      `ignoring ${WS_NEW_CONNECTIONS_PER_MIN_ENV}=${raw} (expected a non-negative integer; using ${DEFAULT_WS_NEW_CONNECTIONS_PER_MIN})`,
+      warn
+    );
+    return DEFAULT_WS_NEW_CONNECTIONS_PER_MIN;
+  }
+  if (value > MAX_WS_NEW_CONNECTIONS_PER_MIN) {
+    reportOnce2(
+      `rate:${raw}`,
+      `clamping ${WS_NEW_CONNECTIONS_PER_MIN_ENV}=${raw} to ${MAX_WS_NEW_CONNECTIONS_PER_MIN} (a higher rate shapes nothing OpenAI throttles on)`,
+      warn
+    );
+    return MAX_WS_NEW_CONNECTIONS_PER_MIN;
+  }
+  return value;
+}
+var sharedPacer;
+function sharedWsUpgradePacer() {
+  sharedPacer ??= new WsUpgradePacer({ ratePerMinute: wsNewConnectionsPerMinute() });
+  return sharedPacer;
+}
+
 // src/oauth/responses-websocket.ts
 var RESPONSES_LITE_HEADER = "x-openai-internal-codex-responses-lite";
 var TERMINAL_EVENT_TYPES = /* @__PURE__ */ new Set(["response.completed", "response.failed", "response.incomplete"]);
@@ -9129,6 +9492,34 @@ function handleSocketMessage(entry, data) {
     closeContext(ctx);
   }
 }
+function pacedRefusalResponse(retryAfterSeconds) {
+  const frame = {
+    type: "error",
+    sequence_number: 0,
+    error: {
+      type: anthropicErrorType(429),
+      code: "429",
+      message: `clodex is limiting how fast it opens new OpenAI connections to reduce the chance of an upstream rate limit; retry after ${retryAfterSeconds}s`,
+      param: null,
+      retry_after_seconds: retryAfterSeconds
+    }
+  };
+  return new Response(`data: ${JSON.stringify(frame)}
+
+`, {
+    status: 200,
+    headers: {
+      "content-type": "text/event-stream; charset=utf-8",
+      // A real header, not just the prose: `getRetryDelayInMs` reads headers and
+      // ignores the body, so without one the SDK falls back to its fixed 2s/4s
+      // ladder. This does NOT de-correlate the group — refusals debit nothing,
+      // so everyone refused at the same instant sees the same deficit and gets
+      // the same hint — it defers the whole group by long enough for the bucket
+      // to refill, which is what turns a retry storm into a successful retry.
+      "retry-after": String(retryAfterSeconds)
+    }
+  });
+}
 function numericRetryAfterHeader(value) {
   const single = Array.isArray(value) ? value[0] : value;
   return typeof single === "string" && /^\d+$/.test(single.trim()) ? Number(single.trim()) : void 0;
@@ -9270,7 +9661,7 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
     const promptFieldHashes = responsesWebSocketPromptFieldHashes(payload);
     const instructionsSnapshot = instructionsFromPayload(payload);
     const diagnosticCorrelation = diagnosticContext.getStore();
-    const now = resolvedOptions.now();
+    let now = resolvedOptions.now();
     const evictions = cleanupExpiredConnections(now);
     const candidates = partitionKey ? connectionEntries(partitionKey) : [];
     const idleCandidates = candidates.filter((entry) => !entry.inFlight);
@@ -9341,6 +9732,53 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
     } else {
       decision = "unpartitioned_socket";
     }
+    let pacingWaitedMs;
+    if (!selected) {
+      const pacer = options.pacer ?? sharedWsUpgradePacer();
+      const pacingStartedAt = resolvedOptions.now();
+      let admission;
+      try {
+        admission = await pacer.admit(init?.signal ?? void 0);
+      } catch (error) {
+        emitDiagnostic(options, {
+          event: "ws_new_connection_paced",
+          outcome: "aborted",
+          decision,
+          waitedMs: Math.max(0, resolvedOptions.now() - pacingStartedAt)
+        }, diagnosticCorrelation);
+        throw error;
+      }
+      if (admission.kind === "refused") {
+        debug(
+          `refused a new connection to hold the pacing rate; retry after ${admission.retryAfterSeconds}s`
+        );
+        emitDiagnostic(options, {
+          event: "ws_new_connection_paced",
+          outcome: "refused",
+          decision,
+          requiredWaitMs: admission.requiredWaitMs,
+          retryAfterSeconds: admission.retryAfterSeconds
+        }, diagnosticCorrelation);
+        return pacedRefusalResponse(admission.retryAfterSeconds);
+      }
+      if (admission.waitedMs > 0) {
+        pacingWaitedMs = admission.waitedMs;
+        debug(`paced new connection by ${admission.waitedMs}ms`);
+        emitDiagnostic(options, {
+          event: "ws_new_connection_paced",
+          outcome: "admitted",
+          decision,
+          waitedMs: admission.waitedMs
+        }, diagnosticCorrelation);
+      }
+      now = resolvedOptions.now();
+      evictions.push(...cleanupExpiredConnections(now));
+      if (persistent && partitionKey && connectionEntries(partitionKey).some((entry) => entry.inFlight)) {
+        persistent = false;
+        decision = "parallel_isolated";
+        debug("parallel request using an isolated socket after pacing");
+      }
+    }
     if (!selected && persistent) {
       evictions.push(...evictOldestIdleGeneration(
         "nursery",
@@ -9382,6 +9820,7 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
       continuationMatchMode: selectedMatch?.mode,
       promotedConnectionId,
       createdConnectionId: selected ? void 0 : nextConnectionDebugId,
+      ...pacingWaitedMs !== void 0 ? { pacingWaitedMs } : {},
       createdGeneration: selected ? void 0 : persistent ? "nursery" : "isolated",
       incrementalInputItems: selectedDelta?.length,
       heads: candidates.map((entry) => ({
@@ -10926,53 +11365,55 @@ function resolveUpstreamTools(tools, messages) {
   return upstream;
 }
 
-// src/upstream-retry.ts
-var UPSTREAM_MAX_RETRIES_ENV = "CLODEX_UPSTREAM_MAX_RETRIES";
-var MAX_UPSTREAM_MAX_RETRIES = 5;
-var reportedValues = /* @__PURE__ */ new Set();
-function reportOnce(raw, message, warn) {
-  if (reportedValues.has(raw)) return;
-  reportedValues.add(raw);
-  try {
-    warn(message);
-  } catch {
-  }
-}
-function upstreamMaxRetries(env = process.env, warn = (message) => emitParentNotice(`clodex: ${message}`)) {
-  const raw = env[UPSTREAM_MAX_RETRIES_ENV]?.trim();
-  if (raw === void 0 || raw === "") return void 0;
-  const value = Number(raw);
-  if (!Number.isInteger(value) || value < 0) {
-    reportOnce(
-      raw,
-      `ignoring ${UPSTREAM_MAX_RETRIES_ENV}=${raw} (expected a non-negative integer)`,
-      warn
-    );
-    return void 0;
-  }
-  if (value > MAX_UPSTREAM_MAX_RETRIES) {
-    reportOnce(
-      raw,
-      `clamping ${UPSTREAM_MAX_RETRIES_ENV}=${raw} to ${MAX_UPSTREAM_MAX_RETRIES} (higher values exceed the 120s streaming idle budget)`,
-      warn
-    );
-    return MAX_UPSTREAM_MAX_RETRIES;
-  }
-  return value;
-}
-var CLIENT_MAX_RETRIES_ENV = "CLAUDE_CODE_MAX_RETRIES";
-var DEFAULT_PASSTHROUGH_RETRIES = 1;
-function passthroughUpstreamRetries(env = process.env) {
-  const explicit = upstreamMaxRetries(env);
-  if (explicit !== void 0) return explicit;
-  const raw = env[CLIENT_MAX_RETRIES_ENV]?.trim();
-  if (raw !== void 0 && raw !== "") {
-    const clientRetries = Number(raw);
-    if (Number.isFinite(clientRetries) && clientRetries === 0) return 0;
-  }
-  return DEFAULT_PASSTHROUGH_RETRIES;
+// src/upstream-attempts.ts
+import { RetryError as RetryError2, wrapLanguageModel as wrapLanguageModel2 } from "ai";
+function trackUpstreamAttempts(model) {
+  if (typeof model === "string") {
+    return { model, deadlineError: (timeoutError) => timeoutError };
+  }
+  const failedAttempts = [];
+  let waitingToRetry = false;
+  const track = async (call) => {
+    waitingToRetry = false;
+    try {
+      const result = await call();
+      failedAttempts.length = 0;
+      return result;
+    } catch (error) {
+      failedAttempts.push(error);
+      waitingToRetry = true;
+      throw error;
+    }
+  };
+  const middleware = {
+    specificationVersion: "v4",
+    wrapGenerate: ({ doGenerate }) => track(doGenerate),
+    wrapStream: ({ doStream }) => track(doStream)
+  };
+  return {
+    model: wrapLanguageModel2({ model, middleware }),
+    deadlineError: (timeoutError) => {
+      if (!waitingToRetry || failedAttempts.length === 0) return timeoutError;
+      const count = failedAttempts.length;
+      return new RetryError2({
+        message: [
+          "Provider retry interrupted by a request deadline after",
+          count,
+          `failed ${count === 1 ? "attempt" : "attempts"}`
+        ].join(" "),
+        reason: "abort",
+        errors: [...failedAttempts]
+      });
+    }
+  };
 }
 
+// src/claude-code-compact-prompt.ts
+var CLAUDE_CODE_COMPACT_PROMPT_MARKERS = Object.freeze({
+  start: "CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.",
+  end: "REMINDER: Do NOT call any tools. Respond with plain text only"
+});
+
 // src/sdk-adapter.ts
 function sdkTranslationErrorSignature(error) {
   const message = error instanceof Error ? error.message : typeof error === "string" ? error : void 0;
@@ -11241,22 +11682,66 @@ function translateToolChoice(tc) {
   if (tc.type === "tool" && tc.name) return { type: "tool", toolName: tc.name };
   return void 0;
 }
-var COMPACT_TEXT_ONLY_START = "CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.";
-var COMPACT_TEXT_ONLY_END = "REMINDER: Do NOT call any tools. Respond with plain text only";
-function isClaudeCodeStructuredOutputCompactRequest(body) {
+var {
+  start: COMPACT_TEXT_ONLY_START,
+  end: COMPACT_TEXT_ONLY_END
+} = CLAUDE_CODE_COMPACT_PROMPT_MARKERS;
+function isClaudeCodeCompactRequest(body) {
   if (body.diagnostics !== void 0) return false;
-  if (!body.tools?.some((candidate) => candidate.name === "StructuredOutput")) return false;
   const finalMessage = body.messages.at(-1);
   if (!finalMessage || finalMessage.role !== "user") return false;
-  const text5 = typeof finalMessage.content === "string" ? finalMessage.content : finalMessage.content.filter((block) => block.type === "text").map((block) => block.text ?? "").join("\n");
-  return text5.includes(COMPACT_TEXT_ONLY_START) && text5.includes(COMPACT_TEXT_ONLY_END);
+  const texts = typeof finalMessage.content === "string" ? [finalMessage.content] : finalMessage.content.filter((block) => block.type === "text").map((block) => block.text ?? "");
+  return texts.some((text5) => text5.startsWith(COMPACT_TEXT_ONLY_START) && text5.includes(COMPACT_TEXT_ONLY_END));
+}
+var COMPACT_DRIFT_ANCHOR = "Tool calls will be REJECTED and will waste your only turn";
+var COMPACT_DRIFT_ANCHOR_LINE = new RegExp(
+  `(?:^|\\n)[-*\u2022\\s]{0,4}${COMPACT_DRIFT_ANCHOR}`
+);
+var COMPACT_DRIFT_OPENING = /^(?:(?:critical|important|warning|caution|urgent|notice):\s*)?(?:respond|return|answer|output|write|provide)\b(?=[^\n]{1,160}(?:\n|$))(?=[^\n]*\b(?:text\s+only|plain\s+text\s+only|only\s+(?:plain\s+)?text)\b)(?=[^\n]*\b(?:do not|don't|never|without)\b[^\n]{0,48}\btools?\b)/i;
+function looksLikeDriftedClaudeCodeCompactRequest(body) {
+  if (body.diagnostics !== void 0) return false;
+  const finalMessage = body.messages.at(-1);
+  if (!finalMessage || finalMessage.role !== "user") return false;
+  const texts = typeof finalMessage.content === "string" ? [finalMessage.content] : finalMessage.content.filter((block) => block.type === "text").map((block) => block.text ?? "");
+  return texts.some((text5) => !text5.startsWith(COMPACT_TEXT_ONLY_START) && COMPACT_DRIFT_OPENING.test(text5) && COMPACT_DRIFT_ANCHOR_LINE.test(text5));
+}
+function claudeCodeVersionFromRequest(body) {
+  const texts = typeof body.system === "string" ? [body.system] : (body.system ?? []).map((block) => typeof block === "string" ? block : block.text ?? "");
+  for (const text5 of texts) {
+    if (!text5.startsWith(CLAUDE_CODE_BILLING_HEADER_PREFIX)) continue;
+    const match = text5.match(/\bcc_version=([0-9A-Za-z][0-9A-Za-z._+-]{0,63})(?:;|\s|$)/);
+    if (match) return match[1];
+  }
+  return void 0;
+}
+var warnedCompactPromptDrifts = /* @__PURE__ */ new Set();
+var MAX_COMPACT_PROMPT_DRIFT_WARNINGS = 3;
+function reportClaudeCodeCompactPromptDrift(body, log12) {
+  if (!looksLikeDriftedClaudeCodeCompactRequest(body)) return;
+  const version = claudeCodeVersionFromRequest(body);
+  const signature = version ?? "unknown-version";
+  try {
+    log12?.(`possible Claude Code compact prompt drift: ${signature}`);
+  } catch {
+  }
+  if (warnedCompactPromptDrifts.has(signature)) return;
+  if (warnedCompactPromptDrifts.size >= MAX_COMPACT_PROMPT_DRIFT_WARNINGS) return;
+  warnedCompactPromptDrifts.add(signature);
+  const versionText = version ? ` from Claude Code ${version}` : "";
+  emitParentNotice(
+    `clodex: warning: a request${versionText} looks like a compaction turn, but its prompt no longer matches clodex's text-only guard. Tools were left enabled and compaction may fail. Please report this at https://github.com/bman654/clodex/issues`
+  );
+  if (warnedCompactPromptDrifts.size === MAX_COMPACT_PROMPT_DRIFT_WARNINGS) {
+    emitParentNotice("clodex: warning: further compact-prompt drift warnings suppressed.");
+  }
 }
 function translateRequest(body, npm, options) {
   const messages = body.messages ?? [];
   annotateToolNames(messages);
   const baseSystem = systemToString(body.system, true);
   const systemText = baseSystem?.trim() || (options?.openAiOAuth ? "You are a coding assistant." : void 0);
-  const compactRequest = isClaudeCodeStructuredOutputCompactRequest(body);
+  const compactRequest = isClaudeCodeCompactRequest(body);
+  if (!compactRequest) reportClaudeCodeCompactPromptDrift(body, options?.log);
   let upstreamTools = resolveUpstreamTools(
     body.tools,
     messages
@@ -11347,8 +11832,6 @@ function toAnthropicUsage(u) {
     cache_read_input_tokens: cacheRead
   };
 }
-var SDK_STREAM_IDLE_TIMEOUT_MS = 12e4;
-var SDK_TOTAL_TIMEOUT_MS = 10 * 6e4;
 function streamAbortError(signal) {
   if (signal?.reason instanceof Error) return signal.reason;
   const error = new Error(
@@ -11569,42 +12052,44 @@ async function writeAnthropicStream(stream, modelId, write, log12, observer, too
   emit("message_stop", { type: "message_stop" });
 }
 async function streamAnthropicResponse(model, params, modelId, write, log12, observer) {
-  const idleTimeoutMs = observer?.idleTimeoutMs ?? SDK_STREAM_IDLE_TIMEOUT_MS;
+  const { idleTimeoutMs, totalTimeoutMs, maxRetries } = upstreamRequestBudget({
+    idleTimeoutMs: observer?.idleTimeoutMs
+  });
+  const attempts = trackUpstreamAttempts(model);
   const idleAbort = new AbortController();
   const stopForwardingAbort = forwardAbortSignal(observer?.abortSignal, idleAbort);
   const abortSignal = idleAbort.signal;
-  let idleTimer = setTimeout(
-    () => idleAbort.abort(new Error(`no data received from provider for ${Math.round(idleTimeoutMs / 1e3)}s`)),
-    idleTimeoutMs
+  const idleError = () => attempts.deadlineError(
+    new Error(`no data received from provider for ${Math.round(idleTimeoutMs / 1e3)}s`)
   );
+  let idleTimer = setTimeout(() => idleAbort.abort(idleError()), idleTimeoutMs);
   const totalTimer = setTimeout(
-    () => idleAbort.abort(new Error(`provider stream exceeded ${Math.round(SDK_TOTAL_TIMEOUT_MS / 1e3)}s`)),
-    SDK_TOTAL_TIMEOUT_MS
+    () => idleAbort.abort(attempts.deadlineError(
+      new Error(`provider stream exceeded ${Math.round(totalTimeoutMs / 1e3)}s`)
+    )),
+    totalTimeoutMs
   );
-  const result = streamText({
-    model,
-    ...params,
-    maxRetries: upstreamMaxRetries(),
-    abortSignal,
-    onError: () => {
-    },
-    onStepFinish: (step) => reportUnsupportedServiceTier(params, step.warnings)
-  });
-  const watchedStream = (async function* () {
-    try {
-      for await (const part of result.stream) {
+  try {
+    const result = streamText({
+      model: attempts.model,
+      ...params,
+      maxRetries,
+      abortSignal,
+      onError: () => {
+      },
+      onStepFinish: (step) => reportUnsupportedServiceTier(params, step.warnings)
+    });
+    const watchedStream = (async function* () {
+      try {
+        for await (const part of result.stream) {
+          clearTimeout(idleTimer);
+          idleTimer = setTimeout(() => idleAbort.abort(idleError()), idleTimeoutMs);
+          yield part;
+        }
+      } finally {
         clearTimeout(idleTimer);
-        idleTimer = setTimeout(
-          () => idleAbort.abort(new Error(`no data received from provider for ${Math.round(idleTimeoutMs / 1e3)}s`)),
-          idleTimeoutMs
-        );
-        yield part;
       }
-    } finally {
-      clearTimeout(idleTimer);
-    }
-  })();
-  try {
+    })();
     await writeAnthropicStream(watchedStream, modelId, write, log12, { ...observer, abortSignal }, params.tools);
   } finally {
     stopForwardingAbort();
@@ -11619,39 +12104,41 @@ async function generateAnthropicResponse(model, params, modelId, options) {
   let finishReason;
   let usage;
   let warnings;
+  const { idleTimeoutMs, totalTimeoutMs, maxRetries } = upstreamRequestBudget({
+    idleTimeoutMs: options?.forceStream ? options.idleTimeoutMs : void 0
+  });
+  const attempts = trackUpstreamAttempts(model);
   if (options?.forceStream) {
     const forceAbort = new AbortController();
     const stopForwardingAbort = forwardAbortSignal(options.abortSignal, forceAbort);
     const abortSignal = forceAbort.signal;
-    const idleTimeoutMs = options.idleTimeoutMs ?? SDK_STREAM_IDLE_TIMEOUT_MS;
-    let idleTimer = setTimeout(
-      () => forceAbort.abort(new Error(`no data received from provider for ${Math.round(idleTimeoutMs / 1e3)}s`)),
-      idleTimeoutMs
+    const idleError = () => attempts.deadlineError(
+      new Error(`no data received from provider for ${Math.round(idleTimeoutMs / 1e3)}s`)
     );
+    let idleTimer = setTimeout(() => forceAbort.abort(idleError()), idleTimeoutMs);
     const totalTimer = setTimeout(
-      () => forceAbort.abort(new Error(`provider stream exceeded ${Math.round(SDK_TOTAL_TIMEOUT_MS / 1e3)}s`)),
-      SDK_TOTAL_TIMEOUT_MS
+      () => forceAbort.abort(attempts.deadlineError(
+        new Error(`provider stream exceeded ${Math.round(totalTimeoutMs / 1e3)}s`)
+      )),
+      totalTimeoutMs
     );
-    const r = streamText({
-      model,
-      ...params,
-      maxRetries: upstreamMaxRetries(),
-      abortSignal,
-      onError: () => {
-      },
-      onStepFinish: (step) => reportUnsupportedServiceTier(params, step.warnings)
-    });
     const streamedText = [];
     const streamedToolCalls = [];
     let streamedFinishReason = "stop";
     let streamedUsage;
     try {
+      const r = streamText({
+        model: attempts.model,
+        ...params,
+        maxRetries,
+        abortSignal,
+        onError: () => {
+        },
+        onStepFinish: (step) => reportUnsupportedServiceTier(params, step.warnings)
+      });
       for await (const part of r.stream) {
         clearTimeout(idleTimer);
-        idleTimer = setTimeout(
-          () => forceAbort.abort(new Error(`no data received from provider for ${Math.round(idleTimeoutMs / 1e3)}s`)),
-          idleTimeoutMs
-        );
+        idleTimer = setTimeout(() => forceAbort.abort(idleError()), idleTimeoutMs);
         options.onPart?.(part.type);
         if (abortSignal.aborted || part.type === "abort") {
           throw streamAbortError(abortSignal);
@@ -11686,17 +12173,22 @@ async function generateAnthropicResponse(model, params, modelId, options) {
     const generateAbort = new AbortController();
     const stopForwardingAbort = forwardAbortSignal(options?.abortSignal, generateAbort);
     const totalTimer = setTimeout(
-      () => generateAbort.abort(new Error(`provider request exceeded ${Math.round(SDK_TOTAL_TIMEOUT_MS / 1e3)}s`)),
-      SDK_TOTAL_TIMEOUT_MS
+      () => generateAbort.abort(attempts.deadlineError(
+        new Error(`provider request exceeded ${Math.round(totalTimeoutMs / 1e3)}s`)
+      )),
+      totalTimeoutMs
     );
     try {
       const r = await generateText({
-        model,
+        model: attempts.model,
         ...params,
-        maxRetries: upstreamMaxRetries(),
+        maxRetries,
         abortSignal: generateAbort.signal
       });
       ({ text: text5, toolCalls, finishReason, usage, warnings } = r);
+    } catch (error) {
+      if (generateAbort.signal.aborted) throw streamAbortError(generateAbort.signal);
+      throw error;
     } finally {
       stopForwardingAbort();
       clearTimeout(totalTimer);
@@ -12159,6 +12651,7 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
             openAiOAuth,
             claudeSessionId,
             maxTools: maxToolsForNpm(route.npm),
+            log: plog,
             reasoningMetadata: {
               providerId: route.providerId,
               apiBaseUrl: route.baseURL,
@@ -16670,24 +17163,81 @@ async function collectOpenAiStream(stream) {
   }
   return collected;
 }
+function startUpstreamBudget(model, streaming) {
+  const { idleTimeoutMs, totalTimeoutMs, maxRetries } = upstreamRequestBudget();
+  const attempts = trackUpstreamAttempts(model);
+  const abort = new AbortController();
+  const idleError = () => attempts.deadlineError(new Error(
+    `no data received from provider for ${Math.round(idleTimeoutMs / 1e3)}s`
+  ));
+  let idleTimer = streaming ? setTimeout(() => abort.abort(idleError()), idleTimeoutMs) : void 0;
+  const totalTimer = setTimeout(
+    () => abort.abort(attempts.deadlineError(new Error(
+      `provider ${streaming ? "stream" : "request"} exceeded ${Math.round(totalTimeoutMs / 1e3)}s`
+    ))),
+    totalTimeoutMs
+  );
+  return {
+    model: attempts.model,
+    maxRetries,
+    abortSignal: abort.signal,
+    onStreamPart: () => {
+      if (idleTimer === void 0) return;
+      clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => abort.abort(idleError()), idleTimeoutMs);
+    },
+    close: () => {
+      if (idleTimer !== void 0) clearTimeout(idleTimer);
+      clearTimeout(totalTimer);
+      if (!abort.signal.aborted) abort.abort();
+    }
+  };
+}
+async function* watchOpenAiStream(stream, budget) {
+  for await (const part of stream) {
+    if (budget.abortSignal.aborted || part.type === "abort") {
+      throw budget.abortSignal.reason instanceof Error ? budget.abortSignal.reason : new Error("SDK stream aborted");
+    }
+    budget.onStreamPart();
+    yield part;
+  }
+  if (budget.abortSignal.aborted) {
+    throw budget.abortSignal.reason instanceof Error ? budget.abortSignal.reason : new Error("SDK stream aborted");
+  }
+}
 async function generateOpenAiResponse(model, params, responseModelId, options) {
   let result;
-  if (options?.forceStream) {
-    const { stream } = streamText2({
-      model,
-      ...params,
-      maxRetries: upstreamMaxRetries(),
-      onError: () => {
-      },
-      onStepFinish: (step) => reportUnsupportedServiceTier(params, step.warnings)
-    });
-    result = await collectOpenAiStream(stream);
-  } else {
-    result = await generateText2({
-      model,
-      ...params,
-      maxRetries: upstreamMaxRetries()
-    });
+  const streaming = options?.forceStream === true;
+  const budget = startUpstreamBudget(model, streaming);
+  try {
+    if (streaming) {
+      const { stream } = streamText2({
+        model: budget.model,
+        ...params,
+        maxRetries: budget.maxRetries,
+        abortSignal: budget.abortSignal,
+        onError: () => {
+        },
+        onStepFinish: (step) => reportUnsupportedServiceTier(params, step.warnings)
+      });
+      result = await collectOpenAiStream(watchOpenAiStream(stream, budget));
+    } else {
+      try {
+        result = await generateText2({
+          model: budget.model,
+          ...params,
+          maxRetries: budget.maxRetries,
+          abortSignal: budget.abortSignal
+        });
+      } catch (error) {
+        if (budget.abortSignal.aborted && budget.abortSignal.reason instanceof Error) {
+          throw budget.abortSignal.reason;
+        }
+        throw error;
+      }
+    }
+  } finally {
+    budget.close();
   }
   reportUnsupportedServiceTier(params, result.warnings);
   const message = { role: "assistant", content: result.text || null };
@@ -16712,41 +17262,47 @@ async function generateOpenAiResponse(model, params, responseModelId, options) {
   };
 }
 async function streamOpenAiResponse(model, params, responseModelId, onChunk) {
-  const { stream } = streamText2({
-    model,
-    ...params,
-    maxRetries: upstreamMaxRetries(),
-    onStepFinish: (step) => reportUnsupportedServiceTier(params, step.warnings)
-  });
-  const baseData = {
-    id: `chatcmpl-${Date.now()}`,
-    object: "chat.completion.chunk",
-    created: Math.floor(Date.now() / 1e3),
-    model: responseModelId
-  };
-  const send = (delta, finish_reason = null) => onChunk(`data: ${JSON.stringify({ ...baseData, choices: [{ index: 0, delta, finish_reason }] })}
+  const budget = startUpstreamBudget(model, true);
+  try {
+    const { stream } = streamText2({
+      model: budget.model,
+      ...params,
+      maxRetries: budget.maxRetries,
+      abortSignal: budget.abortSignal,
+      onStepFinish: (step) => reportUnsupportedServiceTier(params, step.warnings)
+    });
+    const baseData = {
+      id: `chatcmpl-${Date.now()}`,
+      object: "chat.completion.chunk",
+      created: Math.floor(Date.now() / 1e3),
+      model: responseModelId
+    };
+    const send = (delta, finish_reason = null) => onChunk(`data: ${JSON.stringify({ ...baseData, choices: [{ index: 0, delta, finish_reason }] })}
 
 `);
-  for await (const part of stream) {
-    const p13 = part;
-    switch (p13.type) {
-      case "text-delta":
-        send({ role: "assistant", content: p13.textDelta ?? p13.text ?? "" });
-        break;
-      case "tool-input-start":
-        send({ role: "assistant", tool_calls: [{ index: 0, id: p13.id ?? p13.toolCallId, type: "function", function: { name: p13.toolName, arguments: "" } }] });
-        break;
-      case "tool-input-delta":
-        send({ tool_calls: [{ index: 0, function: { arguments: p13.delta ?? p13.text ?? p13.argsTextDelta ?? "" } }] });
-        break;
-      case "finish":
-        send({}, p13.finishReason || "stop");
-        break;
-      case "error":
-        throw p13.error instanceof Error || p13.error && typeof p13.error === "object" ? p13.error : new Error(typeof p13.error === "string" ? p13.error : "Upstream stream failed");
+    for await (const part of watchOpenAiStream(stream, budget)) {
+      const p13 = part;
+      switch (p13.type) {
+        case "text-delta":
+          send({ role: "assistant", content: p13.textDelta ?? p13.text ?? "" });
+          break;
+        case "tool-input-start":
+          send({ role: "assistant", tool_calls: [{ index: 0, id: p13.id ?? p13.toolCallId, type: "function", function: { name: p13.toolName, arguments: "" } }] });
+          break;
+        case "tool-input-delta":
+          send({ tool_calls: [{ index: 0, function: { arguments: p13.delta ?? p13.text ?? p13.argsTextDelta ?? "" } }] });
+          break;
+        case "finish":
+          send({}, p13.finishReason || "stop");
+          break;
+        case "error":
+          throw p13.error instanceof Error || p13.error && typeof p13.error === "object" ? p13.error : new Error(typeof p13.error === "string" ? p13.error : "Upstream stream failed");
+      }
     }
+    onChunk("data: [DONE]\n\n");
+  } finally {
+    budget.close();
   }
-  onChunk("data: [DONE]\n\n");
 }
 
 // src/server/router.ts
@@ -17024,7 +17580,8 @@ async function handleAnthropicMessages(req, res, options, modelCache, plog) {
         compatibility: model.compatibility,
         upstreamModelId: upstreamModelId(model)
       },
-      maxTools: npmMaxTools
+      maxTools: npmMaxTools,
+      log: plog
     });
     const clientWantsStream = Boolean(body.stream);
     const responseModelId = getResponseModelId(body.model, model, options);