chat 4.13.1 → 4.13.2

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { C as CardElement, a as CardJSXElement, M as ModalElement, b as CardChild, A as Actions$1, B as Button$1, c as Card$1, T as Text$1, D as Divider$1, F as Field$1, d as Fields$1, f as fromReactElement$1, I as Image$1, i as isCardElement$1, e as isJSX$1, L as LinkButton$1, S as Section$1, t as toCardElement$1, g as toModalElement$1, h as fromReactModalElement$1, j as isModalElement$1, k as Modal$1, R as RadioSelect$1, l as Select$1, m as SelectOption$1, n as TextInput$1 } from './jsx-runtime-COVsDskT.js';
-export { y as ActionsElement, z as ButtonElement, E as ButtonOptions, o as ButtonProps, G as ButtonStyle, p as CardJSXProps, H as CardOptions, q as CardProps, r as ContainerProps, J as DividerElement, s as DividerProps, K as FieldElement, u as FieldProps, N as FieldsElement, O as ImageElement, v as ImageProps, P as LinkButtonElement, Q as LinkButtonOptions, w as LinkButtonProps, X as ModalChild, Y as ModalOptions, Z as RadioSelectElement, _ as RadioSelectOptions, U as SectionElement, $ as SelectElement, a0 as SelectOptionElement, a1 as SelectOptions, V as TextElement, a2 as TextInputElement, a3 as TextInputOptions, x as TextProps, W as TextStyle } from './jsx-runtime-COVsDskT.js';
+import { C as CardElement, M as ModalElement, a as CardJSXElement, b as CardChild, A as Actions$1, B as Button$1, c as Card$1, T as Text$1, D as Divider$1, F as Field$1, d as Fields$1, f as fromReactElement$1, I as Image$1, i as isCardElement$1, e as isJSX$1, L as LinkButton$1, S as Section$1, t as toCardElement$1, g as toModalElement$1, h as fromReactModalElement$1, j as isModalElement$1, k as Modal$1, R as RadioSelect$1, l as Select$1, m as SelectOption$1, n as TextInput$1 } from './jsx-runtime-Bdt1Dwzf.js';
+export { o as ActionsElement, p as ButtonElement, q as ButtonOptions, J as ButtonProps, r as ButtonStyle, K as CardJSXProps, s as CardOptions, N as CardProps, O as ContainerProps, u as DividerElement, P as DividerProps, v as FieldElement, Q as FieldProps, w as FieldsElement, x as ImageElement, U as ImageProps, y as LinkButtonElement, z as LinkButtonOptions, V as LinkButtonProps, X as ModalChild, Y as ModalOptions, Z as RadioSelectElement, _ as RadioSelectOptions, E as SectionElement, $ as SelectElement, a0 as SelectOptionElement, a1 as SelectOptions, G as TextElement, a2 as TextInputElement, a3 as TextInputOptions, W as TextProps, H as TextStyle } from './jsx-runtime-Bdt1Dwzf.js';
 import { WORKFLOW_SERIALIZE, WORKFLOW_DESERIALIZE } from '@workflow/serde';
 import { Root, Content, Blockquote, Code, Emphasis, InlineCode, Delete, Link, ListItem, List, Paragraph, Strong, Text } from 'mdast';
 export { Blockquote, Code, Content, Delete, Emphasis, InlineCode, Link, List, ListItem, Paragraph, Root, Strong, Text } from 'mdast';
