chat 4.20.2 → 4.22.0

package/dist/index.js

@@ -131,7 +131,7 @@ async function toAiMessages(messages, options) {
     filtered.map(async (msg) => {
       const role = msg.author.isMe ? "assistant" : "user";
       let textContent = includeNames && role === "user" ? `[${msg.author.userName}]: ${msg.text}` : msg.text;
-      if (msg.links.length > 0) {
+      if (msg.links && msg.links.length > 0) {
         const linkParts = msg.links.map((link2) => {
           const parts = link2.fetchMessage ? [`[Embedded message: ${link2.url}]`] : [link2.url];
           if (link2.title) {
@@ -153,7 +153,7 @@ ${linkParts}`;
       let aiMessage;
       if (role === "user") {
         const attachmentParts = [];
-        for (const att of msg.attachments) {
+        for (const att of msg.attachments ?? []) {
           const part = await attachmentToPart(att);
           if (part) {
             attachmentParts.push(part);
@@ -236,7 +236,7 @@ async function* fromFullStream(stream) {
       needsSeparator = false;
       hasEmittedText = true;
       yield textContent;
-    } else if (typed.type === "step-finish") {
+    } else if (typed.type === "finish-step") {
       needsSeparator = true;
     }
   }
@@ -1766,6 +1766,9 @@ function extractMessageContent2(message) {
 
 // src/chat.ts
 var DEFAULT_LOCK_TTL_MS = 3e4;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 var SLACK_USER_ID_REGEX = /^U[A-Z0-9]+$/i;
 var DISCORD_SNOWFLAKE_REGEX = /^\d{17,19}$/;
 var DEDUPE_TTL_MS = 5 * 60 * 1e3;
@@ -1810,6 +1813,9 @@ var Chat = class {
   _dedupeTtlMs;
   _onLockConflict;
   _messageHistory;
+  _concurrencyStrategy;
+  _concurrencyConfig;
+  _lockScope;
   mentionHandlers = [];
   directMessageHandlers = [];
   messagePatterns = [];
@@ -1840,6 +1846,38 @@ var Chat = class {
     this._fallbackStreamingPlaceholderText = config.fallbackStreamingPlaceholderText !== void 0 ? config.fallbackStreamingPlaceholderText : "...";
     this._dedupeTtlMs = config.dedupeTtlMs ?? DEDUPE_TTL_MS;
     this._onLockConflict = config.onLockConflict;
+    this._lockScope = config.lockScope;
+    const concurrency = config.concurrency;
+    if (concurrency) {
+      if (typeof concurrency === "string") {
+        this._concurrencyStrategy = concurrency;
+        this._concurrencyConfig = {
+          debounceMs: 1500,
+          maxConcurrent: Number.POSITIVE_INFINITY,
+          maxQueueSize: 10,
+          onQueueFull: "drop-oldest",
+          queueEntryTtlMs: 9e4
+        };
+      } else {
+        this._concurrencyStrategy = concurrency.strategy;
+        this._concurrencyConfig = {
+          debounceMs: concurrency.debounceMs ?? 1500,
+          maxConcurrent: concurrency.maxConcurrent ?? Number.POSITIVE_INFINITY,
+          maxQueueSize: concurrency.maxQueueSize ?? 10,
+          onQueueFull: concurrency.onQueueFull ?? "drop-oldest",
+          queueEntryTtlMs: concurrency.queueEntryTtlMs ?? 9e4
+        };
+      }
+    } else {
+      this._concurrencyStrategy = "drop";
+      this._concurrencyConfig = {
+        debounceMs: 1500,
+        maxConcurrent: Number.POSITIVE_INFINITY,
+        maxQueueSize: 10,
+        onQueueFull: "drop-oldest",
+        queueEntryTtlMs: 9e4
+      };
+    }
     this._messageHistory = new MessageHistoryCache(
       this._stateAdapter,
       config.messageHistory
@@ -1907,6 +1945,22 @@ var Chat = class {
    */
   async shutdown() {
     this.logger.info("Shutting down chat instance...");
+    const shutdownPromises = Array.from(this.adapters.values()).map(
+      async (adapter) => {
+        if (!adapter.disconnect) {
+          return;
+        }
+        this.logger.debug("Disconnecting adapter", adapter.name);
+        await adapter.disconnect();
+        this.logger.debug("Adapter disconnected", adapter.name);
+      }
+    );
+    const results = await Promise.allSettled(shutdownPromises);
+    for (const result of results) {
+      if (result.status === "rejected") {
+        this.logger.error("Adapter disconnect failed", result.reason);
+      }
+    }
     await this._stateAdapter.disconnect();
     this.initialized = false;
     this.initPromise = null;
@@ -2755,6 +2809,27 @@ var Chat = class {
       "UNKNOWN_USER_ID_FORMAT"
     );
   }
+  /**
+   * Resolve the lock key for a message based on lock scope.
+   * With 'thread' scope, returns threadId. With 'channel' scope,
+   * returns channelId (derived via adapter.channelIdFromThreadId).
+   */
+  async getLockKey(adapter, threadId) {
+    const channelId = adapter.channelIdFromThreadId(threadId);
+    let scope;
+    if (typeof this._lockScope === "function") {
+      const isDM = adapter.isDM?.(threadId) ?? false;
+      scope = await this._lockScope({
+        adapter,
+        channelId,
+        isDM,
+        threadId
+      });
+    } else {
+      scope = this._lockScope ?? adapter.lockScope ?? "thread";
+    }
+    return scope === "channel" ? channelId : threadId;
+  }
   /**
    * Handle an incoming message from an adapter.
    * This is called by adapters when they receive a webhook.
@@ -2763,7 +2838,7 @@ var Chat = class {
    * - Deduplication: Same message may arrive multiple times (e.g., Slack sends
    *   both `message` and `app_mention` events, GChat sends direct webhook + Pub/Sub)
    * - Bot filtering: Messages from the bot itself are skipped
-   * - Locking: Only one instance processes a thread at a time
+   * - Concurrency: Controlled by `concurrency` config (drop, queue, debounce, concurrent)
    */
   async handleIncomingMessage(adapter, threadId, message) {
     this.logger.debug("Incoming message", {
@@ -2805,103 +2880,312 @@ var Chat = class {
       }
       await Promise.all(appends);
     }
+    const lockKey = await this.getLockKey(adapter, threadId);
+    const strategy = this._concurrencyStrategy;
+    if (strategy === "concurrent") {
+      await this.handleConcurrent(adapter, threadId, message);
+      return;
+    }
+    if (strategy === "queue" || strategy === "debounce") {
+      await this.handleQueueOrDebounce(
+        adapter,
+        threadId,
+        lockKey,
+        message,
+        strategy
+      );
+      return;
+    }
+    await this.handleDrop(adapter, threadId, lockKey, message);
+  }
+  /**
+   * Drop strategy: acquire lock or fail. Original behavior.
+   */
+  async handleDrop(adapter, threadId, lockKey, message) {
     let lock = await this._stateAdapter.acquireLock(
-      threadId,
+      lockKey,
       DEFAULT_LOCK_TTL_MS
     );
     if (!lock) {
       const resolution = typeof this._onLockConflict === "function" ? await this._onLockConflict(threadId, message) : this._onLockConflict ?? "drop";
       if (resolution === "force") {
-        this.logger.info("Force-releasing lock on thread", { threadId });
-        await this._stateAdapter.forceReleaseLock(threadId);
-        lock = await this._stateAdapter.acquireLock(
+        this.logger.info("Force-releasing lock on thread", {
           threadId,
+          lockKey
+        });
+        await this._stateAdapter.forceReleaseLock(lockKey);
+        lock = await this._stateAdapter.acquireLock(
+          lockKey,
           DEFAULT_LOCK_TTL_MS
         );
       }
       if (!lock) {
-        this.logger.warn("Could not acquire lock on thread", { threadId });
+        this.logger.warn("Could not acquire lock on thread", {
+          threadId,
+          lockKey
+        });
         throw new LockError(
           `Could not acquire lock on thread ${threadId}. Another instance may be processing.`
         );
       }
     }
-    this.logger.debug("Lock acquired", { threadId, token: lock.token });
+    this.logger.debug("Lock acquired", {
+      threadId,
+      lockKey,
+      token: lock.token
+    });
     try {
-      message.isMention = message.isMention || this.detectMention(adapter, message);
-      const isSubscribed = await this._stateAdapter.isSubscribed(threadId);
-      this.logger.debug("Subscription check", {
-        threadId,
-        isSubscribed,
-        subscribedHandlerCount: this.subscribedMessageHandlers.length
-      });
-      const thread = await this.createThread(
-        adapter,
-        threadId,
-        message,
-        isSubscribed
-      );
-      const isDM = adapter.isDM?.(threadId) ?? false;
-      if (isDM && this.directMessageHandlers.length > 0) {
-        this.logger.debug("Direct message received - calling handlers", {
+      await this.dispatchToHandlers(adapter, threadId, message);
+    } finally {
+      await this._stateAdapter.releaseLock(lock);
+      this.logger.debug("Lock released", { threadId, lockKey });
+    }
+  }
+  /**
+   * Queue/Debounce strategy: enqueue if lock is busy, drain after processing.
+   */
+  async handleQueueOrDebounce(adapter, threadId, lockKey, message, strategy) {
+    const { maxQueueSize, queueEntryTtlMs, onQueueFull, debounceMs } = this._concurrencyConfig;
+    const lock = await this._stateAdapter.acquireLock(
+      lockKey,
+      DEFAULT_LOCK_TTL_MS
+    );
+    if (!lock) {
+      const effectiveMaxSize = strategy === "debounce" ? 1 : maxQueueSize;
+      const depth = await this._stateAdapter.queueDepth(lockKey);
+      if (depth >= effectiveMaxSize && strategy !== "debounce" && onQueueFull === "drop-newest") {
+        this.logger.info("message-dropped", {
           threadId,
-          handlerCount: this.directMessageHandlers.length
+          lockKey,
+          messageId: message.id,
+          reason: "queue-full"
         });
-        const channel = thread.channel;
-        for (const handler of this.directMessageHandlers) {
-          await handler(thread, message, channel);
-        }
         return;
       }
-      if (isDM) {
-        message.isMention = true;
+      await this._stateAdapter.enqueue(
+        lockKey,
+        {
+          message,
+          enqueuedAt: Date.now(),
+          expiresAt: Date.now() + queueEntryTtlMs
+        },
+        effectiveMaxSize
+      );
+      this.logger.info(
+        strategy === "debounce" ? "message-debounce-reset" : "message-queued",
+        {
+          threadId,
+          lockKey,
+          messageId: message.id,
+          queueDepth: Math.min(depth + 1, effectiveMaxSize)
+        }
+      );
+      return;
+    }
+    this.logger.debug("Lock acquired", {
+      threadId,
+      lockKey,
+      token: lock.token
+    });
+    try {
+      if (strategy === "debounce") {
+        await this._stateAdapter.enqueue(
+          lockKey,
+          {
+            message,
+            enqueuedAt: Date.now(),
+            expiresAt: Date.now() + queueEntryTtlMs
+          },
+          1
+        );
+        this.logger.info("message-debouncing", {
+          threadId,
+          lockKey,
+          messageId: message.id,
+          debounceMs
+        });
+        await this.debounceLoop(lock, adapter, threadId, lockKey);
+      } else {
+        await this.dispatchToHandlers(adapter, threadId, message);
+        await this.drainQueue(lock, adapter, threadId, lockKey);
       }
-      if (isSubscribed) {
-        this.logger.debug("Message in subscribed thread - calling handlers", {
+    } finally {
+      await this._stateAdapter.releaseLock(lock);
+      this.logger.debug("Lock released", { threadId, lockKey });
+    }
+  }
+  /**
+   * Debounce loop: wait for debounceMs, check if newer message arrived,
+   * repeat until no new messages, then process the final message.
+   */
+  async debounceLoop(lock, adapter, threadId, lockKey) {
+    const { debounceMs } = this._concurrencyConfig;
+    while (true) {
+      await sleep(debounceMs);
+      await this._stateAdapter.extendLock(lock, DEFAULT_LOCK_TTL_MS);
+      const entry = await this._stateAdapter.dequeue(lockKey);
+      if (!entry) {
+        break;
+      }
+      const msg = this.rehydrateMessage(entry.message);
+      if (Date.now() > entry.expiresAt) {
+        this.logger.info("message-expired", {
           threadId,
-          handlerCount: this.subscribedMessageHandlers.length
+          lockKey,
+          messageId: msg.id
         });
-        await this.runHandlers(this.subscribedMessageHandlers, thread, message);
-        return;
+        continue;
       }
-      if (message.isMention) {
-        this.logger.debug("Bot mentioned", {
+      const depth = await this._stateAdapter.queueDepth(lockKey);
+      if (depth > 0) {
+        this.logger.info("message-superseded", {
           threadId,
-          text: message.text.slice(0, 100)
+          lockKey,
+          droppedId: msg.id
         });
-        await this.runHandlers(this.mentionHandlers, thread, message);
-        return;
+        continue;
       }
-      this.logger.debug("Checking message patterns", {
-        patternCount: this.messagePatterns.length,
-        patterns: this.messagePatterns.map((p) => p.pattern.toString()),
-        messageText: message.text
+      this.logger.info("message-dequeued", {
+        threadId,
+        lockKey,
+        messageId: msg.id
       });
-      let matchedPattern = false;
-      for (const { pattern, handler } of this.messagePatterns) {
-        const matches = pattern.test(message.text);
-        this.logger.debug("Pattern test", {
-          pattern: pattern.toString(),
-          text: message.text,
-          matches
-        });
-        if (matches) {
-          this.logger.debug("Message matched pattern - calling handler", {
-            pattern: pattern.toString()
+      await this.dispatchToHandlers(adapter, threadId, msg);
+      break;
+    }
+  }
+  /**
+   * Drain queue: collect all pending messages, dispatch the latest with
+   * skipped context, then check for more.
+   */
+  async drainQueue(lock, adapter, threadId, lockKey) {
+    while (true) {
+      const pending = [];
+      while (true) {
+        const entry = await this._stateAdapter.dequeue(lockKey);
+        if (!entry) {
+          break;
+        }
+        const msg = this.rehydrateMessage(entry.message);
+        if (Date.now() <= entry.expiresAt) {
+          pending.push({ message: msg, expiresAt: entry.expiresAt });
+        } else {
+          this.logger.info("message-expired", {
+            threadId,
+            lockKey,
+            messageId: msg.id
           });
-          matchedPattern = true;
-          await handler(thread, message);
         }
       }
-      if (!matchedPattern) {
-        this.logger.debug("No handlers matched message", {
-          threadId,
-          text: message.text.slice(0, 100)
+      if (pending.length === 0) {
+        return;
+      }
+      await this._stateAdapter.extendLock(lock, DEFAULT_LOCK_TTL_MS);
+      const latest = pending.at(-1);
+      if (!latest) {
+        return;
+      }
+      const skipped = pending.slice(0, -1).map((e) => e.message);
+      this.logger.info("message-dequeued", {
+        threadId,
+        lockKey,
+        messageId: latest.message.id,
+        skippedCount: skipped.length,
+        totalSinceLastHandler: pending.length
+      });
+      const context = {
+        skipped,
+        totalSinceLastHandler: pending.length
+      };
+      await this.dispatchToHandlers(adapter, threadId, latest.message, context);
+    }
+  }
+  /**
+   * Concurrent strategy: no locking, process immediately.
+   */
+  async handleConcurrent(adapter, threadId, message) {
+    await this.dispatchToHandlers(adapter, threadId, message);
+  }
+  /**
+   * Dispatch a message to the appropriate handler chain based on
+   * subscription status, mention detection, and pattern matching.
+   */
+  async dispatchToHandlers(adapter, threadId, message, context) {
+    message.isMention = message.isMention || this.detectMention(adapter, message);
+    const isSubscribed = await this._stateAdapter.isSubscribed(threadId);
+    this.logger.debug("Subscription check", {
+      threadId,
+      isSubscribed,
+      subscribedHandlerCount: this.subscribedMessageHandlers.length
+    });
+    const thread = await this.createThread(
+      adapter,
+      threadId,
+      message,
+      isSubscribed
+    );
+    const isDM = adapter.isDM?.(threadId) ?? false;
+    if (isDM && this.directMessageHandlers.length > 0) {
+      this.logger.debug("Direct message received - calling handlers", {
+        threadId,
+        handlerCount: this.directMessageHandlers.length
+      });
+      const channel = thread.channel;
+      for (const handler of this.directMessageHandlers) {
+        await handler(thread, message, channel, context);
+      }
+      return;
+    }
+    if (isDM) {
+      message.isMention = true;
+    }
+    if (isSubscribed) {
+      this.logger.debug("Message in subscribed thread - calling handlers", {
+        threadId,
+        handlerCount: this.subscribedMessageHandlers.length
+      });
+      await this.runHandlers(
+        this.subscribedMessageHandlers,
+        thread,
+        message,
+        context
+      );
+      return;
+    }
+    if (message.isMention) {
+      this.logger.debug("Bot mentioned", {
+        threadId,
+        text: message.text.slice(0, 100)
+      });
+      await this.runHandlers(this.mentionHandlers, thread, message, context);
+      return;
+    }
+    this.logger.debug("Checking message patterns", {
+      patternCount: this.messagePatterns.length,
+      patterns: this.messagePatterns.map((p) => p.pattern.toString()),
+      messageText: message.text
+    });
+    let matchedPattern = false;
+    for (const { pattern, handler } of this.messagePatterns) {
+      const matches = pattern.test(message.text);
+      this.logger.debug("Pattern test", {
+        pattern: pattern.toString(),
+        text: message.text,
+        matches
+      });
+      if (matches) {
+        this.logger.debug("Message matched pattern - calling handler", {
+          pattern: pattern.toString()
         });
+        matchedPattern = true;
+        await handler(thread, message, context);
       }
-    } finally {
-      await this._stateAdapter.releaseLock(lock);
-      this.logger.debug("Lock released", { threadId });
+    }
+    if (!matchedPattern) {
+      this.logger.debug("No handlers matched message", {
+        threadId,
+        text: message.text.slice(0, 100)
+      });
     }
   }
   createThread(adapter, threadId, initialMessage, isSubscribedContext = false) {
@@ -2958,9 +3242,45 @@ var Chat = class {
   escapeRegex(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   }
-  async runHandlers(handlers, thread, message) {
+  /**
+   * Reconstruct a proper Message instance from a dequeued entry.
+   * After JSON roundtrip through the state adapter, the message is a plain
+   * object (not a Message instance). This restores class invariants like
+   * `links` defaulting to `[]` and `metadata.dateSent` being a Date.
+   */
+  rehydrateMessage(raw) {
+    if (raw instanceof Message) {
+      return raw;
+    }
+    const obj = raw;
+    if (obj._type === "chat:Message") {
+      return Message.fromJSON(obj);
+    }
+    const metadata = obj.metadata;
+    const dateSent = metadata.dateSent;
+    const editedAt = metadata.editedAt;
+    return new Message({
+      id: obj.id,
+      threadId: obj.threadId,
+      text: obj.text,
+      formatted: obj.formatted,
+      raw: obj.raw,
+      author: obj.author,
+      metadata: {
+        dateSent: dateSent instanceof Date ? dateSent : new Date(dateSent),
+        edited: metadata.edited,
+        editedAt: editedAt ? new Date(
+          editedAt instanceof Date ? editedAt.toISOString() : editedAt
+        ) : void 0
+      },
+      attachments: obj.attachments ?? [],
+      isMention: obj.isMention,
+      links: obj.links ?? []
+    });
+  }
+  async runHandlers(handlers, thread, message, context) {
     for (const handler of handlers) {
-      await handler(thread, message);
+      await handler(thread, message, context);
     }
   }
 };