chat 4.26.0 → 4.28.1

package/dist/index.js

@@ -6,6 +6,7 @@ import {
   CardLink,
   CardText,
   Divider,
+  ExternalSelect,
   Field,
   Fields,
   Image,
@@ -59,7 +60,7 @@ import {
   toModalElement,
   toPlainText,
   walkAst
-} from "./chunk-OPV5U4WG.js";
+} from "./chunk-V25FKIIL.js";
 
 // src/ai.ts
 var TEXT_MIME_PREFIXES = [
@@ -189,6 +190,127 @@ ${linkParts}`;
 // 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}`;
+}
+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
+        };
+        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;
+        }
+      }
+    }
+    if (child.type === "section" && "children" in child && hasCallbackButtons(child.children)) {
+      return true;
+    }
+  }
+  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 result;
+}
+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}`
+  );
+  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/chat-singleton.ts
 var _singleton = null;
 function setChatSingleton(chat) {
@@ -244,6 +366,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;
@@ -282,8 +408,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;
@@ -330,7 +479,8 @@ var Message = class _Message {
         mimeType: att.mimeType,
         size: att.size,
         width: att.width,
-        height: att.height
+        height: att.height,
+        fetchMetadata: att.fetchMetadata
       })),
       isMention: this.isMention,
       links: this.links.length > 0 ? this.links.map((link2) => ({
@@ -495,7 +645,7 @@ var ChannelImpl = class _ChannelImpl {
   _adapterName;
   _stateAdapterInstance;
   _name = null;
-  _messageHistory;
+  _threadHistory;
   constructor(config) {
     this.id = config.id;
     this.isDM = config.isDM ?? false;
@@ -505,7 +655,7 @@ var ChannelImpl = class _ChannelImpl {
     } else {
       this._adapter = config.adapter;
       this._stateAdapterInstance = config.stateAdapter;
-      this._messageHistory = config.messageHistory;
+      this._threadHistory = config.threadHistory;
     }
   }
   get adapter() {
@@ -559,7 +709,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;
@@ -577,8 +727,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];
           }
@@ -635,6 +785,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 });
@@ -647,6 +799,7 @@ var ChannelImpl = class _ChannelImpl {
       }
       postable = card;
     }
+    postable = await this.processCallbackUrls(postable);
     return this.postSingleMessage(postable);
   }
   async handlePostableObject(obj) {
@@ -664,8 +817,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;
   }
@@ -682,6 +835,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);
     }
@@ -711,6 +865,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",
@@ -719,6 +874,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);
   }
@@ -788,6 +961,7 @@ var ChannelImpl = class _ChannelImpl {
           }
           editPostable = card;
         }
+        editPostable = await self.processCallbackUrls(editPostable);
         await adapter.editMessage(threadId, messageId, editPostable);
         return self.createSentMessage(messageId, editPostable);
       },
@@ -856,46 +1030,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";
 
@@ -1166,8 +1300,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;
@@ -1184,7 +1318,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];
@@ -1265,7 +1399,7 @@ var ThreadImpl = class _ThreadImpl {
         stateAdapter: this._stateAdapter,
         isDM: this.isDM,
         channelVisibility: this.channelVisibility,
-        messageHistory: this._messageHistory
+        threadHistory: this._threadHistory
       });
     }
     return this._channel;
@@ -1277,7 +1411,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;
@@ -1297,8 +1431,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];
           }
@@ -1309,7 +1443,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;
@@ -1329,8 +1463,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;
           }
@@ -1338,6 +1472,19 @@ var ThreadImpl = class _ThreadImpl {
       }
     };
   }
+  async getParticipants() {
+    const seen = /* @__PURE__ */ new Map();
+    if (this._currentMessage && !this._currentMessage.author.isMe && !this._currentMessage.author.isBot) {
+      seen.set(this._currentMessage.author.userId, this._currentMessage.author);
+    }
+    for await (const message of this.allMessages) {
+      if (message.author.isMe || message.author.isBot || seen.has(message.author.userId)) {
+        continue;
+      }
+      seen.set(message.author.userId, message.author);
+    }
+    return [...seen.values()];
+  }
   async isSubscribed() {
     if (this._isSubscribedContext) {
       return true;
@@ -1355,6 +1502,16 @@ var ThreadImpl = class _ThreadImpl {
   }
   async post(message) {
     if (isPostableObject(message)) {
+      if (message.kind === "stream") {
+        const data = message.getPostData();
+        const streamOptions = {
+          ...data.options.updateIntervalMs ? { updateIntervalMs: data.options.updateIntervalMs } : {},
+          ...data.options.groupTasks ? { taskDisplayMode: data.options.groupTasks } : {},
+          ...data.options.endWith ? { stopBlocks: data.options.endWith } : {}
+        };
+        await this.handleStream(data.stream, streamOptions);
+        return message;
+      }
       await this.handlePostableObject(message);
       return message;
     }
@@ -1369,14 +1526,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;
   }
@@ -1402,6 +1560,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);
     }
@@ -1420,6 +1579,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)) {
@@ -1431,6 +1608,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",
@@ -1442,15 +1622,16 @@ 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) {
+  async handleStream(rawStream, callerOptions) {
     const textStream = fromFullStream(rawStream);
-    const options = {};
+    const options = { ...callerOptions };
     if (this._currentMessage) {
       options.recipientUserId = this._currentMessage.author.userId;
-      const raw = this._currentMessage.raw;
-      options.recipientTeamId = raw?.team_id ?? raw?.team;
+      options.recipientTeamId = this.extractSlackRecipientTeamId(
+        this._currentMessage.raw
+      );
     }
     if (this.adapter.stream) {
       let accumulated = "";
@@ -1479,8 +1660,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;
     }
@@ -1508,6 +1689,31 @@ var ThreadImpl = class _ThreadImpl {
     };
     return this.fallbackStream(textOnlyStream, options);
   }
+  /**
+   * Slack payloads carry the workspace ID in a few different shapes depending on
+   * the webhook type:
+   * - Message events: `team_id` or `team` as a string
+   * - `block_actions` payloads: `team.id` (object), with `user.team_id` as a fallback
+   */
+  extractSlackRecipientTeamId(raw) {
+    if (!raw || typeof raw !== "object") {
+      return void 0;
+    }
+    const payload = raw;
+    if (typeof payload.team_id === "string" && payload.team_id) {
+      return payload.team_id;
+    }
+    if (typeof payload.team === "string" && payload.team) {
+      return payload.team;
+    }
+    if (payload.team && typeof payload.team === "object" && typeof payload.team.id === "string" && payload.team.id) {
+      return payload.team.id;
+    }
+    if (typeof payload.user?.team_id === "string" && payload.user.team_id) {
+      return payload.user.team_id;
+    }
+    return void 0;
+  }
   async startTyping(status) {
     await this.adapter.startTyping(this.id, status);
   }
@@ -1602,8 +1808,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;
   }
@@ -1611,11 +1817,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 = [];
     }
@@ -1727,6 +1930,7 @@ var ThreadImpl = class _ThreadImpl {
           }
           postable2 = card;
         }
+        postable2 = await self.processCallbackUrls(postable2);
         await adapter.editMessage(threadId, messageId, postable2);
         return self.createSentMessage(messageId, postable2);
       },
@@ -1770,6 +1974,7 @@ var ThreadImpl = class _ThreadImpl {
           }
           postable = card;
         }
+        postable = await self.processCallbackUrls(postable);
         await adapter.editMessage(threadId, messageId, postable);
         return self.createSentMessage(messageId, postable, threadId);
       },
@@ -1851,13 +2056,186 @@ 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) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-var SLACK_USER_ID_REGEX = /^U[A-Z0-9]+$/i;
+var SLACK_USER_ID_REGEX = /^[UW][A-Z0-9]+$/;
 var DISCORD_SNOWFLAKE_REGEX = /^\d{17,19}$/;
+var LINEAR_UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var NUMERIC_REGEX = /^\d+$/;
 var DEDUPE_TTL_MS = 5 * 60 * 1e3;
 var MODAL_CONTEXT_TTL_MS = 24 * 60 * 60 * 1e3;
 var Chat = class {
@@ -1878,6 +2256,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.
@@ -1899,9 +2292,12 @@ var Chat = class {
   _fallbackStreamingPlaceholderText;
   _dedupeTtlMs;
   _onLockConflict;
-  _messageHistory;
+  _threadHistory;
+  _identity;
+  _transcripts;
   _concurrencyStrategy;
   _concurrencyConfig;
+  _concurrentSlots = /* @__PURE__ */ new Map();
   _lockScope;
   mentionHandlers = [];
   directMessageHandlers = [];
@@ -1909,6 +2305,7 @@ var Chat = class {
   subscribedMessageHandlers = [];
   reactionHandlers = [];
   actionHandlers = [];
+  optionsLoadHandlers = [];
   modalSubmitHandlers = [];
   modalCloseHandlers = [];
   slashCommandHandlers = [];
@@ -1934,6 +2331,11 @@ var Chat = class {
     this._dedupeTtlMs = config.dedupeTtlMs ?? DEDUPE_TTL_MS;
     this._onLockConflict = config.onLockConflict;
     this._lockScope = config.lockScope;
+    if (typeof config.logger === "string") {
+      this.logger = new ConsoleLogger(config.logger);
+    } else {
+      this.logger = config.logger || new ConsoleLogger("info");
+    }
     const concurrency = config.concurrency;
     if (concurrency) {
       if (typeof concurrency === "string") {
@@ -1946,6 +2348,16 @@ var Chat = class {
           queueEntryTtlMs: 9e4
         };
       } else {
+        if (concurrency.maxConcurrent !== void 0 && concurrency.maxConcurrent < 1) {
+          throw new Error(
+            `concurrency.maxConcurrent must be >= 1 (got ${concurrency.maxConcurrent})`
+          );
+        }
+        if (concurrency.maxConcurrent !== void 0 && concurrency.strategy !== "concurrent") {
+          this.logger.warn(
+            `concurrency.maxConcurrent has no effect when strategy is "${concurrency.strategy}" \u2014 it only applies to the "concurrent" strategy.`
+          );
+        }
         this._concurrencyStrategy = concurrency.strategy;
         this._concurrencyConfig = {
           debounceMs: concurrency.debounceMs ?? 1500,
@@ -1965,14 +2377,23 @@ var Chat = class {
         queueEntryTtlMs: 9e4
       };
     }
-    this._messageHistory = new MessageHistoryCache(
+    this._threadHistory = new ThreadHistoryCache(
       this._stateAdapter,
-      config.messageHistory
+      config.threadHistory ?? config.messageHistory
     );
-    if (typeof config.logger === "string") {
-      this.logger = new ConsoleLogger(config.logger);
+    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.logger = config.logger || new ConsoleLogger("info");
+      this._identity = config.identity;
     }
     const webhooks = {};
     for (const [name, adapter] of Object.entries(config.adapters)) {
@@ -2180,6 +2601,19 @@ var Chat = class {
       this.logger.debug("Registered action handler", { actionIds });
     }
   }
+  onOptionsLoad(actionIdOrHandler, handler) {
+    if (typeof actionIdOrHandler === "function") {
+      this.optionsLoadHandlers.push({
+        actionIds: [],
+        handler: actionIdOrHandler
+      });
+      this.logger.debug("Registered options load handler for all action IDs");
+    } else if (handler) {
+      const actionIds = Array.isArray(actionIdOrHandler) ? actionIdOrHandler : [actionIdOrHandler];
+      this.optionsLoadHandlers.push({ actionIds, handler });
+      this.logger.debug("Registered options load handler", { actionIds });
+    }
+  }
   onModalSubmit(callbackIdOrHandler, handler) {
     if (typeof callbackIdOrHandler === "function") {
       this.modalSubmitHandlers.push({
@@ -2279,12 +2713,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.
@@ -2319,20 +2755,45 @@ var Chat = class {
     }
     return task;
   }
-  async processModalSubmit(event, contextId, _options) {
-    const { relatedThread, relatedMessage, relatedChannel } = await this.retrieveModalContext(event.adapter.name, contextId);
+  async processOptionsLoad(event, _options) {
+    const matchingHandlers = [
+      ...this.optionsLoadHandlers.filter(
+        ({ actionIds }) => actionIds.length > 0 && actionIds.includes(event.actionId)
+      ),
+      ...this.optionsLoadHandlers.filter(
+        ({ actionIds }) => actionIds.length === 0
+      )
+    ];
+    for (const { handler } of matchingHandlers) {
+      try {
+        const options = await handler(event);
+        if (options) {
+          return options;
+        }
+      } catch (err) {
+        this.logger.error("Options load handler error", {
+          error: err,
+          actionId: event.actionId
+        });
+      }
+    }
+  }
+  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", {
@@ -2342,6 +2803,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 () => {
@@ -2493,7 +2978,8 @@ var Chat = class {
           contextId,
           void 0,
           void 0,
-          channel
+          channel,
+          modalElement.callbackUrl
         );
         if (options?.onOpenModal) {
           return options.onOpenModal(modalElement, contextId);
@@ -2530,12 +3016,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);
@@ -2553,6 +3040,7 @@ var Chat = class {
   async retrieveModalContext(adapterName, contextId) {
     if (!contextId) {
       return {
+        callbackUrl: void 0,
         relatedThread: void 0,
         relatedMessage: void 0,
         relatedChannel: void 0
@@ -2562,6 +3050,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
@@ -2582,7 +3071,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.
@@ -2602,6 +3096,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,
@@ -2620,7 +3141,7 @@ var Chat = class {
       isSubscribed
     ) : null;
     const fullEvent = {
-      ...event,
+      ...actionEvent,
       thread,
       openModal: async (modal) => {
         if (!(event.triggerId || options?.onOpenModal)) {
@@ -2668,7 +3189,8 @@ var Chat = class {
           contextId,
           thread ? thread : void 0,
           message,
-          channel
+          channel,
+          modalElement.callbackUrl
         );
         if (options?.onOpenModal) {
           return options.onOpenModal(modalElement, contextId);
@@ -2700,6 +3222,9 @@ var Chat = class {
         await handler(fullEvent);
       }
     }
+    if (callbackUrlPromise) {
+      await callbackUrlPromise;
+    }
   }
   /**
    * Handle a reaction event internally.
@@ -2818,6 +3343,33 @@ var Chat = class {
     const threadId = await adapter.openDM(userId);
     return this.createThread(adapter, threadId, {}, false);
   }
+  /**
+   * Look up user information by user ID.
+   *
+   * The adapter is automatically inferred from the user ID format.
+   * Returns user details including email (where available — requires
+   * appropriate scopes on some platforms, e.g. `users:read.email` on Slack).
+   *
+   * @param user - Platform-specific user ID string, or an Author object
+   * @returns User info, or null if user not found
+   *
+   * @example
+   * ```typescript
+   * const user = await chat.getUser("U123456");
+   * console.log(user?.email); // "alice@company.com"
+   * ```
+   */
+  async getUser(user) {
+    const userId = typeof user === "string" ? user : user.userId;
+    const adapter = this.inferAdapterFromUserId(userId);
+    if (!adapter.getUser) {
+      throw new ChatError(
+        `Adapter "${adapter.name}" does not support getUser`,
+        "NOT_SUPPORTED"
+      );
+    }
+    return adapter.getUser(userId);
+  }
   /**
    * Get a Channel by its channel ID.
    *
@@ -2865,6 +3417,37 @@ var Chat = class {
       stateAdapter: this._stateAdapter
     });
   }
+  /**
+   * Get a Thread handle by its thread ID.
+   *
+   * The adapter is automatically inferred from the thread ID prefix.
+   *
+   * @param threadId - Full thread ID (e.g., "slack:C123ABC:1234567890.123456")
+   * @returns A Thread that can be used to post messages, subscribe, etc.
+   *
+   * @example
+   * ```typescript
+   * const thread = chat.thread("slack:C123ABC:1234567890.123456");
+   * await thread.post("Hello from outside a webhook!");
+   * ```
+   */
+  thread(threadId) {
+    const adapterName = threadId.split(":")[0];
+    if (!adapterName) {
+      throw new ChatError(
+        `Invalid thread ID: ${threadId}`,
+        "INVALID_THREAD_ID"
+      );
+    }
+    const adapter = this.adapters.get(adapterName);
+    if (!adapter) {
+      throw new ChatError(
+        `Adapter "${adapterName}" not found for thread ID "${threadId}"`,
+        "ADAPTER_NOT_FOUND"
+      );
+    }
+    return this.createThread(adapter, threadId, {}, false);
+  }
   /**
    * Infer which adapter to use based on the userId format.
    */
@@ -2881,20 +3464,44 @@ var Chat = class {
         return adapter;
       }
     }
-    if (SLACK_USER_ID_REGEX.test(userId)) {
-      const adapter = this.adapters.get("slack");
+    if (LINEAR_UUID_REGEX.test(userId)) {
+      const adapter = this.adapters.get("linear");
       if (adapter) {
         return adapter;
       }
     }
-    if (DISCORD_SNOWFLAKE_REGEX.test(userId)) {
-      const adapter = this.adapters.get("discord");
+    if (SLACK_USER_ID_REGEX.test(userId)) {
+      const adapter = this.adapters.get("slack");
       if (adapter) {
         return adapter;
       }
     }
+    if (NUMERIC_REGEX.test(userId)) {
+      const candidates = [];
+      if (DISCORD_SNOWFLAKE_REGEX.test(userId) && this.adapters.has("discord")) {
+        candidates.push("discord");
+      }
+      if (this.adapters.has("telegram")) {
+        candidates.push("telegram");
+      }
+      if (this.adapters.has("github")) {
+        candidates.push("github");
+      }
+      if (candidates.length === 1) {
+        const adapter = this.adapters.get(candidates[0]);
+        if (adapter) {
+          return adapter;
+        }
+      }
+      if (candidates.length > 1) {
+        throw new ChatError(
+          `Numeric userId "${userId}" is ambiguous between adapters: ${candidates.join(", ")}. Call the platform's adapter directly (e.g. \`adapter.getUser(userId)\`).`,
+          "AMBIGUOUS_USER_ID"
+        );
+      }
+    }
     throw new ChatError(
-      `Cannot infer adapter from userId "${userId}". Expected format: Slack (U...), Teams (29:...), Google Chat (users/...), or Discord (numeric snowflake).`,
+      `Cannot infer adapter from userId "${userId}". Expected: Slack ("U..."), Teams ("29:..."), Google Chat ("users/..."), Linear (UUID), or Discord/Telegram/GitHub (numeric).`,
       "UNKNOWN_USER_ID_FORMAT"
     );
   }
