@rulvar/core 1.28.0 → 1.29.0

package/dist/index.d.ts

@@ -2465,11 +2465,16 @@ declare const DEFAULT_RETRY_POLICY: RetryPolicy;
 */
 declare function retryClassOf(error: WireError): RetryClass | undefined;
 /**
-* The delay before retry number `retryIndex` (0-based: the delay after
-* the first failed attempt has index 0). A provider-supplied
-* retryAfterMs REPLACES the computed delay (Appendix A). Jitter is
-* equal-jitter: half the backoff is deterministic, half random, so a
-* jittered delay never collapses to zero.
+* The delay before retry number `retryIndex` (zero based: the delay
+* after the first failed attempt has index 0). A VALID provider
+* supplied retryAfterMs (finite and nonnegative) REPLACES the
+* computed delay (Appendix A); anything else (NaN, Infinity, a
+* negative) is ignored as adapter noise and the policy backoff
+* applies, so this boundary stays defensive against custom adapters
+* (v1.28.0 review P2). Jitter is equal jitter: half the backoff is
+* deterministic, half random, so a jittered delay never collapses to
+* zero. The result is always a finite nonnegative integer clamped to
+* the Node timer maximum (2147483647 ms).
 */
 declare function retryDelayMs(policy: RetryPolicy, retryIndex: number, retryAfterMs?: number, random?: () => number): number;
 //#endregion

package/dist/index.js

@@ -7033,18 +7033,35 @@ function retryClassOf(error) {
 	return "transport";
 }
 /**
-* The delay before retry number `retryIndex` (0-based: the delay after
-* the first failed attempt has index 0). A provider-supplied
-* retryAfterMs REPLACES the computed delay (Appendix A). Jitter is
-* equal-jitter: half the backoff is deterministic, half random, so a
-* jittered delay never collapses to zero.
+* The largest delay a Node timer represents exactly (2^31 above that
+* a timer overflows and fires almost immediately); every returned
+* delay is clamped to it so a huge provider value can never turn
+* into an instant retry storm.
+*/
+const MAX_TIMER_DELAY_MS = 2147483647;
+/** Bounds a delay to a finite nonnegative integer a Node timer can honor. */
+function timerSafe(ms) {
+	if (!Number.isFinite(ms) || ms <= 0) return 0;
+	return Math.min(Math.round(ms), MAX_TIMER_DELAY_MS);
+}
+/**
+* The delay before retry number `retryIndex` (zero based: the delay
+* after the first failed attempt has index 0). A VALID provider
+* supplied retryAfterMs (finite and nonnegative) REPLACES the
+* computed delay (Appendix A); anything else (NaN, Infinity, a
+* negative) is ignored as adapter noise and the policy backoff
+* applies, so this boundary stays defensive against custom adapters
+* (v1.28.0 review P2). Jitter is equal jitter: half the backoff is
+* deterministic, half random, so a jittered delay never collapses to
+* zero. The result is always a finite nonnegative integer clamped to
+* the Node timer maximum (2147483647 ms).
 */
 function retryDelayMs(policy, retryIndex, retryAfterMs, random = nativeRandom) {
-	if (retryAfterMs !== void 0) return retryAfterMs;
+	if (retryAfterMs !== void 0 && Number.isFinite(retryAfterMs) && retryAfterMs >= 0) return timerSafe(retryAfterMs);
 	const { initialMs, factor, maxMs, jitter } = policy.backoff;
 	const base = Math.min(maxMs, initialMs * factor ** retryIndex);
-	if (jitter !== true) return base;
-	return base / 2 + random() * (base / 2);
+	if (jitter !== true) return timerSafe(base);
+	return timerSafe(base / 2 + random() * (base / 2));
 }
 //#endregion
 //#region src/model/roles.ts
@@ -8623,14 +8640,70 @@ async function runAgent(options) {
 	};
 	const retryPolicy = options.retry?.policy ?? DEFAULT_RETRY_POLICY;
 	const retryOn = retryPolicy.retryOn ?? DEFAULT_RETRY_POLICY.retryOn ?? [];
-	const retrySleep = options.retry?.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const injectedSleep = options.retry?.sleep;
 	const retryRandom = options.retry?.random ?? Math.random;
