chat 4.11.0 → 4.13.0

package/dist/index.js

@@ -24,6 +24,9 @@ import {
   toModalElement
 } from "./chunk-WKJEG4FE.js";
 
+// src/channel.ts
+import { WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2, WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2 } from "@workflow/serde";
+
 // src/chat-singleton.ts
 var _singleton = null;
 function setChatSingleton(chat) {
@@ -41,136 +44,6 @@ function hasChatSingleton() {
   return _singleton !== null;
 }
 
-// src/message.ts
-import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from "@workflow/serde";
-var Message = class _Message {
-  /** Unique message ID */
-  id;
-  /** Thread this message belongs to */
-  threadId;
-  /** Plain text content (all formatting stripped) */
-  text;
-  /**
-   * Structured formatting as an AST (mdast Root).
-   * This is the canonical representation - use this for processing.
-   * Use `stringifyMarkdown(message.formatted)` to get markdown string.
-   */
-  formatted;
-  /** Platform-specific raw payload (escape hatch) */
-  raw;
-  /** Message author */
-  author;
-  /** Message metadata */
-  metadata;
-  /** Attachments */
-  attachments;
-  /**
-   * Whether the bot is @-mentioned in this message.
-   *
-   * This is set by the Chat SDK before passing the message to handlers.
-   * It checks for `@username` in the message text using the adapter's
-   * configured `userName` and optional `botUserId`.
-   *
-   * @example
-   * ```typescript
-   * chat.onSubscribedMessage(async (thread, message) => {
-   *   if (message.isMention) {
-   *     await thread.post("You mentioned me!");
-   *   }
-   * });
-   * ```
-   */
-  isMention;
-  constructor(data) {
-    this.id = data.id;
-    this.threadId = data.threadId;
-    this.text = data.text;
-    this.formatted = data.formatted;
-    this.raw = data.raw;
-    this.author = data.author;
-    this.metadata = data.metadata;
-    this.attachments = data.attachments;
-    this.isMention = data.isMention;
-  }
-  /**
-   * Serialize the message to a plain JSON object.
-   * Use this to pass message data to external systems like workflow engines.
-   *
-   * Note: Attachment `data` (Buffer) and `fetchData` (function) are omitted
-   * as they're not serializable.
-   */
-  toJSON() {
-    return {
-      _type: "chat:Message",
-      id: this.id,
-      threadId: this.threadId,
-      text: this.text,
-      formatted: this.formatted,
-      raw: this.raw,
-      author: {
-        userId: this.author.userId,
-        userName: this.author.userName,
-        fullName: this.author.fullName,
-        isBot: this.author.isBot,
-        isMe: this.author.isMe
-      },
-      metadata: {
-        dateSent: this.metadata.dateSent.toISOString(),
-        edited: this.metadata.edited,
-        editedAt: this.metadata.editedAt?.toISOString()
-      },
-      attachments: this.attachments.map((att) => ({
-        type: att.type,
-        url: att.url,
-        name: att.name,
-        mimeType: att.mimeType,
-        size: att.size,
-        width: att.width,
-        height: att.height
-      })),
-      isMention: this.isMention
-    };
-  }
-  /**
-   * Reconstruct a Message from serialized JSON data.
-   * Converts ISO date strings back to Date objects.
-   */
-  static fromJSON(json) {
-    return new _Message({
-      id: json.id,
-      threadId: json.threadId,
-      text: json.text,
-      formatted: json.formatted,
-      raw: json.raw,
-      author: json.author,
-      metadata: {
-        dateSent: new Date(json.metadata.dateSent),
-        edited: json.metadata.edited,
-        editedAt: json.metadata.editedAt ? new Date(json.metadata.editedAt) : void 0
-      },
-      attachments: json.attachments,
-      isMention: json.isMention
-    });
-  }
-  /**
-   * Serialize a Message instance for @workflow/serde.
-   * This static method is automatically called by workflow serialization.
-   */
-  static [WORKFLOW_SERIALIZE](instance) {
-    return instance.toJSON();
-  }
-  /**
-   * Deserialize a Message from @workflow/serde.
-   * This static method is automatically called by workflow deserialization.
-   */
-  static [WORKFLOW_DESERIALIZE](data) {
-    return _Message.fromJSON(data);
-  }
-};
-
-// src/thread.ts
-import { WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2, WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2 } from "@workflow/serde";
-
 // src/markdown.ts
 import { toString } from "mdast-util-to-string";
 import remarkGfm from "remark-gfm";
@@ -380,6 +253,133 @@ var BaseFormatConverter = class {
   }
 };
 
