floe-guard 0.6.0 → 0.8.0

package/dist/index.cjs

@@ -29,7 +29,8 @@ __export(index_exports, {
   budgetGuardMiddleware: () => budgetGuardMiddleware,
   priceTokens: () => priceTokens,
   pricing: () => pricing_exports,
-  resolvePrice: () => resolvePrice
+  resolvePrice: () => resolvePrice,
+  withBudgetRetry: () => withBudgetRetry
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -1480,6 +1481,9 @@ var BudgetGuard = class {
    */
   advisory() {
     const usedBps = this.limitUsd <= 0 ? 1e4 : Math.max(0, Math.min(1e4, Math.floor(this.spentUsd / this.limitUsd * 1e4 + 1e-9)));
+    const remainingUsd = Math.max(0, this.limitUsd - this.spentUsd);
+    const expectedCost = Math.max(this.lastLlmCost, this.lastToolCost);
+    const estCallsRemaining = expectedCost > 0 ? Math.floor(remainingUsd / expectedCost + 1e-9) : null;
     return {
       nearLimit: usedBps >= this.nearLimitBps,
       usedBps,
@@ -1487,10 +1491,12 @@ var BudgetGuard = class {
       // in-flight reservations. Unlike the remainingUsd getter (which subtracts
       // `reserved`), the advisory is a soft utilization signal about money already
       // spent, while the getter reports what a new call can still claim.
-      remainingUsd: Math.max(0, this.limitUsd - this.spentUsd),
+      remainingUsd,
       limitUsd: this.limitUsd,
       spentUsd: this.spentUsd,
-      scope: "local"
+      scope: "local",
+      expectedCost,
+      estCallsRemaining
     };
   }
 };
@@ -1653,6 +1659,42 @@ function budgetGuardMiddleware(guard) {
     }
   };
 }
+
+// src/retry.ts
+function defaultRetryIf(error) {
+  return !(error instanceof BudgetExceeded);
+}
+async function withBudgetRetry(guard, call, options = {}) {
+  const maxAttempts = options.maxAttempts ?? 2;
+  if (!Number.isInteger(maxAttempts) || maxAttempts < 1) {
+    throw new RangeError(`maxAttempts must be an integer >= 1, got ${maxAttempts}`);
+  }
+  const retryIf = options.retryIf ?? defaultRetryIf;
+  let plan = { call, estimatedCost: options.estimatedCost };
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      return await plan.call();
+    } catch (error) {
+      if (attempt >= maxAttempts || !retryIf(error)) {
+        throw error;
+      }
+      plan = await nextPlan(guard, error, plan, options.onDegrade);
+    }
+  }
+  throw new Error("unreachable");
+}
+async function nextPlan(guard, error, current, onDegrade) {
+  const advisory = guard.advisory();
+  if (advisory.nearLimit && onDegrade !== void 0) {
+    const degraded = await onDegrade(error, advisory);
+    if (degraded !== void 0) {
+      guard.check(degraded.estimatedCost);
+      return degraded;
+    }
+  }
+  guard.check(current.estimatedCost);
+  return current;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BudgetExceeded,
@@ -1664,6 +1706,7 @@ function budgetGuardMiddleware(guard) {
   budgetGuardMiddleware,
   priceTokens,
   pricing,
-  resolvePrice
+  resolvePrice,
+  withBudgetRetry
 });
 //# sourceMappingURL=index.cjs.map