@@ -2930,6 +3537,7 @@ var Chat = class {
    * - Concurrency: Controlled by `concurrency` config (drop, queue, debounce, concurrent)
    */
   async handleIncomingMessage(adapter, threadId, message) {
+    setMessageAdapter(message, adapter);
     this.logger.debug("Incoming message", {
       adapter: adapter.name,
       threadId,
@@ -2961,11 +3569,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);
     }
@@ -3116,7 +3724,7 @@ var Chat = class {
       if (!entry) {
         break;
       }
-      const msg = this.rehydrateMessage(entry.message);
+      const msg = this.rehydrateMessage(entry.message, adapter);
       if (Date.now() > entry.expiresAt) {
         this.logger.info("message-expired", {
           threadId,
@@ -3155,7 +3763,7 @@ var Chat = class {
         if (!entry) {
           break;
         }
-        const msg = this.rehydrateMessage(entry.message);
+        const msg = this.rehydrateMessage(entry.message, adapter);
         if (Date.now() <= entry.expiresAt) {
           pending.push({ message: msg, expiresAt: entry.expiresAt });
         } else {
@@ -3190,10 +3798,50 @@ var Chat = class {
     }
   }
   /**
-   * Concurrent strategy: no locking, process immediately.
+   * Concurrent strategy: no locking, process immediately — but cap
+   * simultaneous handlers per thread at `maxConcurrent` (default Infinity).
    */
   async handleConcurrent(adapter, threadId, message) {
-    await this.dispatchToHandlers(adapter, threadId, message);
+    const { maxConcurrent } = this._concurrencyConfig;
+    if (!Number.isFinite(maxConcurrent)) {
+      await this.dispatchToHandlers(adapter, threadId, message);
+      return;
+    }
+    await this.acquireConcurrentSlot(threadId, maxConcurrent);
+    try {
+      await this.dispatchToHandlers(adapter, threadId, message);
+    } finally {
+      this.releaseConcurrentSlot(threadId);
+    }
+  }
+  acquireConcurrentSlot(threadId, maxConcurrent) {
+    let slot = this._concurrentSlots.get(threadId);
+    if (!slot) {
+      slot = { inFlight: 0, waiters: [] };
+      this._concurrentSlots.set(threadId, slot);
+    }
+    if (slot.inFlight < maxConcurrent) {
+      slot.inFlight++;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      slot.waiters.push(resolve);
+    });
+  }
+  releaseConcurrentSlot(threadId) {
+    const slot = this._concurrentSlots.get(threadId);
+    if (!slot) {
+      return;
+    }
+    const next = slot.waiters.shift();
+    if (next) {
+      next();
+      return;
+    }
+    slot.inFlight--;
+    if (slot.inFlight === 0 && slot.waiters.length === 0) {
+      this._concurrentSlots.delete(threadId);
+    }
   }
   /**
    * Dispatch a message to the appropriate handler chain based on
@@ -3213,6 +3861,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", {
@@ -3294,7 +3961,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
     });
   }
   /**
@@ -3338,35 +4005,50 @@ var Chat = class {
    * object (not a Message instance). This restores class invariants like
    * `links` defaulting to `[]` and `metadata.dateSent` being a Date.
    */
-  rehydrateMessage(raw) {
+  rehydrateMessage(raw, adapter) {
     if (raw instanceof Message) {
+      if (adapter) {
+        setMessageAdapter(raw, adapter);
+      }
       return raw;
     }
     const obj = raw;
+    let msg;
     if (obj._type === "chat:Message") {
-      return Message.fromJSON(obj);
-    }
-    const metadata = obj.metadata;
-    const dateSent = metadata.dateSent;
-    const editedAt = metadata.editedAt;
-    return new Message({
-      id: obj.id,
-      threadId: obj.threadId,
-      text: obj.text,
-      formatted: obj.formatted,
-      raw: obj.raw,
-      author: obj.author,
-      metadata: {
-        dateSent: dateSent instanceof Date ? dateSent : new Date(dateSent),
-        edited: metadata.edited,
-        editedAt: editedAt ? new Date(
-          editedAt instanceof Date ? editedAt.toISOString() : editedAt
-        ) : void 0
-      },
-      attachments: obj.attachments ?? [],
-      isMention: obj.isMention,
-      links: obj.links ?? []
-    });
+      msg = Message.fromJSON(obj);
+    } else {
+      const metadata = obj.metadata;
+      const dateSent = metadata.dateSent;
+      const editedAt = metadata.editedAt;
+      msg = new Message({
+        id: obj.id,
+        threadId: obj.threadId,
+        text: obj.text,
+        formatted: obj.formatted,
+        raw: obj.raw,
+        author: obj.author,
+        metadata: {
+          dateSent: dateSent instanceof Date ? dateSent : new Date(dateSent),
+          edited: metadata.edited,
+          editedAt: editedAt ? new Date(
+            editedAt instanceof Date ? editedAt.toISOString() : editedAt
+          ) : void 0
+        },
+        attachments: obj.attachments ?? [],
+        isMention: obj.isMention,
+        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(
+        (att) => att.fetchData ? att : rehydrate(att)
+      );
+    }
+    return msg;
   }
   async runHandlers(handlers, thread, message, context) {
     for (const handler of handlers) {
@@ -3375,6 +4057,9 @@ var Chat = class {
   }
 };
 
+// src/message-history.ts
+var MessageHistoryCache = ThreadHistoryCache;
+
 // src/plan.ts
 function contentToPlainText(content) {
   if (!content) {
@@ -3494,13 +4179,17 @@ var Plan = class {
       return null;
     }
     let current;
-    for (let i = this._model.tasks.length - 1; i >= 0; i--) {
-      if (this._model.tasks[i].status === "in_progress") {
-        current = this._model.tasks[i];
-        break;
+    if (typeof update === "object" && update !== null && "id" in update && update.id) {
+      current = this._model.tasks.find((t) => t.id === update.id);
+    } else {
+      for (let i = this._model.tasks.length - 1; i >= 0; i--) {
+        if (this._model.tasks[i].status === "in_progress") {
+          current = this._model.tasks[i];
+          break;
+        }
       }
+      current ??= this._model.tasks.at(-1);
     }
-    current ??= this._model.tasks.at(-1);
     if (!current) {
       return null;
     }
@@ -3589,6 +4278,38 @@ var Plan = class {
   }
 };
 
+// src/streaming-plan.ts
+var StreamingPlan = class {
+  $$typeof = POSTABLE_OBJECT;
+  kind = "stream";
+  _stream;
+  _options;
+  constructor(stream, options = {}) {
+    this._stream = stream;
+    this._options = options;
+  }
+  get stream() {
+    return this._stream;
+  }
+  get options() {
+    return this._options;
+  }
+  getFallbackText() {
+    return "";
+  }
+  getPostData() {
+    return {
+      stream: this._stream,
+      options: this._options
+    };
+  }
+  isSupported(_adapter) {
+    return true;
+  }
+  onPosted(_context) {
+  }
+};
+
 // src/emoji.ts
 var emojiRegistry = /* @__PURE__ */ new Map();
 function getEmoji(name) {
@@ -3839,6 +4560,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":
@@ -3999,6 +4722,7 @@ var toCardElement2 = toCardElement;
 var toModalElement2 = toModalElement;
 var fromReactModalElement2 = fromReactModalElement;
 var isModalElement2 = isModalElement;
+var ExternalSelect2 = ExternalSelect;
 var Modal2 = Modal;
 var RadioSelect2 = RadioSelect;
 var Select2 = Select;
@@ -4018,6 +4742,7 @@ export {
   DEFAULT_EMOJI_MAP,
   Divider2 as Divider,
   EmojiResolver,
+  ExternalSelect2 as ExternalSelect,
   Field2 as Field,
   Fields2 as Fields,
   Image2 as Image,
@@ -4034,9 +4759,11 @@ export {
   Select2 as Select,
   SelectOption2 as SelectOption,
   StreamingMarkdownRenderer,
+  StreamingPlan,
   THREAD_STATE_TTL_MS,
   Table2 as Table,
   TextInput2 as TextInput,
+  ThreadHistoryCache,
   ThreadImpl,
   blockquote,
   cardChildToFallbackText2 as cardChildToFallbackText,