+// src/message.ts
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from "@workflow/serde";
+var Message = class _Message {
+  /** Unique message ID */
+  id;
+  /** Thread this message belongs to */
+  threadId;
+  /** Plain text content (all formatting stripped) */
+  text;
+  /**
+   * Structured formatting as an AST (mdast Root).
+   * This is the canonical representation - use this for processing.
+   * Use `stringifyMarkdown(message.formatted)` to get markdown string.
+   */
+  formatted;
+  /** Platform-specific raw payload (escape hatch) */
+  raw;
+  /** Message author */
+  author;
+  /** Message metadata */
+  metadata;
+  /** Attachments */
+  attachments;
+  /**
+   * Whether the bot is @-mentioned in this message.
+   *
+   * This is set by the Chat SDK before passing the message to handlers.
+   * It checks for `@username` in the message text using the adapter's
+   * configured `userName` and optional `botUserId`.
+   *
+   * @example
+   * ```typescript
+   * chat.onSubscribedMessage(async (thread, message) => {
+   *   if (message.isMention) {
+   *     await thread.post("You mentioned me!");
+   *   }
+   * });
+   * ```
+   */
+  isMention;
+  constructor(data) {
+    this.id = data.id;
+    this.threadId = data.threadId;
+    this.text = data.text;
+    this.formatted = data.formatted;
+    this.raw = data.raw;
+    this.author = data.author;
+    this.metadata = data.metadata;
+    this.attachments = data.attachments;
+    this.isMention = data.isMention;
+  }
+  /**
+   * Serialize the message to a plain JSON object.
+   * Use this to pass message data to external systems like workflow engines.
+   *
+   * Note: Attachment `data` (Buffer) and `fetchData` (function) are omitted
+   * as they're not serializable.
+   */
+  toJSON() {
+    return {
+      _type: "chat:Message",
+      id: this.id,
+      threadId: this.threadId,
+      text: this.text,
+      formatted: this.formatted,
+      raw: this.raw,
+      author: {
+        userId: this.author.userId,
+        userName: this.author.userName,
+        fullName: this.author.fullName,
+        isBot: this.author.isBot,
+        isMe: this.author.isMe
+      },
+      metadata: {
+        dateSent: this.metadata.dateSent.toISOString(),
+        edited: this.metadata.edited,
+        editedAt: this.metadata.editedAt?.toISOString()
+      },
+      attachments: this.attachments.map((att) => ({
+        type: att.type,
+        url: att.url,
+        name: att.name,
+        mimeType: att.mimeType,
+        size: att.size,
+        width: att.width,
+        height: att.height
+      })),
+      isMention: this.isMention
+    };
+  }
+  /**
+   * Reconstruct a Message from serialized JSON data.
+   * Converts ISO date strings back to Date objects.
+   */
+  static fromJSON(json) {
+    return new _Message({
+      id: json.id,
+      threadId: json.threadId,
+      text: json.text,
+      formatted: json.formatted,
+      raw: json.raw,
+      author: json.author,
+      metadata: {
+        dateSent: new Date(json.metadata.dateSent),
+        edited: json.metadata.edited,
+        editedAt: json.metadata.editedAt ? new Date(json.metadata.editedAt) : void 0
+      },
+      attachments: json.attachments,
+      isMention: json.isMention
+    });
+  }
+  /**
+   * Serialize a Message instance for @workflow/serde.
+   * This static method is automatically called by workflow serialization.
+   */
+  static [WORKFLOW_SERIALIZE](instance) {
+    return instance.toJSON();
+  }
+  /**
+   * Deserialize a Message from @workflow/serde.
+   * This static method is automatically called by workflow deserialization.
+   */
+  static [WORKFLOW_DESERIALIZE](data) {
+    return _Message.fromJSON(data);
+  }
+};
+
 // src/errors.ts
 var ChatError = class extends Error {
   constructor(message, code, cause) {
@@ -409,52 +409,377 @@ var NotImplementedError = class extends ChatError {
     this.name = "NotImplementedError";
   }
 };
-
-// src/logger.ts
-var ConsoleLogger = class _ConsoleLogger {
-  constructor(level = "info", prefix = "chat-sdk") {
-    this.level = level;
-    this.prefix = prefix;
+
+// src/logger.ts
+var ConsoleLogger = class _ConsoleLogger {
+  constructor(level = "info", prefix = "chat-sdk") {
+    this.level = level;
+    this.prefix = prefix;
+  }
+  prefix;
+  shouldLog(level) {
+    const levels = ["debug", "info", "warn", "error", "silent"];
+    return levels.indexOf(level) >= levels.indexOf(this.level);
+  }
+  child(prefix) {
+    return new _ConsoleLogger(this.level, `${this.prefix}:${prefix}`);
+  }
+  // eslint-disable-next-line no-console
+  debug(message, ...args) {
+    if (this.shouldLog("debug"))
+      console.debug(`[${this.prefix}] ${message}`, ...args);
+  }
+  // eslint-disable-next-line no-console
+  info(message, ...args) {
+    if (this.shouldLog("info"))
+      console.info(`[${this.prefix}] ${message}`, ...args);
+  }
+  // eslint-disable-next-line no-console
+  warn(message, ...args) {
+    if (this.shouldLog("warn"))
+      console.warn(`[${this.prefix}] ${message}`, ...args);
+  }
+  // eslint-disable-next-line no-console
+  error(message, ...args) {
+    if (this.shouldLog("error"))
+      console.error(`[${this.prefix}] ${message}`, ...args);
+  }
+};
+
+// src/types.ts
+var THREAD_STATE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+
+// src/channel.ts
+var CHANNEL_STATE_KEY_PREFIX = "channel-state:";
+function isLazyConfig(config) {
+  return "adapterName" in config && !("adapter" in config);
+}
+function isAsyncIterable(value) {
+  return value !== null && typeof value === "object" && Symbol.asyncIterator in value;
+}
+var ChannelImpl = class _ChannelImpl {
+  id;
+  isDM;
+  _adapter;
+  _adapterName;
+  _stateAdapterInstance;
+  _name = null;
+  constructor(config) {
+    this.id = config.id;
+    this.isDM = config.isDM ?? false;
+    if (isLazyConfig(config)) {
+      this._adapterName = config.adapterName;
+    } else {
+      this._adapter = config.adapter;
+      this._stateAdapterInstance = config.stateAdapter;
+    }
+  }
+  get adapter() {
+    if (this._adapter) {
+      return this._adapter;
+    }
+    if (!this._adapterName) {
+      throw new Error("Channel has no adapter configured");
+    }
+    const chat = getChatSingleton();
+    const adapter = chat.getAdapter(this._adapterName);
+    if (!adapter) {
+      throw new Error(
+        `Adapter "${this._adapterName}" not found in Chat singleton`
+      );
+    }
+    this._adapter = adapter;
+    return adapter;
+  }
+  get _stateAdapter() {
+    if (this._stateAdapterInstance) {
+      return this._stateAdapterInstance;
+    }
+    const chat = getChatSingleton();
+    this._stateAdapterInstance = chat.getState();
+    return this._stateAdapterInstance;
+  }
+  get name() {
+    return this._name;
+  }
+  get state() {
+    return this._stateAdapter.get(
+      `${CHANNEL_STATE_KEY_PREFIX}${this.id}`
+    );
+  }
+  async setState(newState, options) {
+    const key = `${CHANNEL_STATE_KEY_PREFIX}${this.id}`;
+    if (options?.replace) {
+      await this._stateAdapter.set(key, newState, THREAD_STATE_TTL_MS);
+    } else {
+      const existing = await this._stateAdapter.get(key);
+      const merged = { ...existing, ...newState };
+      await this._stateAdapter.set(key, merged, THREAD_STATE_TTL_MS);
+    }
+  }
+  /**
+   * 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() {
+    const adapter = this.adapter;
+    const channelId = this.id;
+    return {
+      async *[Symbol.asyncIterator]() {
+        let cursor;
+        while (true) {
+          const fetchOptions = { cursor, direction: "backward" };
+          const result = adapter.fetchChannelMessages ? await adapter.fetchChannelMessages(channelId, fetchOptions) : await adapter.fetchMessages(channelId, fetchOptions);
+          const reversed = [...result.messages].reverse();
+          for (const message of reversed) {
+            yield message;
+          }
+          if (!result.nextCursor || result.messages.length === 0) {
+            break;
+          }
+          cursor = result.nextCursor;
+        }
+      }
+    };
+  }
+  /**
+   * Iterate threads in this channel, most recently active first.
+   */
+  threads() {
+    const adapter = this.adapter;
+    const channelId = this.id;
+    return {
+      async *[Symbol.asyncIterator]() {
+        if (!adapter.listThreads) {
+          return;
+        }
+        let cursor;
+        while (true) {
+          const result = await adapter.listThreads(channelId, {
+            cursor
+          });
+          for (const thread of result.threads) {
+            yield thread;
+          }
+          if (!result.nextCursor || result.threads.length === 0) {
+            break;
+          }
+          cursor = result.nextCursor;
+        }
+      }
+    };
+  }
+  async fetchMetadata() {
+    if (this.adapter.fetchChannelInfo) {
+      const info = await this.adapter.fetchChannelInfo(this.id);
+      this._name = info.name ?? null;
+      return info;
+    }
+    return {
+      id: this.id,
+      isDM: this.isDM,
+      metadata: {}
+    };
+  }
+  async post(message) {
+    if (isAsyncIterable(message)) {
+      let accumulated = "";
+      for await (const chunk of message) {
+        accumulated += chunk;
+      }
+      return this.postSingleMessage(accumulated);
+    }
+    let postable = message;
+    if (isJSX(message)) {
+      const card = toCardElement(message);
+      if (!card) {
+        throw new Error("Invalid JSX element: must be a Card element");
+      }
+      postable = card;
+    }
+    return this.postSingleMessage(postable);
+  }
+  async postSingleMessage(postable) {
+    const rawMessage = this.adapter.postChannelMessage ? await this.adapter.postChannelMessage(this.id, postable) : await this.adapter.postMessage(this.id, postable);
+    return this.createSentMessage(rawMessage.id, postable, rawMessage.threadId);
+  }
+  async postEphemeral(user, message, options) {
+    const { fallbackToDM } = options;
+    const userId = typeof user === "string" ? user : user.userId;
+    let postable;
+    if (isJSX(message)) {
+      const card = toCardElement(message);
+      if (!card) {
+        throw new Error("Invalid JSX element: must be a Card element");
+      }
+      postable = card;
+    } else {
+      postable = message;
+    }
+    if (this.adapter.postEphemeral) {
+      return this.adapter.postEphemeral(this.id, userId, postable);
+    }
+    if (!fallbackToDM) {
+      return null;
+    }
+    if (this.adapter.openDM) {
+      const dmThreadId = await this.adapter.openDM(userId);
+      const result = await this.adapter.postMessage(dmThreadId, postable);
+      return {
+        id: result.id,
+        threadId: dmThreadId,
+        usedFallback: true,
+        raw: result.raw
+      };
+    }
+    return null;
+  }
+  async startTyping() {
+    await this.adapter.startTyping(this.id);
+  }
+  mentionUser(userId) {
+    return `<@${userId}>`;
+  }
+  toJSON() {
+    return {
+      _type: "chat:Channel",
+      id: this.id,
+      adapterName: this.adapter.name,
+      isDM: this.isDM
+    };
+  }
+  static fromJSON(json, adapter) {
+    const channel = new _ChannelImpl({
+      id: json.id,
+      adapterName: json.adapterName,
+      isDM: json.isDM
+    });
+    if (adapter) {
+      channel._adapter = adapter;
+    }
+    return channel;
+  }
+  static [WORKFLOW_SERIALIZE2](instance) {
+    return instance.toJSON();
+  }
+  static [WORKFLOW_DESERIALIZE2](data) {
+    return _ChannelImpl.fromJSON(data);
+  }
+  createSentMessage(messageId, postable, threadIdOverride) {
+    const adapter = this.adapter;
+    const threadId = threadIdOverride || this.id;
+    const self = this;
+    const { plainText, formatted, attachments } = extractMessageContent(postable);
+    const sentMessage = {
+      id: messageId,
+      threadId,
+      text: plainText,
+      formatted,
+      raw: null,
+      author: {
+        userId: "self",
+        userName: adapter.userName,
+        fullName: adapter.userName,
+        isBot: true,
+        isMe: true
+      },
+      metadata: {
+        dateSent: /* @__PURE__ */ new Date(),
+        edited: false
+      },
+      attachments,
+      toJSON() {
+        return new Message(this).toJSON();
+      },
+      async edit(newContent) {
+        let editPostable = newContent;
+        if (isJSX(newContent)) {
+          const card = toCardElement(newContent);
+          if (!card) {
+            throw new Error("Invalid JSX element: must be a Card element");
+          }
+          editPostable = card;
+        }
+        await adapter.editMessage(threadId, messageId, editPostable);
+        return self.createSentMessage(messageId, editPostable);
+      },
+      async delete() {
+        await adapter.deleteMessage(threadId, messageId);
+      },
+      async addReaction(emoji2) {
+        await adapter.addReaction(threadId, messageId, emoji2);
+      },
+      async removeReaction(emoji2) {
+        await adapter.removeReaction(threadId, messageId, emoji2);
+      }
+    };
+    return sentMessage;
+  }
+};
+function deriveChannelId(adapter, threadId) {
+  if (adapter.channelIdFromThreadId) {
+    return adapter.channelIdFromThreadId(threadId);
   }
-  prefix;
-  shouldLog(level) {
-    const levels = ["debug", "info", "warn", "error", "silent"];
-    return levels.indexOf(level) >= levels.indexOf(this.level);
+  const parts = threadId.split(":");
+  return parts.slice(0, 2).join(":");
+}
+function extractMessageContent(message) {
+  if (typeof message === "string") {
+    return {
+      plainText: message,
+      formatted: root([paragraph([text(message)])]),
+      attachments: []
+    };
   }
-  child(prefix) {
-    return new _ConsoleLogger(this.level, `${this.prefix}:${prefix}`);
+  if ("raw" in message) {
+    return {
+      plainText: message.raw,
+      formatted: root([paragraph([text(message.raw)])]),
+      attachments: message.attachments || []
+    };
   }
-  // eslint-disable-next-line no-console
-  debug(message, ...args) {
-    if (this.shouldLog("debug"))
-      console.debug(`[${this.prefix}] ${message}`, ...args);
+  if ("markdown" in message) {
+    const ast = parseMarkdown(message.markdown);
+    return {
+      plainText: toPlainText(ast),
+      formatted: ast,
+      attachments: message.attachments || []
+    };
   }
-  // eslint-disable-next-line no-console
-  info(message, ...args) {
-    if (this.shouldLog("info"))
-      console.info(`[${this.prefix}] ${message}`, ...args);
+  if ("ast" in message) {
+    return {
+      plainText: toPlainText(message.ast),
+      formatted: message.ast,
+      attachments: message.attachments || []
+    };
   }
-  // eslint-disable-next-line no-console
-  warn(message, ...args) {
-    if (this.shouldLog("warn"))
-      console.warn(`[${this.prefix}] ${message}`, ...args);
+  if ("card" in message) {
+    const fallbackText = message.fallbackText || cardToFallbackText(message.card);
+    return {
+      plainText: fallbackText,
+      formatted: root([paragraph([text(fallbackText)])]),
+      attachments: []
+    };
   }
-  // eslint-disable-next-line no-console
-  error(message, ...args) {
-    if (this.shouldLog("error"))
-      console.error(`[${this.prefix}] ${message}`, ...args);
+  if ("type" in message && message.type === "card") {
+    const fallbackText = cardToFallbackText(message);
+    return {
+      plainText: fallbackText,
+      formatted: root([paragraph([text(fallbackText)])]),
+      attachments: []
+    };
   }
-};
-
-// src/types.ts
-var THREAD_STATE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+  throw new Error("Invalid PostableMessage format");
+}
 
 // src/thread.ts
-function isLazyConfig(config) {
+import { WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE3, WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE3 } from "@workflow/serde";
+function isLazyConfig2(config) {
   return "adapterName" in config && !("adapter" in config);
 }
 var THREAD_STATE_KEY_PREFIX = "thread-state:";
-function isAsyncIterable(value) {
+function isAsyncIterable2(value) {
   return value !== null && typeof value === "object" && Symbol.asyncIterator in value;
 }
 var ThreadImpl = class _ThreadImpl {
@@ -473,6 +798,8 @@ var ThreadImpl = class _ThreadImpl {
   _currentMessage;
   /** Update interval for fallback streaming */
   _streamingUpdateIntervalMs;
+  /** Cached channel instance */
+  _channel;
   constructor(config) {
     this.id = config.id;
     this.channelId = config.channelId;
@@ -480,7 +807,7 @@ var ThreadImpl = class _ThreadImpl {
     this._isSubscribedContext = config.isSubscribedContext ?? false;
     this._currentMessage = config.currentMessage;
     this._streamingUpdateIntervalMs = config.streamingUpdateIntervalMs ?? 500;
-    if (isLazyConfig(config)) {
+    if (isLazyConfig2(config)) {
       this._adapterName = config.adapterName;
     } else {
       this._adapter = config.adapter;
@@ -552,6 +879,49 @@ var ThreadImpl = class _ThreadImpl {
       await this._stateAdapter.set(key, merged, THREAD_STATE_TTL_MS);
     }
   }
+  /**
+   * Get the Channel containing this thread.
+   * Lazy-created and cached.
+   */
+  get channel() {
+    if (!this._channel) {
+      const channelId = deriveChannelId(this.adapter, this.id);
+      this._channel = new ChannelImpl({
+        id: channelId,
+        adapter: this.adapter,
+        stateAdapter: this._stateAdapter,
+        isDM: this.isDM
+      });
+    }
+    return this._channel;
+  }
+  /**
+   * Iterate messages newest first (backward from most recent).
+   * Auto-paginates lazily.
+   */
+  get messages() {
+    const adapter = this.adapter;
+    const threadId = this.id;
+    return {
+      async *[Symbol.asyncIterator]() {
+        let cursor;
+        while (true) {
+          const result = await adapter.fetchMessages(threadId, {
+            cursor,
+            direction: "backward"
+          });
+          const reversed = [...result.messages].reverse();
+          for (const message of reversed) {
+            yield message;
+          }
+          if (!result.nextCursor || result.messages.length === 0) {
+            break;
+          }
+          cursor = result.nextCursor;
+        }
+      }
+    };
+  }
   get allMessages() {
     const adapter = this.adapter;
     const threadId = this.id;
@@ -591,7 +961,7 @@ var ThreadImpl = class _ThreadImpl {
     await this._stateAdapter.unsubscribe(this.id);
   }
   async post(message) {
-    if (isAsyncIterable(message)) {
+    if (isAsyncIterable2(message)) {
       return this.handleStream(message);
     }
     let postable = message;
@@ -788,7 +1158,7 @@ var ThreadImpl = class _ThreadImpl {
    * Serialize a ThreadImpl instance for @workflow/serde.
    * This static method is automatically called by workflow serialization.
    */
-  static [WORKFLOW_SERIALIZE2](instance) {
+  static [WORKFLOW_SERIALIZE3](instance) {
     return instance.toJSON();
   }
   /**
@@ -796,14 +1166,14 @@ var ThreadImpl = class _ThreadImpl {
    * Uses lazy adapter resolution from Chat.getSingleton().
    * Requires chat.registerSingleton() to have been called.
    */
-  static [WORKFLOW_DESERIALIZE2](data) {
+  static [WORKFLOW_DESERIALIZE3](data) {
     return _ThreadImpl.fromJSON(data);
   }
   createSentMessage(messageId, postable, threadIdOverride) {
     const adapter = this.adapter;
     const threadId = threadIdOverride || this.id;
     const self = this;
-    const { plainText, formatted, attachments } = extractMessageContent(postable);
+    const { plainText, formatted, attachments } = extractMessageContent2(postable);
     const sentMessage = {
       id: messageId,
       threadId,
@@ -891,7 +1261,7 @@ var ThreadImpl = class _ThreadImpl {
     };
   }
 };
-function extractMessageContent(message) {
+function extractMessageContent2(message) {
   if (typeof message === "string") {
     return {
       plainText: message,
@@ -987,6 +1357,10 @@ var Chat = class {
   actionHandlers = [];
   modalSubmitHandlers = [];
   modalCloseHandlers = [];
+  slashCommandHandlers = [];
+  assistantThreadStartedHandlers = [];
+  assistantContextChangedHandlers = [];
+  appHomeOpenedHandlers = [];
   /** Initialization state */
   initPromise = null;
   initialized = false;
@@ -1201,6 +1575,36 @@ var Chat = class {
       this.logger.debug("Registered modal close handler", { callbackIds });
     }
   }
+  onSlashCommand(commandOrHandler, handler) {
+    if (typeof commandOrHandler === "function") {
+      this.slashCommandHandlers.push({
+        commands: [],
+        handler: commandOrHandler
+      });
+      this.logger.debug("Registered slash command handler for all commands");
+    } else if (handler) {
+      const commands = Array.isArray(commandOrHandler) ? commandOrHandler : [commandOrHandler];
+      const normalizedCommands = commands.map(
+        (cmd) => cmd.startsWith("/") ? cmd : `/${cmd}`
+      );
+      this.slashCommandHandlers.push({ commands: normalizedCommands, handler });
+      this.logger.debug("Registered slash command handler", {
+        commands: normalizedCommands
+      });
+    }
+  }
+  onAssistantThreadStarted(handler) {
+    this.assistantThreadStartedHandlers.push(handler);
+    this.logger.debug("Registered assistant thread started handler");
+  }
+  onAssistantContextChanged(handler) {
+    this.assistantContextChangedHandlers.push(handler);
+    this.logger.debug("Registered assistant context changed handler");
+  }
+  onAppHomeOpened(handler) {
+    this.appHomeOpenedHandlers.push(handler);
+    this.logger.debug("Registered app home opened handler");
+  }
   /**
    * Get an adapter by name with type safety.
    */
@@ -1234,6 +1638,9 @@ var Chat = class {
         if (typed._type === "chat:Thread") {
           return ThreadImpl.fromJSON(value);
         }
+        if (typed._type === "chat:Channel") {
+          return ChannelImpl.fromJSON(value);
+        }
         if (typed._type === "chat:Message") {
           return Message.fromJSON(value);
         }
@@ -1291,14 +1698,12 @@ var Chat = class {
     }
   }
   async processModalSubmit(event, contextId, _options) {
-    const { relatedThread, relatedMessage } = await this.retrieveModalContext(
-      event.adapter.name,
-      contextId
-    );
+    const { relatedThread, relatedMessage, relatedChannel } = await this.retrieveModalContext(event.adapter.name, contextId);
     const fullEvent = {
       ...event,
       relatedThread,
-      relatedMessage
+      relatedMessage,
+      relatedChannel
     };
     for (const { callbackIds, handler } of this.modalSubmitHandlers) {
       if (callbackIds.length === 0 || callbackIds.includes(event.callbackId)) {
@@ -1316,14 +1721,12 @@ var Chat = class {
   }
   processModalClose(event, contextId, options) {
     const task = (async () => {
-      const { relatedThread, relatedMessage } = await this.retrieveModalContext(
-        event.adapter.name,
-        contextId
-      );
+      const { relatedThread, relatedMessage, relatedChannel } = await this.retrieveModalContext(event.adapter.name, contextId);
       const fullEvent = {
         ...event,
         relatedThread,
-        relatedMessage
+        relatedMessage,
+        relatedChannel
       };
       for (const { callbackIds, handler } of this.modalCloseHandlers) {
         if (callbackIds.length === 0 || callbackIds.includes(event.callbackId)) {
@@ -1340,15 +1743,153 @@ var Chat = class {
       options.waitUntil(task);
     }
   }
+  /**
+   * Process an incoming slash command from an adapter.
+   * Handles waitUntil registration and error catching internally.
+   */
+  processSlashCommand(event, options) {
+    const task = this.handleSlashCommandEvent(event).catch((err) => {
+      this.logger.error("Slash command processing error", {
+        error: err,
+        command: event.command,
+        text: event.text
+      });
+    });
+    if (options?.waitUntil) {
+      options.waitUntil(task);
+    }
+  }
+  processAssistantThreadStarted(event, options) {
+    const task = (async () => {
+      for (const handler of this.assistantThreadStartedHandlers) {
+        await handler(event);
+      }
+    })().catch((err) => {
+      this.logger.error("Assistant thread started handler error", {
+        error: err,
+        threadId: event.threadId
+      });
+    });
+    if (options?.waitUntil) {
+      options.waitUntil(task);
+    }
+  }
+  processAssistantContextChanged(event, options) {
+    const task = (async () => {
+      for (const handler of this.assistantContextChangedHandlers) {
+        await handler(event);
+      }
+    })().catch((err) => {
+      this.logger.error("Assistant context changed handler error", {
+        error: err,
+        threadId: event.threadId
+      });
+    });
+    if (options?.waitUntil) {
+      options.waitUntil(task);
+    }
+  }
+  processAppHomeOpened(event, options) {
+    const task = (async () => {
+      for (const handler of this.appHomeOpenedHandlers) {
+        await handler(event);
+      }
+    })().catch((err) => {
+      this.logger.error("App home opened handler error", {
+        error: err,
+        userId: event.userId
+      });
+    });
+    if (options?.waitUntil) {
+      options.waitUntil(task);
+    }
+  }
+  /**
+   * Handle a slash command event internally.
+   */
+  async handleSlashCommandEvent(event) {
+    this.logger.debug("Incoming slash command", {
+      adapter: event.adapter.name,
+      command: event.command,
+      text: event.text,
+      user: event.user.userName
+    });
+    if (event.user.isMe) {
+      this.logger.debug("Skipping slash command from self", {
+        command: event.command
+      });
+      return;
+    }
+    const channel = new ChannelImpl({
+      id: event.channelId,
+      adapter: event.adapter,
+      stateAdapter: this._stateAdapter
+    });
+    const fullEvent = {
+      ...event,
+      channel,
+      openModal: async (modal) => {
+        if (!event.triggerId) {
+          this.logger.warn("Cannot open modal: no triggerId available");
+          return void 0;
+        }
+        if (!event.adapter.openModal) {
+          this.logger.warn(
+            `Cannot open modal: ${event.adapter.name} does not support modals`
+          );
+          return void 0;
+        }
+        let modalElement = modal;
+        if (isJSX(modal)) {
+          const converted = toModalElement(modal);
+          if (!converted) {
+            throw new Error("Invalid JSX element: must be a Modal element");
+          }
+          modalElement = converted;
+        }
+        const contextId = crypto.randomUUID();
+        this.storeModalContext(
+          event.adapter.name,
+          contextId,
+          void 0,
+          void 0,
+          channel
+        );
+        return event.adapter.openModal(
+          event.triggerId,
+          modalElement,
+          contextId
+        );
+      }
+    };
+    this.logger.debug("Checking slash command handlers", {
+      handlerCount: this.slashCommandHandlers.length,
+      command: event.command
+    });
+    for (const { commands, handler } of this.slashCommandHandlers) {
+      if (commands.length === 0) {
+        this.logger.debug("Running catch-all slash command handler");
+        await handler(fullEvent);
+        continue;
+      }
+      if (commands.includes(event.command)) {
+        this.logger.debug("Running matched slash command handler", {
+          command: event.command
+        });
+        await handler(fullEvent);
+      }
+    }
+  }
   /**
    * 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.
    */
-  storeModalContext(adapterName, contextId, thread, message) {
+  storeModalContext(adapterName, contextId, thread, message, channel) {
     const key = `modal-context:${adapterName}:${contextId}`;
     const context = {
-      thread: thread.toJSON(),
-      message: message?.toJSON()
+      thread: thread?.toJSON(),
+      message: message?.toJSON(),
+      channel: channel?.toJSON()
     };
     this._stateAdapter.set(key, context, MODAL_CONTEXT_TTL_MS).catch((err) => {
       this.logger.error("Failed to store modal context", {
@@ -1359,25 +1900,40 @@ var Chat = class {
   }
   /**
    * 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.
    */
   async retrieveModalContext(adapterName, contextId) {
     if (!contextId) {
-      return { relatedThread: void 0, relatedMessage: void 0 };
+      return {
+        relatedThread: void 0,
+        relatedMessage: void 0,
+        relatedChannel: void 0
+      };
     }
     const key = `modal-context:${adapterName}:${contextId}`;
     const stored = await this._stateAdapter.get(key);
     if (!stored) {
-      return { relatedThread: void 0, relatedMessage: void 0 };
+      return {
+        relatedThread: void 0,
+        relatedMessage: void 0,
+        relatedChannel: void 0
+      };
     }
     const adapter = this.adapters.get(adapterName);
-    const thread = ThreadImpl.fromJSON(stored.thread, adapter);
+    let relatedThread;
+    if (stored.thread) {
+      relatedThread = ThreadImpl.fromJSON(stored.thread, adapter);
+    }
     let relatedMessage;
-    if (stored.message) {
+    if (stored.message && relatedThread) {
       const message = Message.fromJSON(stored.message);
-      relatedMessage = thread.createSentMessageFromMessage(message);
+      relatedMessage = relatedThread.createSentMessageFromMessage(message);
+    }
+    let relatedChannel;
+    if (stored.channel) {
+      relatedChannel = ChannelImpl.fromJSON(stored.channel, adapter);
     }
-    return { relatedThread: thread, relatedMessage };
+    return { relatedThread, relatedMessage, relatedChannel };
   }
   /**
    * Handle an action event internally.
@@ -1408,12 +1964,12 @@ var Chat = class {
       metadata: { dateSent: /* @__PURE__ */ new Date(), edited: false },
       attachments: []
     }) : {};
-    const thread = await this.createThread(
+    const thread = event.threadId ? await this.createThread(
       event.adapter,
       event.threadId,
       messageForThread,
       isSubscribed
-    );
+    ) : null;
     const fullEvent = {
       ...event,
       thread,
@@ -1455,11 +2011,13 @@ var Chat = class {
           }
         }
         const contextId = crypto.randomUUID();
+        const channel = thread.channel;
         this.storeModalContext(
           event.adapter.name,
           contextId,
           thread,
-          message
+          message,
+          channel
         );
         return event.adapter.openModal(
           event.triggerId,
@@ -1601,6 +2159,53 @@ var Chat = class {
     const threadId = await adapter.openDM(userId);
     return this.createThread(adapter, threadId, {}, false);
   }
+  /**
+   * 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) {
+    const adapterName = channelId.split(":")[0];
+    if (!adapterName) {
+      throw new ChatError(
+        `Invalid channel ID: ${channelId}`,
+        "INVALID_CHANNEL_ID"
+      );
+    }
+    const adapter = this.adapters.get(adapterName);
+    if (!adapter) {
+      throw new ChatError(
+        `Adapter "${adapterName}" not found for channel ID "${channelId}"`,
+        "ADAPTER_NOT_FOUND"
+      );
+    }
+    return new ChannelImpl({
+      id: channelId,
+      adapter,
+      stateAdapter: this._stateAdapter
+    });
+  }
   /**
    * Infer which adapter to use based on the userId format.
    */
@@ -2206,6 +2811,7 @@ export {
   Button2 as Button,
   Card2 as Card,
   CardText2 as CardText,
+  ChannelImpl,
   Chat,
   ChatError,
   ConsoleLogger,
@@ -2233,6 +2839,7 @@ export {
   convertEmojiPlaceholders,
   createEmoji,
   defaultEmojiResolver,
+  deriveChannelId,
   emoji,
   emphasis,
   fromReactElement2 as fromReactElement,