@bman654/clodex 2.9.0 → 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.9.0",
+  version: "2.10.0",
   publishConfig: {
     access: "public"
   },
@@ -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,162 +11365,6 @@ function resolveUpstreamTools(tools, messages) {
   return upstream;
 }
 
-// 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/upstream-attempts.ts
 import { RetryError as RetryError2, wrapLanguageModel as wrapLanguageModel2 } from "ai";
 function trackUpstreamAttempts(model) {
@@ -11125,6 +11408,12 @@ function trackUpstreamAttempts(model) {
   };
 }
 
+// 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;
@@ -11393,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;
+  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) && 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;
-  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) && 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
@@ -12318,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,
@@ -17246,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);