chat 4.20.2 → 4.22.0

package/dist/index.d.ts

@@ -1,8 +1,114 @@
 import { WORKFLOW_SERIALIZE, WORKFLOW_DESERIALIZE } from '@workflow/serde';
 import { Root, List, Content, Blockquote, Code, Emphasis, InlineCode, Delete, Link, ListItem, Paragraph, Strong, TableCell, Table as Table$1, TableRow, Text } from 'mdast';
 export { Blockquote, Code, Content, Delete, Emphasis, InlineCode, Link, List, ListItem, Table as MdastTable, Paragraph, Root, Strong, TableCell, TableRow, Text } from 'mdast';
-import { C as CardElement, M as ModalElement, a as ChatElement, b as CardChild, A as ActionsComponent, B as ButtonComponent, c as CardComponent, d as cardChildToFallbackText$1, e as CardLinkComponent, T as TextComponent, D as DividerComponent, F as FieldComponent, f as FieldsComponent, g as fromReactElement$1, I as ImageComponent, i as isCardElement$1, h as isJSX$1, L as LinkButtonComponent, S as SectionComponent, j as Table$2, t as toCardElement$1, k as toModalElement$1, l as fromReactModalElement$1, m as isModalElement$1, n as ModalComponent, R as RadioSelectComponent, o as SelectComponent, p as SelectOptionComponent, q as TextInputComponent } from './jsx-runtime-C2ATKxHQ.js';
-export { r as ActionsElement, s as ButtonElement, u as ButtonOptions, V as ButtonProps, v as ButtonStyle, W as CardJSXElement, X as CardJSXProps, Y as CardLinkProps, w as CardOptions, Z as CardProps, _ as ContainerProps, x as DividerElement, $ as DividerProps, y as FieldElement, a0 as FieldProps, z as FieldsElement, E as ImageElement, a1 as ImageProps, G as LinkButtonElement, H as LinkButtonOptions, a2 as LinkButtonProps, J as LinkElement, a8 as ModalChild, a9 as ModalOptions, a3 as ModalProps, aa as RadioSelectElement, ab as RadioSelectOptions, K as SectionElement, ac as SelectElement, ad as SelectOptionElement, a4 as SelectOptionProps, ae as SelectOptions, a5 as SelectProps, N as TableAlignment, O as TableElement, P as TableOptions, Q as TextElement, af as TextInputElement, ag as TextInputOptions, a6 as TextInputProps, a7 as TextProps, U as TextStyle } from './jsx-runtime-C2ATKxHQ.js';
+import { C as ChatElement, a as CardElement, M as ModalElement, b as CardChild, A as ActionsComponent, B as ButtonComponent, c as CardComponent, d as cardChildToFallbackText$1, e as CardLinkComponent, T as TextComponent, D as DividerComponent, F as FieldComponent, f as FieldsComponent, g as fromReactElement$1, I as ImageComponent, i as isCardElement$1, h as isJSX$1, L as LinkButtonComponent, S as SectionComponent, j as Table$2, t as toCardElement$1, k as toModalElement$1, l as fromReactModalElement$1, m as isModalElement$1, n as ModalComponent, R as RadioSelectComponent, o as SelectComponent, p as SelectOptionComponent, q as TextInputComponent } from './jsx-runtime-DraWieqP.js';
+export { r as ActionsElement, s as ButtonElement, u as ButtonOptions, V as ButtonProps, v as ButtonStyle, W as CardJSXElement, X as CardJSXProps, Y as CardLinkProps, w as CardOptions, Z as CardProps, _ as ContainerProps, x as DividerElement, $ as DividerProps, y as FieldElement, a0 as FieldProps, z as FieldsElement, E as ImageElement, a1 as ImageProps, G as LinkButtonElement, H as LinkButtonOptions, a2 as LinkButtonProps, J as LinkElement, a8 as ModalChild, a9 as ModalOptions, a3 as ModalProps, aa as RadioSelectElement, ab as RadioSelectOptions, K as SectionElement, ac as SelectElement, ad as SelectOptionElement, a4 as SelectOptionProps, ae as SelectOptions, a5 as SelectProps, N as TableAlignment, O as TableElement, P as TableOptions, Q as TextElement, af as TextInputElement, ag as TextInputOptions, a6 as TextInputProps, a7 as TextProps, U as TextStyle } from './jsx-runtime-DraWieqP.js';
+
+interface MessageHistoryConfig {
+    /** Maximum messages to keep per thread (default: 100) */
+    maxMessages?: number;
+    /** TTL for cached history in milliseconds (default: 7 days) */
+    ttlMs?: number;
+}
+/**
+ * Persistent message history cache backed by the StateAdapter.
+ *
+ * Used by adapters that lack server-side message history APIs (e.g., WhatsApp, Telegram).
+ * Messages are atomically appended via `state.appendToList()`, which is safe
+ * without holding a thread lock.
+ */
+declare class MessageHistoryCache {
+    private readonly state;
+    private readonly maxMessages;
+    private readonly ttlMs;
+    constructor(state: StateAdapter, config?: MessageHistoryConfig);
+    /**
+     * Atomically append a message to the history for a thread.
+     * Trims to maxMessages (keeps newest) and refreshes TTL.
+     */
+    append(threadId: string, message: Message): Promise<void>;
+    /**
+     * Get messages for a thread in chronological order (oldest first).
+     *
+     * @param threadId - The thread ID
+     * @param limit - Optional limit on number of messages to return (returns newest N)
+     */
+    getMessages(threadId: string, limit?: number): Promise<Message[]>;
+}
+
+/**
+ * Serialized channel data for passing to external systems (e.g., workflow engines).
+ */
+interface SerializedChannel {
+    _type: "chat:Channel";
+    adapterName: string;
+    id: string;
+    isDM: boolean;
+}
+/**
+ * Config for creating a ChannelImpl with explicit adapter/state instances.
+ */
+interface ChannelImplConfigWithAdapter {
+    adapter: Adapter;
+    id: string;
+    isDM?: boolean;
+    messageHistory?: MessageHistoryCache;
+    stateAdapter: StateAdapter;
+}
+/**
+ * Config for creating a ChannelImpl with lazy adapter resolution.
+ */
+interface ChannelImplConfigLazy {
+    adapterName: string;
+    id: string;
+    isDM?: boolean;
+}
+type ChannelImplConfig = ChannelImplConfigWithAdapter | ChannelImplConfigLazy;
+declare class ChannelImpl<TState = Record<string, unknown>> implements Channel<TState> {
+    readonly id: string;
+    readonly isDM: boolean;
+    private _adapter?;
+    private readonly _adapterName?;
+    private _stateAdapterInstance?;
+    private _name;
+    private readonly _messageHistory?;
+    constructor(config: ChannelImplConfig);
+    get adapter(): Adapter;
+    private get _stateAdapter();
+    get name(): string | null;
+    get state(): Promise<TState | null>;
+    setState(newState: Partial<TState>, options?: {
+        replace?: boolean;
+    }): Promise<void>;
+    /**
+     * Iterate messages newest first (backward from most recent).
+     * Uses adapter.fetchChannelMessages if available, otherwise falls back
+     * to adapter.fetchMessages with the channel ID.
+     */
+    get messages(): AsyncIterable<Message>;
+    /**
+     * Iterate threads in this channel, most recently active first.
+     */
+    threads(): AsyncIterable<ThreadSummary>;
+    fetchMetadata(): Promise<ChannelInfo>;
+    post(message: string | PostableMessage | ChatElement): Promise<SentMessage>;
+    private postSingleMessage;
+    postEphemeral(user: string | Author, message: AdapterPostableMessage | ChatElement, options: PostEphemeralOptions): Promise<EphemeralMessage | null>;
+    schedule(message: AdapterPostableMessage | ChatElement, options: {
+        postAt: Date;
+    }): Promise<ScheduledMessage>;
+    startTyping(status?: string): Promise<void>;
+    mentionUser(userId: string): string;
+    toJSON(): SerializedChannel;
+    static fromJSON<TState = Record<string, unknown>>(json: SerializedChannel, adapter?: Adapter): ChannelImpl<TState>;
+    static [WORKFLOW_SERIALIZE](instance: ChannelImpl): SerializedChannel;
+    static [WORKFLOW_DESERIALIZE](data: SerializedChannel): ChannelImpl;
+    private createSentMessage;
+}
+/**
+ * Derive the channel ID from a thread ID.
+ */
+declare function deriveChannelId(adapter: Adapter, threadId: string): string;
 
 /**
  * Logger types and implementations for chat-sdk
@@ -31,6 +137,178 @@ declare class ConsoleLogger implements Logger {
     error(message: string, ...args: unknown[]): void;
 }
 
+/**
+ * Serialized thread data for passing to external systems (e.g., workflow engines).
+ */
+interface SerializedThread {
+    _type: "chat:Thread";
+    adapterName: string;
+    channelId: string;
+    currentMessage?: SerializedMessage;
+    id: string;
+    isDM: boolean;
+}
+/**
+ * Config for creating a ThreadImpl with explicit adapter/state instances.
+ */
+interface ThreadImplConfigWithAdapter {
+    adapter: Adapter;
+    channelId: string;
+    currentMessage?: Message;
+    fallbackStreamingPlaceholderText?: string | null;
+    id: string;
+    initialMessage?: Message;
+    isDM?: boolean;
+    isSubscribedContext?: boolean;
+    logger?: Logger;
+    messageHistory?: MessageHistoryCache;
+    stateAdapter: StateAdapter;
+    streamingUpdateIntervalMs?: number;
+}
+/**
+ * Config for creating a ThreadImpl with lazy adapter resolution.
+ * The adapter will be looked up from the Chat singleton on first access.
+ */
+interface ThreadImplConfigLazy {
+    adapterName: string;
+    channelId: string;
+    currentMessage?: Message;
+    fallbackStreamingPlaceholderText?: string | null;
+    id: string;
+    initialMessage?: Message;
+    isDM?: boolean;
+    isSubscribedContext?: boolean;
+    logger?: Logger;
+    streamingUpdateIntervalMs?: number;
+}
+type ThreadImplConfig = ThreadImplConfigWithAdapter | ThreadImplConfigLazy;
+declare class ThreadImpl<TState = Record<string, unknown>> implements Thread<TState> {
+    readonly id: string;
+    readonly channelId: string;
+    readonly isDM: boolean;
+    /** Direct adapter instance (if provided) */
+    private _adapter?;
+    /** Adapter name for lazy resolution */
+    private readonly _adapterName?;
+    /** Direct state adapter instance (if provided) */
+    private _stateAdapterInstance?;
+    private _recentMessages;
+    private readonly _isSubscribedContext;
+    /** Current message context for streaming - provides userId/teamId */
+    private readonly _currentMessage?;
+    /** Update interval for fallback streaming */
+    private readonly _streamingUpdateIntervalMs;
+    /** Placeholder text for fallback streaming (post + edit) */
+    private readonly _fallbackStreamingPlaceholderText;
+    /** Cached channel instance */
+    private _channel?;
+    /** Message history cache (set only for adapters with persistMessageHistory) */
+    private readonly _messageHistory?;
+    private readonly _logger?;
+    constructor(config: ThreadImplConfig);
+    /**
+     * Get the adapter for this thread.
+     * If created with lazy config, resolves from Chat singleton on first access.
+     */
+    get adapter(): Adapter;
+    /**
+     * Get the state adapter for this thread.
+     * If created with lazy config, resolves from Chat singleton on first access.
+     */
+    private get _stateAdapter();
+    get recentMessages(): Message[];
+    set recentMessages(messages: Message[]);
+    /**
+     * Get the current thread state.
+     * Returns null if no state has been set.
+     */
+    get state(): Promise<TState | null>;
+    /**
+     * Set the thread state. Merges with existing state by default.
+     * State is persisted for 30 days.
+     */
+    setState(newState: Partial<TState>, options?: {
+        replace?: boolean;
+    }): Promise<void>;
+    /**
+     * Get the Channel containing this thread.
+     * Lazy-created and cached.
+     */
+    get channel(): Channel<TState>;
+    /**
+     * Iterate messages newest first (backward from most recent).
+     * Auto-paginates lazily.
+     */
+    get messages(): AsyncIterable<Message>;
+    get allMessages(): AsyncIterable<Message>;
+    isSubscribed(): Promise<boolean>;
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    post(message: string | PostableMessage | ChatElement): Promise<SentMessage>;
+    postEphemeral(user: string | Author, message: AdapterPostableMessage | ChatElement, options: PostEphemeralOptions): Promise<EphemeralMessage | null>;
+    schedule(message: AdapterPostableMessage | ChatElement, options: {
+        postAt: Date;
+    }): Promise<ScheduledMessage>;
+    /**
+     * Handle streaming from an AsyncIterable.
+     * Normalizes the stream (supports both textStream and fullStream from AI SDK),
+     * then uses adapter's native streaming if available, otherwise falls back to post+edit.
+     */
+    private handleStream;
+    startTyping(status?: string): Promise<void>;
+    /**
+     * Fallback streaming implementation using post + edit.
+     * Used when adapter doesn't support native streaming.
+     * Uses recursive setTimeout to send updates every intervalMs (default 500ms).
+     * Schedules next update only after current edit completes to avoid overwhelming slow services.
+     */
+    private fallbackStream;
+    refresh(): Promise<void>;
+    mentionUser(userId: string): string;
+    /**
+     * Serialize the thread to a plain JSON object.
+     * Use this to pass thread data to external systems like workflow engines.
+     *
+     * @example
+     * ```typescript
+     * // Pass to a workflow
+     * await workflow.start("my-workflow", {
+     *   thread: thread.toJSON(),
+     *   message: serializeMessage(message),
+     * });
+     * ```
+     */
+    toJSON(): SerializedThread;
+    /**
+     * Reconstruct a Thread from serialized JSON data.
+     *
+     * Reconstructs a ThreadImpl from serialized data.
+     * Uses lazy resolution from Chat.getSingleton() for adapter and state.
+     *
+     * @param json - Serialized thread data
+     * @requires Call `chat.registerSingleton()` before deserializing threads
+     *
+     * @example
+     * ```typescript
+     * const thread = ThreadImpl.fromJSON(serializedThread);
+     * ```
+     */
+    static fromJSON<TState = Record<string, unknown>>(json: SerializedThread, adapter?: Adapter): ThreadImpl<TState>;
+    /**
+     * Serialize a ThreadImpl instance for @workflow/serde.
+     * This static method is automatically called by workflow serialization.
+     */
+    static [WORKFLOW_SERIALIZE](instance: ThreadImpl): SerializedThread;
+    /**
+     * Deserialize a ThreadImpl from @workflow/serde.
+     * Uses lazy adapter resolution from Chat.getSingleton().
+     * Requires chat.registerSingleton() to have been called.
+     */
+    static [WORKFLOW_DESERIALIZE](data: SerializedThread): ThreadImpl;
+    private createSentMessage;
+    createSentMessageFromMessage(message: Message): SentMessage;
+}
+
 /**
  * Error types for chat-sdk
  */
