nexus-agents 2.92.5 → 2.94.0

package/dist/{chunk-L5BXCSMP.js → chunk-OT6V5ROA.js}

@@ -335,6 +335,238 @@ function extractJsonObject(text) {
   return text.slice(start, end + 1);
 }
 
+// src/core/circular-buffer.ts
+var CircularBuffer = class {
+  /**
+   * Creates a new circular buffer with the specified capacity.
+   *
+   * @param capacity - Maximum number of items to store
+   * @throws Error if capacity is less than 1
+   */
+  constructor(capacity) {
+    this.capacity = capacity;
+    if (capacity < 1) {
+      throw new Error("CircularBuffer capacity must be at least 1");
+    }
+    this.buffer = new Array(capacity);
+  }
+  buffer;
+  head = 0;
+  // Points to oldest item (or next write position when empty)
+  tail = 0;
+  // Points to next write position
+  _size = 0;
+  /**
+   * Returns the number of items currently in the buffer.
+   */
+  get size() {
+    return this._size;
+  }
+  /**
+   * Returns true if the buffer is empty.
+   */
+  get isEmpty() {
+    return this._size === 0;
+  }
+  /**
+   * Returns true if the buffer is at capacity.
+   */
+  get isFull() {
+    return this._size === this.capacity;
+  }
+  /**
+   * Adds an item to the buffer.
+   *
+   * If the buffer is full, the oldest item is overwritten.
+   * This operation is O(1).
+   *
+   * @param item - Item to add
+   */
+  push(item) {
+    this.buffer[this.tail] = item;
+    this.tail = (this.tail + 1) % this.capacity;
+    if (this._size < this.capacity) {
+      this._size++;
+    } else {
+      this.head = (this.head + 1) % this.capacity;
+    }
+  }
+  /**
+   * Removes all items from the buffer.
+   * This operation is O(n) to allow garbage collection of items.
+   */
+  clear() {
+    for (let i = 0; i < this.capacity; i++) {
+      this.buffer[i] = void 0;
+    }
+    this.head = 0;
+    this.tail = 0;
+    this._size = 0;
+  }
+  /**
+   * Returns all items in insertion order (oldest to newest).
+   * This operation is O(n) where n is the number of items.
+   *
+   * @returns Array of items in insertion order
+   */
+  toArray() {
+    if (this._size === 0) {
+      return [];
+    }
+    const result = [];
+    let readIndex = this.head;
+    for (let i = 0; i < this._size; i++) {
+      result.push(this.buffer[readIndex]);
+      readIndex = (readIndex + 1) % this.capacity;
+    }
+    return result;
+  }
+  /**
+   * Iterates over items in insertion order (oldest to newest).
+   */
+  *[Symbol.iterator]() {
+    let readIndex = this.head;
+    for (let i = 0; i < this._size; i++) {
+      yield this.buffer[readIndex];
+      readIndex = (readIndex + 1) % this.capacity;
+    }
+  }
+  /**
+   * Returns the most recently added item, or undefined if empty.
+   * This operation is O(1).
+   */
+  peekNewest() {
+    if (this._size === 0) {
+      return void 0;
+    }
+    const newestIndex = (this.tail - 1 + this.capacity) % this.capacity;
+    return this.buffer[newestIndex];
+  }
+  /**
+   * Returns the oldest item in the buffer, or undefined if empty.
+   * This operation is O(1).
+   */
+  peekOldest() {
+    if (this._size === 0) {
+      return void 0;
+    }
+    return this.buffer[this.head];
+  }
+};
+
+// src/core/bounded-lru-cache.ts
+var BoundedLRUCache = class {
+  /**
+   * @param capacity Maximum entries retained before LRU eviction (>= 1).
+   * @throws Error if capacity < 1.
+   */
+  constructor(capacity) {
+    this.capacity = capacity;
+    if (capacity < 1) {
+      throw new Error("BoundedLRUCache capacity must be at least 1");
+    }
+  }
+  entries = /* @__PURE__ */ new Map();
+  /** Number of entries currently held. */
+  get size() {
+    return this.entries.size;
+  }
+  /** True if `key` is present (does not affect recency). */
+  has(key) {
+    return this.entries.has(key);
+  }
+  /**
+   * Get the value for `key`, or undefined. Side effect: bumps `key` to
+   * most-recently-used.
+   */
+  get(key) {
+    const value = this.entries.get(key);
+    if (value === void 0 && !this.entries.has(key)) return void 0;
+    this.entries.delete(key);
+    this.entries.set(key, value);
+    return value;
+  }
+  /**
+   * Store `value` under `key`, bumping recency. Evicts the least-recently-used
+   * entry when at capacity.
+   */
+  set(key, value) {
+    if (this.entries.has(key)) {
+      this.entries.delete(key);
+    } else if (this.entries.size >= this.capacity) {
+      const oldest = this.entries.keys().next().value;
+      if (oldest !== void 0) this.entries.delete(oldest);
+    }
+    this.entries.set(key, value);
+  }
+  /** Remove `key`. Returns true if it was present. */
+  delete(key) {
+    return this.entries.delete(key);
+  }
+  /** Remove all entries. */
+  clear() {
+    this.entries.clear();
+  }
+};
+
+// src/core/tune-adjustment-store.ts
+var TUNE_DEMOTION_FLOOR = 0.5;
+var TUNE_MAX_STEP = 0.2;
+var TUNE_DECAY_WINDOW_MS = 30 * 6e4;
+var TuneAdjustmentStore = class {
+  adjustments = /* @__PURE__ */ new Map();
+  /**
+   * Apply a bounded demotion to `cli`. `magnitude` is the requested reduction
+   * (capped to {@link TUNE_MAX_STEP}); compounds on any current (decayed) value
+   * but never below {@link TUNE_DEMOTION_FLOOR}. Non-positive magnitudes are a
+   * no-op. Returns the resulting adjustment (or undefined for a no-op).
+   */
+  demote(cli, magnitude, reason) {
+    if (magnitude <= 0) return void 0;
+    const step = Math.min(TUNE_MAX_STEP, magnitude);
+    const current = this.effectiveMultiplier(cli);
+    const next = Math.max(TUNE_DEMOTION_FLOOR, current - step);
+    const adjustment = {
+      cli,
+      multiplier: next,
+      appliedAt: getTimeProvider().now(),
+      reason
+    };
+    this.adjustments.set(cli, adjustment);
+    return adjustment;
+  }
+  /**
+   * Current effective multiplier for `cli` — the stored multiplier decayed
+   * linearly back toward 1.0 over {@link TUNE_DECAY_WINDOW_MS}. Returns 1.0
+   * (no effect) when there is no active adjustment. Fully-decayed entries are
+   * evicted lazily.
+   */
+  effectiveMultiplier(cli) {
+    const adjustment = this.adjustments.get(cli);
+    if (adjustment === void 0) return 1;
+    const elapsed = getTimeProvider().now() - adjustment.appliedAt;
+    if (elapsed >= TUNE_DECAY_WINDOW_MS || elapsed < 0) {
+      this.adjustments.delete(cli);
+      return 1;
+    }
+    const decayFraction = elapsed / TUNE_DECAY_WINDOW_MS;
+    return adjustment.multiplier + (1 - adjustment.multiplier) * decayFraction;
+  }
+  /** Snapshot of active (non-evicted) adjustments — for observability/audit. */
+  list() {
+    return [...this.adjustments.values()];
+  }
+  /** Remove all adjustments. */
+  clear() {
+    this.adjustments.clear();
+  }
+};
+var singleton;
+function getTuneAdjustmentStore() {
+  singleton ??= new TuneAdjustmentStore();
+  return singleton;
+}
+
 // src/core/step-events.ts
 var STEP_SUMMARY_MAX_LEN = 120;
 function truncateSummary(s) {
@@ -8178,18 +8410,18 @@ function groupBy(outcomes, keyFn) {
 var logger7 = createLogger({ component: "EventBus" });
 var DEFAULT_MAX_BUFFER = 1e4;
 var EventBus = class {
-  buffer = [];
-  maxBuffer;
+  buffer;
   subs = [];
   emitCount = 0;
   constructor(options) {
-    this.maxBuffer = options?.maxBufferSize ?? DEFAULT_MAX_BUFFER;
+    const maxBuffer = Math.max(1, options?.maxBufferSize ?? DEFAULT_MAX_BUFFER);
+    this.buffer = new CircularBuffer(maxBuffer);
   }
   get totalEmitted() {
     return this.emitCount;
   }
   get bufferSize() {
-    return this.buffer.length;
+    return this.buffer.size;
   }
   /** Number of active subscriptions (for observability/testing). */
   get subscriptionCount() {
@@ -8209,7 +8441,7 @@ var EventBus = class {
     };
   }
   query(filter, limit) {
-    let results = this.buffer.filter((e) => matchesFilter(e, filter));
+    let results = this.buffer.toArray().filter((e) => matchesFilter(e, filter));
     if (limit !== void 0) {
       results = results.slice(0, limit);
     }
@@ -8219,9 +8451,6 @@ var EventBus = class {
   // Internal
   // ==========================================================================
   addToBuffer(event) {
-    if (this.buffer.length >= this.maxBuffer) {
-      this.buffer.shift();
-    }
     this.buffer.push(event);
   }
   notifySubscribers(event) {
@@ -8669,6 +8898,130 @@ async function fetchCapacityData(adapters) {
   return result;
 }
 
+// src/config/defaults-env.ts
+function parseIntEnv(envKey, fallback) {
+  const envValue = process.env[envKey];
+  if (envValue === void 0) {
+    return fallback;
+  }
+  const parsed = parseInt(envValue, 10);
+  return isNaN(parsed) || parsed <= 0 ? fallback : parsed;
+}
+function parseFloatEnv(envKey, fallback) {
+  const envValue = process.env[envKey];
+  if (envValue === void 0) {
+    return fallback;
+  }
+  const parsed = parseFloat(envValue);
+  return isNaN(parsed) || !isFinite(parsed) ? fallback : parsed;
+}
+function parseBoolEnv(envKey, fallback) {
+  const envValue = process.env[envKey]?.toLowerCase();
+  if (envValue === void 0) {
+    return fallback;
+  }
+  if (envValue === "true" || envValue === "1") return true;
+  if (envValue === "false" || envValue === "0") return false;
+  return fallback;
+}
+function createGetTimeout(timeoutDefaults) {
+  return (key) => {
+    const envKey = `NEXUS_TIMEOUT_${key.replace(/Ms$/, "").toUpperCase()}`;
+    return parseIntEnv(envKey, timeoutDefaults[key]);
+  };
+}
+function createGetRetryConfig(retryDefaults) {
+  return () => {
+    return {
+      maxRetries: parseIntEnv("NEXUS_RETRY_MAX_RETRIES", retryDefaults.maxRetries),
+      baseDelayMs: parseIntEnv("NEXUS_RETRY_BASE_DELAY", retryDefaults.baseDelayMs),
+      maxDelayMs: parseIntEnv("NEXUS_RETRY_MAX_DELAY", retryDefaults.maxDelayMs),
+      jitterFactor: parseFloatEnv("NEXUS_RETRY_JITTER", retryDefaults.jitterFactor)
+    };
+  };
+}
+function createGetRateLimitConfig(rateLimitDefaults) {
+  return () => {
+    return {
+      requestsPerMinute: parseIntEnv("NEXUS_RATE_LIMIT_RPM", rateLimitDefaults.requestsPerMinute),
+      enabled: parseBoolEnv("NEXUS_RATE_LIMIT_ENABLED", rateLimitDefaults.enabled),
+      maxConcurrent: parseIntEnv(
+        "NEXUS_RATE_LIMIT_MAX_CONCURRENT",
+        rateLimitDefaults.maxConcurrent
+      ),
+      capacity: parseIntEnv("NEXUS_RATE_LIMIT_CAPACITY", rateLimitDefaults.capacity),
+      refillRate: parseIntEnv("NEXUS_RATE_LIMIT_REFILL_RATE", rateLimitDefaults.refillRate),
+      refillIntervalMs: parseIntEnv(
+        "NEXUS_RATE_LIMIT_REFILL_INTERVAL",
+        rateLimitDefaults.refillIntervalMs
+      )
+    };
+  };
+}
+function createGetCircuitBreakerConfig(cbDefaults) {
+  return () => {
+    return {
+      failureThreshold: parseIntEnv("NEXUS_CIRCUIT_BREAKER_THRESHOLD", cbDefaults.failureThreshold),
+      resetTimeoutMs: parseIntEnv("NEXUS_CIRCUIT_BREAKER_RESET_TIMEOUT", cbDefaults.resetTimeoutMs),
+      halfOpenSuccessThreshold: cbDefaults.halfOpenSuccessThreshold,
+      countTimeoutsAsFailures: cbDefaults.countTimeoutsAsFailures,
+      countAuthFailuresAsFailures: cbDefaults.countAuthFailuresAsFailures,
+      countRateLimitsAsFailures: cbDefaults.countRateLimitsAsFailures,
+      halfOpenMaxRequests: cbDefaults.halfOpenMaxRequests
+    };
+  };
+}
+function createGetToolRateLimit(toolRateLimits) {
+  return (tool) => {
+    return toolRateLimits[tool];
+  };
+}
+function createGetEnvVarDocumentation(defaults) {
+  return () => {
+    const t = defaults.TIMEOUT_DEFAULTS;
+    const r = defaults.RATE_LIMIT_DEFAULTS;
+    const rt = defaults.RETRY_DEFAULTS;
+    const cb = defaults.CIRCUIT_BREAKER_DEFAULTS;
+    return `# Environment Variable Overrides
+
+All defaults can be overridden via environment variables using the NEXUS_ prefix.
+
+## Timeouts
+
+| Variable | Default | Description |
+| -------- | ------- | ----------- |
+| NEXUS_TIMEOUT_CLI | ${String(t.cliMs)} | CLI execution timeout (ms) |
+| NEXUS_TIMEOUT_API | ${String(t.apiMs)} | API request timeout (ms) |
+| NEXUS_TIMEOUT_WORKFLOW | ${String(t.workflowMs)} | Workflow timeout (ms) |
+| NEXUS_TIMEOUT_MCP | ${String(t.mcpMs)} | MCP operation timeout (ms) |
+
+## Rate Limits
+
+| Variable | Default | Description |
+| -------- | ------- | ----------- |
+| NEXUS_RATE_LIMIT_RPM | ${String(r.requestsPerMinute)} | Requests per minute |
+| NEXUS_RATE_LIMIT_ENABLED | ${String(r.enabled)} | Enable rate limiting |
+| NEXUS_RATE_LIMIT_CAPACITY | ${String(r.capacity)} | Token bucket capacity |
+
+## Retries
+
+| Variable | Default | Description |
+| -------- | ------- | ----------- |
+| NEXUS_RETRY_MAX_RETRIES | ${String(rt.maxRetries)} | Maximum retry attempts |
+| NEXUS_RETRY_BASE_DELAY | ${String(rt.baseDelayMs)} | Base delay (ms) |
+| NEXUS_RETRY_MAX_DELAY | ${String(rt.maxDelayMs)} | Maximum delay (ms) |
+| NEXUS_RETRY_JITTER | ${String(rt.jitterFactor)} | Jitter factor (0-1) |
+
+## Circuit Breaker
+
+| Variable | Default | Description |
+| -------- | ------- | ----------- |
+| NEXUS_CIRCUIT_BREAKER_THRESHOLD | ${String(cb.failureThreshold)} | Failure threshold |
+| NEXUS_CIRCUIT_BREAKER_RESET_TIMEOUT | ${String(cb.resetTimeoutMs)} | Reset timeout (ms) |
+`;
+  };
+}
+
 // src/mcp/tools/weather-report-types.ts
 import { z as z12 } from "zod";
 var WeatherReportInputSchema = z12.object({
@@ -10474,7 +10827,7 @@ async function runScoringStages(task, candidates, stagesExecuted, deps) {
     candidates: filtered
   };
 }
-function aggregateStageScores(scoring, taskContent) {
+function aggregateStageScores(scoring, taskContent, candidates) {
   const weatherScores = getWeatherBonusForTask(taskContent);
   return mergeScoreMaps(
     scoring.cascadeResult.scores,
@@ -10482,9 +10835,23 @@ function aggregateStageScores(scoring, taskContent) {
     scoring.knnResult.scores,
     scoring.distilledResult.scores,
     scoring.resourceResult.scores,
-    weatherScores
+    weatherScores,
+    getTuneAdjustmentScores(candidates)
   );
 }
+var TUNE_ENFORCE_ENV = "NEXUS_TUNE_ENFORCE";
+function getTuneAdjustmentScores(candidates) {
+  const scores = /* @__PURE__ */ new Map();
+  if (!parseBoolEnv(TUNE_ENFORCE_ENV, false)) return scores;
+  const store = getTuneAdjustmentStore();
+  for (const cli of candidates) {
+    const multiplier = store.effectiveMultiplier(cli);
+    if (multiplier < 1) {
+      scores.set(cli, -(1 - multiplier) * 10);
+    }
+  }
+  return scores;
+}
 function getWeatherBonusForTask(taskContent) {
   try {
     const match = detectTaskCategory(taskContent);
@@ -10562,7 +10929,7 @@ async function runPipeline(task, taskProfile, stagesExecuted, cliNames, deps) {
   const overrideResult = applyCategoryOverride(task, candidates, stagesExecuted);
   if (!overrideResult.ok) return overrideResult;
   candidates = overrideResult.value;
-  const stageScores = aggregateStageScores(scoring, task.content);
+  const stageScores = aggregateStageScores(scoring, task.content, candidates);
   const topsisOpts = {
     performanceData: getPerformanceDataForCategory(task.content)
   };
@@ -10707,13 +11074,26 @@ function hasMinimumPreferenceData(deps) {
 }
 var QUALITY_HISTORY_LIMIT = 20;
 var MAX_LATENCY_MS = 3e4;
+var QUALITY_RATE_CACHE_TTL_MS = 15e3;
+var qualityRateCache = /* @__PURE__ */ new Map();
+function getCachedCliSuccessRate(cli) {
+  const now = getTimeProvider().now();
+  const cached = qualityRateCache.get(cli);
+  if (cached !== void 0 && now - cached.computedAt < QUALITY_RATE_CACHE_TTL_MS) {
+    return cached.rate;
+  }
+  const recent = getOutcomeStore().query({ cli, limit: QUALITY_HISTORY_LIMIT });
+  if (recent.length === 0) return void 0;
+  const rate = recent.filter((o) => o.success).length / recent.length;
+  qualityRateCache.set(cli, { rate, computedAt: now });
+  return rate;
+}
 function computeQualityReward(cli, success, durationMs2) {
   if (!success) return 0.1;
   let reward = 0.5;
   try {
-    const recent = getOutcomeStore().query({ cli, limit: QUALITY_HISTORY_LIMIT });
-    if (recent.length > 0) {
-      const rate = recent.filter((o) => o.success).length / recent.length;
+    const rate = getCachedCliSuccessRate(cli);
+    if (rate !== void 0) {
       reward += rate * 0.3;
     }
   } catch (error) {
@@ -11008,7 +11388,7 @@ var CompositeRouter = class _CompositeRouter {
    */
   async consultUnifiedContext(task) {
     try {
-      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-5BJYPAX7.js");
+      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-JM564MOV.js");
       const ctx = await getContextForTask({
         task: task.content,
         category: inferTaskCategory(task.content),
@@ -12154,7 +12534,10 @@ export {
   unwrapOr,
   extractJsonArray,
   extractJsonObject,
+  CircularBuffer,
+  BoundedLRUCache,
   getTimeProvider,
+  getTuneAdjustmentStore,
   withStep,
   sanitize,
   setGlobalLogLevel,
@@ -12279,6 +12662,13 @@ export {
   CompositeRouterConfigSchema,
   DEFAULT_COMPOSITE_CONFIG,
   CompositeRoutingError,
+  parseBoolEnv,
+  createGetTimeout,
+  createGetRetryConfig,
+  createGetRateLimitConfig,
+  createGetCircuitBreakerConfig,
+  createGetToolRateLimit,
+  createGetEnvVarDocumentation,
   WeatherReportInputSchema,
   SECURITY_KEYWORDS,
   ARCHITECTURE_KEYWORDS,
@@ -12329,4 +12719,4 @@ export {
   ParseError,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-L5BXCSMP.js.map
+//# sourceMappingURL=chunk-OT6V5ROA.js.map