+	const abortKind = () => options.budget?.signal?.aborted === true ? "budget" : options.signal?.aborted === true ? "external" : void 0;
+	const abortedOutcome = (aborted) => ({
+		turn: {
+			text: "",
+			toolCalls: []
+		},
+		usage: ZERO_USAGE$1,
+		reported: ZERO_USAGE$1,
+		usageApprox: true,
+		aborted
+	});
+	const backoffWait = async (ms) => {
+		const signals = [];
+		if (options.signal !== void 0) signals.push(options.signal);
+		if (options.budget?.signal !== void 0) signals.push(options.budget.signal);
+		const combined = signals.length === 0 ? void 0 : AbortSignal.any(signals);
+		if (combined?.aborted === true) return;
+		if (injectedSleep === void 0) {
+			await new Promise((resolve) => {
+				let unhook = () => {};
+				const timer = setTimeout(() => {
+					unhook();
+					resolve();
+				}, ms);
+				if (combined !== void 0) {
+					const onAbort = () => {
+						clearTimeout(timer);
+						resolve();
+					};
+					combined.addEventListener("abort", onAbort, { once: true });
+					unhook = () => combined.removeEventListener("abort", onAbort);
+				}
+			});
+			return;
+		}
+		const sleep = Promise.resolve(injectedSleep(ms));
+		if (combined === void 0) {
+			await sleep;
+			return;
+		}
+		let unhook;
+		const wake = new Promise((resolve) => {
+			const onAbort = () => resolve();
+			combined.addEventListener("abort", onAbort, { once: true });
+			unhook = () => combined.removeEventListener("abort", onAbort);
+		});
+		try {
+			await Promise.race([sleep, wake]);
+		} finally {
+			unhook?.();
+			sleep.catch(() => void 0);
+		}
+	};
 	const dispatchPhase = async (site) => {
 		for (;;) {
 			const target = site.chain[site.cursor.index] ?? site.chain[0];
 			let tries = 0;
 			inner: for (;;) {
-				const dispatch = () => streamTurn(target.adapter, site.requestFor(target), site.streamOptionsFor(target));
+				const dispatch = () => {
+					const aborted = abortKind();
+					return aborted === void 0 ? streamTurn(target.adapter, site.requestFor(target), site.streamOptionsFor(target)) : Promise.resolve(abortedOutcome(aborted));
+				};
 				const outcome = await (options.providerSlot === void 0 ? dispatch() : options.providerSlot(target.adapter.id, dispatch));
 				recordUsage(outcome.usage, outcome.reported, target.adapter.id, target.resolved.ref, site.role, outcome.usageViolation);
 				tries += 1;
@@ -8641,6 +8714,11 @@ async function runAgent(options) {
 				};
 				usageApprox = usageApprox || outcome.usageApprox;
 				if (retryOn.includes(retryClass) && tries < retryPolicy.attempts) {
+					const abortedBefore = abortKind();
+					if (abortedBefore !== void 0) return {
+						outcome: abortedOutcome(abortedBefore),
+						target
+					};
 					const retryAfter = (outcome.wireError?.data)?.retryAfterMs;
 					if (outcome.wireError !== void 0) events?.emit({
 						type: "agent:error",
@@ -8649,7 +8727,12 @@ async function runAgent(options) {
 						error: outcome.wireError,
 						willRetry: true
 					});
-					await retrySleep(retryDelayMs(retryPolicy, tries - 1, typeof retryAfter === "number" ? retryAfter : void 0, retryRandom));
+					await backoffWait(retryDelayMs(retryPolicy, tries - 1, typeof retryAfter === "number" ? retryAfter : void 0, retryRandom));
+					const abortedAfter = abortKind();
+					if (abortedAfter !== void 0) return {
+						outcome: abortedOutcome(abortedAfter),
+						target
+					};
 					continue inner;
 				}
 				const trigger = failoverTriggerOf(retryClass);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/core",
-  "version": "1.28.0",
+  "version": "1.29.0",
   "description": "Rulvar core: L0 contracts, journal kernel, ctx primitives, agent runtime, model router, tool system, dynamic orchestrator, InMemory and JSONL stores, event stream.",
   "type": "module",
   "license": "Apache-2.0",