stitchkit 0.77.0 → 0.78.0

package/dist/index-h4pj6fta.js

@@ -0,0 +1,87 @@
+// src/browser/resumable.ts
+import { z } from "zod";
+var PositiveSafeIntegerSchema = z.number().int().positive().safe();
+var BackoffPolicySchema = z.object({
+  minDelayMs: PositiveSafeIntegerSchema,
+  maxDelayMs: PositiveSafeIntegerSchema,
+  jitter: z.number().min(0).max(1)
+}).strict().readonly().refine((policy) => policy.maxDelayMs >= policy.minDelayMs, {
+  message: "maxDelayMs must be at least minDelayMs"
+});
+function createBackoff(policy, random = Math.random) {
+  const { minDelayMs, maxDelayMs, jitter } = BackoffPolicySchema.parse(policy);
+  let attempt = 0;
+  return {
+    next() {
+      const exponential = Math.min(maxDelayMs, minDelayMs * 2 ** attempt);
+      attempt += 1;
+      const spread = exponential * jitter * random();
+      return Math.max(1, Math.round(exponential - spread));
+    },
+    reset() {
+      attempt = 0;
+    }
+  };
+}
+var DEFAULT_RETRY = { minDelayMs: 100, maxDelayMs: 30000, jitter: 0.5 };
+
+class ResumableAbortError extends Error {
+  constructor() {
+    super("Resumable iterator was aborted");
+    this.name = "ResumableAbortError";
+  }
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      reject(new ResumableAbortError);
+    }
+    if (signal?.aborted) {
+      clearTimeout(timer);
+      reject(new ResumableAbortError);
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function* resumableIterator(config) {
+  const backoff = createBackoff(config.retry ?? DEFAULT_RETRY, config.random);
+  let cursor;
+  let attempt = 0;
+  for (;; ) {
+    if (config.signal?.aborted)
+      return;
+    try {
+      const source = await config.open(cursor);
+      for await (const item of source) {
+        if (config.signal?.aborted)
+          return;
+        attempt = 0;
+        backoff.reset();
+        cursor = config.advance(item, cursor);
+        yield item;
+        if (config.isTerminal?.(item))
+          return;
+      }
+      throw new Error("Resumable source ended without a terminal item");
+    } catch (error) {
+      if (config.signal?.aborted || error instanceof ResumableAbortError)
+        return;
+      attempt += 1;
+      const delayMs = backoff.next();
+      config.onAttempt?.({ number: attempt, delayMs, error });
+      try {
+        await sleep(delayMs, config.signal);
+      } catch {
+        return;
+      }
+    }
+  }
+}
+
+export { BackoffPolicySchema, createBackoff, resumableIterator };

package/dist/{index-jqtsc9mj.js → index-j6mfaw26.js}

@@ -1,10 +1,10 @@
 import {
   collectTools,
   createToolRunner
-} from "./index-7qy2ex0m.js";
+} from "./index-cwp38wxn.js";
 import {
   toolErrorFromResult
-} from "./index-s4c8wy8m.js";
+} from "./index-qaajjfp6.js";
 import {
   assertUniqueToolName
 } from "./index-22by16v6.js";