@cjhyy/code-shell-chat 0.9.46 → 0.9.47

package/dist/delivery-queue.d.ts

@@ -7,6 +7,13 @@ export interface DeliveryQueueConfig {
     retryBaseMs: number;
     retryMaxMs: number;
     completedTtlMs: number;
+    /**
+     * Failed attempts during which a retrying record keeps later same-target
+     * messages waiting. Past this, it keeps retrying without holding its target,
+     * so one message that always fails cannot block a conversation forever.
+     * Defaults to {@link DEFAULT_RETRY_HOLD_ATTEMPTS}.
+     */
+    retryHoldAttempts?: number;
     /**
      * Directory for spooled attachment bytes. Defaults to `<path>.attachments`.
      *
@@ -21,6 +28,8 @@ export interface DeliveryQueueConfig {
     /** Largest single attachment to spool. Bigger ones fall back to memory-only. */
     maxSpooledAttachmentBytes?: number;
 }
+/** With default backoff (1s doubling to 30s) this holds a target for about two minutes. */
+export declare const DEFAULT_RETRY_HOLD_ATTEMPTS = 8;
 export interface DeliveryQueueStatus {
     pending: number;
     inFlight: number;

package/dist/delivery-queue.js

@@ -2,6 +2,8 @@ import { randomUUID } from "node:crypto";
 import { constants } from "node:fs";
 import { chmod, lstat, mkdir, open, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
+/** With default backoff (1s doubling to 30s) this holds a target for about two minutes. */
+export const DEFAULT_RETRY_HOLD_ATTEMPTS = 8;
 const MAX_DELIVERY_STATE_BYTES = 64 * 1024 * 1024;
 const MAX_COMPLETED_KEYS = 100_000;
 const MAX_SPOOLED_ATTACHMENTS = 32;
@@ -69,6 +71,11 @@ export class DeliveryQueue {
      */
     async stop() {
         this.stopped = true;
+        // A duplicate must not be acknowledged while the original is still loading
+        // attachments. Wake those waiters without waiting on unbounded media I/O.
+        for (const preparation of this.preparing.values()) {
+            preparation.reject(new Error("Chat Gateway inbox is stopped"));
+        }
         if (this.retryTimer)
             clearTimeout(this.retryTimer);
         this.retryTimer = undefined;
@@ -99,6 +106,8 @@ export class DeliveryQueue {
         let previousPreparation;
         let preparation;
         let releasePreparation;
+        let acceptance;
+        let duplicateAcceptance;
         const reserved = await this.withMutation(async () => {
             if (this.stopped)
                 throw new Error("Chat Gateway inbox is stopped");
@@ -108,14 +117,29 @@ export class DeliveryQueue {
                     // Completed keys persisted before keys named the account cannot say
                     // which account accepted them; stay conservative until they expire.
                     (legacyDedupeKey !== undefined && this.completed.has(legacyDedupeKey)) ||
-                    this.pending.some((entry) => entry.dedupeKey === dedupeKey) ||
-                    [...this.preparing.values()].some((candidate) => candidate === dedupeKey))) {
+                    this.pending.some((entry) => entry.dedupeKey === dedupeKey))) {
                 return false;
             }
+            if (dedupeKey) {
+                const duplicate = [...this.preparing.values()].find((candidate) => candidate.dedupeKey === dedupeKey);
+                if (duplicate) {
+                    duplicateAcceptance = duplicate.accepted;
+                    return false;
+                }
+            }
             if (this.pending.length + this.preparing.size >= this.config.maxPending) {
                 throw new DeliveryBackpressureError(this.config.maxPending);
             }
-            this.preparing.set(id, dedupeKey);
+            let resolve;
+            let reject;
+            const accepted = new Promise((yes, no) => {
+                resolve = yes;
+                reject = no;
+            });
+            // The original enqueue may have no duplicate waiting on this promise.
+            void accepted.catch(() => undefined);
+            acceptance = { dedupeKey, accepted, resolve, reject };
+            this.preparing.set(id, acceptance);
             previousPreparation = this.preparationByTarget.get(target);
             preparation = new Promise((resolve) => {
                 releasePreparation = resolve;
@@ -123,8 +147,11 @@ export class DeliveryQueue {
             this.preparationByTarget.set(target, preparation);
             return true;
         });
-        if (!reserved)
+        if (!reserved) {
+            // Never hold the mutation lock while waiting for the original to persist.
+            await duplicateAcceptance;
             return "duplicate";
+        }
         let spooled;
         let record;
         try {
@@ -154,6 +181,7 @@ export class DeliveryQueue {
                     this.pending.push(record);
                     if (persistent)
                         await this.persist();
+                    acceptance.resolve();
                 }
                 catch (error) {
                     if (record) {
@@ -169,6 +197,7 @@ export class DeliveryQueue {
             });
         }
         catch (error) {
+            acceptance.reject(error);
             this.preparing.delete(id);
             await this.discardSpool(record ?? {
                 id,
@@ -200,11 +229,25 @@ export class DeliveryQueue {
             clearTimeout(this.retryTimer);
         this.retryTimer = undefined;
         const now = Date.now();
+        const holdAttempts = this.config.retryHoldAttempts ?? DEFAULT_RETRY_HOLD_ATTEMPTS;
         while (this.inFlight.size < this.config.maxConcurrent) {
+            const delayedTargets = new Set();
             const entry = this.pending.find((candidate) => {
-                if (this.inFlight.has(candidate.id) || candidate.nextAttemptAt > now)
+                if (this.inFlight.has(candidate.id))
+                    return false;
+                const key = targetKey(candidate.message);
+                if (delayedTargets.has(key))
                     return false;
-                return ((this.targetInFlight.get(targetKey(candidate.message)) ?? 0) < this.config.maxPerTarget);
+                if (candidate.nextAttemptAt > now) {
+                    // Bounded hold: a record that keeps failing stops blocking its
+                    // conversation but stays queued for its own retries.
+                    if (candidate.attempts < holdAttempts)
+                        delayedTargets.add(key);
+                    return false;
+                }
+                // Already-running peers may share a target when configured, but a
+                // queued retry must not be overtaken by later messages for that target.
+                return (this.targetInFlight.get(key) ?? 0) < this.config.maxPerTarget;
             });
             if (!entry)
                 break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-chat",
-  "version": "0.9.46",
+  "version": "0.9.47",
   "description": "A standalone, transport-agnostic multi-channel chat gateway for Node.js and Bun.",
   "type": "module",
   "main": "./dist/index.js",