nexus-agents 2.93.0 → 2.94.0

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

@@ -509,6 +509,64 @@ var BoundedLRUCache = class {
   }
 };
 
+// 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) {
@@ -8840,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({
@@ -10645,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,
@@ -10653,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);
@@ -10733,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)
   };
@@ -10878,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) {
@@ -11179,7 +11388,7 @@ var CompositeRouter = class _CompositeRouter {
    */
   async consultUnifiedContext(task) {
     try {
-      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-TZGIETJO.js");
+      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-JM564MOV.js");
       const ctx = await getContextForTask({
         task: task.content,
         category: inferTaskCategory(task.content),
@@ -12328,6 +12537,7 @@ export {
   CircularBuffer,
   BoundedLRUCache,
   getTimeProvider,
+  getTuneAdjustmentStore,
   withStep,
   sanitize,
   setGlobalLogLevel,
@@ -12452,6 +12662,13 @@ export {
   CompositeRouterConfigSchema,
   DEFAULT_COMPOSITE_CONFIG,
   CompositeRoutingError,
+  parseBoolEnv,
+  createGetTimeout,
+  createGetRetryConfig,
+  createGetRateLimitConfig,
+  createGetCircuitBreakerConfig,
+  createGetToolRateLimit,
+  createGetEnvVarDocumentation,
   WeatherReportInputSchema,
   SECURITY_KEYWORDS,
   ARCHITECTURE_KEYWORDS,
@@ -12502,4 +12719,4 @@ export {
   ParseError,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-HKISF2E7.js.map
+//# sourceMappingURL=chunk-OT6V5ROA.js.map