nexus-agents 3.8.0 → 3.8.2

package/dist/{chunk-6G4FMCXS.js → chunk-Q4N2AMUH.js}

@@ -5,34 +5,34 @@ import {
   planOptionalParams,
   requireApiKey,
   validateApiKeyPresence
-} from "./chunk-RYOQ3WJR.js";
+} from "./chunk-PRMJRGTB.js";
 import {
   CUSTOM_API_DEFAULT_MODEL
-} from "./chunk-C62JS6A7.js";
+} from "./chunk-BIG3SAUY.js";
 import {
   CUSTOM_API_BASE_URL_ENV,
   PROVIDER_ENV_KEYS,
   assertCustomApiHostResolvesPublic,
   validateCustomApiBaseUrl
-} from "./chunk-2XFBHREJ.js";
+} from "./chunk-ATOORYKU.js";
 import {
   nexusMkdtempSync
 } from "./chunk-SNJNRDKZ.js";
 import {
   getAvailabilityCache
-} from "./chunk-5CXAYPSU.js";
+} from "./chunk-YCJVIYXU.js";
 import {
   extractSystemPrompt
 } from "./chunk-QZUG667L.js";
 import {
   generateHyphenId
-} from "./chunk-GX3QJX7X.js";
+} from "./chunk-FH5GVIUB.js";
 import {
   CliCircuitBreaker,
   DEFAULT_CIRCUIT_BREAKER_CONFIG,
   getCliCircuitBreakerSnapshot,
   getDefaultCliCircuitBreakerRegistry
-} from "./chunk-7ILVQDUT.js";
+} from "./chunk-RH2XESKI.js";
 import {
   CLI_SUBPROCESS_TIMEOUTS,
   CLI_TIMEOUTS,
@@ -69,7 +69,7 @@ import {
   ok,
   parseRetryAfterMs,
   resolveCliAlias
-} from "./chunk-YSE3VQ4A.js";
+} from "./chunk-TSCF7SCI.js";
 
 // src/cli-adapters/cli-to-model-adapter.ts
 var CliToModelAdapter = class {
@@ -221,6 +221,210 @@ function createCliToModelAdapter(cliAdapter, config) {
   return new CliToModelAdapter(cliAdapter, config);
 }
 
+// src/cli-adapters/capacity-tracker.ts
+var DEFAULT_TOKEN_LIMITS = {
+  claude: 1e5,
+  // Claude API Build tier
+  gemini: 1e6,
+  // Gemini Pro generous limits
+  codex: 5e5,
+  // OpenAI tier 1
+  opencode: 5e5
+  // Multi-provider proxy
+};
+var DEFAULT_REQUEST_LIMITS = {
+  claude: 50,
+  // Claude API Build tier
+  gemini: 60,
+  // Gemini Pro
+  codex: 500,
+  // OpenAI tier 1
+  opencode: 300
+  // Multi-provider proxy
+};
+var RATE_LIMIT_WINDOW_MS = 6e4;
+function getDefaultConfig(cli) {
+  const envPrefix = `NEXUS_${cli.toUpperCase()}`;
+  const tokenEnv = process.env[`${envPrefix}_TOKEN_LIMIT`];
+  const requestEnv = process.env[`${envPrefix}_REQUEST_LIMIT`];
+  return {
+    tokenLimit: tokenEnv !== void 0 && tokenEnv !== "" ? parseInt(tokenEnv, 10) : DEFAULT_TOKEN_LIMITS[cli],
+    requestLimit: requestEnv !== void 0 && requestEnv !== "" ? parseInt(requestEnv, 10) : DEFAULT_REQUEST_LIMITS[cli],
+    windowMs: RATE_LIMIT_WINDOW_MS
+  };
+}
+var CapacityTracker = class {
+  config;
+  usageHistory;
+  requestCount;
+  windowStart;
+  /**
+   * Timestamps of every recorded request (#3026 finding 4).
+   *
+   * Pre-fix, `requestCount` was a plain counter reset only by the
+   * tumbling-window branch of `pruneOldEntries`. Under continuous
+   * traffic across a window boundary, that branch drops requests that
+   * are still inside the *sliding* window — e.g. with windowMs=60s, a
+   * request at t=59s followed by one at t=61s would tumbling-reset
+   * the counter to 1 even though the t=59s request is still inside
+   * the [1s, 61s] window. The downstream `remainingRequests === 0`
+   * exhaustion check fired prematurely (or too late) depending on
+   * burst patterns.
+   *
+   * Counting via a per-request timestamp array that's pruned the same
+   * way as `usageHistory` keeps the two views consistent. Every
+   * `recordUsage` pushes here; `requestCount` is derived from
+   * `.length` after pruning.
+   */
+  requestTimestamps;
+  /**
+   * Whether this process has recorded even one request against this adapter
+   * (#4374). Sticky: pruning the usage window back to empty does NOT clear it,
+   * because the process has still seen the adapter work — it simply has no
+   * recent samples. Without this flag a never-used tracker is indistinguishable
+   * from an idle healthy one, and both report full remaining capacity.
+   */
+  hasObserved = false;
+  /**
+   * Provider-asserted quota exhaustion (#4456), with the horizon the provider
+   * gave. Null until a provider says so — never inferred from local counting.
+   */
+  quotaExhaustedUntil = null;
+  constructor(config) {
+    this.config = config;
+    this.usageHistory = [];
+    this.requestCount = 0;
+    this.requestTimestamps = [];
+    this.windowStart = getTimeProvider().now();
+  }
+  /**
+   * Records token usage from a completed request.
+   */
+  recordUsage(usage) {
+    const now = getTimeProvider().now();
+    this.hasObserved = true;
+    this.pruneOldEntries(now);
+    this.quotaExhaustedUntil = null;
+    this.requestTimestamps.push(now);
+    this.requestCount = this.requestTimestamps.length;
+    if (usage !== void 0) {
+      const tokens = usage.totalTokens ?? usage.inputTokens + usage.outputTokens;
+      this.usageHistory.push({
+        timestamp: now,
+        tokens
+      });
+    }
+  }
+  /**
+   * Gets current capacity status based on tracked usage.
+   */
+  getCapacity() {
+    const now = getTimeProvider().now();
+    this.pruneOldEntries(now);
+    const usedTokens = this.usageHistory.reduce((sum, entry) => sum + entry.tokens, 0);
+    const remainingTokens = Math.max(0, this.config.tokenLimit - usedTokens);
+    const remainingRequests = Math.max(0, this.config.requestLimit - this.requestCount);
+    const tokenUtilization = usedTokens / this.config.tokenLimit * 100;
+    const requestUtilization = this.requestCount / this.config.requestLimit * 100;
+    const utilizationPercent = clampPercent(Math.max(tokenUtilization, requestUtilization));
+    const rateLimited = remainingTokens === 0 || remainingRequests === 0;
+    const resetTime = new Date(this.windowStart + this.config.windowMs);
+    if (this.quotaExhaustedUntil !== null && now >= this.quotaExhaustedUntil) {
+      this.quotaExhaustedUntil = null;
+    }
+    const quotaExhausted = this.quotaExhaustedUntil !== null;
+    return {
+      remainingTokens,
+      remainingRequests,
+      resetTime,
+      utilizationPercent: Math.round(utilizationPercent * 100) / 100,
+      rateLimited,
+      // #4456: identical value, deprecated name. Kept so the rename is not a
+      // breaking change to an exported type; removal is scheduled for the next
+      // major, and `no-restricted-syntax` blocks new reads in the meantime.
+      exhausted: rateLimited,
+      quotaExhausted,
+      ...this.quotaExhaustedUntil !== null ? { quotaResetAt: new Date(this.quotaExhaustedUntil) } : {},
+      observed: this.hasObserved
+    };
+  }
+  /**
+   * Record a PROVIDER's assertion that durable quota is exhausted (#4456).
+   *
+   * Only a `retryAfterMs` longer than the local window counts. A shorter one
+   * is an ordinary per-minute throttle, which {@link CapacityStatus.rateLimited}
+   * already covers — treating it as quota exhaustion would empty the candidate
+   * pool for a condition that clears in under a minute, the failure mode that
+   * kept #4373's enforcement stage switched off.
+   *
+   * Without a `retryAfterMs` the provider gave no horizon, so nothing is
+   * asserted: an exhaustion with no end is not distinguishable here from a
+   * transient error, and inventing a horizon would manufacture a measurement.
+   *
+   * @param retryAfterMs - The provider's stated wait, from `retry-after`.
+   * @returns true when the assertion was durable enough to record.
+   */
+  recordProviderQuotaExhaustion(retryAfterMs) {
+    if (retryAfterMs === void 0 || retryAfterMs <= this.config.windowMs) return false;
+    this.hasObserved = true;
+    this.quotaExhaustedUntil = getTimeProvider().now() + retryAfterMs;
+    return true;
+  }
+  /**
+   * Gets time until the rate limit window resets.
+   */
+  getTimeUntilReset() {
+    const now = getTimeProvider().now();
+    const resetTime = this.windowStart + this.config.windowMs;
+    return Math.max(0, resetTime - now);
+  }
+  /**
+   * Resets all tracked usage (for testing or manual reset).
+   */
+  reset() {
+    this.usageHistory.length = 0;
+    this.requestTimestamps.length = 0;
+    this.requestCount = 0;
+    this.windowStart = getTimeProvider().now();
+    this.quotaExhaustedUntil = null;
+  }
+  /**
+   * Updates configuration (e.g., after receiving actual rate limit info).
+   */
+  updateConfig(partial) {
+    Object.assign(this.config, partial);
+  }
+  /**
+   * Gets current configuration.
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Removes entries older than the window duration.
+   */
+  pruneOldEntries(now) {
+    const cutoff = now - this.config.windowMs;
+    while (this.usageHistory[0] !== void 0 && this.usageHistory[0].timestamp < cutoff) {
+      this.usageHistory.shift();
+    }
+    while (this.requestTimestamps[0] !== void 0 && this.requestTimestamps[0] < cutoff) {
+      this.requestTimestamps.shift();
+    }
+    this.requestCount = this.requestTimestamps.length;
+    const earliestRequest = this.requestTimestamps[0];
+    const earliestUsage = this.usageHistory[0]?.timestamp;
+    if (earliestRequest === void 0 && earliestUsage === void 0) {
+      this.windowStart = now;
+    } else {
+      this.windowStart = Math.min(earliestRequest ?? Infinity, earliestUsage ?? Infinity);
+    }
+  }
+};
+function createCapacityTracker(cli) {
+  return new CapacityTracker(getDefaultConfig(cli));
+}
+
 // src/cli-adapters/model-to-cli-adapter.ts
 var DEFAULT_CONTEXT_WINDOW = FALLBACK_CONTEXT_WINDOW;
 var NEUTRAL_CAPABILITIES = {
@@ -236,10 +440,18 @@ var ModelToCliAdapter = class {
   transport = API_TRANSPORT;
   capabilities;
   modelAdapter;
+  /**
+   * Per-arm capacity state (#4602). The same canonical `CapacityTracker` the
+   * subprocess adapters use — this bridge previously answered `getCapacity()`
+   * from literals, so no API/SDK arm could report a quota signal at all.
+   * Per-instance, so one arm's exhaustion never speaks for another's.
+   */
+  capacityTracker;
   constructor(modelAdapter, config) {
     this.modelAdapter = modelAdapter;
     this.name = config.name;
     this.capabilities = config.capabilities ?? NEUTRAL_CAPABILITIES;
+    this.capacityTracker = createCapacityTracker(config.name);
   }
   /** Build a single-turn CompletionRequest from a CliTask. */
   toCompletionRequest(task, options) {
@@ -284,24 +496,50 @@ var ModelToCliAdapter = class {
    * Convert a ModelError to a CliError. Rate-limit text → RATE_LIMITED
    * (retryable); everything else → EXECUTION_ERROR (non-retryable) so the
    * routing/circuit layers see a real, typed failure.
+   *
+   * #4602: parses `retryAfterMs` off the message, mirroring
+   * `base-adapter.ts`'s `createError`. Pre-fix this bridge classified
+   * RATE_LIMITED and then threw the provider's stated horizon away — and that
+   * horizon is the sole input `CapacityTracker.recordProviderQuotaExhaustion`
+   * accepts, so the API/SDK arms could never assert quota exhaustion.
+   *
+   * Only parsed on a retryable error, as on the subprocess path: a wait hint
+   * inside a 500 body is not a rate-limit assertion.
    */
   toCliError(error) {
     const rateLimited = isRateLimitText(error.message);
     const code = rateLimited ? "RATE_LIMITED" : "EXECUTION_ERROR";
+    const retryAfterMs = rateLimited ? parseRetryAfterMs(error.message) : void 0;
     const base = {
       code,
       message: error.message,
       cli: this.name,
-      retryable: rateLimited
+      retryable: rateLimited,
+      ...retryAfterMs !== void 0 && { retryAfterMs }
     };
     return error.cause instanceof Error ? { ...base, cause: error.cause } : base;
   }
+  /**
+   * Feed a provider's own rate-limit assertion into capacity tracking (#4602).
+   *
+   * The API-side counterpart of `BaseCliAdapter.recordQuotaSignal`. The
+   * tracker — not this adapter — decides whether the stated wait is long
+   * enough to mean durable quota rather than a per-minute throttle.
+   */
+  recordQuotaSignal(error) {
+    if (error.code !== "RATE_LIMITED") return;
+    this.capacityTracker.recordProviderQuotaExhaustion(error.retryAfterMs);
+  }
   async execute(task, options) {
     const result = await this.modelAdapter.complete(this.toCompletionRequest(task, options));
     if (!result.ok) {
-      return err(this.toCliError(result.error));
+      const cliError = this.toCliError(result.error);
+      this.recordQuotaSignal(cliError);
+      return err(cliError);
     }
-    return ok(this.toCliResponse(result.value));
+    const response = this.toCliResponse(result.value);
+    this.capacityTracker.recordUsage(response.usage);
+    return ok(response);
   }
   /** Health is derived from the model adapter's config validation. */
   async healthCheck() {
@@ -315,25 +553,22 @@ var ModelToCliAdapter = class {
     });
   }
   /**
-   * API adapters don't expose subprocess-style rate windows; report
-   * non-exhausted capacity. Real rate-limit signals surface via execute()'s
-   * RATE_LIMITED error, which the resilience layer acts on.
+   * Report this arm's capacity from its `CapacityTracker` (#4602).
    *
-   * #4374: `observed: false` — the infinities below are a stand-in for "this
-   * adapter has no rate window to report", not a measurement. Reporting them as
-   * observed would tell consumers we had checked and found unlimited capacity.
+   * Previously this returned literals: `POSITIVE_INFINITY` remaining,
+   * `quotaExhausted: false`, `observed: false`. The `observed: false` half was
+   * honest (#4374 — nothing had been observed), but `quotaExhausted: false`
+   * asserted a measurement that never happened, and since `assessCapacity`
+   * reaches `'exhausted'` only through `quotaExhausted`, it made every
+   * API/SDK arm unexcludable for quota by construction — a check that cannot
+   * fail, whatever the provider said.
+   *
+   * The tracker keeps the honest empty case: until this arm has served a call
+   * or a provider has asserted a horizon, it reports `observed: false` and the
+   * stage grades it `unmeasured`, never `healthy`.
    */
   getCapacity() {
-    return Promise.resolve({
-      remainingTokens: Number.POSITIVE_INFINITY,
-      remainingRequests: Number.POSITIVE_INFINITY,
-      resetTime: /* @__PURE__ */ new Date(0),
-      utilizationPercent: 0,
-      rateLimited: false,
-      exhausted: false,
-      quotaExhausted: false,
-      observed: false
-    });
+    return Promise.resolve(this.capacityTracker.getCapacity());
   }
   getVersion() {
     return Promise.resolve("api");
@@ -1620,209 +1855,6 @@ function getTimeoutForTaskAuto(cli, taskDescription) {
   return getAdaptiveTimeout(cli, taskDescription);
 }
 
-// src/cli-adapters/capacity-tracker.ts
-var DEFAULT_TOKEN_LIMITS = {
-  claude: 1e5,
-  // Claude API Build tier
-  gemini: 1e6,
-  // Gemini Pro generous limits
-  codex: 5e5,
-  // OpenAI tier 1
-  opencode: 5e5
-  // Multi-provider proxy
-};
-var DEFAULT_REQUEST_LIMITS = {
-  claude: 50,
-  // Claude API Build tier
-  gemini: 60,
-  // Gemini Pro
-  codex: 500,
-  // OpenAI tier 1
-  opencode: 300
-  // Multi-provider proxy
-};
-var RATE_LIMIT_WINDOW_MS = 6e4;
-function getDefaultConfig(cli) {
-  const envPrefix = `NEXUS_${cli.toUpperCase()}`;
-  const tokenEnv = process.env[`${envPrefix}_TOKEN_LIMIT`];
-  const requestEnv = process.env[`${envPrefix}_REQUEST_LIMIT`];
-  return {
-    tokenLimit: tokenEnv !== void 0 && tokenEnv !== "" ? parseInt(tokenEnv, 10) : DEFAULT_TOKEN_LIMITS[cli],
-    requestLimit: requestEnv !== void 0 && requestEnv !== "" ? parseInt(requestEnv, 10) : DEFAULT_REQUEST_LIMITS[cli],
-    windowMs: RATE_LIMIT_WINDOW_MS
-  };
-}
-var CapacityTracker = class {
-  config;
-  usageHistory;
-  requestCount;
-  windowStart;
-  /**
-   * Timestamps of every recorded request (#3026 finding 4).
-   *
-   * Pre-fix, `requestCount` was a plain counter reset only by the
-   * tumbling-window branch of `pruneOldEntries`. Under continuous
-   * traffic across a window boundary, that branch drops requests that
-   * are still inside the *sliding* window — e.g. with windowMs=60s, a
-   * request at t=59s followed by one at t=61s would tumbling-reset
-   * the counter to 1 even though the t=59s request is still inside
-   * the [1s, 61s] window. The downstream `remainingRequests === 0`
-   * exhaustion check fired prematurely (or too late) depending on
-   * burst patterns.
-   *
-   * Counting via a per-request timestamp array that's pruned the same
-   * way as `usageHistory` keeps the two views consistent. Every
-   * `recordUsage` pushes here; `requestCount` is derived from
-   * `.length` after pruning.
-   */
-  requestTimestamps;
-  /**
-   * Whether this process has recorded even one request against this adapter
-   * (#4374). Sticky: pruning the usage window back to empty does NOT clear it,
-   * because the process has still seen the adapter work — it simply has no
-   * recent samples. Without this flag a never-used tracker is indistinguishable
-   * from an idle healthy one, and both report full remaining capacity.
-   */
-  hasObserved = false;
-  /**
-   * Provider-asserted quota exhaustion (#4456), with the horizon the provider
-   * gave. Null until a provider says so — never inferred from local counting.
-   */
-  quotaExhaustedUntil = null;
-  constructor(config) {
-    this.config = config;
-    this.usageHistory = [];
-    this.requestCount = 0;
-    this.requestTimestamps = [];
-    this.windowStart = getTimeProvider().now();
-  }
-  /**
-   * Records token usage from a completed request.
-   */
-  recordUsage(usage) {
-    const now = getTimeProvider().now();
-    this.hasObserved = true;
-    this.pruneOldEntries(now);
-    this.quotaExhaustedUntil = null;
-    this.requestTimestamps.push(now);
-    this.requestCount = this.requestTimestamps.length;
-    if (usage !== void 0) {
-      const tokens = usage.totalTokens ?? usage.inputTokens + usage.outputTokens;
-      this.usageHistory.push({
-        timestamp: now,
-        tokens
-      });
-    }
-  }
-  /**
-   * Gets current capacity status based on tracked usage.
-   */
-  getCapacity() {
-    const now = getTimeProvider().now();
-    this.pruneOldEntries(now);
-    const usedTokens = this.usageHistory.reduce((sum, entry) => sum + entry.tokens, 0);
-    const remainingTokens = Math.max(0, this.config.tokenLimit - usedTokens);
-    const remainingRequests = Math.max(0, this.config.requestLimit - this.requestCount);
-    const tokenUtilization = usedTokens / this.config.tokenLimit * 100;
-    const requestUtilization = this.requestCount / this.config.requestLimit * 100;
-    const utilizationPercent = clampPercent(Math.max(tokenUtilization, requestUtilization));
-    const rateLimited = remainingTokens === 0 || remainingRequests === 0;
-    const resetTime = new Date(this.windowStart + this.config.windowMs);
-    if (this.quotaExhaustedUntil !== null && now >= this.quotaExhaustedUntil) {
-      this.quotaExhaustedUntil = null;
-    }
-    const quotaExhausted = this.quotaExhaustedUntil !== null;
-    return {
-      remainingTokens,
-      remainingRequests,
-      resetTime,
-      utilizationPercent: Math.round(utilizationPercent * 100) / 100,
-      rateLimited,
-      // #4456: identical value, deprecated name. Kept so the rename is not a
-      // breaking change to an exported type; removal is scheduled for the next
-      // major, and `no-restricted-syntax` blocks new reads in the meantime.
-      exhausted: rateLimited,
-      quotaExhausted,
-      ...this.quotaExhaustedUntil !== null ? { quotaResetAt: new Date(this.quotaExhaustedUntil) } : {},
-      observed: this.hasObserved
-    };
-  }
-  /**
-   * Record a PROVIDER's assertion that durable quota is exhausted (#4456).
-   *
-   * Only a `retryAfterMs` longer than the local window counts. A shorter one
-   * is an ordinary per-minute throttle, which {@link CapacityStatus.rateLimited}
-   * already covers — treating it as quota exhaustion would empty the candidate
-   * pool for a condition that clears in under a minute, the failure mode that
-   * kept #4373's enforcement stage switched off.
-   *
-   * Without a `retryAfterMs` the provider gave no horizon, so nothing is
-   * asserted: an exhaustion with no end is not distinguishable here from a
-   * transient error, and inventing a horizon would manufacture a measurement.
-   *
-   * @param retryAfterMs - The provider's stated wait, from `retry-after`.
-   * @returns true when the assertion was durable enough to record.
-   */
-  recordProviderQuotaExhaustion(retryAfterMs) {
-    if (retryAfterMs === void 0 || retryAfterMs <= this.config.windowMs) return false;
-    this.quotaExhaustedUntil = getTimeProvider().now() + retryAfterMs;
-    return true;
-  }
-  /**
-   * Gets time until the rate limit window resets.
-   */
-  getTimeUntilReset() {
-    const now = getTimeProvider().now();
-    const resetTime = this.windowStart + this.config.windowMs;
-    return Math.max(0, resetTime - now);
-  }
-  /**
-   * Resets all tracked usage (for testing or manual reset).
-   */
-  reset() {
-    this.usageHistory.length = 0;
-    this.requestTimestamps.length = 0;
-    this.requestCount = 0;
-    this.windowStart = getTimeProvider().now();
-    this.quotaExhaustedUntil = null;
-  }
-  /**
-   * Updates configuration (e.g., after receiving actual rate limit info).
-   */
-  updateConfig(partial) {
-    Object.assign(this.config, partial);
-  }
-  /**
-   * Gets current configuration.
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-  /**
-   * Removes entries older than the window duration.
-   */
-  pruneOldEntries(now) {
-    const cutoff = now - this.config.windowMs;
-    while (this.usageHistory[0] !== void 0 && this.usageHistory[0].timestamp < cutoff) {
-      this.usageHistory.shift();
-    }
-    while (this.requestTimestamps[0] !== void 0 && this.requestTimestamps[0] < cutoff) {
-      this.requestTimestamps.shift();
-    }
-    this.requestCount = this.requestTimestamps.length;
-    const earliestRequest = this.requestTimestamps[0];
-    const earliestUsage = this.usageHistory[0]?.timestamp;
-    if (earliestRequest === void 0 && earliestUsage === void 0) {
-      this.windowStart = now;
-    } else {
-      this.windowStart = Math.min(earliestRequest ?? Infinity, earliestUsage ?? Infinity);
-    }
-  }
-};
-function createCapacityTracker(cli) {
-  return new CapacityTracker(getDefaultConfig(cli));
-}
-
 // src/utils/async-utils.ts
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -4824,4 +4856,4 @@ export {
   SdkAdapter,
   createAutoAdapter
 };
-//# sourceMappingURL=chunk-6G4FMCXS.js.map
+//# sourceMappingURL=chunk-Q4N2AMUH.js.map