@@ -58,6 +336,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
@@ -72,6 +364,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.
@@ -88,6 +391,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
@@ -149,6 +454,8 @@ interface Adapter<TThreadId = unknown, TRawMessage = unknown> {
     decodeThreadId(threadId: string): TThreadId;
     /** Delete a message */
     deleteMessage(threadId: string, messageId: string): Promise<void>;
+    /** Cleanup hook called when Chat instance is shutdown */
+    disconnect?(): Promise<void>;
     /** Edit an existing message */
     editMessage(threadId: string, messageId: string, message: AdapterPostableMessage): Promise<RawMessage<TRawMessage>>;
     /** Encode platform-specific data into a thread ID string */
@@ -221,6 +528,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;
     /**
@@ -436,6 +751,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>;
@@ -448,8 +814,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>;
     /**
@@ -464,6 +834,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 */
@@ -566,6 +938,11 @@ interface Channel<TState = Record<string, unknown>, TRawMessage = unknown> exten
      * Empty iterable on threadless platforms.
      */
     threads(): AsyncIterable<ThreadSummary<TRawMessage>>;
+    /**
+     * Serialize the channel to a plain JSON object.
+     * Use this to pass channel data to external systems like workflow engines.
+     */
+    toJSON(): SerializedChannel;
 }
 /**
  * Lightweight summary of a thread within a channel.
@@ -738,6 +1115,11 @@ interface Thread<TState = Record<string, unknown>, TRawMessage = unknown> extend
      * ```
      */
     subscribe(): Promise<void>;
