chat 4.11.0 → 4.13.0

package/dist/index.d.ts

@@ -234,6 +234,29 @@ interface Adapter<TThreadId = unknown, TRawMessage = unknown> {
      * @returns The raw message after streaming completes
      */
     stream?(threadId: string, textStream: AsyncIterable<string>, options?: StreamOptions): Promise<RawMessage<TRawMessage>>;
+    /**
+     * Derive channel ID from a thread ID.
+     * Default fallback: first two colon-separated parts (e.g., "slack:C123").
+     * Adapters with different structures should override this.
+     */
+    channelIdFromThreadId?(threadId: string): string;
+    /**
+     * Fetch channel-level messages (top-level, not thread replies).
+     * For example, Slack's conversations.history vs conversations.replies.
+     */
+    fetchChannelMessages?(channelId: string, options?: FetchOptions): Promise<FetchResult<TRawMessage>>;
+    /**
+     * List threads in a channel.
+     */
+    listThreads?(channelId: string, options?: ListThreadsOptions): Promise<ListThreadsResult<TRawMessage>>;
+    /**
+     * Fetch channel info/metadata.
+     */
+    fetchChannelInfo?(channelId: string): Promise<ChannelInfo>;
+    /**
+     * Post a message to channel top-level (not in a thread).
+     */
+    postChannelMessage?(channelId: string, message: AdapterPostableMessage): Promise<RawMessage<TRawMessage>>;
 }
 /**
  * Options for streaming messages.
@@ -246,6 +269,8 @@ interface StreamOptions {
     recipientTeamId?: string;
     /** Minimum interval between updates in ms (default: 1000). Used for fallback mode (GChat/Teams). */
     updateIntervalMs?: number;
