chat 1.0.8 → 4.0.0

package/dist/index.js

@@ -0,0 +1,1433 @@
+import {
+  Actions,
+  Button,
+  Card,
+  CardText,
+  Divider,
+  Field,
+  Fields,
+  Image,
+  Section,
+  cardToFallbackText,
+  fromReactElement,
+  isCardElement,
+  isJSX,
+  toCardElement
+} from "./chunk-ACQNDPTB.js";
+
+// src/markdown.ts
+import { toString } from "mdast-util-to-string";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import remarkStringify from "remark-stringify";
+import { unified } from "unified";
+function parseMarkdown(markdown) {
+  const processor = unified().use(remarkParse).use(remarkGfm);
+  return processor.parse(markdown);
+}
+function stringifyMarkdown(ast) {
+  const processor = unified().use(remarkStringify).use(remarkGfm);
+  return processor.stringify(ast);
+}
+function toPlainText(ast) {
+  return toString(ast);
+}
+function markdownToPlainText(markdown) {
+  const ast = parseMarkdown(markdown);
+  return toString(ast);
+}
+function walkAst(node, visitor) {
+  if ("children" in node && Array.isArray(node.children)) {
+    node.children = node.children.map((child) => {
+      const result = visitor(child);
+      if (result === null) return null;
+      return walkAst(result, visitor);
+    }).filter((n) => n !== null);
+  }
+  return node;
+}
+function text(value) {
+  return { type: "text", value };
+}
+function strong(children) {
+  return { type: "strong", children };
+}
+function emphasis(children) {
+  return { type: "emphasis", children };
+}
+function strikethrough(children) {
+  return { type: "delete", children };
+}
+function inlineCode(value) {
+  return { type: "inlineCode", value };
+}
+function codeBlock(value, lang) {
+  return { type: "code", value, lang };
+}
+function link(url, children, title) {
+  return { type: "link", url, children, title };
+}
+function blockquote(children) {
+  return { type: "blockquote", children };
+}
+function paragraph(children) {
+  return { type: "paragraph", children };
+}
+function root(children) {
+  return { type: "root", children };
+}
+var BaseFormatConverter = class {
+  extractPlainText(platformText) {
+    return toPlainText(this.toAst(platformText));
+  }
+  // Convenience methods for markdown string I/O
+  fromMarkdown(markdown) {
+    return this.fromAst(parseMarkdown(markdown));
+  }
+  toMarkdown(platformText) {
+    return stringifyMarkdown(this.toAst(platformText));
+  }
+  /** @deprecated Use extractPlainText instead */
+  toPlainText(platformText) {
+    return this.extractPlainText(platformText);
+  }
+  /**
+   * Convert a PostableMessage to platform format (text only).
+   * - string: passed through as raw text (no conversion)
+   * - { raw: string }: passed through as raw text (no conversion)
+   * - { markdown: string }: converted from markdown to platform format
+   * - { ast: Root }: converted from AST to platform format
+   * - { card: CardElement }: returns fallback text (cards should be handled by adapter)
+   * - CardElement: returns fallback text (cards should be handled by adapter)
+   *
+   * Note: For cards, adapters should check for card content first and render
+   * them using platform-specific card APIs, using this method only for fallback.
+   */
+  renderPostable(message) {
+    if (typeof message === "string") {
+      return message;
+    }
+    if ("raw" in message) {
+      return message.raw;
+    }
+    if ("markdown" in message) {
+      return this.fromMarkdown(message.markdown);
+    }
+    if ("ast" in message) {
+      return this.fromAst(message.ast);
+    }
+    if ("card" in message) {
+      return message.fallbackText || this.cardToFallbackText(message.card);
+    }
+    if ("type" in message && message.type === "card") {
+      return this.cardToFallbackText(message);
+    }
+    throw new Error("Invalid PostableMessage format");
+  }
+  /**
+   * Generate fallback text from a card element.
+   * Override in subclasses for platform-specific formatting.
+   */
+  cardToFallbackText(card) {
+    const parts = [];
+    if (card.title) {
+      parts.push(`**${card.title}**`);
+    }
+    if (card.subtitle) {
+      parts.push(card.subtitle);
+    }
+    for (const child of card.children) {
+      const text2 = this.cardChildToFallbackText(child);
+      if (text2) {
+        parts.push(text2);
+      }
+    }
+    return parts.join("\n");
+  }
+  /**
+   * Convert card child element to fallback text.
+   */
+  cardChildToFallbackText(child) {
+    switch (child.type) {
+      case "text":
+        return child.content;
+      case "fields":
+        return child.children.map((f) => `**${f.label}**: ${f.value}`).join("\n");
+      case "actions":
+        return `[${child.children.map((b) => b.label).join("] [")}]`;
+      case "section":
+        return child.children.map((c) => this.cardChildToFallbackText(c)).filter(Boolean).join("\n");
+      default:
+        return null;
+    }
+  }
+};
+
+// src/thread.ts
+var ThreadImpl = class {
+  id;
+  adapter;
+  channelId;
+  isDM;
+  state;
+  _recentMessages = [];
+  _isSubscribedContext;
+  constructor(config) {
+    this.id = config.id;
+    this.adapter = config.adapter;
+    this.channelId = config.channelId;
+    this.isDM = config.isDM ?? false;
+    this.state = config.state;
+    this._isSubscribedContext = config.isSubscribedContext ?? false;
+    if (config.initialMessage) {
+      this._recentMessages = [config.initialMessage];
+    }
+  }
+  get recentMessages() {
+    return this._recentMessages;
+  }
+  set recentMessages(messages) {
+    this._recentMessages = messages;
+  }
+  get allMessages() {
+    const adapter = this.adapter;
+    const threadId = this.id;
+    return {
+      async *[Symbol.asyncIterator]() {
+        let before;
+        let hasMore = true;
+        while (hasMore) {
+          const messages = await adapter.fetchMessages(threadId, {
+            limit: 100,
+            before
+          });
+          if (messages.length === 0) {
+            hasMore = false;
+            break;
+          }
+          for (const message of messages) {
+            yield message;
+          }
+          before = messages[messages.length - 1]?.id;
+          if (messages.length < 100) {
+            hasMore = false;
+          }
+        }
+      }
+    };
+  }
+  async isSubscribed() {
+    if (this._isSubscribedContext) {
+      return true;
+    }
+    return this.state.isSubscribed(this.id);
+  }
+  async subscribe() {
+    await this.state.subscribe(this.id);
+    if (this.adapter.onThreadSubscribe) {
+      await this.adapter.onThreadSubscribe(this.id);
+    }
+  }
+  async unsubscribe() {
+    await this.state.unsubscribe(this.id);
+  }
+  async post(message) {
+    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;
+    }
+    const rawMessage = await this.adapter.postMessage(this.id, postable);
+    return this.createSentMessage(rawMessage.id, postable);
+  }
+  async startTyping() {
+    await this.adapter.startTyping(this.id);
+  }
+  async refresh() {
+    const messages = await this.adapter.fetchMessages(this.id, { limit: 50 });
+    this._recentMessages = messages;
+  }
+  mentionUser(userId) {
+    return `<@${userId}>`;
+  }
+  createSentMessage(messageId, postable) {
+    const adapter = this.adapter;
+    const threadId = this.id;
+    const self = this;
+    const { plainText, formatted, attachments } = extractMessageContent(postable);
+    const sentMessage = {
+      id: messageId,
+      threadId,
+      text: plainText,
+      formatted,
+      raw: null,
+      // Will be populated if needed
+      author: {
+        userId: "self",
+        userName: adapter.userName,
+        fullName: adapter.userName,
+        isBot: true,
+        isMe: true
+      },
+      metadata: {
+        dateSent: /* @__PURE__ */ new Date(),
+        edited: false
+      },
+      attachments,
+      async edit(newContent) {
+        let postable2 = newContent;
+        if (isJSX(newContent)) {
+          const card = toCardElement(newContent);
+          if (!card) {
+            throw new Error("Invalid JSX element: must be a Card element");
+          }
+          postable2 = card;
+        }
+        await adapter.editMessage(threadId, messageId, postable2);
+        return self.createSentMessage(messageId, postable2);
+      },
+      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 extractMessageContent(message) {
+  if (typeof message === "string") {
+    return {
+      plainText: message,
+      formatted: root([paragraph([text(message)])]),
+      attachments: []
+    };
+  }
+  if ("raw" in message) {
+    return {
+      plainText: message.raw,
+      formatted: root([paragraph([text(message.raw)])]),
+      attachments: message.attachments || []
+    };
+  }
+  if ("markdown" in message) {
+    const ast = parseMarkdown(message.markdown);
+    return {
+      plainText: toPlainText(ast),
+      formatted: ast,
+      attachments: message.attachments || []
+    };
+  }
+  if ("ast" in message) {
+    return {
+      plainText: toPlainText(message.ast),
+      formatted: message.ast,
+      attachments: message.attachments || []
+    };
+  }
+  if ("card" in message) {
+    const fallbackText = message.fallbackText || cardToFallbackText(message.card);
+    return {
+      plainText: fallbackText,
+      formatted: root([paragraph([text(fallbackText)])]),
+      attachments: []
+    };
+  }
+  if ("type" in message && message.type === "card") {
+    const fallbackText = cardToFallbackText(message);
+    return {
+      plainText: fallbackText,
+      formatted: root([paragraph([text(fallbackText)])]),
+      attachments: []
+    };
+  }
+  throw new Error("Invalid PostableMessage format");
+}
+
+// src/types.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);
+  }
+};
+var ChatError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "ChatError";
+  }
+};
+var RateLimitError = class extends ChatError {
+  constructor(message, retryAfterMs, cause) {
+    super(message, "RATE_LIMITED", cause);
+    this.retryAfterMs = retryAfterMs;
+    this.name = "RateLimitError";
+  }
+};
+var LockError = class extends ChatError {
+  constructor(message, cause) {
+    super(message, "LOCK_FAILED", cause);
+    this.name = "LockError";
+  }
+};
+var NotImplementedError = class extends ChatError {
+  constructor(message, feature, cause) {
+    super(message, "NOT_IMPLEMENTED", cause);
+    this.feature = feature;
+    this.name = "NotImplementedError";
+  }
+};
+
+// src/chat.ts
+var DEFAULT_LOCK_TTL_MS = 3e4;
+var DEDUPE_TTL_MS = 6e4;
+var Chat = class {
+  adapters;
+  state;
+  userName;
+  logger;
+  mentionHandlers = [];
+  messagePatterns = [];
+  subscribedMessageHandlers = [];
+  reactionHandlers = [];
+  actionHandlers = [];
+  /** Initialization state */
+  initPromise = null;
+  initialized = false;
+  /**
+   * Type-safe webhook handlers keyed by adapter name.
+   * @example
+   * chat.webhooks.slack(request, { backgroundTask: waitUntil });
+   */
+  webhooks;
+  constructor(config) {
+    this.userName = config.userName;
+    this.state = config.state;
+    this.adapters = /* @__PURE__ */ new Map();
+    if (!config.logger) {
+      this.logger = new ConsoleLogger("info");
+    } else if (typeof config.logger === "string") {
+      this.logger = new ConsoleLogger(config.logger);
+    } else {
+      this.logger = config.logger;
+    }
+    const webhooks = {};
+    for (const [name, adapter] of Object.entries(config.adapters)) {
+      this.adapters.set(name, adapter);
+      webhooks[name] = (request, options) => this.handleWebhook(name, request, options);
+    }
+    this.webhooks = webhooks;
+    this.logger.debug("Chat instance created", {
+      adapters: Object.keys(config.adapters)
+    });
+  }
+  /**
+   * Handle a webhook request for a specific adapter.
+   * Automatically initializes adapters on first call.
+   */
+  async handleWebhook(adapterName, request, options) {
+    await this.ensureInitialized();
+    const adapter = this.adapters.get(adapterName);
+    if (!adapter) {
+      return new Response(`Unknown adapter: ${adapterName}`, { status: 404 });
+    }
+    return adapter.handleWebhook(request, options);
+  }
+  /**
+   * Ensure the chat instance is initialized.
+   * This is called automatically before handling webhooks.
+   */
+  async ensureInitialized() {
+    if (this.initialized) {
+      return;
+    }
+    if (!this.initPromise) {
+      this.initPromise = this.doInitialize();
+    }
+    await this.initPromise;
+  }
+  async doInitialize() {
+    this.logger.info("Initializing chat instance...");
+    await this.state.connect();
+    this.logger.debug("State connected");
+    const initPromises = Array.from(this.adapters.values()).map(
+      async (adapter) => {
+        this.logger.debug("Initializing adapter", adapter.name);
+        const result = await adapter.initialize(this);
+        this.logger.debug("Adapter initialized", adapter.name);
+        return result;
+      }
+    );
+    await Promise.all(initPromises);
+    this.initialized = true;
+    this.logger.info("Chat instance initialized", {
+      adapters: Array.from(this.adapters.keys())
+    });
+  }
+  /**
+   * Gracefully shut down the chat instance.
+   */
+  async shutdown() {
+    this.logger.info("Shutting down chat instance...");
+    await this.state.disconnect();
+    this.initialized = false;
+    this.initPromise = null;
+    this.logger.info("Chat instance shut down");
+  }
+  /**
+   * Register a handler for new @-mentions of the bot.
+   *
+   * **Important**: This handler is ONLY called for mentions in **unsubscribed** threads.
+   * Once a thread is subscribed (via `thread.subscribe()`), subsequent messages
+   * including @-mentions go to `onSubscribedMessage` handlers instead.
+   *
+   * To detect mentions in subscribed threads, check `message.isMention`:
+   *
+   * @example
+   * ```typescript
+   * // Handle new mentions (unsubscribed threads only)
+   * chat.onNewMention(async (thread, message) => {
+   *   await thread.subscribe();  // Subscribe to follow-up messages
+   *   await thread.post("Hello! I'll be watching this thread.");
+   * });
+   *
+   * // Handle all messages in subscribed threads
+   * chat.onSubscribedMessage(async (thread, message) => {
+   *   if (message.isMention) {
+   *     // User @-mentioned us in a thread we're already watching
+   *     await thread.post("You mentioned me again!");
+   *   }
+   * });
+   * ```
+   */
+  onNewMention(handler) {
+    this.mentionHandlers.push(handler);
+    this.logger.debug("Registered mention handler");
+  }
+  /**
+   * Register a handler for messages matching a regex pattern.
+   *
+   * @param pattern - Regular expression to match against message text
+   * @param handler - Handler called when pattern matches
+   *
+   * @example
+   * ```typescript
+   * // Match messages starting with "!help"
+   * chat.onNewMessage(/^!help/, async (thread, message) => {
+   *   await thread.post("Available commands: !help, !status, !ping");
+   * });
+   * ```
+   */
+  onNewMessage(pattern, handler) {
+    this.messagePatterns.push({ pattern, handler });
+    this.logger.debug("Registered message pattern handler", {
+      pattern: pattern.toString()
+    });
+  }
+  /**
+   * Register a handler for messages in subscribed threads.
+   *
+   * Called for all messages in threads that have been subscribed via `thread.subscribe()`.
+   * This includes:
+   * - Follow-up messages from users
+   * - Messages that @-mention the bot (check `message.isMention`)
+   *
+   * Does NOT fire for:
+   * - The message that triggered the subscription (e.g., the initial @mention)
+   * - Messages sent by the bot itself
+   *
+   * @example
+   * ```typescript
+   * chat.onSubscribedMessage(async (thread, message) => {
+   *   // Handle all follow-up messages
+   *   if (message.isMention) {
+   *     // User @-mentioned us in a subscribed thread
+   *   }
+   *   await thread.post(`Got your message: ${message.text}`);
+   * });
+   * ```
+   */
+  onSubscribedMessage(handler) {
+    this.subscribedMessageHandlers.push(handler);
+    this.logger.debug("Registered subscribed message handler");
+  }
+  onReaction(emojiOrHandler, handler) {
+    if (typeof emojiOrHandler === "function") {
+      this.reactionHandlers.push({ emoji: [], handler: emojiOrHandler });
+      this.logger.debug("Registered reaction handler for all emoji");
+    } else if (handler) {
+      this.reactionHandlers.push({ emoji: emojiOrHandler, handler });
+      this.logger.debug("Registered reaction handler", {
+        emoji: emojiOrHandler.map((e) => typeof e === "string" ? e : e.name)
+      });
+    }
+  }
+  onAction(actionIdOrHandler, handler) {
+    if (typeof actionIdOrHandler === "function") {
+      this.actionHandlers.push({ actionIds: [], handler: actionIdOrHandler });
+      this.logger.debug("Registered action handler for all actions");
+    } else if (handler) {
+      const actionIds = Array.isArray(actionIdOrHandler) ? actionIdOrHandler : [actionIdOrHandler];
+      this.actionHandlers.push({ actionIds, handler });
+      this.logger.debug("Registered action handler", { actionIds });
+    }
+  }
+  /**
+   * Get an adapter by name with type safety.
+   */
+  getAdapter(name) {
+    return this.adapters.get(name);
+  }
+  // ChatInstance interface implementations
+  /**
+   * Process an incoming message from an adapter.
+   * Handles waitUntil registration and error catching internally.
+   * Adapters should call this instead of handleIncomingMessage directly.
+   */
+  processMessage(adapter, threadId, messageOrFactory, options) {
+    const task = (async () => {
+      const message = typeof messageOrFactory === "function" ? await messageOrFactory() : messageOrFactory;
+      await this.handleIncomingMessage(adapter, threadId, message);
+    })().catch((err) => {
+      this.logger.error("Message processing error", { error: err, threadId });
+    });
+    if (options?.waitUntil) {
+      options.waitUntil(task);
+    }
+  }
+  /**
+   * Process an incoming reaction event from an adapter.
+   * Handles waitUntil registration and error catching internally.
+   */
+  processReaction(event, options) {
+    const task = this.handleReactionEvent(event).catch((err) => {
+      this.logger.error("Reaction processing error", {
+        error: err,
+        emoji: event.emoji,
+        messageId: event.messageId
+      });
+    });
+    if (options?.waitUntil) {
+      options.waitUntil(task);
+    }
+  }
+  /**
+   * Process an incoming action event (button click) from an adapter.
+   * Handles waitUntil registration and error catching internally.
+   */
+  processAction(event, options) {
+    const task = this.handleActionEvent(event).catch((err) => {
+      this.logger.error("Action processing error", {
+        error: err,
+        actionId: event.actionId,
+        messageId: event.messageId
+      });
+    });
+    if (options?.waitUntil) {
+      options.waitUntil(task);
+    }
+  }
+  /**
+   * Handle an action event internally.
+   */
+  async handleActionEvent(event) {
+    this.logger.debug("Incoming action", {
+      adapter: event.adapter.name,
+      actionId: event.actionId,
+      value: event.value,
+      user: event.user.userName,
+      messageId: event.messageId,
+      threadId: event.threadId
+    });
+    if (event.user.isMe) {
+      this.logger.debug("Skipping action from self", {
+        actionId: event.actionId
+      });
+      return;
+    }
+    const isSubscribed = await this.state.isSubscribed(event.threadId);
+    const thread = await this.createThread(
+      event.adapter,
+      event.threadId,
+      {},
+      isSubscribed
+    );
+    const fullEvent = {
+      ...event,
+      thread
+    };
+    this.logger.debug("Checking action handlers", {
+      handlerCount: this.actionHandlers.length,
+      actionId: event.actionId
+    });
+    for (const { actionIds, handler } of this.actionHandlers) {
+      if (actionIds.length === 0) {
+        this.logger.debug("Running catch-all action handler");
+        await handler(fullEvent);
+        continue;
+      }
+      if (actionIds.includes(event.actionId)) {
+        this.logger.debug("Running matched action handler", {
+          actionId: event.actionId
+        });
+        await handler(fullEvent);
+      }
+    }
+  }
+  /**
+   * Handle a reaction event internally.
+   */
+  async handleReactionEvent(event) {
+    this.logger.debug("Incoming reaction", {
+      adapter: event.adapter?.name,
+      emoji: event.emoji,
+      rawEmoji: event.rawEmoji,
+      added: event.added,
+      user: event.user.userName,
+      messageId: event.messageId,
+      threadId: event.threadId
+    });
+    if (event.user.isMe) {
+      this.logger.debug("Skipping reaction from self", {
+        emoji: event.emoji
+      });
+      return;
+    }
+    if (!event.adapter) {
+      this.logger.error("Reaction event missing adapter");
+      return;
+    }
+    const isSubscribed = await this.state.isSubscribed(event.threadId);
+    const thread = await this.createThread(
+      event.adapter,
+      event.threadId,
+      event.message ?? {},
+      isSubscribed
+    );
+    const fullEvent = {
+      ...event,
+      adapter: event.adapter,
+      thread
+    };
+    this.logger.debug("Checking reaction handlers", {
+      handlerCount: this.reactionHandlers.length,
+      emoji: event.emoji.name,
+      rawEmoji: event.rawEmoji
+    });
+    for (const { emoji: emojiFilter, handler } of this.reactionHandlers) {
+      if (emojiFilter.length === 0) {
+        this.logger.debug("Running catch-all reaction handler");
+        await handler(fullEvent);
+        continue;
+      }
+      const matches = emojiFilter.some((filter) => {
+        if (filter === fullEvent.emoji) return true;
+        const filterName = typeof filter === "string" ? filter : filter.name;
+        return filterName === fullEvent.emoji.name || filterName === fullEvent.rawEmoji;
+      });
+      this.logger.debug("Reaction filter check", {
+        filterEmoji: emojiFilter.map(
+          (e) => typeof e === "string" ? e : e.name
+        ),
+        eventEmoji: fullEvent.emoji.name,
+        matches
+      });
+      if (matches) {
+        this.logger.debug("Running matched reaction handler");
+        await handler(fullEvent);
+      }
+    }
+  }
+  getState() {
+    return this.state;
+  }
+  getUserName() {
+    return this.userName;
+  }
+  getLogger(prefix) {
+    if (prefix) {
+      return this.logger.child(prefix);
+    }
+    return this.logger;
+  }
+  /**
+   * Open a direct message conversation with a user.
+   *
+   * 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")
+   * - Teams: `29:...` (e.g., "29:198PbJuw...")
+   * - Google Chat: `users/...` (e.g., "users/117994873354375860089")
+   *
+   * @param user - Platform-specific user ID string, or an Author object
+   * @returns A Thread that can be used to post messages
+   *
+   * @example
+   * ```ts
+   * // Using user ID directly
+   * const dmThread = await chat.openDM("U123456");
+   * await dmThread.post("Hello via DM!");
+   *
+   * // Using Author object from a message
+   * chat.onSubscribedMessage(async (thread, message) => {
+   *   const dmThread = await chat.openDM(message.author);
+   *   await dmThread.post("Hello via DM!");
+   * });
+   * ```
+   */
+  async openDM(user) {
+    const userId = typeof user === "string" ? user : user.userId;
+    const adapter = this.inferAdapterFromUserId(userId);
+    if (!adapter.openDM) {
+      throw new ChatError(
+        `Adapter "${adapter.name}" does not support openDM`,
+        "NOT_SUPPORTED"
+      );
+    }
+    const threadId = await adapter.openDM(userId);
+    return this.createThread(adapter, threadId, {}, false);
+  }
+  /**
+   * Infer which adapter to use based on the userId format.
+   */
+  inferAdapterFromUserId(userId) {
+    if (userId.startsWith("users/")) {
+      const adapter = this.adapters.get("gchat");
+      if (adapter) return adapter;
+    }
+    if (userId.startsWith("29:")) {
+      const adapter = this.adapters.get("teams");
+      if (adapter) return adapter;
+    }
+    if (/^U[A-Z0-9]+$/i.test(userId)) {
+      const adapter = this.adapters.get("slack");
+      if (adapter) return adapter;
+    }
+    throw new ChatError(
+      `Cannot infer adapter from userId "${userId}". Expected format: Slack (U...), Teams (29:...), or Google Chat (users/...).`,
+      "UNKNOWN_USER_ID_FORMAT"
+    );
+  }
+  /**
+   * Handle an incoming message from an adapter.
+   * This is called by adapters when they receive a webhook.
+   *
+   * The Chat class handles common concerns centrally:
+   * - Deduplication: Same message may arrive multiple times (e.g., Slack sends
+   *   both `message` and `app_mention` events, GChat sends direct webhook + Pub/Sub)
+   * - Bot filtering: Messages from the bot itself are skipped
+   * - Locking: Only one instance processes a thread at a time
+   */
+  async handleIncomingMessage(adapter, threadId, message) {
+    this.logger.debug("Incoming message", {
+      adapter: adapter.name,
+      threadId,
+      messageId: message.id,
+      text: message.text,
+      author: message.author.userName,
+      authorUserId: message.author.userId,
+      isBot: message.author.isBot,
+      isMe: message.author.isMe
+    });
+    if (message.author.isMe) {
+      this.logger.debug("Skipping message from self (isMe=true)", {
+        adapter: adapter.name,
+        threadId,
+        author: message.author.userName
+      });
+      return;
+    }
+    const dedupeKey = `dedupe:${adapter.name}:${message.id}`;
+    const alreadyProcessed = await this.state.get(dedupeKey);
+    if (alreadyProcessed) {
+      this.logger.debug("Skipping duplicate message", {
+        adapter: adapter.name,
+        messageId: message.id
+      });
+      return;
+    }
+    await this.state.set(dedupeKey, true, DEDUPE_TTL_MS);
+    const lock = await this.state.acquireLock(threadId, DEFAULT_LOCK_TTL_MS);
+    if (!lock) {
+      this.logger.warn("Could not acquire lock on thread", { threadId });
+      throw new LockError(
+        `Could not acquire lock on thread ${threadId}. Another instance may be processing.`
+      );
+    }
+    this.logger.debug("Lock acquired", { threadId, token: lock.token });
+    try {
+      message.isMention = this.detectMention(adapter, message);
+      const isSubscribed = await this.state.isSubscribed(threadId);
+      this.logger.debug("Subscription check", {
+        threadId,
+        isSubscribed,
+        subscribedHandlerCount: this.subscribedMessageHandlers.length
+      });
+      const thread = await this.createThread(
+        adapter,
+        threadId,
+        message,
+        isSubscribed
+      );
+      if (isSubscribed) {
+        this.logger.debug("Message in subscribed thread - calling handlers", {
+          threadId,
+          handlerCount: this.subscribedMessageHandlers.length
+        });
+        await this.runHandlers(this.subscribedMessageHandlers, thread, message);
+        return;
+      }
+      if (message.isMention) {
+        this.logger.debug("Bot mentioned", {
+          threadId,
+          text: message.text.slice(0, 100)
+        });
+        await this.runHandlers(this.mentionHandlers, thread, message);
+        return;
+      }
+      this.logger.debug("Checking message patterns", {
+        patternCount: this.messagePatterns.length,
+        patterns: this.messagePatterns.map((p) => p.pattern.toString()),
+        messageText: message.text
+      });
+      let matchedPattern = false;
+      for (const { pattern, handler } of this.messagePatterns) {
+        const matches = pattern.test(message.text);
+        this.logger.debug("Pattern test", {
+          pattern: pattern.toString(),
+          text: message.text,
+          matches
+        });
+        if (matches) {
+          this.logger.debug("Message matched pattern - calling handler", {
+            pattern: pattern.toString()
+          });
+          matchedPattern = true;
+          await handler(thread, message);
+        }
+      }
+      if (!matchedPattern) {
+        this.logger.debug("No handlers matched message", {
+          threadId,
+          text: message.text.slice(0, 100)
+        });
+      }
+    } finally {
+      await this.state.releaseLock(lock);
+      this.logger.debug("Lock released", { threadId });
+    }
+  }
+  async createThread(adapter, threadId, initialMessage, isSubscribedContext = false) {
+    const parts = threadId.split(":");
+    const channelId = parts[1] || "";
+    const isDM = adapter.isDM?.(threadId) ?? false;
+    return new ThreadImpl({
+      id: threadId,
+      adapter,
+      channelId,
+      state: this.state,
+      initialMessage,
+      isSubscribedContext,
+      isDM
+    });
+  }
+  /**
+   * Detect if the bot was mentioned in the message.
+   * All adapters normalize mentions to @name format, so we just check for @username.
+   */
+  detectMention(adapter, message) {
+    const botUserName = adapter.userName || this.userName;
+    const botUserId = adapter.botUserId;
+    const usernamePattern = new RegExp(
+      `@${this.escapeRegex(botUserName)}\\b`,
+      "i"
+    );
+    if (usernamePattern.test(message.text)) {
+      return true;
+    }
+    if (botUserId) {
+      const userIdPattern = new RegExp(
+        `@${this.escapeRegex(botUserId)}\\b`,
+        "i"
+      );
+      if (userIdPattern.test(message.text)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  async runHandlers(handlers, thread, message) {
+    for (const handler of handlers) {
+      await handler(thread, message);
+    }
+  }
+};
+
+// src/emoji.ts
+var emojiRegistry = /* @__PURE__ */ new Map();
+function getEmoji(name) {
+  let emojiValue = emojiRegistry.get(name);
+  if (!emojiValue) {
+    emojiValue = Object.freeze({
+      name,
+      toString: () => `{{emoji:${name}}}`,
+      toJSON: () => `{{emoji:${name}}}`
+    });
+    emojiRegistry.set(name, emojiValue);
+  }
+  return emojiValue;
+}
+var DEFAULT_EMOJI_MAP = {
+  // Reactions & Gestures
+  thumbs_up: { slack: ["+1", "thumbsup"], gchat: "\u{1F44D}" },
+  thumbs_down: { slack: ["-1", "thumbsdown"], gchat: "\u{1F44E}" },
+  clap: { slack: "clap", gchat: "\u{1F44F}" },
+  wave: { slack: "wave", gchat: "\u{1F44B}" },
+  pray: { slack: "pray", gchat: "\u{1F64F}" },
+  muscle: { slack: "muscle", gchat: "\u{1F4AA}" },
+  ok_hand: { slack: "ok_hand", gchat: "\u{1F44C}" },
+  point_up: { slack: "point_up", gchat: "\u{1F446}" },
+  point_down: { slack: "point_down", gchat: "\u{1F447}" },
+  point_left: { slack: "point_left", gchat: "\u{1F448}" },
+  point_right: { slack: "point_right", gchat: "\u{1F449}" },
+  raised_hands: { slack: "raised_hands", gchat: "\u{1F64C}" },
+  shrug: { slack: "shrug", gchat: "\u{1F937}" },
+  facepalm: { slack: "facepalm", gchat: "\u{1F926}" },
+  // Emotions & Faces
+  heart: { slack: "heart", gchat: ["\u2764\uFE0F", "\u2764"] },
+  smile: { slack: ["smile", "slightly_smiling_face"], gchat: "\u{1F60A}" },
+  laugh: { slack: ["laughing", "satisfied", "joy"], gchat: ["\u{1F602}", "\u{1F606}"] },
+  thinking: { slack: "thinking_face", gchat: "\u{1F914}" },
+  sad: { slack: ["cry", "sad", "white_frowning_face"], gchat: "\u{1F622}" },
+  cry: { slack: "sob", gchat: "\u{1F62D}" },
+  angry: { slack: "angry", gchat: "\u{1F620}" },
+  love_eyes: { slack: "heart_eyes", gchat: "\u{1F60D}" },
+  cool: { slack: "sunglasses", gchat: "\u{1F60E}" },
+  wink: { slack: "wink", gchat: "\u{1F609}" },
+  surprised: { slack: "open_mouth", gchat: "\u{1F62E}" },
+  worried: { slack: "worried", gchat: "\u{1F61F}" },
+  confused: { slack: "confused", gchat: "\u{1F615}" },
+  neutral: { slack: "neutral_face", gchat: "\u{1F610}" },
+  sleeping: { slack: "sleeping", gchat: "\u{1F634}" },
+  sick: { slack: "nauseated_face", gchat: "\u{1F922}" },
+  mind_blown: { slack: "exploding_head", gchat: "\u{1F92F}" },
+  relieved: { slack: "relieved", gchat: "\u{1F60C}" },
+  grimace: { slack: "grimacing", gchat: "\u{1F62C}" },
+  rolling_eyes: { slack: "rolling_eyes", gchat: "\u{1F644}" },
+  hug: { slack: "hugging_face", gchat: "\u{1F917}" },
+  zany: { slack: "zany_face", gchat: "\u{1F92A}" },
+  // Status & Symbols
+  check: {
+    slack: ["white_check_mark", "heavy_check_mark"],
+    gchat: ["\u2705", "\u2714\uFE0F"]
+  },
+  x: { slack: ["x", "heavy_multiplication_x"], gchat: ["\u274C", "\u2716\uFE0F"] },
+  question: { slack: "question", gchat: ["\u2753", "?"] },
+  exclamation: { slack: "exclamation", gchat: "\u2757" },
+  warning: { slack: "warning", gchat: "\u26A0\uFE0F" },
+  stop: { slack: "octagonal_sign", gchat: "\u{1F6D1}" },
+  info: { slack: "information_source", gchat: "\u2139\uFE0F" },
+  "100": { slack: "100", gchat: "\u{1F4AF}" },
+  fire: { slack: "fire", gchat: "\u{1F525}" },
+  star: { slack: "star", gchat: "\u2B50" },
+  sparkles: { slack: "sparkles", gchat: "\u2728" },
+  lightning: { slack: "zap", gchat: "\u26A1" },
+  boom: { slack: "boom", gchat: "\u{1F4A5}" },
+  eyes: { slack: "eyes", gchat: "\u{1F440}" },
+  // Status Indicators (colored circles)
+  green_circle: { slack: "large_green_circle", gchat: "\u{1F7E2}" },
+  yellow_circle: { slack: "large_yellow_circle", gchat: "\u{1F7E1}" },
+  red_circle: { slack: "red_circle", gchat: "\u{1F534}" },
+  blue_circle: { slack: "large_blue_circle", gchat: "\u{1F535}" },
+  white_circle: { slack: "white_circle", gchat: "\u26AA" },
+  black_circle: { slack: "black_circle", gchat: "\u26AB" },
+  // Objects & Tools
+  rocket: { slack: "rocket", gchat: "\u{1F680}" },
+  party: { slack: ["tada", "partying_face"], gchat: ["\u{1F389}", "\u{1F973}"] },
+  confetti: { slack: "confetti_ball", gchat: "\u{1F38A}" },
+  balloon: { slack: "balloon", gchat: "\u{1F388}" },
+  gift: { slack: "gift", gchat: "\u{1F381}" },
+  trophy: { slack: "trophy", gchat: "\u{1F3C6}" },
+  medal: { slack: "first_place_medal", gchat: "\u{1F947}" },
+  lightbulb: { slack: "bulb", gchat: "\u{1F4A1}" },
+  gear: { slack: "gear", gchat: "\u2699\uFE0F" },
+  wrench: { slack: "wrench", gchat: "\u{1F527}" },
+  hammer: { slack: "hammer", gchat: "\u{1F528}" },
+  bug: { slack: "bug", gchat: "\u{1F41B}" },
+  link: { slack: "link", gchat: "\u{1F517}" },
+  lock: { slack: "lock", gchat: "\u{1F512}" },
+  unlock: { slack: "unlock", gchat: "\u{1F513}" },
+  key: { slack: "key", gchat: "\u{1F511}" },
+  pin: { slack: "pushpin", gchat: "\u{1F4CC}" },
+  memo: { slack: "memo", gchat: "\u{1F4DD}" },
+  clipboard: { slack: "clipboard", gchat: "\u{1F4CB}" },
+  calendar: { slack: "calendar", gchat: "\u{1F4C5}" },
+  clock: { slack: "clock1", gchat: "\u{1F550}" },
+  hourglass: { slack: "hourglass", gchat: "\u23F3" },
+  bell: { slack: "bell", gchat: "\u{1F514}" },
+  megaphone: { slack: "mega", gchat: "\u{1F4E2}" },
+  speech_bubble: { slack: "speech_balloon", gchat: "\u{1F4AC}" },
+  email: { slack: "email", gchat: "\u{1F4E7}" },
+  inbox: { slack: "inbox_tray", gchat: "\u{1F4E5}" },
+  outbox: { slack: "outbox_tray", gchat: "\u{1F4E4}" },
+  package: { slack: "package", gchat: "\u{1F4E6}" },
+  folder: { slack: "file_folder", gchat: "\u{1F4C1}" },
+  file: { slack: "page_facing_up", gchat: "\u{1F4C4}" },
+  chart_up: { slack: "chart_with_upwards_trend", gchat: "\u{1F4C8}" },
+  chart_down: { slack: "chart_with_downwards_trend", gchat: "\u{1F4C9}" },
+  coffee: { slack: "coffee", gchat: "\u2615" },
+  pizza: { slack: "pizza", gchat: "\u{1F355}" },
+  beer: { slack: "beer", gchat: "\u{1F37A}" },
+  // Arrows & Directions
+  arrow_up: { slack: "arrow_up", gchat: "\u2B06\uFE0F" },
+  arrow_down: { slack: "arrow_down", gchat: "\u2B07\uFE0F" },
+  arrow_left: { slack: "arrow_left", gchat: "\u2B05\uFE0F" },
+  arrow_right: { slack: "arrow_right", gchat: "\u27A1\uFE0F" },
+  refresh: { slack: "arrows_counterclockwise", gchat: "\u{1F504}" },
+  // Nature & Weather
+  sun: { slack: "sunny", gchat: "\u2600\uFE0F" },
+  cloud: { slack: "cloud", gchat: "\u2601\uFE0F" },
+  rain: { slack: "rain_cloud", gchat: "\u{1F327}\uFE0F" },
+  snow: { slack: "snowflake", gchat: "\u2744\uFE0F" },
+  rainbow: { slack: "rainbow", gchat: "\u{1F308}" }
+};
+var EmojiResolver = class {
+  emojiMap;
+  slackToNormalized;
+  gchatToNormalized;
+  constructor(customMap) {
+    this.emojiMap = { ...DEFAULT_EMOJI_MAP, ...customMap };
+    this.slackToNormalized = /* @__PURE__ */ new Map();
+    this.gchatToNormalized = /* @__PURE__ */ new Map();
+    this.buildReverseMaps();
+  }
+  buildReverseMaps() {
+    for (const [normalized, formats] of Object.entries(this.emojiMap)) {
+      const slackFormats = Array.isArray(formats.slack) ? formats.slack : [formats.slack];
+      for (const slack of slackFormats) {
+        this.slackToNormalized.set(slack.toLowerCase(), normalized);
+      }
+      const gchatFormats = Array.isArray(formats.gchat) ? formats.gchat : [formats.gchat];
+      for (const gchat of gchatFormats) {
+        this.gchatToNormalized.set(gchat, normalized);
+      }
+    }
+  }
+  /**
+   * Convert a Slack emoji name to normalized EmojiValue.
+   * Returns an EmojiValue for the raw emoji if no mapping exists.
+   */
+  fromSlack(slackEmoji) {
+    const cleaned = slackEmoji.replace(/^:|:$/g, "").toLowerCase();
+    const normalized = this.slackToNormalized.get(cleaned) ?? slackEmoji;
+    return getEmoji(normalized);
+  }
+  /**
+   * Convert a Google Chat unicode emoji to normalized EmojiValue.
+   * Returns an EmojiValue for the raw emoji if no mapping exists.
+   */
+  fromGChat(gchatEmoji) {
+    const normalized = this.gchatToNormalized.get(gchatEmoji) ?? gchatEmoji;
+    return getEmoji(normalized);
+  }
+  /**
+   * Convert a Teams reaction type to normalized EmojiValue.
+   * Teams uses specific names: like, heart, laugh, surprised, sad, angry
+   * Returns an EmojiValue for the raw reaction if no mapping exists.
+   */
+  fromTeams(teamsReaction) {
+    const teamsMap = {
+      like: "thumbs_up",
+      heart: "heart",
+      laugh: "laugh",
+      surprised: "surprised",
+      sad: "sad",
+      angry: "angry"
+    };
+    const normalized = teamsMap[teamsReaction] ?? teamsReaction;
+    return getEmoji(normalized);
+  }
+  /**
+   * Convert a normalized emoji (or EmojiValue) to Slack format.
+   * Returns the first Slack format if multiple exist.
+   */
+  toSlack(emoji2) {
+    const name = typeof emoji2 === "string" ? emoji2 : emoji2.name;
+    const formats = this.emojiMap[name];
+    if (!formats) return name;
+    return Array.isArray(formats.slack) ? formats.slack[0] : formats.slack;
+  }
+  /**
+   * Convert a normalized emoji (or EmojiValue) to Google Chat format.
+   * Returns the first GChat format if multiple exist.
+   */
+  toGChat(emoji2) {
+    const name = typeof emoji2 === "string" ? emoji2 : emoji2.name;
+    const formats = this.emojiMap[name];
+    if (!formats) return name;
+    return Array.isArray(formats.gchat) ? formats.gchat[0] : formats.gchat;
+  }
+  /**
+   * Check if an emoji (in any format) matches a normalized emoji name or EmojiValue.
+   */
+  matches(rawEmoji, normalized) {
+    const name = typeof normalized === "string" ? normalized : normalized.name;
+    const formats = this.emojiMap[name];
+    if (!formats) return rawEmoji === name;
+    const slackFormats = Array.isArray(formats.slack) ? formats.slack : [formats.slack];
+    const gchatFormats = Array.isArray(formats.gchat) ? formats.gchat : [formats.gchat];
+    const cleanedRaw = rawEmoji.replace(/^:|:$/g, "").toLowerCase();
+    return slackFormats.some((s) => s.toLowerCase() === cleanedRaw) || gchatFormats.includes(rawEmoji);
+  }
+  /**
+   * Add or override emoji mappings.
+   */
+  extend(customMap) {
+    Object.assign(this.emojiMap, customMap);
+    this.buildReverseMaps();
+  }
+};
+var defaultEmojiResolver = new EmojiResolver();
+var EMOJI_PLACEHOLDER_REGEX = /\{\{emoji:([a-z0-9_]+)\}\}/gi;
+function convertEmojiPlaceholders(text2, platform, resolver = defaultEmojiResolver) {
+  return text2.replace(EMOJI_PLACEHOLDER_REGEX, (_, emojiName) => {
+    switch (platform) {
+      case "slack":
+        return `:${resolver.toSlack(emojiName)}:`;
+      case "gchat":
+        return resolver.toGChat(emojiName);
+      case "teams":
+        return resolver.toGChat(emojiName);
+      default:
+        return resolver.toGChat(emojiName);
+    }
+  });
+}
+function createEmoji(customEmoji) {
+  const wellKnownEmoji = [
+    // Reactions & Gestures
+    "thumbs_up",
+    "thumbs_down",
+    "clap",
+    "wave",
+    "pray",
+    "muscle",
+    "ok_hand",
+    "point_up",
+    "point_down",
+    "point_left",
+    "point_right",
+    "raised_hands",
+    "shrug",
+    "facepalm",
+    // Emotions & Faces
+    "heart",
+    "smile",
+    "laugh",
+    "thinking",
+    "sad",
+    "cry",
+    "angry",
+    "love_eyes",
+    "cool",
+    "wink",
+    "surprised",
+    "worried",
+    "confused",
+    "neutral",
+    "sleeping",
+    "sick",
+    "mind_blown",
+    "relieved",
+    "grimace",
+    "rolling_eyes",
+    "hug",
+    "zany",
+    // Status & Symbols
+    "check",
+    "x",
+    "question",
+    "exclamation",
+    "warning",
+    "stop",
+    "info",
+    "100",
+    "fire",
+    "star",
+    "sparkles",
+    "lightning",
+    "boom",
+    "eyes",
+    // Status Indicators
+    "green_circle",
+    "yellow_circle",
+    "red_circle",
+    "blue_circle",
+    "white_circle",
+    "black_circle",
+    // Objects & Tools
+    "rocket",
+    "party",
+    "confetti",
+    "balloon",
+    "gift",
+    "trophy",
+    "medal",
+    "lightbulb",
+    "gear",
+    "wrench",
+    "hammer",
+    "bug",
+    "link",
+    "lock",
+    "unlock",
+    "key",
+    "pin",
+    "memo",
+    "clipboard",
+    "calendar",
+    "clock",
+    "hourglass",
+    "bell",
+    "megaphone",
+    "speech_bubble",
+    "email",
+    "inbox",
+    "outbox",
+    "package",
+    "folder",
+    "file",
+    "chart_up",
+    "chart_down",
+    "coffee",
+    "pizza",
+    "beer",
+    // Arrows & Directions
+    "arrow_up",
+    "arrow_down",
+    "arrow_left",
+    "arrow_right",
+    "refresh",
+    // Nature & Weather
+    "sun",
+    "cloud",
+    "rain",
+    "snow",
+    "rainbow"
+  ];
+  const helper = {
+    custom: (name) => getEmoji(name)
+  };
+  for (const name of wellKnownEmoji) {
+    helper[name] = getEmoji(name);
+  }
+  if (customEmoji) {
+    for (const key of Object.keys(customEmoji)) {
+      helper[key] = getEmoji(key);
+    }
+    defaultEmojiResolver.extend(customEmoji);
+  }
+  return helper;
+}
+var emoji = createEmoji();
+
+// src/index.ts
+var Actions2 = Actions;
+var Button2 = Button;
+var Card2 = Card;
+var CardText2 = CardText;
+var Divider2 = Divider;
+var Field2 = Field;
+var Fields2 = Fields;
+var fromReactElement2 = fromReactElement;
+var Image2 = Image;
+var isCardElement2 = isCardElement;
+var isJSX2 = isJSX;
+var Section2 = Section;
+var toCardElement2 = toCardElement;
+export {
+  Actions2 as Actions,
+  BaseFormatConverter,
+  Button2 as Button,
+  Card2 as Card,
+  CardText2 as CardText,
+  Chat,
+  ChatError,
+  ConsoleLogger,
+  DEFAULT_EMOJI_MAP,
+  Divider2 as Divider,
+  EmojiResolver,
+  Field2 as Field,
+  Fields2 as Fields,
+  Image2 as Image,
+  LockError,
+  NotImplementedError,
+  RateLimitError,
+  Section2 as Section,
+  blockquote,
+  codeBlock,
+  convertEmojiPlaceholders,
+  createEmoji,
+  defaultEmojiResolver,
+  emoji,
+  emphasis,
+  fromReactElement2 as fromReactElement,
+  getEmoji,
+  inlineCode,
+  isCardElement2 as isCardElement,
+  isJSX2 as isJSX,
+  link,
+  markdownToPlainText,
+  paragraph,
+  parseMarkdown,
+  root,
+  strikethrough,
+  stringifyMarkdown,
+  strong,
+  text,
+  toCardElement2 as toCardElement,
+  toPlainText,
+  walkAst
+};
+//# sourceMappingURL=index.js.map