@robzilla1738/agentswarm 0.2.0 → 0.5.0

package/dist/deepseek.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CancelledError = exports.ApiError = void 0;
+exports.CallGate = exports.CancelledError = exports.ApiError = void 0;
+exports.gateFor = gateFor;
 exports.chat = chat;
 exports.isFatalAuthError = isFatalAuthError;
 exports.validateAuth = validateAuth;
@@ -13,10 +14,13 @@ function providerOf(cfg) {
 class ApiError extends Error {
     status;
     body;
-    constructor(status, body) {
+    /** Parsed Retry-After (ms) when the server sent one with a 429. */
+    retryAfterMs;
+    constructor(status, body, retryAfterMs) {
         super(`API ${status}: ${body.slice(0, 600)}`);
         this.status = status;
         this.body = body;
+        this.retryAfterMs = retryAfterMs;
     }
 }
 exports.ApiError = ApiError;
@@ -66,25 +70,135 @@ function sanitizeMessages(messages, thinking) {
     });
 }
 /**
- * One streaming chat-completions call with retries. Streams deltas (text and
- * reasoning), accumulates tool calls, captures usage from the final chunk.
+ * Bounds concurrent streaming calls per provider endpoint so a 100-agent swarm
+ * doesn't turn into a 429 storm. AIMD: a 429 halves the ceiling (min 2) and
+ * imposes the server's Retry-After as a cool-down; sustained successes recover
+ * it additively back toward the configured max. Two-tier FIFO: "high" priority
+ * (conductor/orchestration) jumps ahead so queued workers can't starve the
+ * brain of the swarm.
+ */
+class CallGate {
+    max;
+    ceiling;
+    active = 0;
+    high = [];
+    low = [];
+    successes = 0;
+    cooldownUntil = 0;
+    onState;
+    constructor(max) {
+        this.max = Math.max(1, max);
+        this.ceiling = this.max;
+    }
+    state() {
+        return { ceiling: this.ceiling, active: this.active, queued: this.high.length + this.low.length };
+    }
+    configure(max) {
+        this.max = Math.max(1, max);
+        if (this.ceiling > this.max)
+            this.ceiling = this.max;
+        this.pump();
+    }
+    async acquire(priority, signal) {
+        const wait = this.cooldownUntil - Date.now();
+        if (wait > 0)
+            await (0, util_1.sleep)(wait);
+        if (signal?.aborted)
+            throw new CancelledError();
+        if (this.active < this.ceiling) {
+            this.active++;
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            const queue = priority === "high" ? this.high : this.low;
+            const entry = () => {
+                signal?.removeEventListener("abort", onAbort);
+                resolve();
+            };
+            const onAbort = () => {
+                const i = queue.indexOf(entry);
+                if (i >= 0)
+                    queue.splice(i, 1);
+                reject(new CancelledError());
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+            queue.push(entry);
+        });
+    }
+    release() {
+        this.active = Math.max(0, this.active - 1);
+        this.pump();
+    }
+    reportRateLimit(retryAfterMs) {
+        this.ceiling = Math.max(2, Math.floor(this.ceiling / 2));
+        this.successes = 0;
+        if (retryAfterMs && retryAfterMs > 0) {
+            this.cooldownUntil = Math.max(this.cooldownUntil, Date.now() + Math.min(retryAfterMs, 60_000));
+        }
+        this.onState?.(this.state());
+    }
+    reportSuccess() {
+        if (this.ceiling >= this.max)
+            return;
+        if (++this.successes >= 10) {
+            this.successes = 0;
+            this.ceiling++;
+            this.onState?.(this.state());
+            this.pump();
+        }
+    }
+    pump() {
+        while (this.active < this.ceiling) {
+            const next = this.high.shift() ?? this.low.shift();
+            if (!next)
+                break;
+            this.active++;
+            next();
+        }
+    }
+}
+exports.CallGate = CallGate;
+const gates = new Map();
+function gateFor(cfg) {
+    const key = cfg.baseUrl;
+    let g = gates.get(key);
+    if (!g) {
+        g = new CallGate(cfg.maxConcurrentCalls);
+        gates.set(key, g);
+    }
+    g.configure(cfg.maxConcurrentCalls);
+    return g;
+}
+/**
+ * One streaming chat-completions call with retries, behind the global gate.
+ * The retry backoff sleeps OUTSIDE the gate so a waiting call never holds a
+ * concurrency slot.
  */
 async function chat(cfg, o) {
+    const gate = gateFor(cfg);
     let lastErr;
     const attempts = 4;
     for (let i = 0; i < attempts; i++) {
+        await gate.acquire(o.priority ?? "normal", o.signal);
         try {
-            return await chatOnce(cfg, o);
+            const res = await chatOnce(cfg, o);
+            gate.reportSuccess();
+            return res;
         }
         catch (e) {
             lastErr = e;
+            if (e instanceof ApiError && e.status === 429)
+                gate.reportRateLimit(e.retryAfterMs);
             if (!retryable(e) || i === attempts - 1)
                 throw e;
-            const backoff = [1500, 5000, 15000][i] ?? 15000;
-            await (0, util_1.sleep)(backoff + Math.random() * 1000);
-            if (o.signal?.aborted)
-                throw new CancelledError();
         }
+        finally {
+            gate.release();
+        }
+        const backoff = [1500, 5000, 15000][i] ?? 15000;
+        await (0, util_1.sleep)(backoff + Math.random() * 1000);
+        if (o.signal?.aborted)
+            throw new CancelledError();
     }
     throw lastErr;
 }
@@ -149,7 +263,8 @@ async function chatOnce(cfg, o) {
         });
         if (!res.ok) {
             const text = await res.text().catch(() => "");
-            throw new ApiError(res.status, text);
+            const ra = Number(res.headers.get("retry-after"));
+            throw new ApiError(res.status, text, Number.isFinite(ra) && ra >= 0 ? ra * 1000 : undefined);
         }
         if (!res.body)
             throw new ApiError(0, "empty response body");