chat 4.21.0 → 4.23.0

package/dist/index.d.ts

@@ -42,6 +42,7 @@ declare class MessageHistoryCache {
 interface SerializedChannel {
     _type: "chat:Channel";
     adapterName: string;
+    channelVisibility?: ChannelVisibility;
     id: string;
     isDM: boolean;
 }
@@ -50,6 +51,7 @@ interface SerializedChannel {
  */
 interface ChannelImplConfigWithAdapter {
     adapter: Adapter;
+    channelVisibility?: ChannelVisibility;
     id: string;
     isDM?: boolean;
     messageHistory?: MessageHistoryCache;
@@ -60,6 +62,7 @@ interface ChannelImplConfigWithAdapter {
  */
 interface ChannelImplConfigLazy {
     adapterName: string;
+    channelVisibility?: ChannelVisibility;
     id: string;
     isDM?: boolean;
 }
@@ -67,6 +70,7 @@ type ChannelImplConfig = ChannelImplConfigWithAdapter | ChannelImplConfigLazy;
 declare class ChannelImpl<TState = Record<string, unknown>> implements Channel<TState> {
     readonly id: string;
     readonly isDM: boolean;
+    readonly channelVisibility: ChannelVisibility;
     private _adapter?;
     private readonly _adapterName?;
     private _stateAdapterInstance?;
@@ -144,6 +148,7 @@ interface SerializedThread {
     _type: "chat:Thread";
     adapterName: string;
     channelId: string;
+    channelVisibility?: ChannelVisibility;
     currentMessage?: SerializedMessage;
     id: string;
     isDM: boolean;
@@ -154,6 +159,7 @@ interface SerializedThread {
 interface ThreadImplConfigWithAdapter {
     adapter: Adapter;
     channelId: string;
+    channelVisibility?: ChannelVisibility;
     currentMessage?: Message;
     fallbackStreamingPlaceholderText?: string | null;
     id: string;
@@ -172,6 +178,7 @@ interface ThreadImplConfigWithAdapter {
 interface ThreadImplConfigLazy {
     adapterName: string;
     channelId: string;
+    channelVisibility?: ChannelVisibility;
     currentMessage?: Message;
     fallbackStreamingPlaceholderText?: string | null;
     id: string;
@@ -186,6 +193,7 @@ declare class ThreadImpl<TState = Record<string, unknown>> implements Thread<TSt
     readonly id: string;
     readonly channelId: string;
     readonly isDM: boolean;
+    readonly channelVisibility: ChannelVisibility;
     /** Direct adapter instance (if provided) */
     private _adapter?;
     /** Adapter name for lazy resolution */
@@ -329,6 +337,16 @@ declare class NotImplementedError extends ChatError {
     constructor(message: string, feature?: string, cause?: unknown);
 }
 
+/**
+ * Represents the visibility scope of a channel.
+ *
+ * - `private`: Channel is only visible to invited members (e.g., private Slack channels)
+ * - `workspace`: Channel is visible to all workspace members (e.g., public Slack channels)
+ * - `external`: Channel is shared with external organizations (e.g., Slack Connect)
+ * - `unknown`: Visibility cannot be determined
+ */
+type ChannelVisibility = "private" | "workspace" | "external" | "unknown";
+
 /**
  * Chat configuration with type-safe adapter inference.
  * @template TAdapters - Record of adapter name to adapter instance
@@ -336,6 +354,20 @@ declare class NotImplementedError extends ChatError {
 interface ChatConfig<TAdapters extends Record<string, Adapter> = Record<string, Adapter>> {
     /** Map of adapter name to adapter instance */
     adapters: TAdapters;
+    /**
+     * How to handle messages that arrive while a handler is already
+     * processing on the same thread.
+     *
+     * - `'drop'` (default) — discard the message (throw `LockError`)
+     * - `'queue'` — queue the message; when the current handler finishes,
+     *   process only the latest queued message with `context.skipped` containing
+     *   all intermediate messages
+     * - `'debounce'` — all messages start/reset a debounce timer; only the
+     *   final message in a burst is processed
+     * - `'concurrent'` — no locking; all messages processed in parallel
+     * - `ConcurrencyConfig` — fine-grained control over strategy and parameters
+     */
+    concurrency?: ConcurrencyStrategy | ConcurrencyConfig;
     /**
      * TTL for message deduplication entries in milliseconds.
      * Defaults to 300000 (5 minutes). Increase if your webhook cold starts
@@ -350,6 +382,17 @@ interface ChatConfig<TAdapters extends Record<string, Adapter> = Record<string,
      * wait until some real text has been streamed before creating the message.
      */
     fallbackStreamingPlaceholderText?: string | null;
+    /**
+     * Lock scope determines which messages contend for the same lock.
+     *
+     * - `'thread'`: lock per threadId (default for most adapters)
+     * - `'channel'`: lock per channelId (default for WhatsApp, Telegram)
+     * - function: resolve scope dynamically per message (async supported)
+     *
+     * When not set, falls back to the adapter's `lockScope` property,
+     * then to `'thread'`.
+     */
+    lockScope?: LockScope | ((context: LockScopeContext) => LockScope | Promise<LockScope>);
     /**
      * Logger instance or log level.
      * Pass "silent" to disable all logging.
@@ -366,6 +409,8 @@ interface ChatConfig<TAdapters extends Record<string, Adapter> = Record<string,
         ttlMs?: number;
     };
     /**
+     * @deprecated Use `concurrency` instead.
+     *
      * Behavior when a thread lock cannot be acquired (another handler is processing).
      * - `'drop'` (default) — throw `LockError`, preserving current behavior
      * - `'force'` — force-release the existing lock and re-acquire
@@ -486,6 +531,16 @@ interface Adapter<TThreadId = unknown, TRawMessage = unknown> {
     fetchMessages(threadId: string, options?: FetchOptions): Promise<FetchResult<TRawMessage>>;
     /** Fetch thread metadata */
     fetchThread(threadId: string): Promise<ThreadInfo>;
+    /**
+     * Get the visibility scope of a channel containing the thread.
+     *
+     * This distinguishes between private channels, workspace-visible channels,
+     * and externally shared channels (e.g., Slack Connect).
+     *
+     * @param threadId - The thread ID to check
+     * @returns The channel visibility scope
+     */
+    getChannelVisibility?(threadId: string): ChannelVisibility;
     /** Handle incoming webhook request */
     handleWebhook(request: Request, options?: WebhookOptions): Promise<Response>;
     /** Called when Chat instance is created (internal use) */
@@ -501,6 +556,14 @@ interface Adapter<TThreadId = unknown, TRawMessage = unknown> {
      * List threads in a channel.
      */
     listThreads?(channelId: string, options?: ListThreadsOptions): Promise<ListThreadsResult<TRawMessage>>;
+    /**
+     * Default lock scope for this adapter.
+     * - `'thread'` (default): lock per threadId
+     * - `'channel'`: lock per channelId (for channel-based platforms like WhatsApp, Telegram)
+     *
+     * Can be overridden by `ChatConfig.lockScope`.
+     */
+    readonly lockScope?: LockScope;
     /** Unique name for this adapter (e.g., "slack", "teams") */
     readonly name: string;
     /**
@@ -716,6 +779,57 @@ interface ChatInstance {
         channelId: string;
     }, options?: WebhookOptions): void;
 }
+/** Lock scope determines which messages contend for the same lock. */
+type LockScope = "thread" | "channel";
+/** Context provided to the lockScope resolver function. */
+interface LockScopeContext {
+    adapter: Adapter;
+    channelId: string;
+    isDM: boolean;
+    threadId: string;
+}
+/** Concurrency strategy for overlapping messages on the same thread. */
+type ConcurrencyStrategy = "drop" | "queue" | "debounce" | "concurrent";
+/** Fine-grained concurrency configuration. */
+interface ConcurrencyConfig {
+    /** Debounce window in milliseconds (debounce strategy). Default: 1500. */
+    debounceMs?: number;
+    /** Max concurrent handlers per thread (concurrent strategy). Default: Infinity. */
+    maxConcurrent?: number;
+    /** Max queued messages per thread (queue/debounce strategy). Default: 10. */
+    maxQueueSize?: number;
+    /** What to do when queue is full. Default: 'drop-oldest'. */
+    onQueueFull?: "drop-oldest" | "drop-newest";
+    /** TTL for queued entries in milliseconds. Default: 90000 (90s). */
+    queueEntryTtlMs?: number;
+    /** The concurrency strategy to use. */
+    strategy: ConcurrencyStrategy;
+}
+/**
+ * An entry in the per-thread message queue.
+ * Used by the `queue` and `debounce` concurrency strategies.
+ */
+interface QueueEntry {
+    /** When this entry was enqueued (Unix ms). */
+    enqueuedAt: number;
+    /** When this entry expires (Unix ms). Stale entries are discarded on dequeue. */
+    expiresAt: number;
+    /** The queued message. */
+    message: Message;
+}
+/**
+ * Context provided to message handlers when messages were queued
+ * while a previous handler was running.
+ */
+interface MessageContext {
+    /**
+     * Messages that arrived while the previous handler was running,
+     * in chronological order, excluding the current message (which is the latest).
+     */
+    skipped: Message[];
+    /** Total messages received since last handler ran (skipped.length + 1). */
+    totalSinceLastHandler: number;
+}
 interface StateAdapter {
     /** Acquire a lock on a thread (returns null if already locked) */
     acquireLock(threadId: string, ttlMs: number): Promise<Lock | null>;
@@ -728,8 +842,12 @@ interface StateAdapter {
     connect(): Promise<void>;
     /** Delete a cached value */
     delete(key: string): Promise<void>;
+    /** Pop the next message from the thread's queue. Returns null if empty. */
+    dequeue(threadId: string): Promise<QueueEntry | null>;
     /** Disconnect from the state backend */
     disconnect(): Promise<void>;
+    /** Atomically append a message to the thread's pending queue. Returns new queue depth. */
+    enqueue(threadId: string, entry: QueueEntry, maxSize: number): Promise<number>;
     /** Extend a lock's TTL */
     extendLock(lock: Lock, ttlMs: number): Promise<boolean>;
     /**
@@ -744,6 +862,8 @@ interface StateAdapter {
     getList<T = unknown>(key: string): Promise<T[]>;
     /** Check if subscribed to a thread */
     isSubscribed(threadId: string): Promise<boolean>;
+    /** Get the current queue depth for a thread. */
+    queueDepth(threadId: string): Promise<number>;
     /** Release a lock */
     releaseLock(lock: Lock): Promise<void>;
     /** Set a cached value with optional TTL in milliseconds */
@@ -770,6 +890,8 @@ interface Lock {
 interface Postable<TState = Record<string, unknown>, TRawMessage = unknown> {
     /** The adapter this entity belongs to */
     readonly adapter: Adapter;
+    /** The visibility scope of this channel */
+    readonly channelVisibility: ChannelVisibility;
     /** Unique ID */
     readonly id: string;
     /** Whether this is a direct message conversation */
@@ -869,6 +991,8 @@ interface ThreadSummary<TRawMessage = unknown> {
  * Channel metadata returned by fetchInfo().
  */
 interface ChannelInfo {
+    /** The visibility scope of this channel */
+    channelVisibility?: ChannelVisibility;
     id: string;
     isDM?: boolean;
     memberCount?: number;
@@ -1038,6 +1162,8 @@ interface Thread<TState = Record<string, unknown>, TRawMessage = unknown> extend
 interface ThreadInfo {
     channelId: string;
     channelName?: string;
+    /** The visibility scope of this channel */
+    channelVisibility?: ChannelVisibility;
     id: string;
     /** Whether this is a direct message conversation */
     isDM?: boolean;
@@ -1349,7 +1475,7 @@ interface FileUpload {
  * });
  * ```
  */
-type MentionHandler<TState = Record<string, unknown>> = (thread: Thread<TState>, message: Message) => void | Promise<void>;
+type MentionHandler<TState = Record<string, unknown>> = (thread: Thread<TState>, message: Message, context?: MessageContext) => void | Promise<void>;
 /**
  * Handler for direct messages (1:1 conversations with the bot).
  *
@@ -1358,14 +1484,14 @@ type MentionHandler<TState = Record<string, unknown>> = (thread: Thread<TState>,
  * handlers are registered, DMs fall through to `onNewMention` for backward
  * compatibility.
  */
-type DirectMessageHandler<TState = Record<string, unknown>> = (thread: Thread<TState>, message: Message, channel: Channel<TState>) => void | Promise<void>;
+type DirectMessageHandler<TState = Record<string, unknown>> = (thread: Thread<TState>, message: Message, channel: Channel<TState>, context?: MessageContext) => void | Promise<void>;
 /**
  * Handler for messages matching a regex pattern.
  *
  * Registered via `chat.onNewMessage(pattern, handler)`. Called when a message
  * matches the pattern in an unsubscribed thread.
  */
-type MessageHandler<TState = Record<string, unknown>> = (thread: Thread<TState>, message: Message) => void | Promise<void>;
+type MessageHandler<TState = Record<string, unknown>> = (thread: Thread<TState>, message: Message, context?: MessageContext) => void | Promise<void>;
 /**
  * Handler for messages in subscribed threads.
  *
@@ -1389,7 +1515,7 @@ type MessageHandler<TState = Record<string, unknown>> = (thread: Thread<TState>,
  * });
  * ```
  */
-type SubscribedMessageHandler<TState = Record<string, unknown>> = (thread: Thread<TState>, message: Message) => void | Promise<void>;
+type SubscribedMessageHandler<TState = Record<string, unknown>> = (thread: Thread<TState>, message: Message, context?: MessageContext) => void | Promise<void>;
 /**
  * Well-known emoji that work across platforms (Slack and Google Chat).
  * These are normalized to a common format regardless of platform.
@@ -2101,6 +2227,9 @@ declare class Chat<TAdapters extends Record<string, Adapter> = Record<string, Ad
     private readonly _dedupeTtlMs;
     private readonly _onLockConflict;
     private readonly _messageHistory;
+    private readonly _concurrencyStrategy;
+    private readonly _concurrencyConfig;
+    private readonly _lockScope;
     private readonly mentionHandlers;
     private readonly directMessageHandlers;
     private readonly messagePatterns;
@@ -2470,6 +2599,12 @@ declare class Chat<TAdapters extends Record<string, Adapter> = Record<string, Ad
      * Infer which adapter to use based on the userId format.
      */
     private inferAdapterFromUserId;
+    /**
+     * 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).
+     */
+    private getLockKey;
     /**
      * Handle an incoming message from an adapter.
      * This is called by adapters when they receive a webhook.
@@ -2478,9 +2613,36 @@ declare class Chat<TAdapters extends Record<string, Adapter> = Record<string, Ad
      * - 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)
      */
     handleIncomingMessage(adapter: Adapter, threadId: string, message: Message): Promise<void>;
+    /**
+     * Drop strategy: acquire lock or fail. Original behavior.
+     */
+    private handleDrop;
+    /**
+     * Queue/Debounce strategy: enqueue if lock is busy, drain after processing.
+     */
+    private handleQueueOrDebounce;
+    /**
+     * Debounce loop: wait for debounceMs, check if newer message arrived,
+     * repeat until no new messages, then process the final message.
+     */
+    private debounceLoop;
+    /**
+     * Drain queue: collect all pending messages, dispatch the latest with
+     * skipped context, then check for more.
+     */
+    private drainQueue;
+    /**
+     * Concurrent strategy: no locking, process immediately.
+     */
+    private handleConcurrent;
+    /**
+     * Dispatch a message to the appropriate handler chain based on
+     * subscription status, mention detection, and pattern matching.
+     */
+    private dispatchToHandlers;
     private createThread;
     /**
      * Detect if the bot was mentioned in the message.
@@ -2488,6 +2650,13 @@ declare class Chat<TAdapters extends Record<string, Adapter> = Record<string, Ad
      */
     private detectMention;
     private escapeRegex;
+    /**
+     * 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.
+     */
+    private rehydrateMessage;
     private runHandlers;
 }
 
@@ -3001,4 +3170,4 @@ declare const Select: SelectComponent;
 declare const SelectOption: SelectOptionComponent;
 declare const TextInput: TextInputComponent;
 
-export { type ActionEvent, type ActionHandler, Actions, ActionsComponent, type Adapter, type AdapterPostableMessage, type AiAssistantMessage, type AiFilePart, type AiImagePart, type AiMessage, type AiMessagePart, type AiTextPart, type AiUserMessage, type AppHomeOpenedEvent, type AppHomeOpenedHandler, type AssistantContextChangedEvent, type AssistantContextChangedHandler, type AssistantThreadStartedEvent, type AssistantThreadStartedHandler, type Attachment, type Author, BaseFormatConverter, Button, ButtonComponent, Card, CardChild, CardComponent, CardElement, CardLink, CardLinkComponent, CardText, type Channel, ChannelImpl, type ChannelInfo, Chat, type ChatConfig, ChatElement, ChatError, type ChatInstance, ConsoleLogger, type CustomEmojiMap, DEFAULT_EMOJI_MAP, type DirectMessageHandler, Divider, DividerComponent, type Emoji, type EmojiFormats, type EmojiMapConfig, EmojiResolver, type EmojiValue, type EphemeralMessage, type FetchDirection, type FetchOptions, type FetchResult, Field, FieldComponent, Fields, FieldsComponent, type FileUpload, type FormatConverter, type FormattedContent, Image, ImageComponent, LinkButton, LinkButtonComponent, type LinkPreview, type ListThreadsOptions, type ListThreadsResult, type Lock, LockError, type LogLevel, type Logger, type MarkdownConverter, type MarkdownTextChunk, type MemberJoinedChannelEvent, type MemberJoinedChannelHandler, type MentionHandler, Message, type MessageData, type MessageHandler, MessageHistoryCache, type MessageHistoryConfig, type MessageMetadata, Modal, type ModalCloseEvent, type ModalCloseHandler, type ModalCloseResponse, ModalComponent, ModalElement, type ModalErrorsResponse, type ModalPushResponse, type ModalResponse, type ModalSubmitEvent, type ModalSubmitHandler, type ModalUpdateResponse, NotImplementedError, type PlanUpdateChunk, type PostEphemeralOptions, type Postable, type PostableAst, type PostableCard, type PostableMarkdown, type PostableMessage, type PostableRaw, RadioSelect, RadioSelectComponent, RateLimitError, type RawMessage, type ReactionEvent, type ReactionHandler, type ScheduledMessage, Section, SectionComponent, Select, SelectComponent, SelectOption, SelectOptionComponent, type SentMessage, type SerializedChannel, type SerializedMessage, type SerializedThread, type SlashCommandEvent, type SlashCommandHandler, type StateAdapter, type StreamChunk, type StreamEvent, type StreamOptions, StreamingMarkdownRenderer, type SubscribedMessageHandler, THREAD_STATE_TTL_MS, Table, type TaskUpdateChunk, TextComponent, TextInput, TextInputComponent, type Thread, ThreadImpl, type ThreadInfo, type ThreadSummary, type WebhookOptions, type WellKnownEmoji, blockquote, cardChildToFallbackText, codeBlock, convertEmojiPlaceholders, createEmoji, defaultEmojiResolver, deriveChannelId, emoji, emphasis, fromFullStream, fromReactElement, fromReactModalElement, getEmoji, getNodeChildren, getNodeValue, inlineCode, isBlockquoteNode, isCardElement, isCodeNode, isDeleteNode, isEmphasisNode, isInlineCodeNode, isJSX, isLinkNode, isListItemNode, isListNode, isModalElement, isParagraphNode, isStrongNode, isTableCellNode, isTableNode, isTableRowNode, isTextNode, link, markdownToPlainText, paragraph, parseMarkdown, root, strikethrough, stringifyMarkdown, strong, tableElementToAscii, tableToAscii, text, toAiMessages, toCardElement, toModalElement, toPlainText, walkAst };
+export { type ActionEvent, type ActionHandler, Actions, ActionsComponent, type Adapter, type AdapterPostableMessage, type AiAssistantMessage, type AiFilePart, type AiImagePart, type AiMessage, type AiMessagePart, type AiTextPart, type AiUserMessage, type AppHomeOpenedEvent, type AppHomeOpenedHandler, type AssistantContextChangedEvent, type AssistantContextChangedHandler, type AssistantThreadStartedEvent, type AssistantThreadStartedHandler, type Attachment, type Author, BaseFormatConverter, Button, ButtonComponent, Card, CardChild, CardComponent, CardElement, CardLink, CardLinkComponent, CardText, type Channel, ChannelImpl, type ChannelInfo, type ChannelVisibility, Chat, type ChatConfig, ChatElement, ChatError, type ChatInstance, type ConcurrencyConfig, type ConcurrencyStrategy, ConsoleLogger, type CustomEmojiMap, DEFAULT_EMOJI_MAP, type DirectMessageHandler, Divider, DividerComponent, type Emoji, type EmojiFormats, type EmojiMapConfig, EmojiResolver, type EmojiValue, type EphemeralMessage, type FetchDirection, type FetchOptions, type FetchResult, Field, FieldComponent, Fields, FieldsComponent, type FileUpload, type FormatConverter, type FormattedContent, Image, ImageComponent, LinkButton, LinkButtonComponent, type LinkPreview, type ListThreadsOptions, type ListThreadsResult, type Lock, LockError, type LockScope, type LockScopeContext, type LogLevel, type Logger, type MarkdownConverter, type MarkdownTextChunk, type MemberJoinedChannelEvent, type MemberJoinedChannelHandler, type MentionHandler, Message, type MessageContext, type MessageData, type MessageHandler, MessageHistoryCache, type MessageHistoryConfig, type MessageMetadata, Modal, type ModalCloseEvent, type ModalCloseHandler, type ModalCloseResponse, ModalComponent, ModalElement, type ModalErrorsResponse, type ModalPushResponse, type ModalResponse, type ModalSubmitEvent, type ModalSubmitHandler, type ModalUpdateResponse, NotImplementedError, type PlanUpdateChunk, type PostEphemeralOptions, type Postable, type PostableAst, type PostableCard, type PostableMarkdown, type PostableMessage, type PostableRaw, type QueueEntry, RadioSelect, RadioSelectComponent, RateLimitError, type RawMessage, type ReactionEvent, type ReactionHandler, type ScheduledMessage, Section, SectionComponent, Select, SelectComponent, SelectOption, SelectOptionComponent, type SentMessage, type SerializedChannel, type SerializedMessage, type SerializedThread, type SlashCommandEvent, type SlashCommandHandler, type StateAdapter, type StreamChunk, type StreamEvent, type StreamOptions, StreamingMarkdownRenderer, type SubscribedMessageHandler, THREAD_STATE_TTL_MS, Table, type TaskUpdateChunk, TextComponent, TextInput, TextInputComponent, type Thread, ThreadImpl, type ThreadInfo, type ThreadSummary, type WebhookOptions, type WellKnownEmoji, blockquote, cardChildToFallbackText, codeBlock, convertEmojiPlaceholders, createEmoji, defaultEmojiResolver, deriveChannelId, emoji, emphasis, fromFullStream, fromReactElement, fromReactModalElement, getEmoji, getNodeChildren, getNodeValue, inlineCode, isBlockquoteNode, isCardElement, isCodeNode, isDeleteNode, isEmphasisNode, isInlineCodeNode, isJSX, isLinkNode, isListItemNode, isListNode, isModalElement, isParagraphNode, isStrongNode, isTableCellNode, isTableNode, isTableRowNode, isTextNode, link, markdownToPlainText, paragraph, parseMarkdown, root, strikethrough, stringifyMarkdown, strong, tableElementToAscii, tableToAscii, text, toAiMessages, toCardElement, toModalElement, toPlainText, walkAst };