+    /** Block Kit elements to attach when stopping the stream (Slack only, via chat.stopStream) */
+    stopBlocks?: unknown[];
 }
 /** Internal interface for Chat instance passed to adapters */
 interface ChatInstance {
@@ -286,19 +311,33 @@ interface ChatInstance {
     /**
      * Process a modal submit event from an adapter.
      *
-     * @param event - The modal submit event (without relatedThread/relatedMessage)
-     * @param contextId - Context ID for retrieving stored thread/message context
+     * @param event - The modal submit event (without relatedThread/relatedMessage/relatedChannel)
+     * @param contextId - Context ID for retrieving stored thread/message/channel context
      * @param options - Webhook options
      */
-    processModalSubmit(event: Omit<ModalSubmitEvent, "relatedThread" | "relatedMessage">, contextId?: string, options?: WebhookOptions): Promise<ModalResponse | undefined>;
+    processModalSubmit(event: Omit<ModalSubmitEvent, "relatedThread" | "relatedMessage" | "relatedChannel">, contextId?: string, options?: WebhookOptions): Promise<ModalResponse | undefined>;
     /**
      * Process a modal close event from an adapter.
      *
-     * @param event - The modal close event (without relatedThread/relatedMessage)
-     * @param contextId - Context ID for retrieving stored thread/message context
+     * @param event - The modal close event (without relatedThread/relatedMessage/relatedChannel)
+     * @param contextId - Context ID for retrieving stored thread/message/channel context
      * @param options - Webhook options
      */
-    processModalClose(event: Omit<ModalCloseEvent, "relatedThread" | "relatedMessage">, contextId?: string, options?: WebhookOptions): void;
+    processModalClose(event: Omit<ModalCloseEvent, "relatedThread" | "relatedMessage" | "relatedChannel">, contextId?: string, options?: WebhookOptions): void;
+    /**
+     * Process an incoming slash command from an adapter.
+     * Handles waitUntil registration and error catching internally.
+     *
+     * @param event - The slash command event
+     * @param options - Webhook options including waitUntil
+     */
+    processSlashCommand(event: Omit<SlashCommandEvent, "channel" | "openModal"> & {
+        adapter: Adapter;
+        channelId: string;
+    }, options?: WebhookOptions): void;
+    processAssistantThreadStarted(event: AssistantThreadStartedEvent, options?: WebhookOptions): void;
+    processAssistantContextChanged(event: AssistantContextChangedEvent, options?: WebhookOptions): void;
+    processAppHomeOpened(event: AppHomeOpenedEvent, options?: WebhookOptions): void;
     getState(): StateAdapter;
     getUserName(): string;
     /** Get the configured logger, optionally with a child prefix */
@@ -335,54 +374,121 @@ interface Lock {
     token: string;
     expiresAt: number;
 }
-/** Default TTL for thread state (30 days in milliseconds) */
-declare const THREAD_STATE_TTL_MS: number;
 /**
- * Thread interface with support for custom state.
- * @template TState - Custom state type stored per-thread (default: Record<string, unknown>)
+ * Base interface for entities that can receive messages.
+ * Both Thread and Channel extend this interface.
+ *
+ * @template TState - Custom state type stored per entity
  * @template TRawMessage - Platform-specific raw message type
  */
-interface Thread<TState = Record<string, unknown>, TRawMessage = unknown> {
-    /** Unique thread ID (format: "adapter:channel:thread") */
+interface Postable<TState = Record<string, unknown>, TRawMessage = unknown> {
+    /** Unique ID */
     readonly id: string;
-    /** The adapter this thread belongs to */
+    /** The adapter this entity belongs to */
     readonly adapter: Adapter;
-    /** Channel/conversation ID */
-    readonly channelId: string;
     /** Whether this is a direct message conversation */
     readonly isDM: boolean;
     /**
-     * Get the current thread state.
+     * Get the current state.
      * Returns null if no state has been set.
-     *
-     * @example
-     * ```typescript
-     * const state = await thread.state;
-     * if (state?.aiMode) {
-     *   // AI mode is enabled
-     * }
-     * ```
      */
     readonly state: Promise<TState | null>;
     /**
-     * Set the thread state. Merges with existing state by default.
-     * State is persisted for 30 days.
-     *
-     * @param state - Partial state to merge, or full state if replace is true
-     * @param options - Options for setting state
-     *
-     * @example
-     * ```typescript
-     * // Merge with existing state
-     * await thread.setState({ aiMode: true });
-     *
-     * // Replace entire state
-     * await thread.setState({ aiMode: true }, { replace: true });
-     * ```
+     * Set the state. Merges with existing state by default.
      */
     setState(state: Partial<TState>, options?: {
         replace?: boolean;
     }): Promise<void>;
+    /**
+     * Iterate messages newest first (backward from most recent).
+     * Auto-paginates lazily — only fetches pages as consumed.
+     */
+    readonly messages: AsyncIterable<Message<TRawMessage>>;
+    /**
+     * Post a message.
+     */
+    post(message: string | PostableMessage | CardJSXElement): Promise<SentMessage<TRawMessage>>;
+    /**
+     * Post an ephemeral message visible only to a specific user.
+     */
+    postEphemeral(user: string | Author, message: AdapterPostableMessage | CardJSXElement, options: PostEphemeralOptions): Promise<EphemeralMessage | null>;
+    /** Show typing indicator */
+    startTyping(): Promise<void>;
+    /**
+     * Get a platform-specific mention string for a user.
+     */
+    mentionUser(userId: string): string;
+}
+/**
+ * Represents a channel/conversation container that holds threads.
+ * Extends Postable for message posting capabilities.
+ *
+ * @template TState - Custom state type stored per channel
+ * @template TRawMessage - Platform-specific raw message type
+ */
+interface Channel<TState = Record<string, unknown>, TRawMessage = unknown> extends Postable<TState, TRawMessage> {
+    /** Channel name (e.g., "#general"). Null until fetchInfo() is called. */
+    readonly name: string | null;
+    /**
+     * Iterate threads in this channel, most recently active first.
+     * Returns ThreadSummary (lightweight) for efficiency.
+     * Empty iterable on threadless platforms.
+     */
+    threads(): AsyncIterable<ThreadSummary<TRawMessage>>;
+    /** Fetch channel metadata from the platform */
+    fetchMetadata(): Promise<ChannelInfo>;
+}
+/**
+ * Lightweight summary of a thread within a channel.
+ */
+interface ThreadSummary<TRawMessage = unknown> {
+    /** Full thread ID */
+    id: string;
+    /** Root/first message of the thread */
+    rootMessage: Message<TRawMessage>;
+    /** Reply count (if available) */
+    replyCount?: number;
+    /** Timestamp of most recent reply */
+    lastReplyAt?: Date;
+}
+/**
+ * Channel metadata returned by fetchInfo().
+ */
+interface ChannelInfo {
+    id: string;
+    name?: string;
+    isDM?: boolean;
+    memberCount?: number;
+    metadata: Record<string, unknown>;
+}
+/**
+ * Options for listing threads in a channel.
+ */
+interface ListThreadsOptions {
+    limit?: number;
+    cursor?: string;
+}
+/**
+ * Result of listing threads in a channel.
+ */
+interface ListThreadsResult<TRawMessage = unknown> {
+    threads: ThreadSummary<TRawMessage>[];
+    nextCursor?: string;
+}
+/** Default TTL for thread state (30 days in milliseconds) */
+declare const THREAD_STATE_TTL_MS: number;
+/**
+ * Thread interface with support for custom state.
+ * Extends Postable for shared message posting capabilities.
+ *
+ * @template TState - Custom state type stored per-thread (default: Record<string, unknown>)
+ * @template TRawMessage - Platform-specific raw message type
+ */
+interface Thread<TState = Record<string, unknown>, TRawMessage = unknown> extends Postable<TState, TRawMessage> {
+    /** Channel/conversation ID */
+    readonly channelId: string;
+    /** Get the Channel containing this thread */
+    readonly channel: Channel<TState, TRawMessage>;
     /** Recently fetched messages (cached) */
     recentMessages: Message<TRawMessage>[];
     /**
@@ -1014,6 +1120,11 @@ interface ModalSubmitEvent<TRawMessage = unknown> {
      * This is a SentMessage with edit/delete capabilities.
      */
     relatedMessage?: SentMessage<TRawMessage>;
+    /**
+     * The channel where the modal was originally triggered from.
+     * Available when the modal was opened via SlashCommandEvent.openModal().
+     */
+    relatedChannel?: Channel<Record<string, unknown>, TRawMessage>;
 }
 /**
  * Event emitted when a user closes/cancels a modal (requires notifyOnClose).
@@ -1045,6 +1156,11 @@ interface ModalCloseEvent<TRawMessage = unknown> {
      * This is a SentMessage with edit/delete capabilities.
      */
     relatedMessage?: SentMessage<TRawMessage>;
+    /**
+     * The channel where the modal was originally triggered from.
+     * Available when the modal was opened via SlashCommandEvent.openModal().
+     */
+    relatedChannel?: Channel<Record<string, unknown>, TRawMessage>;
 }
 type ModalErrorsResponse = {
     action: "errors";
@@ -1064,6 +1180,123 @@ type ModalCloseResponse = {
 type ModalResponse = ModalCloseResponse | ModalErrorsResponse | ModalUpdateResponse | ModalPushResponse;
 type ModalSubmitHandler = (event: ModalSubmitEvent) => Promise<ModalResponse | undefined>;
 type ModalCloseHandler = (event: ModalCloseEvent) => Promise<void>;
+/**
+ * Event emitted when a user invokes a slash command.
+ *
+ * Slash commands are triggered when a user types `/command` in the message composer.
+ * The event provides access to the channel where the command was invoked, allowing
+ * you to post responses using standard SDK methods.
+ *
+ * @example
+ * ```typescript
+ * chat.onSlashCommand("/help", async (event) => {
+ *   // Post visible to everyone in the channel
+ *   await event.channel.post("Here are the available commands...");
+ * });
+ *
+ * chat.onSlashCommand("/secret", async (event) => {
+ *   // Post ephemeral (only the invoking user sees it)
+ *   await event.channel.postEphemeral(
+ *     event.user,
+ *     "This is just for you!",
+ *     { fallbackToDM: false }
+ *   );
+ * });
+ *
+ * chat.onSlashCommand("/feedback", async (event) => {
+ *   // Open a modal
+ *   await event.openModal({
+ *     type: "modal",
+ *     callbackId: "feedback_modal",
+ *     title: "Submit Feedback",
+ *     children: [{ type: "text_input", id: "feedback", label: "Your feedback" }],
+ *   });
+ * });
+ * ```
+ */
+interface SlashCommandEvent<TState = Record<string, unknown>> {
+    /** The slash command name (e.g., "/help") */
+    command: string;
+    /** Arguments text after the command (e.g., "topic search" from "/help topic search") */
+    text: string;
+    /** The user who invoked the command */
+    user: Author;
+    /** The channel where the command was invoked */
+    channel: Channel<TState>;
+    /** The adapter that received this event */
+    adapter: Adapter;
+    /** Platform-specific raw payload */
+    raw: unknown;
+    /** Trigger ID for opening modals (time-limited, typically ~3 seconds) */
+    triggerId?: string;
+    /**
+     * Open a modal/dialog form in response to this slash command.
+     *
+     * @param modal - The modal element to display (JSX or ModalElement)
+     * @returns The view/dialog ID, or undefined if modals are not supported
+     */
+    openModal(modal: ModalElement | CardJSXElement): Promise<{
+        viewId: string;
+    } | undefined>;
+}
+/**
+ * Handler for slash command events.
+ *
+ * @example
+ * ```typescript
+ * // Handle a specific command
+ * chat.onSlashCommand("/status", async (event) => {
+ *   await event.channel.post("All systems operational!");
+ * });
+ *
+ * // Handle multiple commands
+ * chat.onSlashCommand(["/help", "/info"], async (event) => {
+ *   await event.channel.post(`You invoked ${event.command}`);
+ * });
+ *
+ * // Catch-all handler
+ * chat.onSlashCommand(async (event) => {
+ *   console.log(`Command: ${event.command}, Args: ${event.text}`);
+ * });
+ * ```
+ */
+type SlashCommandHandler<TState = Record<string, unknown>> = (event: SlashCommandEvent<TState>) => Promise<void>;
+interface AssistantThreadStartedEvent {
+    threadId: string;
+    userId: string;
+    channelId: string;
+    threadTs: string;
+    context: {
+        channelId?: string;
+        teamId?: string;
+        enterpriseId?: string;
+        threadEntryPoint?: string;
+        forceSearch?: boolean;
+    };
+    adapter: Adapter;
+}
+type AssistantThreadStartedHandler = (event: AssistantThreadStartedEvent) => Promise<void>;
+interface AssistantContextChangedEvent {
+    threadId: string;
+    userId: string;
+    channelId: string;
+    threadTs: string;
+    context: {
+        channelId?: string;
+        teamId?: string;
+        enterpriseId?: string;
+        threadEntryPoint?: string;
+        forceSearch?: boolean;
+    };
+    adapter: Adapter;
+}
+type AssistantContextChangedHandler = (event: AssistantContextChangedEvent) => Promise<void>;
+interface AppHomeOpenedEvent {
+    userId: string;
+    channelId: string;
+    adapter: Adapter;
+}
+type AppHomeOpenedHandler = (event: AppHomeOpenedEvent) => Promise<void>;
 
 /**
  * Message class with serialization support for workflow engines.
@@ -1212,6 +1445,77 @@ declare class Message<TRawMessage = unknown> {
     static [WORKFLOW_DESERIALIZE](data: SerializedMessage): Message;
 }
 
+/**
+ * Serialized channel data for passing to external systems (e.g., workflow engines).
+ */
+interface SerializedChannel {
+    _type: "chat:Channel";
+    id: string;
+    adapterName: string;
+    isDM: boolean;
+}
+/**
+ * Config for creating a ChannelImpl with explicit adapter/state instances.
+ */
+interface ChannelImplConfigWithAdapter {
+    id: string;
+    adapter: Adapter;
+    stateAdapter: StateAdapter;
+    isDM?: boolean;
+}
+/**
+ * Config for creating a ChannelImpl with lazy adapter resolution.
+ */
+interface ChannelImplConfigLazy {
+    id: string;
+    adapterName: 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 _adapterName?;
+    private _stateAdapterInstance?;
+    private _name;
+    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 | CardJSXElement): Promise<SentMessage>;
+    private postSingleMessage;
+    postEphemeral(user: string | Author, message: AdapterPostableMessage | CardJSXElement, options: PostEphemeralOptions): Promise<EphemeralMessage | null>;
+    startTyping(): 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.
+ * Uses adapter.channelIdFromThreadId if available, otherwise defaults to
+ * first two colon-separated parts.
+ */
+declare function deriveChannelId(adapter: Adapter, threadId: string): string;
+
 /** Filter can be EmojiValue objects, emoji names, or raw emoji formats */
 type EmojiFilter = EmojiValue | string;
 /**
@@ -1288,6 +1592,10 @@ declare class Chat<TAdapters extends Record<string, Adapter> = Record<string, Ad
     private actionHandlers;
     private modalSubmitHandlers;
     private modalCloseHandlers;
+    private slashCommandHandlers;
+    private assistantThreadStartedHandlers;
+    private assistantContextChangedHandlers;
+    private appHomeOpenedHandlers;
     /** Initialization state */
     private initPromise;
     private initialized;
@@ -1445,6 +1753,48 @@ declare class Chat<TAdapters extends Record<string, Adapter> = Record<string, Ad
     onModalClose(handler: ModalCloseHandler): void;
     onModalClose(callbackId: string, handler: ModalCloseHandler): void;
     onModalClose(callbackIds: string[], handler: ModalCloseHandler): void;
+    /**
+     * Register a handler for slash command events.
+     *
+     * Slash commands are triggered when a user types `/command` in the message composer.
+     * Use `event.channel.post()` or `event.channel.postEphemeral()` to respond.
+     *
+     * @example
+     * ```typescript
+     * // Handle a specific command
+     * chat.onSlashCommand("/help", async (event) => {
+     *   await event.channel.post("Here are the available commands...");
+     * });
+     *
+     * // Handle multiple commands
+     * chat.onSlashCommand(["/status", "/health"], async (event) => {
+     *   await event.channel.post("All systems operational!");
+     * });
+     *
+     * // Handle all commands (catch-all)
+     * chat.onSlashCommand(async (event) => {
+     *   console.log(`Received command: ${event.command} ${event.text}`);
+     * });
+     *
+     * // Open a modal from a slash command
+     * chat.onSlashCommand("/feedback", async (event) => {
+     *   await event.openModal({
+     *     callbackId: "feedback_modal",
+     *     title: "Submit Feedback",
+     *     inputs: [{ id: "feedback", type: "text_input", label: "Your feedback" }],
+     *   });
+     * });
+     * ```
+     *
+     * @param commandOrHandler - Either a command, array of commands, or the handler
+     * @param handler - The handler (if command filter is provided)
+     */
+    onSlashCommand(handler: SlashCommandHandler<TState>): void;
+    onSlashCommand(command: string, handler: SlashCommandHandler<TState>): void;
+    onSlashCommand(commands: string[], handler: SlashCommandHandler<TState>): void;
+    onAssistantThreadStarted(handler: AssistantThreadStartedHandler): void;
+    onAssistantContextChanged(handler: AssistantContextChangedHandler): void;
+    onAppHomeOpened(handler: AppHomeOpenedHandler): void;
     /**
      * Get an adapter by name with type safety.
      */
@@ -1489,16 +1839,31 @@ declare class Chat<TAdapters extends Record<string, Adapter> = Record<string, Ad
     processAction(event: Omit<ActionEvent, "thread" | "openModal"> & {
         adapter: Adapter;
     }, options?: WebhookOptions): void;
-    processModalSubmit(event: Omit<ModalSubmitEvent, "relatedThread" | "relatedMessage">, contextId?: string, _options?: WebhookOptions): Promise<ModalResponse | undefined>;
-    processModalClose(event: Omit<ModalCloseEvent, "relatedThread" | "relatedMessage">, contextId?: string, options?: WebhookOptions): void;
+    processModalSubmit(event: Omit<ModalSubmitEvent, "relatedThread" | "relatedMessage" | "relatedChannel">, contextId?: string, _options?: WebhookOptions): Promise<ModalResponse | undefined>;
+    processModalClose(event: Omit<ModalCloseEvent, "relatedThread" | "relatedMessage" | "relatedChannel">, contextId?: string, options?: WebhookOptions): void;
+    /**
+     * Process an incoming slash command from an adapter.
+     * Handles waitUntil registration and error catching internally.
+     */
+    processSlashCommand(event: Omit<SlashCommandEvent, "channel" | "openModal"> & {
+        adapter: Adapter;
+        channelId: string;
+    }, options?: WebhookOptions): void;
+    processAssistantThreadStarted(event: AssistantThreadStartedEvent, options?: WebhookOptions): void;
+    processAssistantContextChanged(event: AssistantContextChangedEvent, options?: WebhookOptions): void;
+    processAppHomeOpened(event: AppHomeOpenedEvent, options?: WebhookOptions): void;
+    /**
+     * Handle a slash command event internally.
+     */
+    private handleSlashCommandEvent;
     /**
      * Store modal context server-side with a context ID.
-     * Called when opening a modal to preserve thread/message for the submit handler.
+     * Called when opening a modal to preserve thread/message/channel for the submit handler.
      */
     private storeModalContext;
     /**
      * Retrieve and delete modal context from server-side storage.
-     * Called when processing modal submit/close to reconstruct thread/message.
+     * Called when processing modal submit/close to reconstruct thread/message/channel.
      */
     private retrieveModalContext;
     /**
@@ -1540,6 +1905,33 @@ declare class Chat<TAdapters extends Record<string, Adapter> = Record<string, Ad
      * ```
      */
     openDM(user: string | Author): Promise<Thread<TState>>;
+    /**
+     * Get a Channel by its channel ID.
+     *
+     * The adapter is automatically inferred from the channel ID prefix.
+     *
+     * @param channelId - Channel ID (e.g., "slack:C123ABC", "gchat:spaces/ABC123")
+     * @returns A Channel that can be used to list threads, post messages, iterate messages, etc.
+     *
+     * @example
+     * ```typescript
+     * const channel = chat.channel("slack:C123ABC");
+     *
+     * // Iterate messages newest first
+     * for await (const msg of channel.messages) {
+     *   console.log(msg.text);
+     * }
+     *
+     * // List threads
+     * for await (const t of channel.threads()) {
+     *   console.log(t.rootMessage.text, t.replyCount);
+     * }
+     *
+     * // Post to channel
+     * await channel.post("Hello channel!");
+     * ```
+     */
+    channel(channelId: string): Channel<TState>;
     /**
      * Infer which adapter to use based on the userId format.
      */
@@ -1620,6 +2012,8 @@ declare class ThreadImpl<TState = Record<string, unknown>> implements Thread<TSt
     private _currentMessage?;
     /** Update interval for fallback streaming */
     private _streamingUpdateIntervalMs;
+    /** Cached channel instance */
+    private _channel?;
     constructor(config: ThreadImplConfig);
     /**
      * Get the adapter for this thread.
@@ -1645,6 +2039,16 @@ declare class ThreadImpl<TState = Record<string, unknown>> implements Thread<TSt
     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>;
@@ -2103,4 +2507,4 @@ declare const Select: typeof Select$1;
 declare const SelectOption: typeof SelectOption$1;
 declare const TextInput: typeof TextInput$1;
 
-export { type ActionEvent, type ActionHandler, Actions, type Adapter, type AdapterPostableMessage, type Attachment, type Author, BaseFormatConverter, Button, Card, CardChild, CardElement, CardJSXElement, CardText, Chat, type ChatConfig, ChatError, type ChatInstance, ConsoleLogger, type CustomEmojiMap, DEFAULT_EMOJI_MAP, Divider, type Emoji, type EmojiFormats, type EmojiMapConfig, EmojiResolver, type EmojiValue, type EphemeralMessage, type FetchDirection, type FetchOptions, type FetchResult, Field, Fields, type FileUpload, type FormatConverter, type FormattedContent, Image, LinkButton, type Lock, LockError, type LogLevel, type Logger, type MarkdownConverter, type MentionHandler, Message, type MessageData, type MessageHandler, type MessageMetadata, Modal, type ModalCloseEvent, type ModalCloseHandler, type ModalCloseResponse, ModalElement, type ModalErrorsResponse, type ModalPushResponse, type ModalResponse, type ModalSubmitEvent, type ModalSubmitHandler, type ModalUpdateResponse, NotImplementedError, type PostEphemeralOptions, type PostableAst, type PostableCard, type PostableMarkdown, type PostableMessage, type PostableRaw, RadioSelect, RateLimitError, type RawMessage, type ReactionEvent, type ReactionHandler, Section, Select, SelectOption, type SentMessage, type SerializedMessage, type SerializedThread, type StateAdapter, type StreamOptions, type SubscribedMessageHandler, THREAD_STATE_TTL_MS, TextInput, type Thread, ThreadImpl, type ThreadInfo, type WebhookOptions, type WellKnownEmoji, blockquote, codeBlock, convertEmojiPlaceholders, createEmoji, defaultEmojiResolver, emoji, emphasis, fromReactElement, fromReactModalElement, getEmoji, getNodeChildren, getNodeValue, inlineCode, isBlockquoteNode, isCardElement, isCodeNode, isDeleteNode, isEmphasisNode, isInlineCodeNode, isJSX, isLinkNode, isListItemNode, isListNode, isModalElement, isParagraphNode, isStrongNode, isTextNode, link, markdownToPlainText, paragraph, parseMarkdown, root, strikethrough, stringifyMarkdown, strong, text, toCardElement, toModalElement, toPlainText, walkAst };
+export { type ActionEvent, type ActionHandler, Actions, type Adapter, type AdapterPostableMessage, type AppHomeOpenedEvent, type AppHomeOpenedHandler, type AssistantContextChangedEvent, type AssistantContextChangedHandler, type AssistantThreadStartedEvent, type AssistantThreadStartedHandler, type Attachment, type Author, BaseFormatConverter, Button, Card, CardChild, CardElement, CardJSXElement, CardText, type Channel, ChannelImpl, type ChannelInfo, Chat, type ChatConfig, ChatError, type ChatInstance, ConsoleLogger, type CustomEmojiMap, DEFAULT_EMOJI_MAP, Divider, type Emoji, type EmojiFormats, type EmojiMapConfig, EmojiResolver, type EmojiValue, type EphemeralMessage, type FetchDirection, type FetchOptions, type FetchResult, Field, Fields, type FileUpload, type FormatConverter, type FormattedContent, Image, LinkButton, type ListThreadsOptions, type ListThreadsResult, type Lock, LockError, type LogLevel, type Logger, type MarkdownConverter, type MentionHandler, Message, type MessageData, type MessageHandler, type MessageMetadata, Modal, type ModalCloseEvent, type ModalCloseHandler, type ModalCloseResponse, ModalElement, type ModalErrorsResponse, type ModalPushResponse, type ModalResponse, type ModalSubmitEvent, type ModalSubmitHandler, type ModalUpdateResponse, NotImplementedError, type PostEphemeralOptions, type Postable, type PostableAst, type PostableCard, type PostableMarkdown, type PostableMessage, type PostableRaw, RadioSelect, RateLimitError, type RawMessage, type ReactionEvent, type ReactionHandler, Section, Select, SelectOption, type SentMessage, type SerializedChannel, type SerializedMessage, type SerializedThread, type SlashCommandEvent, type SlashCommandHandler, type StateAdapter, type StreamOptions, type SubscribedMessageHandler, THREAD_STATE_TTL_MS, TextInput, type Thread, ThreadImpl, type ThreadInfo, type ThreadSummary, type WebhookOptions, type WellKnownEmoji, blockquote, codeBlock, convertEmojiPlaceholders, createEmoji, defaultEmojiResolver, deriveChannelId, emoji, emphasis, fromReactElement, fromReactModalElement, getEmoji, getNodeChildren, getNodeValue, inlineCode, isBlockquoteNode, isCardElement, isCodeNode, isDeleteNode, isEmphasisNode, isInlineCodeNode, isJSX, isLinkNode, isListItemNode, isListNode, isModalElement, isParagraphNode, isStrongNode, isTextNode, link, markdownToPlainText, paragraph, parseMarkdown, root, strikethrough, stringifyMarkdown, strong, text, toCardElement, toModalElement, toPlainText, walkAst };