+    /**
+     * Serialize the thread to a plain JSON object.
+     * Use this to pass thread data to external systems like workflow engines.
+     */
+    toJSON(): SerializedThread;
     /**
      * Unsubscribe from this thread.
      *
@@ -1059,7 +1441,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).
  *
@@ -1068,14 +1450,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.
  *
@@ -1099,7 +1481,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.
@@ -1684,165 +2066,59 @@ type AiMessagePart = AiTextPart | AiImagePart | AiFilePart;
  *
  * This is a discriminated union matching AI SDK's ModelMessage type:
  * - User messages can have text, image, and file parts
- * - Assistant messages have string content only
- */
-type AiMessage = AiUserMessage | AiAssistantMessage;
-interface AiUserMessage {
-    content: string | AiMessagePart[];
-    role: "user";
-}
-interface AiAssistantMessage {
-    content: string;
-    role: "assistant";
-}
-/**
- * Options for converting messages to AI SDK format.
- */
-interface ToAiMessagesOptions {
-    /** When true, prefixes user messages with "[username]: " for multi-user context */
-    includeNames?: boolean;
-    /**
-     * Called when an attachment type is not supported (video, audio).
-     * Defaults to `console.warn`.
-     */
-    onUnsupportedAttachment?: (attachment: Attachment, message: Message) => void;
-    /**
-     * Called for each message after default processing (text, links, attachments).
-     * Return the message (modified or as-is) to include it, or `null` to skip it.
-     *
-     * @param aiMessage - The processed AI message
-     * @param source - The original chat Message
-     * @returns The message to include, or null to skip
-     */
-    transformMessage?: (aiMessage: AiMessage, source: Message) => AiMessage | null | Promise<AiMessage | null>;
-}
-/**
- * Convert chat SDK messages to AI SDK conversation format.
- *
- * - Filters out messages with empty/whitespace-only text
- * - Maps `author.isMe === true` to `"assistant"`, otherwise `"user"`
- * - Uses `message.text` for content
- * - Appends link metadata when available
- * - Includes image attachments and text files as `FilePart`
- * - Uses `fetchData()` when available to include attachment data inline (base64)
- * - Warns on unsupported attachment types (video, audio)
- *
- * Works with `FetchResult.messages`, `thread.recentMessages`, or collected iterables.
- *
- * @example
- * ```typescript
- * const result = await thread.adapter.fetchMessages(thread.id, { limit: 20 });
- * const history = await toAiMessages(result.messages);
- * const response = await agent.stream({ prompt: history });
- * ```
- */
-declare function toAiMessages(messages: Message[], options?: ToAiMessagesOptions): Promise<AiMessage[]>;
-
-interface MessageHistoryConfig {
-    /** Maximum messages to keep per thread (default: 100) */
-    maxMessages?: number;
-    /** TTL for cached history in milliseconds (default: 7 days) */
-    ttlMs?: number;
-}
-/**
- * Persistent message history cache backed by the StateAdapter.
- *
- * Used by adapters that lack server-side message history APIs (e.g., WhatsApp, Telegram).
- * Messages are atomically appended via `state.appendToList()`, which is safe
- * without holding a thread lock.
- */
-declare class MessageHistoryCache {
-    private readonly state;
-    private readonly maxMessages;
-    private readonly ttlMs;
-    constructor(state: StateAdapter, config?: MessageHistoryConfig);
-    /**
-     * Atomically append a message to the history for a thread.
-     * Trims to maxMessages (keeps newest) and refreshes TTL.
-     */
-    append(threadId: string, message: Message): Promise<void>;
-    /**
-     * Get messages for a thread in chronological order (oldest first).
-     *
-     * @param threadId - The thread ID
-     * @param limit - Optional limit on number of messages to return (returns newest N)
-     */
-    getMessages(threadId: string, limit?: number): Promise<Message[]>;
-}
-
-/**
- * Serialized channel data for passing to external systems (e.g., workflow engines).
- */
-interface SerializedChannel {
-    _type: "chat:Channel";
-    adapterName: string;
-    id: string;
-    isDM: boolean;
-}
-/**
- * Config for creating a ChannelImpl with explicit adapter/state instances.
- */
-interface ChannelImplConfigWithAdapter {
-    adapter: Adapter;
-    id: string;
-    isDM?: boolean;
-    messageHistory?: MessageHistoryCache;
-    stateAdapter: StateAdapter;
-}
-/**
- * Config for creating a ChannelImpl with lazy adapter resolution.
- */
-interface ChannelImplConfigLazy {
-    adapterName: string;
-    id: string;
-    isDM?: boolean;
-}
-type ChannelImplConfig = ChannelImplConfigWithAdapter | ChannelImplConfigLazy;
-declare class ChannelImpl<TState = Record<string, unknown>> implements Channel<TState> {
-    readonly id: string;
-    readonly isDM: boolean;
-    private _adapter?;
-    private readonly _adapterName?;
-    private _stateAdapterInstance?;
-    private _name;
-    private readonly _messageHistory?;
-    constructor(config: ChannelImplConfig);
-    get adapter(): Adapter;
-    private get _stateAdapter();
-    get name(): string | null;
-    get state(): Promise<TState | null>;
-    setState(newState: Partial<TState>, options?: {
-        replace?: boolean;
-    }): Promise<void>;
+ * - Assistant messages have string content only
+ */
+type AiMessage = AiUserMessage | AiAssistantMessage;
+interface AiUserMessage {
+    content: string | AiMessagePart[];
+    role: "user";
+}
+interface AiAssistantMessage {
+    content: string;
+    role: "assistant";
+}
+/**
+ * Options for converting messages to AI SDK format.
+ */
+interface ToAiMessagesOptions {
+    /** When true, prefixes user messages with "[username]: " for multi-user context */
+    includeNames?: boolean;
     /**
-     * Iterate messages newest first (backward from most recent).
-     * Uses adapter.fetchChannelMessages if available, otherwise falls back
-     * to adapter.fetchMessages with the channel ID.
+     * Called when an attachment type is not supported (video, audio).
+     * Defaults to `console.warn`.
      */
-    get messages(): AsyncIterable<Message>;
+    onUnsupportedAttachment?: (attachment: Attachment, message: Message) => void;
     /**
-     * Iterate threads in this channel, most recently active first.
+     * Called for each message after default processing (text, links, attachments).
+     * Return the message (modified or as-is) to include it, or `null` to skip it.
+     *
+     * @param aiMessage - The processed AI message
+     * @param source - The original chat Message
+     * @returns The message to include, or null to skip
      */
-    threads(): AsyncIterable<ThreadSummary>;
-    fetchMetadata(): Promise<ChannelInfo>;
-    post(message: string | PostableMessage | ChatElement): Promise<SentMessage>;
-    private postSingleMessage;
-    postEphemeral(user: string | Author, message: AdapterPostableMessage | ChatElement, options: PostEphemeralOptions): Promise<EphemeralMessage | null>;
-    schedule(message: AdapterPostableMessage | ChatElement, options: {
-        postAt: Date;
-    }): Promise<ScheduledMessage>;
-    startTyping(status?: string): Promise<void>;
-    mentionUser(userId: string): string;
-    toJSON(): SerializedChannel;
-    static fromJSON<TState = Record<string, unknown>>(json: SerializedChannel, adapter?: Adapter): ChannelImpl<TState>;
-    static [WORKFLOW_SERIALIZE](instance: ChannelImpl): SerializedChannel;
-    static [WORKFLOW_DESERIALIZE](data: SerializedChannel): ChannelImpl;
-    private createSentMessage;
+    transformMessage?: (aiMessage: AiMessage, source: Message) => AiMessage | null | Promise<AiMessage | null>;
 }
 /**
- * Derive the channel ID from a thread ID.
+ * Convert chat SDK messages to AI SDK conversation format.
+ *
+ * - Filters out messages with empty/whitespace-only text
+ * - Maps `author.isMe === true` to `"assistant"`, otherwise `"user"`
+ * - Uses `message.text` for content
+ * - Appends link metadata when available
+ * - Includes image attachments and text files as `FilePart`
+ * - Uses `fetchData()` when available to include attachment data inline (base64)
+ * - Warns on unsupported attachment types (video, audio)
+ *
+ * Works with `FetchResult.messages`, `thread.recentMessages`, or collected iterables.
+ *
+ * @example
+ * ```typescript
+ * const result = await thread.adapter.fetchMessages(thread.id, { limit: 20 });
+ * const history = await toAiMessages(result.messages);
+ * const response = await agent.stream({ prompt: history });
+ * ```
  */
-declare function deriveChannelId(adapter: Adapter, threadId: string): string;
+declare function toAiMessages(messages: Message[], options?: ToAiMessagesOptions): Promise<AiMessage[]>;
 
 /** Filter can be EmojiValue objects, emoji names, or raw emoji formats */
 type EmojiFilter = EmojiValue | string;
@@ -1917,6 +2193,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;
@@ -2286,6 +2565,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.
@@ -2294,9 +2579,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.
@@ -2304,6 +2616,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;
 }
 