@@ -9,19 +9,19 @@ export { Blockquote, Code, Content, Delete, Emphasis, InlineCode, Link, List, Li
  */
 type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
 interface Logger {
+    /** Create a sub-logger with a prefix */
+    child(prefix: string): Logger;
     debug(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
     info(message: string, ...args: unknown[]): void;
     warn(message: string, ...args: unknown[]): void;
-    error(message: string, ...args: unknown[]): void;
-    /** Create a sub-logger with a prefix */
-    child(prefix: string): Logger;
 }
 /**
  * Default console logger implementation.
  */
 declare class ConsoleLogger implements Logger {
-    private level;
-    private prefix;
+    private readonly prefix;
+    private readonly level;
     constructor(level?: LogLevel, prefix?: string);
     private shouldLog;
     child(prefix: string): Logger;
@@ -36,19 +36,19 @@ declare class ConsoleLogger implements Logger {
  */
 declare class ChatError extends Error {
     readonly code: string;
-    readonly cause?: unknown | undefined;
-    constructor(message: string, code: string, cause?: unknown | undefined);
+    readonly cause?: unknown;
+    constructor(message: string, code: string, cause?: unknown);
 }
 declare class RateLimitError extends ChatError {
-    readonly retryAfterMs?: number | undefined;
-    constructor(message: string, retryAfterMs?: number | undefined, cause?: unknown);
+    readonly retryAfterMs?: number;
+    constructor(message: string, retryAfterMs?: number, cause?: unknown);
 }
 declare class LockError extends ChatError {
     constructor(message: string, cause?: unknown);
 }
 declare class NotImplementedError extends ChatError {
-    readonly feature?: string | undefined;
-    constructor(message: string, feature?: string | undefined, cause?: unknown);
+    readonly feature?: string;
+    constructor(message: string, feature?: string, cause?: unknown);
 }
 
 /**
@@ -56,22 +56,22 @@ declare class NotImplementedError extends ChatError {
  * @template TAdapters - Record of adapter name to adapter instance
  */
 interface ChatConfig<TAdapters extends Record<string, Adapter> = Record<string, Adapter>> {
-    /** Default bot username across all adapters */
-    userName: string;
     /** Map of adapter name to adapter instance */
     adapters: TAdapters;
-    /** State adapter for subscriptions and locking */
-    state: StateAdapter;
     /**
      * Logger instance or log level.
      * Pass "silent" to disable all logging.
      */
     logger: Logger | LogLevel;
+    /** State adapter for subscriptions and locking */
+    state: StateAdapter;
     /**
      * Update interval for fallback streaming (post + edit) in milliseconds.
      * Defaults to 500ms. Lower values provide smoother updates but may hit rate limits.
      */
     streamingUpdateIntervalMs?: number;
+    /** Default bot username across all adapters */
+    userName: string;
 }
 /**
  * Options for webhook handling.
@@ -99,28 +99,42 @@ interface WebhookOptions {
  * @template TRawMessage - Platform-specific raw message type
  */
 interface Adapter<TThreadId = unknown, TRawMessage = unknown> {
-    /** Unique name for this adapter (e.g., "slack", "teams") */
-    readonly name: string;
-    /** Bot username (can override global userName) */
-    readonly userName: string;
+    /** Add a reaction to a message */
+    addReaction(threadId: string, messageId: string, emoji: EmojiValue | string): Promise<void>;
     /** Bot user ID for platforms that use IDs in mentions (e.g., Slack's <@U123>) */
     readonly botUserId?: string;
-    /** Called when Chat instance is created (internal use) */
-    initialize(chat: ChatInstance): Promise<void>;
-    /** Handle incoming webhook request */
-    handleWebhook(request: Request, options?: WebhookOptions): Promise<Response>;
-    /** Post a message to a thread */
-    postMessage(threadId: string, message: AdapterPostableMessage): Promise<RawMessage<TRawMessage>>;
-    /** Edit an existing message */
-    editMessage(threadId: string, messageId: string, message: AdapterPostableMessage): 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;
+    /** Decode thread ID string back to platform-specific data */
+    decodeThreadId(threadId: string): TThreadId;
     /** Delete a message */
     deleteMessage(threadId: string, messageId: string): Promise<void>;
-    /** Add a reaction to a message */
-    addReaction(threadId: string, messageId: string, emoji: EmojiValue | string): Promise<void>;
-    /** Remove a reaction from a message */
-    removeReaction(threadId: string, messageId: string, emoji: EmojiValue | string): Promise<void>;
-    /** Show typing indicator */
-    startTyping(threadId: string): 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 */
+    encodeThreadId(platformData: TThreadId): string;
+    /**
+     * Fetch channel info/metadata.
+     */
+    fetchChannelInfo?(channelId: string): Promise<ChannelInfo>;
+    /**
+     * 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>>;
+    /**
+     * Fetch a single message by ID.
+     * Optional - adapters that don't implement this will return null.
+     *
+     * @param threadId - The thread ID containing the message
+     * @param messageId - The platform-specific message ID
+     * @returns The message, or null if not found/not supported
+     */
+    fetchMessage?(threadId: string, messageId: string): Promise<Message<TRawMessage> | null>;
     /**
      * Fetch messages from a thread.
      *
@@ -156,23 +170,23 @@ interface Adapter<TThreadId = unknown, TRawMessage = unknown> {
     fetchMessages(threadId: string, options?: FetchOptions): Promise<FetchResult<TRawMessage>>;
     /** Fetch thread metadata */
     fetchThread(threadId: string): Promise<ThreadInfo>;
+    /** Handle incoming webhook request */
+    handleWebhook(request: Request, options?: WebhookOptions): Promise<Response>;
+    /** Called when Chat instance is created (internal use) */
+    initialize(chat: ChatInstance): Promise<void>;
     /**
-     * Fetch a single message by ID.
-     * Optional - adapters that don't implement this will return null.
+     * Check if a thread is a direct message conversation.
      *
-     * @param threadId - The thread ID containing the message
-     * @param messageId - The platform-specific message ID
-     * @returns The message, or null if not found/not supported
+     * @param threadId - The thread ID to check
+     * @returns True if the thread is a DM, false otherwise
      */
-    fetchMessage?(threadId: string, messageId: string): Promise<Message<TRawMessage> | null>;
-    /** Encode platform-specific data into a thread ID string */
-    encodeThreadId(platformData: TThreadId): string;
-    /** Decode thread ID string back to platform-specific data */
-    decodeThreadId(threadId: string): TThreadId;
-    /** Parse platform message format to normalized format */
-    parseMessage(raw: TRawMessage): Message<TRawMessage>;
-    /** Render formatted content to platform-specific string */
-    renderFormatted(content: FormattedContent): string;
+    isDM?(threadId: string): boolean;
+    /**
+     * List threads in a channel.
+     */
+    listThreads?(channelId: string, options?: ListThreadsOptions): Promise<ListThreadsResult<TRawMessage>>;
+    /** Unique name for this adapter (e.g., "slack", "teams") */
+    readonly name: string;
     /**
      * Optional hook called when a thread is subscribed to.
      * Adapters can use this to set up platform-specific subscriptions
@@ -192,6 +206,23 @@ interface Adapter<TThreadId = unknown, TRawMessage = unknown> {
      * ```
      */
     openDM?(userId: string): Promise<string>;
+    /**
+     * Open a modal/dialog form.
+     *
+     * @param triggerId - Platform-specific trigger ID from the action event
+     * @param modal - The modal element to display
+     * @param contextId - Optional context ID for server-side stored thread/message context
+     * @returns The view/dialog ID
+     */
+    openModal?(triggerId: string, modal: ModalElement, contextId?: string): Promise<{
+        viewId: string;
+    }>;
+    /** Parse platform message format to normalized format */
+    parseMessage(raw: TRawMessage): Message<TRawMessage>;
+    /**
+     * Post a message to channel top-level (not in a thread).
+     */
+    postChannelMessage?(channelId: string, message: AdapterPostableMessage): Promise<RawMessage<TRawMessage>>;
     /**
      * Post an ephemeral message visible only to a specific user.
      *
@@ -204,24 +235,14 @@ interface Adapter<TThreadId = unknown, TRawMessage = unknown> {
      * @returns EphemeralMessage with usedFallback: false
      */
     postEphemeral?(threadId: string, userId: string, message: AdapterPostableMessage): Promise<EphemeralMessage>;
-    /**
-     * Check if a thread is a direct message conversation.
-     *
-     * @param threadId - The thread ID to check
-     * @returns True if the thread is a DM, false otherwise
-     */
-    isDM?(threadId: string): boolean;
-    /**
-     * Open a modal/dialog form.
-     *
-     * @param triggerId - Platform-specific trigger ID from the action event
-     * @param modal - The modal element to display
-     * @param contextId - Optional context ID for server-side stored thread/message context
-     * @returns The view/dialog ID
-     */
-    openModal?(triggerId: string, modal: ModalElement, contextId?: string): Promise<{
-        viewId: string;
-    }>;
+    /** Post a message to a thread */
+    postMessage(threadId: string, message: AdapterPostableMessage): Promise<RawMessage<TRawMessage>>;
+    /** Remove a reaction from a message */
+    removeReaction(threadId: string, messageId: string, emoji: EmojiValue | string): Promise<void>;
+    /** Render formatted content to platform-specific string */
+    renderFormatted(content: FormattedContent): string;
+    /** Show typing indicator */
+    startTyping(threadId: string): Promise<void>;
     /**
      * Stream a message using platform-native streaming APIs.
      *
@@ -234,80 +255,64 @@ 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>>;
+    /** Bot username (can override global userName) */
+    readonly userName: string;
 }
 /**
  * Options for streaming messages.
  * Platform-specific options are passed through to the adapter.
  */
 interface StreamOptions {
-    /** Slack: The user ID to stream to (for AI assistant context) */
-    recipientUserId?: string;
     /** Slack: The team/workspace ID */
     recipientTeamId?: string;
-    /** Minimum interval between updates in ms (default: 1000). Used for fallback mode (GChat/Teams). */
-    updateIntervalMs?: number;
+    /** Slack: The user ID to stream to (for AI assistant context) */
+    recipientUserId?: string;
     /** Block Kit elements to attach when stopping the stream (Slack only, via chat.stopStream) */
     stopBlocks?: unknown[];
+    /** Minimum interval between updates in ms (default: 1000). Used for fallback mode (GChat/Teams). */
+    updateIntervalMs?: number;
 }
 /** Internal interface for Chat instance passed to adapters */
 interface ChatInstance {
-    /**
-     * Process an incoming message from an adapter.
-     * Handles waitUntil registration and error catching internally.
-     *
-     * @param adapter - The adapter that received the message
-     * @param threadId - The thread ID
-     * @param message - Either a parsed message, or a factory function for lazy async parsing
-     * @param options - Webhook options including waitUntil
-     */
-    processMessage(adapter: Adapter, threadId: string, message: Message | (() => Promise<Message>), options?: WebhookOptions): void;
+    /** Get the configured logger, optionally with a child prefix */
+    getLogger(prefix?: string): Logger;
+    getState(): StateAdapter;
+    getUserName(): string;
     /**
      * @deprecated Use processMessage instead. This method is for internal use.
      */
     handleIncomingMessage(adapter: Adapter, threadId: string, message: Message): Promise<void>;
     /**
-     * Process an incoming reaction event from an adapter.
+     * Process an incoming action event (button click) from an adapter.
      * Handles waitUntil registration and error catching internally.
      *
-     * @param event - The reaction event (without adapter field, will be added)
+     * @param event - The action event (without thread field, will be added)
      * @param options - Webhook options including waitUntil
      */
-    processReaction(event: Omit<ReactionEvent, "adapter" | "thread"> & {
-        adapter?: Adapter;
+    processAction(event: Omit<ActionEvent, "thread" | "openModal"> & {
+        adapter: Adapter;
     }, options?: WebhookOptions): void;
+    processAppHomeOpened(event: AppHomeOpenedEvent, options?: WebhookOptions): void;
+    processAssistantContextChanged(event: AssistantContextChangedEvent, options?: WebhookOptions): void;
+    processAssistantThreadStarted(event: AssistantThreadStartedEvent, options?: WebhookOptions): void;
     /**
-     * Process an incoming action event (button click) from an adapter.
+     * Process an incoming message from an adapter.
      * Handles waitUntil registration and error catching internally.
      *
-     * @param event - The action event (without thread field, will be added)
+     * @param adapter - The adapter that received the message
+     * @param threadId - The thread ID
+     * @param message - Either a parsed message, or a factory function for lazy async parsing
      * @param options - Webhook options including waitUntil
      */
-    processAction(event: Omit<ActionEvent, "thread" | "openModal"> & {
-        adapter: Adapter;
-    }, options?: WebhookOptions): void;
+    processMessage(adapter: Adapter, threadId: string, message: Message | (() => Promise<Message>), options?: WebhookOptions): void;
+    /**
+     * Process a modal close event from an adapter.
+     *
+     * @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" | "relatedChannel">, contextId?: string, options?: WebhookOptions): void;
     /**
      * Process a modal submit event from an adapter.
      *
@@ -317,13 +322,15 @@ interface ChatInstance {
      */
     processModalSubmit(event: Omit<ModalSubmitEvent, "relatedThread" | "relatedMessage" | "relatedChannel">, contextId?: string, options?: WebhookOptions): Promise<ModalResponse | undefined>;
     /**
-     * Process a modal close event from an adapter.
+     * Process an incoming reaction event from an adapter.
+     * Handles waitUntil registration and error catching internally.
      *
-     * @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
+     * @param event - The reaction event (without adapter field, will be added)
+     * @param options - Webhook options including waitUntil
      */
-    processModalClose(event: Omit<ModalCloseEvent, "relatedThread" | "relatedMessage" | "relatedChannel">, contextId?: string, options?: WebhookOptions): void;
+    processReaction(event: Omit<ReactionEvent, "adapter" | "thread"> & {
+        adapter?: Adapter;
+    }, options?: WebhookOptions): void;
     /**
      * Process an incoming slash command from an adapter.
      * Handles waitUntil registration and error catching internally.
@@ -335,44 +342,35 @@ interface ChatInstance {
         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 */
-    getLogger(prefix?: string): Logger;
 }
 interface StateAdapter {
+    /** Acquire a lock on a thread (returns null if already locked) */
+    acquireLock(threadId: string, ttlMs: number): Promise<Lock | null>;
     /** Connect to the state backend */
     connect(): Promise<void>;
+    /** Delete a cached value */
+    delete(key: string): Promise<void>;
     /** Disconnect from the state backend */
     disconnect(): Promise<void>;
-    /** Subscribe to a thread (persists across restarts) */
-    subscribe(threadId: string): Promise<void>;
-    /** Unsubscribe from a thread */
-    unsubscribe(threadId: string): Promise<void>;
-    /** Check if subscribed to a thread */
-    isSubscribed(threadId: string): Promise<boolean>;
-    /** List all subscriptions, optionally filtered by adapter */
-    listSubscriptions(adapterName?: string): AsyncIterable<string>;
-    /** Acquire a lock on a thread (returns null if already locked) */
-    acquireLock(threadId: string, ttlMs: number): Promise<Lock | null>;
-    /** Release a lock */
-    releaseLock(lock: Lock): Promise<void>;
     /** Extend a lock's TTL */
     extendLock(lock: Lock, ttlMs: number): Promise<boolean>;
     /** Get a cached value by key */
     get<T = unknown>(key: string): Promise<T | null>;
+    /** Check if subscribed to a thread */
+    isSubscribed(threadId: string): Promise<boolean>;
+    /** Release a lock */
+    releaseLock(lock: Lock): Promise<void>;
     /** Set a cached value with optional TTL in milliseconds */
     set<T = unknown>(key: string, value: T, ttlMs?: number): Promise<void>;
-    /** Delete a cached value */
-    delete(key: string): Promise<void>;
+    /** Subscribe to a thread (persists across restarts) */
+    subscribe(threadId: string): Promise<void>;
+    /** Unsubscribe from a thread */
+    unsubscribe(threadId: string): Promise<void>;
 }
 interface Lock {
+    expiresAt: number;
     threadId: string;
     token: string;
-    expiresAt: number;
 }
 /**
  * Base interface for entities that can receive messages.
@@ -382,23 +380,16 @@ interface Lock {
  * @template TRawMessage - Platform-specific raw message type
  */
 interface Postable<TState = Record<string, unknown>, TRawMessage = unknown> {
-    /** Unique ID */
-    readonly id: string;
     /** The adapter this entity belongs to */
     readonly adapter: Adapter;
+    /** Unique ID */
+    readonly id: string;
     /** Whether this is a direct message conversation */
     readonly isDM: boolean;
     /**
-     * Get the current state.
-     * Returns null if no state has been set.
-     */
-    readonly state: Promise<TState | null>;
-    /**
-     * Set the state. Merges with existing state by default.
+     * Get a platform-specific mention string for a user.
      */
-    setState(state: Partial<TState>, options?: {
-        replace?: boolean;
-    }): Promise<void>;
+    mentionUser(userId: string): string;
     /**
      * Iterate messages newest first (backward from most recent).
      * Auto-paginates lazily — only fetches pages as consumed.
@@ -412,12 +403,19 @@ interface Postable<TState = Record<string, unknown>, TRawMessage = unknown> {
      * Post an ephemeral message visible only to a specific user.
      */
     postEphemeral(user: string | Author, message: AdapterPostableMessage | CardJSXElement, options: PostEphemeralOptions): Promise<EphemeralMessage | null>;
+    /**
+     * Set the state. Merges with existing state by default.
+     */
+    setState(state: Partial<TState>, options?: {
+        replace?: boolean;
+    }): Promise<void>;
     /** Show typing indicator */
     startTyping(): Promise<void>;
     /**
-     * Get a platform-specific mention string for a user.
+     * Get the current state.
+     * Returns null if no state has been set.
      */
-    mentionUser(userId: string): string;
+    readonly state: Promise<TState | null>;
 }
 /**
  * Represents a channel/conversation container that holds threads.
@@ -427,6 +425,8 @@ interface Postable<TState = Record<string, unknown>, TRawMessage = unknown> {
  * @template TRawMessage - Platform-specific raw message type
  */
 interface Channel<TState = Record<string, unknown>, TRawMessage = unknown> extends Postable<TState, TRawMessage> {
+    /** Fetch channel metadata from the platform */
+    fetchMetadata(): Promise<ChannelInfo>;
     /** Channel name (e.g., "#general"). Null until fetchInfo() is called. */
     readonly name: string | null;
     /**
@@ -435,8 +435,6 @@ interface Channel<TState = Record<string, unknown>, TRawMessage = unknown> exten
      * 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.
@@ -444,36 +442,36 @@ interface Channel<TState = Record<string, unknown>, TRawMessage = unknown> exten
 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;
+    /** Reply count (if available) */
+    replyCount?: number;
+    /** Root/first message of the thread */
+    rootMessage: Message<TRawMessage>;
 }
 /**
  * Channel metadata returned by fetchInfo().
  */
 interface ChannelInfo {
     id: string;
-    name?: string;
     isDM?: boolean;
     memberCount?: number;
     metadata: Record<string, unknown>;
+    name?: string;
 }
 /**
  * Options for listing threads in a channel.
  */
 interface ListThreadsOptions {
-    limit?: number;
     cursor?: string;
+    limit?: number;
 }
 /**
  * Result of listing threads in a channel.
  */
 interface ListThreadsResult<TRawMessage = unknown> {
-    threads: ThreadSummary<TRawMessage>[];
     nextCursor?: string;
+    threads: ThreadSummary<TRawMessage>[];
 }
 /** Default TTL for thread state (30 days in milliseconds) */
 declare const THREAD_STATE_TTL_MS: number;
@@ -485,18 +483,21 @@ declare const THREAD_STATE_TTL_MS: number;
  * @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>[];
     /**
      * Async iterator for all messages in the thread.
      * Messages are yielded in chronological order (oldest first).
      * Automatically handles pagination.
      */
     allMessages: AsyncIterable<Message<TRawMessage>>;
+    /** Get the Channel containing this thread */
+    readonly channel: Channel<TState, TRawMessage>;
+    /** Channel/conversation ID */
+    readonly channelId: string;
+    /**
+     * Wrap a Message object as a SentMessage with edit/delete capabilities.
+     * Used internally for reconstructing messages from serialized data.
+     */
+    createSentMessageFromMessage(message: Message<TRawMessage>): SentMessage<TRawMessage>;
     /**
      * Check if this thread is currently subscribed.
      *
@@ -507,26 +508,12 @@ interface Thread<TState = Record<string, unknown>, TRawMessage = unknown> extend
      */
     isSubscribed(): Promise<boolean>;
     /**
-     * Subscribe to future messages in this thread.
-     *
-     * Once subscribed, all messages in this thread will trigger `onSubscribedMessage` handlers.
-     * The initial message that triggered subscription will NOT fire the handler.
-     *
+     * Get a platform-specific mention string for a user.
+     * Use this to @-mention a user in a message.
      * @example
-     * ```typescript
-     * chat.onNewMention(async (thread, message) => {
-     *   await thread.subscribe();  // Subscribe to follow-up messages
-     *   await thread.post("I'm now watching this thread!");
-     * });
-     * ```
-     */
-    subscribe(): Promise<void>;
-    /**
-     * Unsubscribe from this thread.
-     *
-     * Future messages will no longer trigger `onSubscribedMessage` handlers.
+     * await thread.post(`Hey ${thread.mentionUser(userId)}, check this out!`);
      */
-    unsubscribe(): Promise<void>;
+    mentionUser(userId: string): string;
     /**
      * Post a message to this thread.
      *
@@ -590,12 +577,8 @@ interface Thread<TState = Record<string, unknown>, TRawMessage = unknown> extend
      * ```
      */
     postEphemeral(user: string | Author, message: AdapterPostableMessage | CardJSXElement, options: PostEphemeralOptions): Promise<EphemeralMessage | null>;
-    /**
-     * Show typing indicator in the thread.
-     *
-     * Some platforms support persistent typing indicators, others just send once.
-     */
-    startTyping(): Promise<void>;
+    /** Recently fetched messages (cached) */
+    recentMessages: Message<TRawMessage>[];
     /**
      * Refresh `recentMessages` from the API.
      *
@@ -603,22 +586,37 @@ interface Thread<TState = Record<string, unknown>, TRawMessage = unknown> extend
      */
     refresh(): Promise<void>;
     /**
-     * Wrap a Message object as a SentMessage with edit/delete capabilities.
-     * Used internally for reconstructing messages from serialized data.
+     * Show typing indicator in the thread.
+     *
+     * Some platforms support persistent typing indicators, others just send once.
      */
-    createSentMessageFromMessage(message: Message<TRawMessage>): SentMessage<TRawMessage>;
+    startTyping(): Promise<void>;
     /**
-     * Get a platform-specific mention string for a user.
-     * Use this to @-mention a user in a message.
+     * Subscribe to future messages in this thread.
+     *
+     * Once subscribed, all messages in this thread will trigger `onSubscribedMessage` handlers.
+     * The initial message that triggered subscription will NOT fire the handler.
+     *
      * @example
-     * await thread.post(`Hey ${thread.mentionUser(userId)}, check this out!`);
+     * ```typescript
+     * chat.onNewMention(async (thread, message) => {
+     *   await thread.subscribe();  // Subscribe to follow-up messages
+     *   await thread.post("I'm now watching this thread!");
+     * });
+     * ```
      */
-    mentionUser(userId: string): string;
+    subscribe(): Promise<void>;
+    /**
+     * Unsubscribe from this thread.
+     *
+     * Future messages will no longer trigger `onSubscribedMessage` handlers.
+     */
+    unsubscribe(): Promise<void>;
 }
 interface ThreadInfo {
-    id: string;
     channelId: string;
     channelName?: string;
+    id: string;
     /** Whether this is a direct message conversation */
     isDM?: boolean;
     /** Platform-specific metadata */
@@ -657,8 +655,6 @@ type FetchDirection = "forward" | "backward";
  * Options for fetching messages from a thread.
  */
 interface FetchOptions {
-    /** Maximum number of messages to fetch. Default varies by adapter (50-100). */
-    limit?: number;
     /**
      * Pagination cursor for fetching the next page of messages.
      * Pass the `nextCursor` from a previous `FetchResult`.
@@ -673,6 +669,8 @@ interface FetchOptions {
      * Messages within each page are always returned in chronological order (oldest first).
      */
     direction?: FetchDirection;
+    /** Maximum number of messages to fetch. Default varies by adapter (50-100). */
+    limit?: number;
 }
 /**
  * Result of fetching messages from a thread.
@@ -704,20 +702,20 @@ type FormattedContent = Root;
 /** Raw message returned from adapter (before wrapping as SentMessage) */
 interface RawMessage<TRawMessage = unknown> {
     id: string;
-    threadId: string;
     raw: TRawMessage;
+    threadId: string;
 }
 interface Author {
-    /** Unique user ID */
-    userId: string;
-    /** Username/handle for @-mentions */
-    userName: string;
     /** Display name */
     fullName: string;
     /** Whether the author is a bot */
     isBot: boolean | "unknown";
     /** Whether the author is this bot */
     isMe: boolean;
+    /** Unique user ID */
+    userId: string;
+    /** Username/handle for @-mentions */
+    userName: string;
 }
 interface MessageMetadata {
     /** When the message was sent */
@@ -728,12 +726,12 @@ interface MessageMetadata {
     editedAt?: Date;
 }
 interface SentMessage<TRawMessage = unknown> extends Message<TRawMessage> {
-    /** Edit this message with text, a PostableMessage, or a JSX Card element */
-    edit(newContent: string | PostableMessage | CardJSXElement): Promise<SentMessage<TRawMessage>>;
-    /** Delete this message */
-    delete(): Promise<void>;
     /** Add a reaction to this message */
     addReaction(emoji: EmojiValue | string): Promise<void>;
+    /** Delete this message */
+    delete(): Promise<void>;
+    /** Edit this message with text, a PostableMessage, or a JSX Card element */
+    edit(newContent: string | PostableMessage | CardJSXElement): Promise<SentMessage<TRawMessage>>;
     /** Remove a reaction from this message */
     removeReaction(emoji: EmojiValue | string): Promise<void>;
 }
@@ -746,12 +744,12 @@ interface SentMessage<TRawMessage = unknown> extends Message<TRawMessage> {
 interface EphemeralMessage {
     /** Message ID (may be empty for some platforms) */
     id: string;
+    /** Platform-specific raw response */
+    raw: unknown;
     /** Thread ID where message was sent (or DM thread if fallback was used) */
     threadId: string;
     /** Whether this used native ephemeral or fell back to DM */
     usedFallback: boolean;
-    /** Platform-specific raw response */
-    raw: unknown;
 }
 /**
  * Options for posting ephemeral messages.
@@ -783,20 +781,20 @@ type AdapterPostableMessage = string | PostableRaw | PostableMarkdown | Postable
  */
 type PostableMessage = AdapterPostableMessage | AsyncIterable<string>;
 interface PostableRaw {
-    /** Raw text passed through as-is to the platform */
-    raw: string;
     /** File/image attachments */
     attachments?: Attachment[];
     /** Files to upload */
     files?: FileUpload[];
+    /** Raw text passed through as-is to the platform */
+    raw: string;
 }
 interface PostableMarkdown {
-    /** Markdown text, converted to platform format */
-    markdown: string;
     /** File/image attachments */
     attachments?: Attachment[];
     /** Files to upload */
     files?: FileUpload[];
+    /** Markdown text, converted to platform format */
+    markdown: string;
 }
 interface PostableAst {
     /** mdast AST, converted to platform format */
@@ -815,28 +813,28 @@ interface PostableCard {
     files?: FileUpload[];
 }
 interface Attachment {
-    /** Type of attachment */
-    type: "image" | "file" | "video" | "audio";
-    /** URL to the file (for linking/downloading) */
-    url?: string;
     /** Binary data (for uploading or if already fetched) */
     data?: Buffer | Blob;
-    /** Filename */
-    name?: string;
-    /** MIME type */
-    mimeType?: string;
-    /** File size in bytes */
-    size?: number;
-    /** Image/video width (if applicable) */
-    width?: number;
-    /** Image/video height (if applicable) */
-    height?: number;
     /**
      * Fetch the attachment data.
      * For platforms that require authentication (like Slack private URLs),
      * this method handles the auth automatically.
      */
     fetchData?: () => Promise<Buffer>;
+    /** Image/video height (if applicable) */
+    height?: number;
+    /** MIME type */
+    mimeType?: string;
+    /** Filename */
+    name?: string;
+    /** File size in bytes */
+    size?: number;
+    /** Type of attachment */
+    type: "image" | "file" | "video" | "audio";
+    /** URL to the file (for linking/downloading) */
+    url?: string;
+    /** Image/video width (if applicable) */
+    width?: number;
 }
 /**
  * File to upload with a message.
@@ -875,14 +873,14 @@ interface FileUpload {
  * });
  * ```
  */
-type MentionHandler<TState = Record<string, unknown>> = (thread: Thread<TState>, message: Message) => Promise<void>;
+type MentionHandler<TState = Record<string, unknown>> = (thread: Thread<TState>, message: Message) => 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) => Promise<void>;
+type MessageHandler<TState = Record<string, unknown>> = (thread: Thread<TState>, message: Message) => void | Promise<void>;
 /**
  * Handler for messages in subscribed threads.
  *
@@ -906,7 +904,7 @@ type MessageHandler<TState = Record<string, unknown>> = (thread: Thread<TState>,
  * });
  * ```
  */
-type SubscribedMessageHandler<TState = Record<string, unknown>> = (thread: Thread<TState>, message: Message) => Promise<void>;
+type SubscribedMessageHandler<TState = Record<string, unknown>> = (thread: Thread<TState>, message: Message) => void | Promise<void>;
 /**
  * Well-known emoji that work across platforms (Slack and Google Chat).
  * These are normalized to a common format regardless of platform.
@@ -916,10 +914,10 @@ type WellKnownEmoji = "thumbs_up" | "thumbs_down" | "clap" | "wave" | "pray" | "
  * Platform-specific emoji formats for a single emoji.
  */
 interface EmojiFormats {
-    /** Slack emoji name (without colons), e.g., "+1", "heart" */
-    slack: string | string[];
     /** Google Chat unicode emoji, e.g., "👍", "❤️" */
     gchat: string | string[];
+    /** Slack emoji name (without colons), e.g., "+1", "heart" */
+    slack: string | string[];
 }
 /**
  * Emoji map type - can be extended by users to add custom emoji.
@@ -968,29 +966,29 @@ type EmojiMapConfig = Partial<Record<Emoji, EmojiFormats>>;
 interface EmojiValue {
     /** The normalized emoji name (e.g., "thumbs_up") */
     readonly name: string;
-    /** Returns the placeholder string for message formatting */
-    toString(): string;
     /** Returns the placeholder string (for JSON.stringify) */
     toJSON(): string;
+    /** Returns the placeholder string for message formatting */
+    toString(): string;
 }
 /**
  * Reaction event fired when a user adds or removes a reaction.
- */
-interface ReactionEvent<TRawMessage = unknown> {
-    /** The normalized emoji as an EmojiValue singleton (enables `===` comparison) */
-    emoji: EmojiValue;
-    /** The raw platform-specific emoji (e.g., "+1" for Slack, "👍" for GChat) */
-    rawEmoji: string;
+ */
+interface ReactionEvent<TRawMessage = unknown> {
+    /** The adapter that received the event */
+    adapter: Adapter;
     /** Whether the reaction was added (true) or removed (false) */
     added: boolean;
-    /** The user who added/removed the reaction */
-    user: Author;
+    /** The normalized emoji as an EmojiValue singleton (enables `===` comparison) */
+    emoji: EmojiValue;
     /** The message that was reacted to (if available) */
     message?: Message<TRawMessage>;
     /** The message ID that was reacted to */
     messageId: string;
-    /** The thread ID */
-    threadId: string;
+    /** Platform-specific raw event data */
+    raw: unknown;
+    /** The raw platform-specific emoji (e.g., "+1" for Slack, "👍" for GChat) */
+    rawEmoji: string;
     /**
      * The thread where the reaction occurred.
      * Use this to post replies or check subscription status.
@@ -1003,10 +1001,10 @@ interface ReactionEvent<TRawMessage = unknown> {
      * ```
      */
     thread: Thread<TRawMessage>;
-    /** The adapter that received the event */
-    adapter: Adapter;
-    /** Platform-specific raw event data */
-    raw: unknown;
+    /** The thread ID */
+    threadId: string;
+    /** The user who added/removed the reaction */
+    user: Author;
 }
 /**
  * Handler for reaction events.
@@ -1024,7 +1022,7 @@ interface ReactionEvent<TRawMessage = unknown> {
  * });
  * ```
  */
-type ReactionHandler = (event: ReactionEvent) => Promise<void>;
+type ReactionHandler = (event: ReactionEvent) => void | Promise<void>;
 /**
  * Action event fired when a user clicks a button in a card.
  *
@@ -1038,22 +1036,10 @@ type ReactionHandler = (event: ReactionEvent) => Promise<void>;
 interface ActionEvent<TRawMessage = unknown> {
     /** The action ID from the button (matches Button's `id` prop) */
     actionId: string;
-    /** Optional value/payload from the button */
-    value?: string;
-    /** User who clicked the button */
-    user: Author;
-    /** The thread where the action occurred */
-    thread: Thread<TRawMessage>;
-    /** The message ID containing the card */
-    messageId: string;
-    /** The thread ID */
-    threadId: string;
     /** The adapter that received the event */
     adapter: Adapter;
-    /** Platform-specific raw event data */
-    raw: unknown;
-    /** Trigger ID for opening modals (required by some platforms, may expire quickly) */
-    triggerId?: string;
+    /** The message ID containing the card */
+    messageId: string;
     /**
      * Open a modal/dialog form in response to this action.
      *
@@ -1063,6 +1049,18 @@ interface ActionEvent<TRawMessage = unknown> {
     openModal(modal: ModalElement | CardJSXElement): Promise<{
         viewId: string;
     } | undefined>;
+    /** Platform-specific raw event data */
+    raw: unknown;
+    /** The thread where the action occurred */
+    thread: Thread<TRawMessage>;
+    /** The thread ID */
+    threadId: string;
+    /** Trigger ID for opening modals (required by some platforms, may expire quickly) */
+    triggerId?: string;
+    /** User who clicked the button */
+    user: Author;
+    /** Optional value/payload from the button */
+    value?: string;
 }
 /**
  * Handler for action events (button clicks in cards).
@@ -1087,33 +1085,27 @@ interface ActionEvent<TRawMessage = unknown> {
  * });
  * ```
  */
-type ActionHandler = (event: ActionEvent) => Promise<void>;
+type ActionHandler = (event: ActionEvent) => void | Promise<void>;
 /**
  * Event emitted when a user submits a modal form.
  */
 interface ModalSubmitEvent<TRawMessage = unknown> {
-    /** The callback ID specified when creating the modal */
-    callbackId: string;
-    /** Platform-specific view/dialog ID */
-    viewId: string;
-    /** Form field values keyed by input ID */
-    values: Record<string, string>;
-    /** The user who submitted the modal */
-    user: Author;
     /** The adapter that received this event */
     adapter: Adapter;
-    /** Raw platform-specific payload */
-    raw: unknown;
+    /** The callback ID specified when creating the modal */
+    callbackId: string;
     /**
      * The private metadata string set when the modal was created.
      * Use this to pass arbitrary context (e.g., JSON) through the modal lifecycle.
      */
     privateMetadata?: string;
+    /** Raw platform-specific payload */
+    raw: unknown;
     /**
-     * The thread where the modal was originally triggered from.
-     * Available when the modal was opened via ActionEvent.openModal().
+     * The channel where the modal was originally triggered from.
+     * Available when the modal was opened via SlashCommandEvent.openModal().
      */
-    relatedThread?: Thread<Record<string, unknown>, TRawMessage>;
+    relatedChannel?: Channel<Record<string, unknown>, TRawMessage>;
     /**
      * The message that contained the action which opened the modal.
      * Available when the modal was opened from a message action via ActionEvent.openModal().
@@ -1121,35 +1113,37 @@ interface ModalSubmitEvent<TRawMessage = unknown> {
      */
     relatedMessage?: SentMessage<TRawMessage>;
     /**
-     * The channel where the modal was originally triggered from.
-     * Available when the modal was opened via SlashCommandEvent.openModal().
+     * The thread where the modal was originally triggered from.
+     * Available when the modal was opened via ActionEvent.openModal().
      */
-    relatedChannel?: Channel<Record<string, unknown>, TRawMessage>;
+    relatedThread?: Thread<Record<string, unknown>, TRawMessage>;
+    /** The user who submitted the modal */
+    user: Author;
+    /** Form field values keyed by input ID */
+    values: Record<string, string>;
+    /** Platform-specific view/dialog ID */
+    viewId: string;
 }
 /**
  * Event emitted when a user closes/cancels a modal (requires notifyOnClose).
  */
 interface ModalCloseEvent<TRawMessage = unknown> {
-    /** The callback ID specified when creating the modal */
-    callbackId: string;
-    /** Platform-specific view/dialog ID */
-    viewId: string;
-    /** The user who closed the modal */
-    user: Author;
     /** The adapter that received this event */
     adapter: Adapter;
-    /** Raw platform-specific payload */
-    raw: unknown;
+    /** The callback ID specified when creating the modal */
+    callbackId: string;
     /**
      * The private metadata string set when the modal was created.
      * Use this to pass arbitrary context (e.g., JSON) through the modal lifecycle.
      */
     privateMetadata?: string;
+    /** Raw platform-specific payload */
+    raw: unknown;
     /**
-     * The thread where the modal was originally triggered from.
-     * Available when the modal was opened via ActionEvent.openModal().
+     * The channel where the modal was originally triggered from.
+     * Available when the modal was opened via SlashCommandEvent.openModal().
      */
-    relatedThread?: Thread<Record<string, unknown>, TRawMessage>;
+    relatedChannel?: Channel<Record<string, unknown>, TRawMessage>;
     /**
      * The message that contained the action which opened the modal.
      * Available when the modal was opened from a message action via ActionEvent.openModal().
@@ -1157,29 +1151,33 @@ interface ModalCloseEvent<TRawMessage = unknown> {
      */
     relatedMessage?: SentMessage<TRawMessage>;
     /**
-     * The channel where the modal was originally triggered from.
-     * Available when the modal was opened via SlashCommandEvent.openModal().
+     * The thread where the modal was originally triggered from.
+     * Available when the modal was opened via ActionEvent.openModal().
      */
-    relatedChannel?: Channel<Record<string, unknown>, TRawMessage>;
+    relatedThread?: Thread<Record<string, unknown>, TRawMessage>;
+    /** The user who closed the modal */
+    user: Author;
+    /** Platform-specific view/dialog ID */
+    viewId: string;
 }
-type ModalErrorsResponse = {
+interface ModalErrorsResponse {
     action: "errors";
     errors: Record<string, string>;
-};
-type ModalUpdateResponse = {
+}
+interface ModalUpdateResponse {
     action: "update";
     modal: ModalElement;
-};
-type ModalPushResponse = {
+}
+interface ModalPushResponse {
     action: "push";
     modal: ModalElement;
-};
-type ModalCloseResponse = {
+}
+interface ModalCloseResponse {
     action: "close";
-};
+}
 type ModalResponse = ModalCloseResponse | ModalErrorsResponse | ModalUpdateResponse | ModalPushResponse;
-type ModalSubmitHandler = (event: ModalSubmitEvent) => Promise<ModalResponse | undefined>;
-type ModalCloseHandler = (event: ModalCloseEvent) => Promise<void>;
+type ModalSubmitHandler = (event: ModalSubmitEvent) => void | Promise<ModalResponse | undefined>;
+type ModalCloseHandler = (event: ModalCloseEvent) => void | Promise<void>;
 /**
  * Event emitted when a user invokes a slash command.
  *
@@ -1215,20 +1213,12 @@ type ModalCloseHandler = (event: ModalCloseEvent) => Promise<void>;
  * ```
  */
 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;
+    /** The channel where the command was invoked */
+    channel: Channel<TState>;
+    /** The slash command name (e.g., "/help") */
+    command: string;
     /**
      * Open a modal/dialog form in response to this slash command.
      *
@@ -1238,6 +1228,14 @@ interface SlashCommandEvent<TState = Record<string, unknown>> {
     openModal(modal: ModalElement | CardJSXElement): Promise<{
         viewId: string;
     } | undefined>;
+    /** Platform-specific raw payload */
+    raw: unknown;
+    /** Arguments text after the command (e.g., "topic search" from "/help topic search") */
+    text: string;
+    /** Trigger ID for opening modals (time-limited, typically ~3 seconds) */
+    triggerId?: string;
+    /** The user who invoked the command */
+    user: Author;
 }
 /**
  * Handler for slash command events.
@@ -1260,12 +1258,10 @@ interface SlashCommandEvent<TState = Record<string, unknown>> {
  * });
  * ```
  */
-type SlashCommandHandler<TState = Record<string, unknown>> = (event: SlashCommandEvent<TState>) => Promise<void>;
+type SlashCommandHandler<TState = Record<string, unknown>> = (event: SlashCommandEvent<TState>) => void | Promise<void>;
 interface AssistantThreadStartedEvent {
-    threadId: string;
-    userId: string;
+    adapter: Adapter;
     channelId: string;
-    threadTs: string;
     context: {
         channelId?: string;
         teamId?: string;
@@ -1273,14 +1269,14 @@ interface AssistantThreadStartedEvent {
         threadEntryPoint?: string;
         forceSearch?: boolean;
     };
-    adapter: Adapter;
-}
-type AssistantThreadStartedHandler = (event: AssistantThreadStartedEvent) => Promise<void>;
-interface AssistantContextChangedEvent {
     threadId: string;
+    threadTs: string;
     userId: string;
+}
+type AssistantThreadStartedHandler = (event: AssistantThreadStartedEvent) => void | Promise<void>;
+interface AssistantContextChangedEvent {
+    adapter: Adapter;
     channelId: string;
-    threadTs: string;
     context: {
         channelId?: string;
         teamId?: string;
@@ -1288,15 +1284,17 @@ interface AssistantContextChangedEvent {
         threadEntryPoint?: string;
         forceSearch?: boolean;
     };
-    adapter: Adapter;
+    threadId: string;
+    threadTs: string;
+    userId: string;
 }
-type AssistantContextChangedHandler = (event: AssistantContextChangedEvent) => Promise<void>;
+type AssistantContextChangedHandler = (event: AssistantContextChangedEvent) => void | Promise<void>;
 interface AppHomeOpenedEvent {
-    userId: string;
-    channelId: string;
     adapter: Adapter;
+    channelId: string;
+    userId: string;
 }
-type AppHomeOpenedHandler = (event: AppHomeOpenedEvent) => Promise<void>;
+type AppHomeOpenedHandler = (event: AppHomeOpenedEvent) => void | Promise<void>;
 
 /**
  * Message class with serialization support for workflow engines.
@@ -1307,24 +1305,24 @@ type AppHomeOpenedHandler = (event: AppHomeOpenedEvent) => Promise<void>;
  * Use this interface when constructing Message objects.
  */
 interface MessageData<TRawMessage = unknown> {
-    /** Unique message ID */
-    id: string;
-    /** Thread this message belongs to */
-    threadId: string;
-    /** Plain text content (all formatting stripped) */
-    text: string;
-    /** Structured formatting as an AST (mdast Root) */
-    formatted: FormattedContent;
-    /** Platform-specific raw payload (escape hatch) */
-    raw: TRawMessage;
-    /** Message author */
-    author: Author;
-    /** Message metadata */
-    metadata: MessageMetadata;
     /** Attachments */
     attachments: Attachment[];
+    /** Message author */
+    author: Author;
+    /** Structured formatting as an AST (mdast Root) */
+    formatted: FormattedContent;
+    /** Unique message ID */
+    id: string;
     /** Whether the bot is @-mentioned in this message */
     isMention?: boolean;
+    /** Message metadata */
+    metadata: MessageMetadata;
+    /** Platform-specific raw payload (escape hatch) */
+    raw: TRawMessage;
+    /** Plain text content (all formatting stripped) */
+    text: string;
+    /** Thread this message belongs to */
+    threadId: string;
 }
 /**
  * Serialized message data for passing to external systems (e.g., workflow engines).
@@ -1332,11 +1330,15 @@ interface MessageData<TRawMessage = unknown> {
  */
 interface SerializedMessage {
     _type: "chat:Message";
-    id: string;
-    threadId: string;
-    text: string;
-    formatted: Root;
-    raw: unknown;
+    attachments: Array<{
+        type: "image" | "file" | "video" | "audio";
+        url?: string;
+        name?: string;
+        mimeType?: string;
+        size?: number;
+        width?: number;
+        height?: number;
+    }>;
     author: {
         userId: string;
         userName: string;
@@ -1344,21 +1346,17 @@ interface SerializedMessage {
         isBot: boolean | "unknown";
         isMe: boolean;
     };
+    formatted: Root;
+    id: string;
+    isMention?: boolean;
     metadata: {
         dateSent: string;
         edited: boolean;
         editedAt?: string;
     };
-    attachments: Array<{
-        type: "image" | "file" | "video" | "audio";
-        url?: string;
-        name?: string;
-        mimeType?: string;
-        size?: number;
-        width?: number;
-        height?: number;
-    }>;
-    isMention?: boolean;
+    raw: unknown;
+    text: string;
+    threadId: string;
 }
 /**
  * A chat message with serialization support for workflow engines.
@@ -1450,25 +1448,25 @@ declare class Message<TRawMessage = unknown> {
  */
 interface SerializedChannel {
     _type: "chat:Channel";
-    id: string;
     adapterName: string;
+    id: string;
     isDM: boolean;
 }
 /**
  * Config for creating a ChannelImpl with explicit adapter/state instances.
  */
 interface ChannelImplConfigWithAdapter {
-    id: string;
     adapter: Adapter;
-    stateAdapter: StateAdapter;
+    id: string;
     isDM?: boolean;
+    stateAdapter: StateAdapter;
 }
 /**
  * Config for creating a ChannelImpl with lazy adapter resolution.
  */
 interface ChannelImplConfigLazy {
-    id: string;
     adapterName: string;
+    id: string;
     isDM?: boolean;
 }
 type ChannelImplConfig = ChannelImplConfigWithAdapter | ChannelImplConfigLazy;
@@ -1476,7 +1474,7 @@ declare class ChannelImpl<TState = Record<string, unknown>> implements Channel<T
     readonly id: string;
     readonly isDM: boolean;
     private _adapter?;
-    private _adapterName?;
+    private readonly _adapterName?;
     private _stateAdapterInstance?;
     private _name;
     constructor(config: ChannelImplConfig);
@@ -1580,22 +1578,22 @@ declare class Chat<TAdapters extends Record<string, Adapter> = Record<string, Ad
      * Check if a singleton has been registered.
      */
     static hasSingleton(): boolean;
-    private adapters;
-    private _stateAdapter;
-    private userName;
-    private logger;
-    private _streamingUpdateIntervalMs;
-    private mentionHandlers;
-    private messagePatterns;
-    private subscribedMessageHandlers;
-    private reactionHandlers;
-    private actionHandlers;
-    private modalSubmitHandlers;
-    private modalCloseHandlers;
-    private slashCommandHandlers;
-    private assistantThreadStartedHandlers;
-    private assistantContextChangedHandlers;
-    private appHomeOpenedHandlers;
+    private readonly adapters;
+    private readonly _stateAdapter;
+    private readonly userName;
+    private readonly logger;
+    private readonly _streamingUpdateIntervalMs;
+    private readonly mentionHandlers;
+    private readonly messagePatterns;
+    private readonly subscribedMessageHandlers;
+    private readonly reactionHandlers;
+    private readonly actionHandlers;
+    private readonly modalSubmitHandlers;
+    private readonly modalCloseHandlers;
+    private readonly slashCommandHandlers;
+    private readonly assistantThreadStartedHandlers;
+    private readonly assistantContextChangedHandlers;
+    private readonly appHomeOpenedHandlers;
     /** Initialization state */
     private initPromise;
     private initialized;
@@ -1745,14 +1743,11 @@ declare class Chat<TAdapters extends Record<string, Adapter> = Record<string, Ad
      * @param handler - The handler (if action ID filter is provided)
      */
     onAction(handler: ActionHandler): void;
-    onAction(actionId: string, handler: ActionHandler): void;
-    onAction(actionIds: string[], handler: ActionHandler): void;
+    onAction(actionIds: string[] | string, handler: ActionHandler): void;
     onModalSubmit(handler: ModalSubmitHandler): void;
-    onModalSubmit(callbackId: string, handler: ModalSubmitHandler): void;
-    onModalSubmit(callbackIds: string[], handler: ModalSubmitHandler): void;
+    onModalSubmit(callbackIds: string[] | string, handler: ModalSubmitHandler): void;
     onModalClose(handler: ModalCloseHandler): void;
-    onModalClose(callbackId: string, handler: ModalCloseHandler): void;
-    onModalClose(callbackIds: string[], handler: ModalCloseHandler): void;
+    onModalClose(callbackIds: string[] | string, handler: ModalCloseHandler): void;
     /**
      * Register a handler for slash command events.
      *
@@ -1790,8 +1785,7 @@ declare class Chat<TAdapters extends Record<string, Adapter> = Record<string, Ad
      * @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;
+    onSlashCommand(commands: string[] | string, handler: SlashCommandHandler<TState>): void;
     onAssistantThreadStarted(handler: AssistantThreadStartedHandler): void;
     onAssistantContextChanged(handler: AssistantContextChangedHandler): void;
     onAppHomeOpened(handler: AppHomeOpenedHandler): void;
@@ -1883,9 +1877,9 @@ declare class Chat<TAdapters extends Record<string, Adapter> = Record<string, Ad
      * Accepts either a user ID string or an Author object (from message.author or event.user).
      *
      * The adapter is automatically inferred from the userId format:
-     * - Slack: `U...` (e.g., "U03STHCA1JM")
+     * - Slack: `U...` (e.g., "U00FAKEUSER1")
      * - Teams: `29:...` (e.g., "29:198PbJuw...")
-     * - Google Chat: `users/...` (e.g., "users/117994873354375860089")
+     * - Google Chat: `users/...` (e.g., "users/100000000000000000001")
      * - Discord: numeric snowflake (e.g., "1033044521375764530")
      *
      * @param user - Platform-specific user ID string, or an Author object
@@ -1962,23 +1956,23 @@ declare class Chat<TAdapters extends Record<string, Adapter> = Record<string, Ad
  */
 interface SerializedThread {
     _type: "chat:Thread";
-    id: string;
+    adapterName: string;
     channelId: string;
+    id: string;
     isDM: boolean;
-    adapterName: string;
 }
 /**
  * Config for creating a ThreadImpl with explicit adapter/state instances.
  */
 interface ThreadImplConfigWithAdapter {
-    id: string;
     adapter: Adapter;
     channelId: string;
-    stateAdapter: StateAdapter;
+    currentMessage?: Message;
+    id: string;
     initialMessage?: Message;
-    isSubscribedContext?: boolean;
     isDM?: boolean;
-    currentMessage?: Message;
+    isSubscribedContext?: boolean;
+    stateAdapter: StateAdapter;
     streamingUpdateIntervalMs?: number;
 }
 /**
@@ -1986,13 +1980,13 @@ interface ThreadImplConfigWithAdapter {
  * The adapter will be looked up from the Chat singleton on first access.
  */
 interface ThreadImplConfigLazy {
-    id: string;
     adapterName: string;
     channelId: string;
+    currentMessage?: Message;
+    id: string;
     initialMessage?: Message;
-    isSubscribedContext?: boolean;
     isDM?: boolean;
-    currentMessage?: Message;
+    isSubscribedContext?: boolean;
     streamingUpdateIntervalMs?: number;
 }
 type ThreadImplConfig = ThreadImplConfigWithAdapter | ThreadImplConfigLazy;
@@ -2003,15 +1997,15 @@ declare class ThreadImpl<TState = Record<string, unknown>> implements Thread<TSt
     /** Direct adapter instance (if provided) */
     private _adapter?;
     /** Adapter name for lazy resolution */
-    private _adapterName?;
+    private readonly _adapterName?;
     /** Direct state adapter instance (if provided) */
     private _stateAdapterInstance?;
     private _recentMessages;
-    private _isSubscribedContext;
+    private readonly _isSubscribedContext;
     /** Current message context for streaming - provides userId/teamId */
-    private _currentMessage?;
+    private readonly _currentMessage?;
     /** Update interval for fallback streaming */
-    private _streamingUpdateIntervalMs;
+    private readonly _streamingUpdateIntervalMs;
     /** Cached channel instance */
     private _channel?;
     constructor(config: ThreadImplConfig);
@@ -2137,9 +2131,9 @@ declare const DEFAULT_EMOJI_MAP: Record<string, EmojiFormats>;
  * Emoji resolver that handles conversion between platform formats and normalized names.
  */
 declare class EmojiResolver {
-    private emojiMap;
-    private slackToNormalized;
-    private gchatToNormalized;
+    private readonly emojiMap;
+    private readonly slackToNormalized;
+    private readonly gchatToNormalized;
     constructor(customMap?: EmojiMapConfig);
     private buildReverseMaps;
     /**
@@ -2414,6 +2408,11 @@ declare function root(children: Content[]): Root;
  * their platform-specific format and the standard AST.
  */
 interface FormatConverter {
+    /**
+     * Extract plain text from platform format.
+     * Convenience method - default implementation uses toAst + toPlainText.
+     */
+    extractPlainText(platformText: string): string;
     /**
      * Render an AST to the platform's native format.
      * This is the primary method used when sending messages.
@@ -2424,11 +2423,6 @@ interface FormatConverter {
      * This is the primary method used when receiving messages.
      */
     toAst(platformText: string): Root;
-    /**
-     * Extract plain text from platform format.
-     * Convenience method - default implementation uses toAst + toPlainText.
-     */
-    extractPlainText(platformText: string): string;
 }
 /**
  * @deprecated Use FormatConverter instead