chat 4.27.0 → 4.29.0

package/dist/index.js

@@ -60,135 +60,134 @@ import {
   toModalElement,
   toPlainText,
   walkAst
-} from "./chunk-AN7MRAVW.js";
+} from "./chunk-V25FKIIL.js";
+import {
+  toAiMessages
+} from "./chunk-HD375J7S.js";
 
-// src/ai.ts
-var TEXT_MIME_PREFIXES = [
-  "text/",
-  "application/json",
-  "application/xml",
-  "application/javascript",
-  "application/typescript",
-  "application/yaml",
-  "application/x-yaml",
-  "application/toml"
-];
-function isTextMimeType(mimeType) {
-  return TEXT_MIME_PREFIXES.some(
-    (prefix) => mimeType === prefix || mimeType.startsWith(prefix)
-  );
+// src/channel.ts
+import { WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2, WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2 } from "@workflow/serde";
+
+// src/callback-url.ts
+var CALLBACK_TOKEN_PREFIX = "__cb:";
+var CALLBACK_CACHE_KEY_PREFIX = "chat:callback:";
+var CALLBACK_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+function encodeCallbackValue(token) {
+  return `${CALLBACK_TOKEN_PREFIX}${token}`;
 }
-async function attachmentToPart(att) {
-  if (att.type === "image") {
-    if (att.fetchData) {
-      try {
-        const buffer = await att.fetchData();
-        const mimeType = att.mimeType ?? "image/png";
-        return {
-          type: "file",
-          data: `data:${mimeType};base64,${buffer.toString("base64")}`,
-          mediaType: mimeType,
-          filename: att.name
+function decodeCallbackValue(value) {
+  if (!value?.startsWith(CALLBACK_TOKEN_PREFIX)) {
+    return { callbackToken: void 0 };
+  }
+  return { callbackToken: value.slice(CALLBACK_TOKEN_PREFIX.length) };
+}
+function generateToken() {
+  return crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+}
+async function processActionsElement(actions, stateAdapter) {
+  return {
+    type: "actions",
+    children: await Promise.all(
+      actions.children.map(async (el) => {
+        if (el.type !== "button" || !el.callbackUrl) {
+          return el;
+        }
+        const token = generateToken();
+        const stored = {
+          url: el.callbackUrl,
+          originalValue: el.value
         };
-      } catch (error) {
-        console.error("toAiMessages: failed to fetch image data", error);
-        return null;
+        await stateAdapter.set(
+          `${CALLBACK_CACHE_KEY_PREFIX}${token}`,
+          stored,
+          CALLBACK_TTL_MS
+        );
+        const processed = {
+          type: "button",
+          id: el.id,
+          label: el.label,
+          style: el.style,
+          disabled: el.disabled,
+          value: encodeCallbackValue(token),
+          actionType: el.actionType
+        };
+        return processed;
+      })
+    )
+  };
+}
+function hasCallbackButtons(children) {
+  for (const child of children) {
+    if (child.type === "actions") {
+      for (const el of child.children) {
+        if (el.type === "button" && el.callbackUrl) {
+          return true;
+        }
       }
     }
-    return null;
+    if (child.type === "section" && "children" in child && hasCallbackButtons(child.children)) {
+      return true;
+    }
   }
-  if (att.type === "file" && att.mimeType && isTextMimeType(att.mimeType)) {
-    if (att.fetchData) {
-      try {
-        const buffer = await att.fetchData();
-        return {
-          type: "file",
-          data: `data:${att.mimeType};base64,${buffer.toString("base64")}`,
-          filename: att.name,
-          mediaType: att.mimeType
-        };
-      } catch (error) {
-        console.error("toAiMessages: failed to fetch file data", error);
-        return null;
-      }
+  return false;
+}
+async function processChildren(children, stateAdapter) {
+  const result = [];
+  for (const child of children) {
+    if (child.type === "actions") {
+      result.push(await processActionsElement(child, stateAdapter));
+    } else if (child.type === "section" && "children" in child) {
+      result.push({
+        ...child,
+        children: await processChildren(child.children, stateAdapter)
+      });
+    } else {
+      result.push(child);
     }
-    return null;
   }
-  return null;
+  return result;
 }
-async function toAiMessages(messages, options) {
-  const includeNames = options?.includeNames ?? false;
-  const transformMessage = options?.transformMessage;
-  const onUnsupported = options?.onUnsupportedAttachment ?? ((att) => {
-    console.warn(
-      `toAiMessages: unsupported attachment type "${att.type}"${att.name ? ` (${att.name})` : ""} \u2014 skipped`
-    );
-  });
-  const sorted = [...messages].sort(
-    (a, b) => (a.metadata.dateSent?.getTime() ?? 0) - (b.metadata.dateSent?.getTime() ?? 0)
-  );
-  const filtered = sorted.filter((msg) => msg.text.trim());
-  const results = await Promise.all(
-    filtered.map(async (msg) => {
-      const role = msg.author.isMe ? "assistant" : "user";
-      let textContent = includeNames && role === "user" ? `[${msg.author.userName}]: ${msg.text}` : msg.text;
-      if (msg.links && msg.links.length > 0) {
-        const linkParts = msg.links.map((link2) => {
-          const parts = link2.fetchMessage ? [`[Embedded message: ${link2.url}]`] : [link2.url];
-          if (link2.title) {
-            parts.push(`Title: ${link2.title}`);
-          }
-          if (link2.description) {
-            parts.push(`Description: ${link2.description}`);
-          }
-          if (link2.siteName) {
-            parts.push(`Site: ${link2.siteName}`);
-          }
-          return parts.join("\n");
-        }).join("\n\n");
-        textContent += `
-
-Links:
-${linkParts}`;
-      }
-      let aiMessage;
-      if (role === "user") {
-        const attachmentParts = [];
-        for (const att of msg.attachments ?? []) {
-          const part = await attachmentToPart(att);
-          if (part) {
-            attachmentParts.push(part);
-          } else if (att.type === "video" || att.type === "audio") {
-            onUnsupported(att, msg);
-          }
-        }
-        if (attachmentParts.length > 0) {
-          aiMessage = {
-            role,
-            content: [
-              { type: "text", text: textContent },
-              ...attachmentParts
-            ]
-          };
-        } else {
-          aiMessage = { role, content: textContent };
-        }
-      } else {
-        aiMessage = { role, content: textContent };
-      }
-      if (transformMessage) {
-        return { result: await transformMessage(aiMessage, msg), source: msg };
-      }
-      return { result: aiMessage, source: msg };
-    })
+async function processCardCallbackUrls(card, stateAdapter) {
+  if (!hasCallbackButtons(card.children)) {
+    return card;
+  }
+  return {
+    ...card,
+    children: await processChildren(card.children, stateAdapter)
+  };
+}
+async function resolveCallbackUrl(token, stateAdapter) {
+  const stored = await stateAdapter.get(
+    `${CALLBACK_CACHE_KEY_PREFIX}${token}`
   );
-  return results.filter(
-    (r) => r.result != null
-  ).map((r) => r.result);
+  if (!stored) {
+    return null;
+  }
+  if (typeof stored === "string") {
+    return { url: stored };
+  }
+  return stored;
+}
+async function postToCallbackUrl(callbackUrl, payload) {
+  try {
+    const response = await fetch(callbackUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      return {
+        error: new Error(
+          `Callback URL returned ${response.status}: ${await response.text().catch(() => "")}`
+        ),
+        status: response.status
+      };
+    }
+    return { status: response.status };
+  } catch (error) {
+    return { error };
+  }
 }
-
-// src/channel.ts
-import { WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2, WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2 } from "@workflow/serde";
 
 // src/chat-singleton.ts
 var _singleton = null;
@@ -245,6 +244,10 @@ async function* fromFullStream(stream) {
 
 // src/message.ts
 import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from "@workflow/serde";
+var adapterMap = /* @__PURE__ */ new WeakMap();
+function setMessageAdapter(message, adapter) {
+  adapterMap.set(message, adapter);
+}
 var Message = class _Message {
   /** Unique message ID */
   id;
@@ -283,8 +286,31 @@ var Message = class _Message {
    * ```
    */
   isMention;
+  /**
+   * Cross-platform user key for this message's author.
+   *
+   * Set by the Chat SDK before passing the message to handlers, when
+   * `ChatConfig.identity` is configured. `undefined` if no resolver is
+   * configured; `undefined` (i.e. absent) when the resolver returned null.
+   *
+   * Used by the Transcripts API to look up / append per-user transcripts.
+   */
+  userKey;
   /** Links found in the message */
   links;
+  _subjectPromise;
+  get subject() {
+    if (this._subjectPromise) {
+      return this._subjectPromise;
+    }
+    const adapter = adapterMap.get(this);
+    if (!adapter?.fetchSubject) {
+      this._subjectPromise = Promise.resolve(null);
+      return this._subjectPromise;
+    }
+    this._subjectPromise = adapter.fetchSubject(this.raw).catch(() => null);
+    return this._subjectPromise;
+  }
   constructor(data) {
     this.id = data.id;
     this.threadId = data.threadId;
@@ -497,7 +523,7 @@ var ChannelImpl = class _ChannelImpl {
   _adapterName;
   _stateAdapterInstance;
   _name = null;
-  _messageHistory;
+  _threadHistory;
   constructor(config) {
     this.id = config.id;
     this.isDM = config.isDM ?? false;
@@ -507,7 +533,7 @@ var ChannelImpl = class _ChannelImpl {
     } else {
       this._adapter = config.adapter;
       this._stateAdapterInstance = config.stateAdapter;
-      this._messageHistory = config.messageHistory;
+      this._threadHistory = config.threadHistory;
     }
   }
   get adapter() {
@@ -561,7 +587,7 @@ var ChannelImpl = class _ChannelImpl {
   get messages() {
     const adapter = this.adapter;
     const channelId = this.id;
-    const messageHistory = this._messageHistory;
+    const threadHistory = this._threadHistory;
     return {
       async *[Symbol.asyncIterator]() {
         let cursor;
@@ -579,8 +605,8 @@ var ChannelImpl = class _ChannelImpl {
           }
           cursor = result.nextCursor;
         }
-        if (!yieldedAny && messageHistory) {
-          const cached = await messageHistory.getMessages(channelId);
+        if (!yieldedAny && threadHistory) {
+          const cached = await threadHistory.getMessages(channelId);
           for (let i = cached.length - 1; i >= 0; i--) {
             yield cached[i];
           }
@@ -637,6 +663,8 @@ var ChannelImpl = class _ChannelImpl {
       for await (const chunk of fromFullStream(message)) {
         if (typeof chunk === "string") {
           accumulated += chunk;
+        } else if (chunk.type === "markdown_text") {
+          accumulated += chunk.text;
         }
       }
       return this.postSingleMessage({ markdown: accumulated });
@@ -649,6 +677,7 @@ var ChannelImpl = class _ChannelImpl {
       }
       postable = card;
     }
+    postable = await this.processCallbackUrls(postable);
     return this.postSingleMessage(postable);
   }
   async handlePostableObject(obj) {
@@ -666,8 +695,8 @@ var ChannelImpl = class _ChannelImpl {
       postable,
       rawMessage.threadId
     );
-    if (this._messageHistory) {
-      await this._messageHistory.append(this.id, new Message(sent));
+    if (this._threadHistory) {
+      await this._threadHistory.append(this.id, new Message(sent));
     }
     return sent;
   }
@@ -684,6 +713,7 @@ var ChannelImpl = class _ChannelImpl {
     } else {
       postable = message;
     }
+    postable = await this.processCallbackUrls(postable);
     if (this.adapter.postEphemeral) {
       return this.adapter.postEphemeral(this.id, userId, postable);
     }
@@ -713,6 +743,7 @@ var ChannelImpl = class _ChannelImpl {
     } else {
       postable = message;
     }
+    postable = await this.processCallbackUrls(postable);
     if (!this.adapter.scheduleMessage) {
       throw new NotImplementedError(
         "Scheduled messages are not supported by this adapter",
@@ -721,6 +752,24 @@ var ChannelImpl = class _ChannelImpl {
     }
     return this.adapter.scheduleMessage(this.id, postable, options);
   }
+  async processCallbackUrls(postable) {
+    if (typeof postable === "string") {
+      return postable;
+    }
+    if ("type" in postable && postable.type === "card") {
+      return processCardCallbackUrls(postable, this._stateAdapter);
+    }
+    if ("card" in postable && postable.card?.type === "card") {
+      const processed = await processCardCallbackUrls(
+        postable.card,
+        this._stateAdapter
+      );
+      if (processed !== postable.card) {
+        return { ...postable, card: processed };
+      }
+    }
+    return postable;
+  }
   async startTyping(status) {
     await this.adapter.startTyping(this.id, status);
   }
@@ -790,6 +839,7 @@ var ChannelImpl = class _ChannelImpl {
           }
           editPostable = card;
         }
+        editPostable = await self.processCallbackUrls(editPostable);
         await adapter.editMessage(threadId, messageId, editPostable);
         return self.createSentMessage(messageId, editPostable);
       },
@@ -858,46 +908,6 @@ function extractMessageContent(message) {
   throw new Error("Invalid PostableMessage format");
 }
 
-// src/message-history.ts
-var DEFAULT_MAX_MESSAGES = 100;
-var DEFAULT_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
-var KEY_PREFIX = "msg-history:";
-var MessageHistoryCache = class {
-  state;
-  maxMessages;
-  ttlMs;
-  constructor(state, config) {
-    this.state = state;
-    this.maxMessages = config?.maxMessages ?? DEFAULT_MAX_MESSAGES;
-    this.ttlMs = config?.ttlMs ?? DEFAULT_TTL_MS;
-  }
-  /**
-   * Atomically append a message to the history for a thread.
-   * Trims to maxMessages (keeps newest) and refreshes TTL.
-   */
-  async append(threadId, message) {
-    const key = `${KEY_PREFIX}${threadId}`;
-    const serialized = message.toJSON();
-    serialized.raw = null;
-    await this.state.appendToList(key, serialized, {
-      maxLength: this.maxMessages,
-      ttlMs: this.ttlMs
-    });
-  }
-  /**
-   * Get messages for a thread in chronological order (oldest first).
-   *
-   * @param threadId - The thread ID
-   * @param limit - Optional limit on number of messages to return (returns newest N)
-   */
-  async getMessages(threadId, limit) {
-    const key = `${KEY_PREFIX}${threadId}`;
-    const stored = await this.state.getList(key);
-    const sliced = limit && stored.length > limit ? stored.slice(stored.length - limit) : stored;
-    return sliced.map((s) => Message.fromJSON(s));
-  }
-};
-
 // src/thread.ts
 import { WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE3, WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE3 } from "@workflow/serde";
 
@@ -1168,8 +1178,8 @@ var ThreadImpl = class _ThreadImpl {
   _fallbackStreamingPlaceholderText;
   /** Cached channel instance */
   _channel;
-  /** Message history cache (set only for adapters with persistMessageHistory) */
-  _messageHistory;
+  /** Thread history cache (set only for adapters with persistThreadHistory) */
+  _threadHistory;
   _logger;
   constructor(config) {
     this.id = config.id;
@@ -1186,7 +1196,7 @@ var ThreadImpl = class _ThreadImpl {
     } else {
       this._adapter = config.adapter;
       this._stateAdapterInstance = config.stateAdapter;
-      this._messageHistory = config.messageHistory;
+      this._threadHistory = config.threadHistory;
     }
     if (config.initialMessage) {
       this._recentMessages = [config.initialMessage];
@@ -1267,7 +1277,7 @@ var ThreadImpl = class _ThreadImpl {
         stateAdapter: this._stateAdapter,
         isDM: this.isDM,
         channelVisibility: this.channelVisibility,
-        messageHistory: this._messageHistory
+        threadHistory: this._threadHistory
       });
     }
     return this._channel;
@@ -1279,7 +1289,7 @@ var ThreadImpl = class _ThreadImpl {
   get messages() {
     const adapter = this.adapter;
     const threadId = this.id;
-    const messageHistory = this._messageHistory;
+    const threadHistory = this._threadHistory;
     return {
       async *[Symbol.asyncIterator]() {
         let cursor;
@@ -1299,8 +1309,8 @@ var ThreadImpl = class _ThreadImpl {
           }
           cursor = result.nextCursor;
         }
-        if (!yieldedAny && messageHistory) {
-          const cached = await messageHistory.getMessages(threadId);
+        if (!yieldedAny && threadHistory) {
+          const cached = await threadHistory.getMessages(threadId);
           for (let i = cached.length - 1; i >= 0; i--) {
             yield cached[i];
           }
@@ -1311,7 +1321,7 @@ var ThreadImpl = class _ThreadImpl {
   get allMessages() {
     const adapter = this.adapter;
     const threadId = this.id;
-    const messageHistory = this._messageHistory;
+    const threadHistory = this._threadHistory;
     return {
       async *[Symbol.asyncIterator]() {
         let cursor;
@@ -1331,8 +1341,8 @@ var ThreadImpl = class _ThreadImpl {
           }
           cursor = result.nextCursor;
         }
-        if (!yieldedAny && messageHistory) {
-          const cached = await messageHistory.getMessages(threadId);
+        if (!yieldedAny && threadHistory) {
+          const cached = await threadHistory.getMessages(threadId);
           for (const message of cached) {
             yield message;
           }
@@ -1394,14 +1404,15 @@ var ThreadImpl = class _ThreadImpl {
       }
       postable = card;
     }
+    postable = await this.processCallbackUrls(postable);
     const rawMessage = await this.adapter.postMessage(this.id, postable);
     const result = this.createSentMessage(
       rawMessage.id,
       postable,
       rawMessage.threadId
     );
-    if (this._messageHistory) {
-      await this._messageHistory.append(this.id, new Message(result));
+    if (this._threadHistory) {
+      await this._threadHistory.append(this.id, new Message(result));
     }
     return result;
   }
@@ -1427,6 +1438,7 @@ var ThreadImpl = class _ThreadImpl {
     } else {
       postable = message;
     }
+    postable = await this.processCallbackUrls(postable);
     if (this.adapter.postEphemeral) {
       return this.adapter.postEphemeral(this.id, userId, postable);
     }
@@ -1445,6 +1457,24 @@ var ThreadImpl = class _ThreadImpl {
     }
     return null;
   }
+  async processCallbackUrls(postable) {
+    if (typeof postable === "string") {
+      return postable;
+    }
+    if ("type" in postable && postable.type === "card") {
+      return processCardCallbackUrls(postable, this._stateAdapter);
+    }
+    if ("card" in postable && postable.card?.type === "card") {
+      const processed = await processCardCallbackUrls(
+        postable.card,
+        this._stateAdapter
+      );
+      if (processed !== postable.card) {
+        return { ...postable, card: processed };
+      }
+    }
+    return postable;
+  }
   async schedule(message, options) {
     let postable;
     if (isJSX(message)) {
@@ -1456,6 +1486,9 @@ var ThreadImpl = class _ThreadImpl {
     } else {
       postable = message;
     }
+    postable = await this.processCallbackUrls(
+      postable
+    );
     if (!this.adapter.scheduleMessage) {
       throw new NotImplementedError(
         "Scheduled messages are not supported by this adapter",
@@ -1467,7 +1500,7 @@ var ThreadImpl = class _ThreadImpl {
   /**
    * Handle streaming from an AsyncIterable.
    * Normalizes the stream (supports both textStream and fullStream from AI SDK),
-   * then uses adapter's native streaming if available, otherwise falls back to post+edit.
+   * then uses the adapter's stream implementation if available, otherwise falls back to post+edit.
    */
   async handleStream(rawStream, callerOptions) {
     const textStream = fromFullStream(rawStream);
@@ -1505,8 +1538,8 @@ var ThreadImpl = class _ThreadImpl {
         { markdown: accumulated },
         raw.threadId
       );
-      if (this._messageHistory) {
-        await this._messageHistory.append(this.id, new Message(sent));
+      if (this._threadHistory) {
+        await this._threadHistory.append(this.id, new Message(sent));
       }
       return sent;
     }
@@ -1653,8 +1686,8 @@ var ThreadImpl = class _ThreadImpl {
       { markdown: accumulated },
       threadIdForEdits
     );
-    if (this._messageHistory) {
-      await this._messageHistory.append(this.id, new Message(sent));
+    if (this._threadHistory) {
+      await this._threadHistory.append(this.id, new Message(sent));
     }
     return sent;
   }
@@ -1662,11 +1695,8 @@ var ThreadImpl = class _ThreadImpl {
     const result = await this.adapter.fetchMessages(this.id, { limit: 50 });
     if (result.messages.length > 0) {
       this._recentMessages = result.messages;
-    } else if (this._messageHistory) {
-      this._recentMessages = await this._messageHistory.getMessages(
-        this.id,
-        50
-      );
+    } else if (this._threadHistory) {
+      this._recentMessages = await this._threadHistory.getMessages(this.id, 50);
     } else {
       this._recentMessages = [];
     }
@@ -1778,6 +1808,7 @@ var ThreadImpl = class _ThreadImpl {
           }
           postable2 = card;
         }
+        postable2 = await self.processCallbackUrls(postable2);
         await adapter.editMessage(threadId, messageId, postable2);
         return self.createSentMessage(messageId, postable2);
       },
@@ -1821,6 +1852,7 @@ var ThreadImpl = class _ThreadImpl {
           }
           postable = card;
         }
+        postable = await self.processCallbackUrls(postable);
         await adapter.editMessage(threadId, messageId, postable);
         return self.createSentMessage(messageId, postable, threadId);
       },
@@ -1902,6 +1934,177 @@ function reviver(_key, value) {
   return value;
 }
 
+// src/thread-history.ts
+var DEFAULT_MAX_MESSAGES = 100;
+var DEFAULT_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var KEY_PREFIX = "msg-history:";
+var ThreadHistoryCache = class {
+  state;
+  maxMessages;
+  ttlMs;
+  constructor(state, config) {
+    this.state = state;
+    this.maxMessages = config?.maxMessages ?? DEFAULT_MAX_MESSAGES;
+    this.ttlMs = config?.ttlMs ?? DEFAULT_TTL_MS;
+  }
+  /**
+   * Atomically append a message to the history for a thread.
+   * Trims to maxMessages (keeps newest) and refreshes TTL.
+   */
+  async append(threadId, message) {
+    const key = `${KEY_PREFIX}${threadId}`;
+    const serialized = message.toJSON();
+    serialized.raw = null;
+    await this.state.appendToList(key, serialized, {
+      maxLength: this.maxMessages,
+      ttlMs: this.ttlMs
+    });
+  }
+  /**
+   * Get messages for a thread in chronological order (oldest first).
+   *
+   * @param threadId - The thread ID
+   * @param limit - Optional limit on number of messages to return (returns newest N)
+   */
+  async getMessages(threadId, limit) {
+    const key = `${KEY_PREFIX}${threadId}`;
+    const stored = await this.state.getList(key);
+    const sliced = limit && stored.length > limit ? stored.slice(stored.length - limit) : stored;
+    return sliced.map((s) => Message.fromJSON(s));
+  }
+};
+
+// src/transcripts.ts
+var KEY_PREFIX2 = "transcripts:user:";
+var DEFAULT_MAX_PER_USER = 200;
+var DEFAULT_LIST_LIMIT = 50;
+var DURATION_RE = /^(\d+)([smhd])$/;
+var TOMBSTONE_MARKER = "__chatSdkTombstone";
+function isTombstone(value) {
+  return typeof value === "object" && value !== null && value[TOMBSTONE_MARKER] === true;
+}
+var MS_PER_UNIT = {
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+var TranscriptsApiImpl = class {
+  state;
+  maxPerUser;
+  retentionMs;
+  storeFormatted;
+  constructor(state, config) {
+    this.state = state;
+    this.maxPerUser = config.maxPerUser ?? DEFAULT_MAX_PER_USER;
+    this.retentionMs = parseDuration(config.retention);
+    this.storeFormatted = config.storeFormatted ?? false;
+  }
+  async append(thread, message, options) {
+    const isMessage = message instanceof Message;
+    let userKey;
+    let role;
+    let platformMessageId;
+    if (isMessage) {
+      userKey = message.userKey;
+      role = "user";
+      platformMessageId = message.id;
+      if (!userKey) {
+        return null;
+      }
+    } else {
+      userKey = options?.userKey;
+      role = message.role;
+      platformMessageId = message.platformMessageId;
+      if (!userKey) {
+        throw new Error(
+          "transcripts.append: options.userKey is required when appending an AppendInput"
+        );
+      }
+    }
+    const entry = {
+      id: crypto.randomUUID(),
+      userKey,
+      role,
+      text: message.text,
+      platform: thread.adapter.name,
+      threadId: thread.id,
+      timestamp: Date.now()
+    };
+    if (this.storeFormatted && message.formatted) {
+      entry.formatted = message.formatted;
+    }
+    if (platformMessageId !== void 0) {
+      entry.platformMessageId = platformMessageId;
+    }
+    await this.state.appendToList(keyFor(userKey), entry, {
+      maxLength: this.maxPerUser,
+      ttlMs: this.retentionMs
+    });
+    return entry;
+  }
+  async list(query) {
+    const raw = await this.state.getList(
+      keyFor(query.userKey)
+    );
+    let filtered = raw.filter(
+      (entry) => !isTombstone(entry)
+    );
+    if (query.platforms && query.platforms.length > 0) {
+      const platforms = new Set(query.platforms);
+      filtered = filtered.filter((m) => platforms.has(m.platform));
+    }
+    if (query.threadId !== void 0) {
+      const tid = query.threadId;
+      filtered = filtered.filter((m) => m.threadId === tid);
+    }
+    if (query.roles && query.roles.length > 0) {
+      const roles = new Set(query.roles);
+      filtered = filtered.filter((m) => roles.has(m.role));
+    }
+    const limit = query.limit ?? DEFAULT_LIST_LIMIT;
+    if (filtered.length > limit) {
+      filtered = filtered.slice(filtered.length - limit);
+    }
+    return filtered;
+  }
+  async count(query) {
+    const raw = await this.state.getList(keyFor(query.userKey));
+    return raw.filter((entry) => !isTombstone(entry)).length;
+  }
+  async delete(target) {
+    const key = keyFor(target.userKey);
+    const existing = await this.state.getList(key);
+    const previous = existing.filter((entry) => !isTombstone(entry)).length;
+    const tombstone = { [TOMBSTONE_MARKER]: true };
+    await this.state.appendToList(key, tombstone, {
+      maxLength: 1,
+      ttlMs: this.retentionMs
+    });
+    return { deleted: previous };
+  }
+};
+function keyFor(userKey) {
+  return `${KEY_PREFIX2}${userKey}`;
+}
+function parseDuration(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  const match = DURATION_RE.exec(value);
+  if (!match) {
+    throw new Error(
+      `Invalid duration: ${value} (expected number of ms, or "<n>[smhd]")`
+    );
+  }
+  const n = Number.parseInt(match[1], 10);
+  const unit = match[2];
+  return n * MS_PER_UNIT[unit];
+}
+
 // src/chat.ts
 var DEFAULT_LOCK_TTL_MS = 3e4;
 function sleep(ms) {
@@ -1931,6 +2134,21 @@ var Chat = class {
     setChatSingleton(this);
     return this;
   }
+  /**
+   * Cross-platform per-user transcript store.
+   *
+   * Available only when `transcripts` is configured on the Chat instance
+   * (and an `identity` resolver is set). Throws on access otherwise so
+   * callers fail loudly rather than silently no-op'ing.
+   */
+  get transcripts() {
+    if (!this._transcripts) {
+      throw new Error(
+        "chat.transcripts is not configured \u2014 pass `transcripts` and `identity` to ChatConfig to enable it"
+      );
+    }
+    return this._transcripts;
+  }
   /**
    * Get the registered singleton Chat instance.
    * Throws if no singleton has been registered.
@@ -1952,7 +2170,9 @@ var Chat = class {
   _fallbackStreamingPlaceholderText;
   _dedupeTtlMs;
   _onLockConflict;
-  _messageHistory;
+  _threadHistory;
+  _identity;
+  _transcripts;
   _concurrencyStrategy;
   _concurrencyConfig;
   _concurrentSlots = /* @__PURE__ */ new Map();
@@ -2035,10 +2255,24 @@ var Chat = class {
         queueEntryTtlMs: 9e4
       };
     }
-    this._messageHistory = new MessageHistoryCache(
+    this._threadHistory = new ThreadHistoryCache(
       this._stateAdapter,
-      config.messageHistory
+      config.threadHistory ?? config.messageHistory
     );
+    if (config.transcripts) {
+      if (!config.identity) {
+        throw new Error(
+          "ChatConfig.transcripts requires ChatConfig.identity to be set \u2014 the cross-platform user key must be resolvable"
+        );
+      }
+      this._identity = config.identity;
+      this._transcripts = new TranscriptsApiImpl(
+        this._stateAdapter,
+        config.transcripts
+      );
+    } else {
+      this._identity = config.identity;
+    }
     const webhooks = {};
     for (const [name, adapter] of Object.entries(config.adapters)) {
       this.adapters.set(name, adapter);
@@ -2159,9 +2393,13 @@ var Chat = class {
   /**
    * Register a handler for direct messages.
    *
-   * Called when a message is received in a DM thread that is not subscribed.
-   * If no `onDirectMessage` handlers are registered, DMs fall through to
-   * `onNewMention` for backward compatibility.
+   * Called for every message received in a DM thread when at least one
+   * direct message handler is registered. Direct message handlers run before
+   * `onSubscribedMessage`, `onNewMention`, and pattern handlers.
+   *
+   * If no `onDirectMessage` handlers are registered, DMs continue through
+   * normal routing. Unsubscribed DMs fall through to `onNewMention` for
+   * backward compatibility.
    *
    * @param handler - Handler called for DM messages
    *
@@ -2357,12 +2595,14 @@ var Chat = class {
     const task = (async () => {
       const message = typeof messageOrFactory === "function" ? await messageOrFactory() : messageOrFactory;
       await this.handleIncomingMessage(adapter, threadId, message);
-    })().catch((err) => {
+    })();
+    const tracked = task.catch((err) => {
       this.logger.error("Message processing error", { error: err, threadId });
     });
     if (options?.waitUntil) {
-      options.waitUntil(task);
+      options.waitUntil(tracked);
     }
+    return task;
   }
   /**
    * Process an incoming reaction event from an adapter.
@@ -2420,20 +2660,22 @@ var Chat = class {
       }
     }
   }
-  async processModalSubmit(event, contextId, _options) {
-    const { relatedThread, relatedMessage, relatedChannel } = await this.retrieveModalContext(event.adapter.name, contextId);
+  async processModalSubmit(event, contextId, options) {
+    const { callbackUrl, relatedThread, relatedMessage, relatedChannel } = await this.retrieveModalContext(event.adapter.name, contextId);
     const fullEvent = {
       ...event,
       relatedThread,
       relatedMessage,
       relatedChannel
     };
+    let result;
     for (const { callbackIds, handler } of this.modalSubmitHandlers) {
       if (callbackIds.length === 0 || callbackIds.includes(event.callbackId)) {
         try {
           const response = await handler(fullEvent);
           if (response) {
-            return response;
+            result = response;
+            break;
           }
         } catch (err) {
           this.logger.error("Modal submit handler error", {
@@ -2443,6 +2685,30 @@ var Chat = class {
         }
       }
     }
+    if (callbackUrl && result?.action !== "errors") {
+      const task = postToCallbackUrl(callbackUrl, {
+        type: "modal_submit",
+        callbackId: event.callbackId,
+        values: event.values,
+        user: { id: event.user.userId, name: event.user.userName }
+      }).then(({ error }) => {
+        if (error) {
+          this.logger.error("Modal callbackUrl POST failed", {
+            callbackUrl,
+            error
+          });
+        }
+      }).catch((error) => {
+        this.logger.error("Modal callbackUrl POST failed", {
+          callbackUrl,
+          error
+        });
+      });
+      if (options?.waitUntil) {
+        options.waitUntil(task);
+      }
+    }
+    return result;
   }
   processModalClose(event, contextId, options) {
     const task = (async () => {
@@ -2594,7 +2860,8 @@ var Chat = class {
           contextId,
           void 0,
           void 0,
-          channel
+          channel,
+          modalElement.callbackUrl
         );
         if (options?.onOpenModal) {
           return options.onOpenModal(modalElement, contextId);
@@ -2631,12 +2898,13 @@ var Chat = class {
    * Store modal context server-side with a context ID.
    * Called when opening a modal to preserve thread/message/channel for the submit handler.
    */
-  async storeModalContext(adapterName, contextId, thread, message, channel) {
+  async storeModalContext(adapterName, contextId, thread, message, channel, callbackUrl) {
     const key = `modal-context:${adapterName}:${contextId}`;
     const context = {
       thread: thread?.toJSON(),
       message: message?.toJSON(),
-      channel: channel?.toJSON()
+      channel: channel?.toJSON(),
+      callbackUrl
     };
     try {
       await this._stateAdapter.set(key, context, MODAL_CONTEXT_TTL_MS);
@@ -2654,6 +2922,7 @@ var Chat = class {
   async retrieveModalContext(adapterName, contextId) {
     if (!contextId) {
       return {
+        callbackUrl: void 0,
         relatedThread: void 0,
         relatedMessage: void 0,
         relatedChannel: void 0
@@ -2663,6 +2932,7 @@ var Chat = class {
     const stored = await this._stateAdapter.get(key);
     if (!stored) {
       return {
+        callbackUrl: void 0,
         relatedThread: void 0,
         relatedMessage: void 0,
         relatedChannel: void 0
@@ -2683,7 +2953,12 @@ var Chat = class {
     if (stored.channel) {
       relatedChannel = ChannelImpl.fromJSON(stored.channel, adapter);
     }
-    return { relatedThread, relatedMessage, relatedChannel };
+    return {
+      callbackUrl: stored.callbackUrl,
+      relatedThread,
+      relatedMessage,
+      relatedChannel
+    };
   }
   /**
    * Handle an action event internally.
@@ -2703,6 +2978,33 @@ var Chat = class {
       });
       return;
     }
+    const { callbackToken } = decodeCallbackValue(event.value);
+    let resolved = null;
+    if (callbackToken) {
+      resolved = await resolveCallbackUrl(callbackToken, this._stateAdapter);
+    }
+    const actionEvent = resolved ? { ...event, value: resolved.originalValue } : event;
+    let callbackUrlPromise;
+    if (resolved) {
+      const callbackUrl = resolved.url;
+      callbackUrlPromise = (async () => {
+        const { error } = await postToCallbackUrl(callbackUrl, {
+          type: "action",
+          actionId: event.actionId,
+          value: resolved.originalValue,
+          user: { id: event.user.userId, name: event.user.userName },
+          threadId: event.threadId,
+          messageId: event.messageId
+        });
+        if (error) {
+          this.logger.error("Button callbackUrl POST failed", {
+            callbackUrl,
+            actionId: event.actionId,
+            error
+          });
+        }
+      })();
+    }
     const isSubscribed = false;
     const messageForThread = event.messageId ? new Message({
       id: event.messageId,
@@ -2721,7 +3023,7 @@ var Chat = class {
       isSubscribed
     ) : null;
     const fullEvent = {
-      ...event,
+      ...actionEvent,
       thread,
       openModal: async (modal) => {
         if (!(event.triggerId || options?.onOpenModal)) {
@@ -2769,7 +3071,8 @@ var Chat = class {
           contextId,
           thread ? thread : void 0,
           message,
-          channel
+          channel,
+          modalElement.callbackUrl
         );
         if (options?.onOpenModal) {
           return options.onOpenModal(modalElement, contextId);
@@ -2801,6 +3104,9 @@ var Chat = class {
         await handler(fullEvent);
       }
     }
+    if (callbackUrlPromise) {
+      await callbackUrlPromise;
+    }
   }
   /**
    * Handle a reaction event internally.
@@ -3110,9 +3416,10 @@ var Chat = class {
    * - 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
-   * - Concurrency: Controlled by `concurrency` config (drop, queue, debounce, concurrent)
+   * - Concurrency: Controlled by `concurrency` config (drop, queue, debounce, burst, concurrent)
    */
   async handleIncomingMessage(adapter, threadId, message) {
+    setMessageAdapter(message, adapter);
     this.logger.debug("Incoming message", {
       adapter: adapter.name,
       threadId,
@@ -3144,11 +3451,11 @@ var Chat = class {
       });
       return;
     }
-    if (adapter.persistMessageHistory) {
+    if (adapter.persistThreadHistory || adapter.persistMessageHistory) {
       const channelId = adapter.channelIdFromThreadId(threadId);
-      const appends = [this._messageHistory.append(threadId, message)];
+      const appends = [this._threadHistory.append(threadId, message)];
       if (channelId !== threadId) {
-        appends.push(this._messageHistory.append(channelId, message));
+        appends.push(this._threadHistory.append(channelId, message));
       }
       await Promise.all(appends);
     }
@@ -3158,7 +3465,7 @@ var Chat = class {
       await this.handleConcurrent(adapter, threadId, message);
       return;
     }
-    if (strategy === "queue" || strategy === "debounce") {
+    if (strategy === "queue" || strategy === "debounce" || strategy === "burst") {
       await this.handleQueueOrDebounce(
         adapter,
         threadId,
@@ -3277,6 +3584,25 @@ var Chat = class {
           debounceMs
         });
         await this.debounceLoop(lock, adapter, threadId, lockKey);
+      } else if (strategy === "burst") {
+        await this._stateAdapter.enqueue(
+          lockKey,
+          {
+            message,
+            enqueuedAt: Date.now(),
+            expiresAt: Date.now() + queueEntryTtlMs
+          },
+          maxQueueSize
+        );
+        this.logger.info("message-debouncing", {
+          threadId,
+          lockKey,
+          messageId: message.id,
+          debounceMs
+        });
+        await sleep(debounceMs);
+        await this._stateAdapter.extendLock(lock, DEFAULT_LOCK_TTL_MS);
+        await this.drainQueue(lock, adapter, threadId, lockKey);
       } else {
         await this.dispatchToHandlers(adapter, threadId, message);
         await this.drainQueue(lock, adapter, threadId, lockKey);
@@ -3436,6 +3762,25 @@ var Chat = class {
       message,
       isSubscribed
     );
+    if (this._identity && message.userKey === void 0) {
+      try {
+        const resolved = await this._identity({
+          adapter: adapter.name,
+          author: message.author,
+          message
+        });
+        if (resolved) {
+          message.userKey = resolved;
+        }
+      } catch (err) {
+        this.logger.warn("Identity resolver threw; skipping userKey", {
+          error: err,
+          adapter: adapter.name,
+          threadId,
+          authorUserId: message.author.userId
+        });
+      }
+    }
     const isDM = adapter.isDM?.(threadId) ?? false;
     if (isDM && this.directMessageHandlers.length > 0) {
       this.logger.debug("Direct message received - calling handlers", {
@@ -3517,7 +3862,7 @@ var Chat = class {
       logger: this.logger,
       streamingUpdateIntervalMs: this._streamingUpdateIntervalMs,
       fallbackStreamingPlaceholderText: this._fallbackStreamingPlaceholderText,
-      messageHistory: adapter.persistMessageHistory ? this._messageHistory : void 0
+      threadHistory: adapter.persistThreadHistory || adapter.persistMessageHistory ? this._threadHistory : void 0
     });
   }
   /**
@@ -3563,6 +3908,9 @@ var Chat = class {
    */
   rehydrateMessage(raw, adapter) {
     if (raw instanceof Message) {
+      if (adapter) {
+        setMessageAdapter(raw, adapter);
+      }
       return raw;
     }
     const obj = raw;
@@ -3592,6 +3940,9 @@ var Chat = class {
         links: obj.links ?? []
       });
     }
+    if (adapter) {
+      setMessageAdapter(msg, adapter);
+    }
     const rehydrate = adapter?.rehydrateAttachment?.bind(adapter);
     if (rehydrate && msg.attachments.length > 0) {
       msg.attachments = msg.attachments.map(
@@ -3607,6 +3958,9 @@ var Chat = class {
   }
 };
 
+// src/message-history.ts
+var MessageHistoryCache = ThreadHistoryCache;
+
 // src/plan.ts
 function contentToPlainText(content) {
   if (!content) {
@@ -4107,6 +4461,8 @@ function convertEmojiPlaceholders(text2, platform, resolver = defaultEmojiResolv
         return resolver.toGChat(emojiName);
       case "discord":
         return resolver.toDiscord(emojiName);
+      case "messenger":
+        return resolver.toGChat(emojiName);
       case "github":
         return resolver.toGChat(emojiName);
       case "linear":
@@ -4308,6 +4664,7 @@ export {
   THREAD_STATE_TTL_MS,
   Table2 as Table,
   TextInput2 as TextInput,
+  ThreadHistoryCache,
   ThreadImpl,
   blockquote,
   cardChildToFallbackText2 as cardChildToFallbackText,