@@ -2374,178 +2693,6 @@ declare class StreamingMarkdownRenderer {
     finish(): string;
 }
 
-/**
- * Serialized thread data for passing to external systems (e.g., workflow engines).
- */
-interface SerializedThread {
-    _type: "chat:Thread";
-    adapterName: string;
-    channelId: string;
-    currentMessage?: SerializedMessage;
-    id: string;
-    isDM: boolean;
-}
-/**
- * Config for creating a ThreadImpl with explicit adapter/state instances.
- */
-interface ThreadImplConfigWithAdapter {
-    adapter: Adapter;
-    channelId: string;
-    currentMessage?: Message;
-    fallbackStreamingPlaceholderText?: string | null;
-    id: string;
-    initialMessage?: Message;
-    isDM?: boolean;
-    isSubscribedContext?: boolean;
-    logger?: Logger;
-    messageHistory?: MessageHistoryCache;
-    stateAdapter: StateAdapter;
-    streamingUpdateIntervalMs?: number;
-}
-/**
- * Config for creating a ThreadImpl with lazy adapter resolution.
- * The adapter will be looked up from the Chat singleton on first access.
- */
-interface ThreadImplConfigLazy {
-    adapterName: string;
-    channelId: string;
-    currentMessage?: Message;
-    fallbackStreamingPlaceholderText?: string | null;
-    id: string;
-    initialMessage?: Message;
-    isDM?: boolean;
-    isSubscribedContext?: boolean;
-    logger?: Logger;
-    streamingUpdateIntervalMs?: number;
-}
-type ThreadImplConfig = ThreadImplConfigWithAdapter | ThreadImplConfigLazy;
-declare class ThreadImpl<TState = Record<string, unknown>> implements Thread<TState> {
-    readonly id: string;
-    readonly channelId: string;
-    readonly isDM: boolean;
-    /** Direct adapter instance (if provided) */
-    private _adapter?;
-    /** Adapter name for lazy resolution */
-    private readonly _adapterName?;
-    /** Direct state adapter instance (if provided) */
-    private _stateAdapterInstance?;
-    private _recentMessages;
-    private readonly _isSubscribedContext;
-    /** Current message context for streaming - provides userId/teamId */
-    private readonly _currentMessage?;
-    /** Update interval for fallback streaming */
-    private readonly _streamingUpdateIntervalMs;
-    /** Placeholder text for fallback streaming (post + edit) */
-    private readonly _fallbackStreamingPlaceholderText;
-    /** Cached channel instance */
-    private _channel?;
-    /** Message history cache (set only for adapters with persistMessageHistory) */
-    private readonly _messageHistory?;
-    private readonly _logger?;
-    constructor(config: ThreadImplConfig);
-    /**
-     * Get the adapter for this thread.
-     * If created with lazy config, resolves from Chat singleton on first access.
-     */
-    get adapter(): Adapter;
-    /**
-     * Get the state adapter for this thread.
-     * If created with lazy config, resolves from Chat singleton on first access.
-     */
-    private get _stateAdapter();
-    get recentMessages(): Message[];
-    set recentMessages(messages: Message[]);
-    /**
-     * Get the current thread state.
-     * Returns null if no state has been set.
-     */
-    get state(): Promise<TState | null>;
-    /**
-     * Set the thread state. Merges with existing state by default.
-     * State is persisted for 30 days.
-     */
-    setState(newState: Partial<TState>, options?: {
-        replace?: boolean;
-    }): Promise<void>;
-    /**
-     * Get the Channel containing this thread.
-     * Lazy-created and cached.
-     */
-    get channel(): Channel<TState>;
-    /**
-     * Iterate messages newest first (backward from most recent).
-     * Auto-paginates lazily.
-     */
-    get messages(): AsyncIterable<Message>;
-    get allMessages(): AsyncIterable<Message>;
-    isSubscribed(): Promise<boolean>;
-    subscribe(): Promise<void>;
-    unsubscribe(): Promise<void>;
-    post(message: string | PostableMessage | ChatElement): Promise<SentMessage>;
-    postEphemeral(user: string | Author, message: AdapterPostableMessage | ChatElement, options: PostEphemeralOptions): Promise<EphemeralMessage | null>;
-    schedule(message: AdapterPostableMessage | ChatElement, options: {
-        postAt: Date;
-    }): Promise<ScheduledMessage>;
-    /**
-     * Handle streaming from an AsyncIterable.
-     * Normalizes the stream (supports both textStream and fullStream from AI SDK),
-     * then uses adapter's native streaming if available, otherwise falls back to post+edit.
-     */
-    private handleStream;
-    startTyping(status?: string): Promise<void>;
-    /**
-     * Fallback streaming implementation using post + edit.
-     * Used when adapter doesn't support native streaming.
-     * Uses recursive setTimeout to send updates every intervalMs (default 500ms).
-     * Schedules next update only after current edit completes to avoid overwhelming slow services.
-     */
-    private fallbackStream;
-    refresh(): Promise<void>;
-    mentionUser(userId: string): string;
-    /**
-     * Serialize the thread to a plain JSON object.
-     * Use this to pass thread data to external systems like workflow engines.
-     *
-     * @example
-     * ```typescript
-     * // Pass to a workflow
-     * await workflow.start("my-workflow", {
-     *   thread: thread.toJSON(),
-     *   message: serializeMessage(message),
-     * });
-     * ```
-     */
-    toJSON(): SerializedThread;
-    /**
-     * Reconstruct a Thread from serialized JSON data.
-     *
-     * Reconstructs a ThreadImpl from serialized data.
-     * Uses lazy resolution from Chat.getSingleton() for adapter and state.
-     *
-     * @param json - Serialized thread data
-     * @requires Call `chat.registerSingleton()` before deserializing threads
-     *
-     * @example
-     * ```typescript
-     * const thread = ThreadImpl.fromJSON(serializedThread);
-     * ```
-     */
-    static fromJSON<TState = Record<string, unknown>>(json: SerializedThread, adapter?: Adapter): ThreadImpl<TState>;
-    /**
-     * Serialize a ThreadImpl instance for @workflow/serde.
-     * This static method is automatically called by workflow serialization.
-     */
-    static [WORKFLOW_SERIALIZE](instance: ThreadImpl): SerializedThread;
-    /**
-     * Deserialize a ThreadImpl from @workflow/serde.
-     * Uses lazy adapter resolution from Chat.getSingleton().
-     * Requires chat.registerSingleton() to have been called.
-     */
-    static [WORKFLOW_DESERIALIZE](data: SerializedThread): ThreadImpl;
-    private createSentMessage;
-    createSentMessageFromMessage(message: Message): SentMessage;
-}
-
 /**
  * Get or create an immutable singleton EmojiValue.
  *
@@ -2989,4 +3136,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, 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 };