nexus-agents 3.8.2 → 3.8.3

package/dist/{chunk-TSCF7SCI.js → chunk-RWMQ3YJW.js}

@@ -2623,7 +2623,7 @@ function setDefaultRegistry(registry) {
 }
 async function reloadDefaultRegistry() {
   globalRegistry = buildDefaultRegistry();
-  const { resetGlobalRegistry } = await import("./unified-registry-2JCOLE4F.js");
+  const { resetGlobalRegistry } = await import("./unified-registry-SGS73VVW.js");
   resetGlobalRegistry();
   return globalRegistry;
 }
@@ -11188,27 +11188,86 @@ function isRateLimitText(text) {
 function isRateLimitLikeError(error) {
   return isRateLimitText(getErrorMessage(error));
 }
+var RETRY_HINT_PATTERNS = [
+  // "retry after X seconds" / "retry-after: X sec"
+  { pattern: /retry[- ]?after[:\s]+(\d+(?:\.\d+)?)\s*(?:s|sec)/i, msPerUnit: 1e3 },
+  // "retry after X ms" / "wait X milliseconds"
+  { pattern: /(?:retry[- ]?after|wait)[:\s]+(\d+)\s*(?:ms|millisecond)/i, msPerUnit: 1 },
+  // "try again in X seconds" — the OpenAI family's phrasing.
+  { pattern: /try again in (\d+(?:\.\d+)?)\s*(?:s|sec)/i, msPerUnit: 1e3 },
+  // #4606: the sub-second variant. The rule above cannot match "try again in
+  // 632ms" — `632` is followed by `m`, not `s` — so the OpenAI family silently
+  // lost every horizon shorter than a second.
+  { pattern: /try again in (\d+(?:\.\d+)?)\s*ms\b/i, msPerUnit: 1 },
+  // #4606: Gemini states its horizon only as google.rpc.RetryInfo inside the
+  // response body, and `@google/genai` stringifies that whole body into the
+  // error message (its `ApiError` carries `{message, status}` and no headers),
+  // so this is the only place the horizon is reachable on that vendor.
+  { pattern: /"retrydelay"\s*:\s*"(\d+(?:\.\d+)?)s"/i, msPerUnit: 1e3 }
+];
 function parseRetryAfterMs(errorMessage) {
   const lower = errorMessage.toLowerCase();
-  const secondsMatch = /retry[- ]?after[:\s]+(\d+(?:\.\d+)?)\s*(?:s|sec)/i.exec(lower);
-  if (secondsMatch !== null) {
-    const parsed = parseFloat(secondsMatch[1] ?? "0");
-    return Math.ceil(parsed * 1e3);
+  for (const { pattern, msPerUnit } of RETRY_HINT_PATTERNS) {
+    const match = pattern.exec(lower);
+    const captured = match?.[1];
+    if (captured !== void 0) {
+      return Math.ceil(Number.parseFloat(captured) * msPerUnit);
+    }
   }
-  const msMatch = /(?:retry[- ]?after|wait)[:\s]+(\d+)\s*(?:ms|millisecond)/i.exec(lower);
-  if (msMatch !== null) {
-    return parseInt(msMatch[1] ?? "0", 10);
+  return void 0;
+}
+var RETRY_AFTER_HEADER = "retry-after";
+var HEADER_BAG_FIELDS = ["headers", "responseHeaders"];
+var MAX_CAUSE_DEPTH = 3;
+var HTTP_DATE_PREFIX = /^(?:mon|tue|wed|thu|fri|sat|sun)/i;
+function parseRetryAfterHeader(value) {
+  if (value === null || value === void 0) return void 0;
+  const trimmed = value.trim();
+  if (trimmed === "") return void 0;
+  if (/^\d+$/.test(trimmed)) {
+    return Number.parseInt(trimmed, 10) * 1e3;
+  }
+  if (!HTTP_DATE_PREFIX.test(trimmed)) return void 0;
+  const at = Date.parse(trimmed);
+  if (Number.isNaN(at)) return void 0;
+  return Math.max(0, at - getTimeProvider().now());
+}
+function readRetryAfterField(bag) {
+  if (bag === null || typeof bag !== "object") return void 0;
+  const getter = bag.get;
+  if (typeof getter === "function") {
+    const raw = bag.get(RETRY_AFTER_HEADER);
+    return typeof raw === "string" ? raw : void 0;
+  }
+  for (const [key, val] of Object.entries(bag)) {
+    if (key.toLowerCase() === RETRY_AFTER_HEADER && typeof val === "string") return val;
   }
-  const againMatch = /try again in (\d+(?:\.\d+)?)\s*(?:s|sec)/i.exec(lower);
-  if (againMatch !== null) {
-    const parsed = parseFloat(againMatch[1] ?? "0");
-    return Math.ceil(parsed * 1e3);
+  return void 0;
+}
+function extractRetryAfterMs(error) {
+  let current = error;
+  for (let depth = 0; depth <= MAX_CAUSE_DEPTH; depth++) {
+    if (current === null || typeof current !== "object") return void 0;
+    const obj = current;
+    for (const field of HEADER_BAG_FIELDS) {
+      const parsed = parseRetryAfterHeader(readRetryAfterField(obj[field]));
+      if (parsed !== void 0) return parsed;
+    }
+    current = obj["cause"];
   }
   return void 0;
 }
+var RETRY_AFTER_CONTEXT_KEY = "retryAfterMs";
+function retryAfterMsFromContext(context) {
+  const raw = context?.[RETRY_AFTER_CONTEXT_KEY];
+  return typeof raw === "number" && Number.isFinite(raw) && raw >= 0 ? raw : void 0;
+}
+function resolveRetryAfterMs(error, message) {
+  return extractRetryAfterMs(error) ?? parseRetryAfterMs(message);
+}
 function toRateLimitError(error, provider) {
   const message = getErrorMessage(error);
-  const retryAfterMs = parseRetryAfterMs(message);
+  const retryAfterMs = resolveRetryAfterMs(error, message);
   return new RateLimitError(message, {
     ...retryAfterMs !== void 0 ? { retryAfterMs } : {},
     ...provider !== void 0 ? { provider } : {},
@@ -14776,7 +14835,7 @@ var CompositeRouter = class _CompositeRouter {
    */
   async consultUnifiedContext(task) {
     try {
-      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-CD4M2XZI.js");
+      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-LICMS4FY.js");
       const ctx = await getContextForTask({
         task: task.content,
         category: inferTaskCategory(task.content),
@@ -16230,6 +16289,9 @@ export {
   isRateLimitText,
   isRateLimitLikeError,
   parseRetryAfterMs,
+  RETRY_AFTER_CONTEXT_KEY,
+  retryAfterMsFromContext,
+  resolveRetryAfterMs,
   toRateLimitError,
   recordRateLimitEvent,
   getFallbackChainForCategory,
@@ -16362,4 +16424,4 @@ export {
   AgentCapability,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-TSCF7SCI.js.map
+//# sourceMappingURL=chunk-RWMQ3YJW.js.map