chat 4.18.0 → 4.20.0

package/dist/index.js

@@ -59,7 +59,20 @@ import {
   toModalElement,
   toPlainText,
   walkAst
-} from "./chunk-WAB7KMH4.js";
+} from "./chunk-JW7GYSMH.js";
+
+// src/ai.ts
+function toAiMessages(messages, options) {
+  const includeNames = options?.includeNames ?? false;
+  const sorted = [...messages].sort(
+    (a, b) => (a.metadata.dateSent?.getTime() ?? 0) - (b.metadata.dateSent?.getTime() ?? 0)
+  );
+  return sorted.filter((msg) => msg.text.trim()).map((msg) => {
+    const role = msg.author.isMe ? "assistant" : "user";
+    const content = includeNames && role === "user" ? `[${msg.author.userName}]: ${msg.text}` : msg.text;
+    return { role, content };
+  });
+}
 
 // src/channel.ts
 import { WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2, WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2 } from "@workflow/serde";
@@ -81,6 +94,42 @@ function hasChatSingleton() {
   return _singleton !== null;
 }
 
+// src/from-full-stream.ts
+var STREAM_CHUNK_TYPES = /* @__PURE__ */ new Set([
+  "markdown_text",
+  "task_update",
+  "plan_update"
+]);
+async function* fromFullStream(stream) {
+  let needsSeparator = false;
+  let hasEmittedText = false;
+  for await (const event of stream) {
+    if (typeof event === "string") {
+      yield event;
+      continue;
+    }
+    if (event === null || typeof event !== "object" || !("type" in event)) {
+      continue;
+    }
+    const typed = event;
+    if (STREAM_CHUNK_TYPES.has(typed.type)) {
+      yield event;
+      continue;
+    }
+    const textContent = typed.text ?? typed.delta ?? typed.textDelta;
+    if (typed.type === "text-delta" && typeof textContent === "string") {
+      if (needsSeparator && hasEmittedText) {
+        yield "\n\n";
+      }
+      needsSeparator = false;
+      hasEmittedText = true;
+      yield textContent;
+    } else if (typed.type === "step-finish") {
+      needsSeparator = true;
+    }
+  }
+}
+
 // src/message.ts
 import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from "@workflow/serde";
 var Message = class _Message {
@@ -301,6 +350,7 @@ var ChannelImpl = class _ChannelImpl {
   _adapterName;
   _stateAdapterInstance;
   _name = null;
+  _messageHistory;
   constructor(config) {
     this.id = config.id;
     this.isDM = config.isDM ?? false;
@@ -309,6 +359,7 @@ var ChannelImpl = class _ChannelImpl {
     } else {
       this._adapter = config.adapter;
       this._stateAdapterInstance = config.stateAdapter;
+      this._messageHistory = config.messageHistory;
     }
   }
   get adapter() {
@@ -362,14 +413,17 @@ var ChannelImpl = class _ChannelImpl {
   get messages() {
     const adapter = this.adapter;
     const channelId = this.id;
+    const messageHistory = this._messageHistory;
     return {
       async *[Symbol.asyncIterator]() {
         let cursor;
+        let yieldedAny = false;
         while (true) {
           const fetchOptions = { cursor, direction: "backward" };
           const result = adapter.fetchChannelMessages ? await adapter.fetchChannelMessages(channelId, fetchOptions) : await adapter.fetchMessages(channelId, fetchOptions);
           const reversed = [...result.messages].reverse();
           for (const message of reversed) {
+            yieldedAny = true;
             yield message;
           }
           if (!result.nextCursor || result.messages.length === 0) {
@@ -377,6 +431,12 @@ var ChannelImpl = class _ChannelImpl {
           }
           cursor = result.nextCursor;
         }
+        if (!yieldedAny && messageHistory) {
+          const cached = await messageHistory.getMessages(channelId);
+          for (let i = cached.length - 1; i >= 0; i--) {
+            yield cached[i];
+          }
+        }
       }
     };
   }
@@ -422,10 +482,12 @@ var ChannelImpl = class _ChannelImpl {
   async post(message) {
     if (isAsyncIterable(message)) {
       let accumulated = "";
-      for await (const chunk of message) {
-        accumulated += chunk;
+      for await (const chunk of fromFullStream(message)) {
+        if (typeof chunk === "string") {
+          accumulated += chunk;
+        }
       }
-      return this.postSingleMessage(accumulated);
+      return this.postSingleMessage({ markdown: accumulated });
     }
     let postable = message;
     if (isJSX(message)) {
@@ -439,7 +501,15 @@ var ChannelImpl = class _ChannelImpl {
   }
   async postSingleMessage(postable) {
     const rawMessage = this.adapter.postChannelMessage ? await this.adapter.postChannelMessage(this.id, postable) : await this.adapter.postMessage(this.id, postable);
-    return this.createSentMessage(rawMessage.id, postable, rawMessage.threadId);
+    const sent = this.createSentMessage(
+      rawMessage.id,
+      postable,
+      rawMessage.threadId
+    );
+    if (this._messageHistory) {
+      await this._messageHistory.append(this.id, new Message(sent));
+    }
+    return sent;
   }
   async postEphemeral(user, message, options) {
     const { fallbackToDM } = options;
@@ -472,6 +542,25 @@ var ChannelImpl = class _ChannelImpl {
     }
     return null;
   }
+  async schedule(message, options) {
+    let postable;
+    if (isJSX(message)) {
+      const card = toCardElement(message);
+      if (!card) {
+        throw new Error("Invalid JSX element: must be a Card element");
+      }
+      postable = card;
+    } else {
+      postable = message;
+    }
+    if (!this.adapter.scheduleMessage) {
+      throw new NotImplementedError(
+        "Scheduled messages are not supported by this adapter",
+        "scheduling"
+      );
+    }
+    return this.adapter.scheduleMessage(this.id, postable, options);
+  }
   async startTyping(status) {
     await this.adapter.startTyping(this.id, status);
   }
@@ -555,11 +644,7 @@ var ChannelImpl = class _ChannelImpl {
   }
 };
 function deriveChannelId(adapter, threadId) {
-  if (adapter.channelIdFromThreadId) {
-    return adapter.channelIdFromThreadId(threadId);
-  }
-  const parts = threadId.split(":");
-  return parts.slice(0, 2).join(":");
+  return adapter.channelIdFromThreadId(threadId);
 }
 function extractMessageContent(message) {
   if (typeof message === "string") {
@@ -610,45 +695,49 @@ 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";
 
-// src/from-full-stream.ts
-var STREAM_CHUNK_TYPES = /* @__PURE__ */ new Set([
-  "markdown_text",
-  "task_update",
-  "plan_update"
-]);
-async function* fromFullStream(stream) {
-  let needsSeparator = false;
-  let hasEmittedText = false;
-  for await (const event of stream) {
-    if (typeof event === "string") {
-      yield event;
-      continue;
-    }
-    if (event === null || typeof event !== "object" || !("type" in event)) {
-      continue;
-    }
-    const typed = event;
-    if (STREAM_CHUNK_TYPES.has(typed.type)) {
-      yield event;
-      continue;
-    }
-    const textContent = typed.text ?? typed.delta ?? typed.textDelta;
-    if (typed.type === "text-delta" && typeof textContent === "string") {
-      if (needsSeparator && hasEmittedText) {
-        yield "\n\n";
-      }
-      needsSeparator = false;
-      hasEmittedText = true;
-      yield textContent;
-    } else if (typed.type === "step-finish") {
-      needsSeparator = true;
-    }
-  }
-}
-
 // src/streaming-markdown.ts
 import remend from "remend";
 var StreamingMarkdownRenderer = class {
@@ -902,6 +991,8 @@ var ThreadImpl = class _ThreadImpl {
   _fallbackStreamingPlaceholderText;
   /** Cached channel instance */
   _channel;
+  /** Message history cache (set only for adapters with persistMessageHistory) */
+  _messageHistory;
   constructor(config) {
     this.id = config.id;
     this.channelId = config.channelId;
@@ -915,6 +1006,7 @@ var ThreadImpl = class _ThreadImpl {
     } else {
       this._adapter = config.adapter;
       this._stateAdapterInstance = config.stateAdapter;
+      this._messageHistory = config.messageHistory;
     }
     if (config.initialMessage) {
       this._recentMessages = [config.initialMessage];
@@ -993,7 +1085,8 @@ var ThreadImpl = class _ThreadImpl {
         id: channelId,
         adapter: this.adapter,
         stateAdapter: this._stateAdapter,
-        isDM: this.isDM
+        isDM: this.isDM,
+        messageHistory: this._messageHistory
       });
     }
     return this._channel;
@@ -1005,9 +1098,11 @@ var ThreadImpl = class _ThreadImpl {
   get messages() {
     const adapter = this.adapter;
     const threadId = this.id;
+    const messageHistory = this._messageHistory;
     return {
       async *[Symbol.asyncIterator]() {
         let cursor;
+        let yieldedAny = false;
         while (true) {
           const result = await adapter.fetchMessages(threadId, {
             cursor,
@@ -1015,6 +1110,7 @@ var ThreadImpl = class _ThreadImpl {
           });
           const reversed = [...result.messages].reverse();
           for (const message of reversed) {
+            yieldedAny = true;
             yield message;
           }
           if (!result.nextCursor || result.messages.length === 0) {
@@ -1022,15 +1118,23 @@ var ThreadImpl = class _ThreadImpl {
           }
           cursor = result.nextCursor;
         }
+        if (!yieldedAny && messageHistory) {
+          const cached = await messageHistory.getMessages(threadId);
+          for (let i = cached.length - 1; i >= 0; i--) {
+            yield cached[i];
+          }
+        }
       }
     };
   }
   get allMessages() {
     const adapter = this.adapter;
     const threadId = this.id;
+    const messageHistory = this._messageHistory;
     return {
       async *[Symbol.asyncIterator]() {
         let cursor;
+        let yieldedAny = false;
         while (true) {
           const result = await adapter.fetchMessages(threadId, {
             limit: 100,
@@ -1038,6 +1142,7 @@ var ThreadImpl = class _ThreadImpl {
             direction: "forward"
           });
           for (const message of result.messages) {
+            yieldedAny = true;
             yield message;
           }
           if (!result.nextCursor || result.messages.length === 0) {
@@ -1045,6 +1150,12 @@ var ThreadImpl = class _ThreadImpl {
           }
           cursor = result.nextCursor;
         }
+        if (!yieldedAny && messageHistory) {
+          const cached = await messageHistory.getMessages(threadId);
+          for (const message of cached) {
+            yield message;
+          }
+        }
       }
     };
   }
@@ -1081,6 +1192,9 @@ var ThreadImpl = class _ThreadImpl {
       postable,
       rawMessage.threadId
     );
+    if (this._messageHistory) {
+      await this._messageHistory.append(this.id, new Message(result));
+    }
     return result;
   }
   async postEphemeral(user, message, options) {
@@ -1114,6 +1228,25 @@ var ThreadImpl = class _ThreadImpl {
     }
     return null;
   }
+  async schedule(message, options) {
+    let postable;
+    if (isJSX(message)) {
+      const card = toCardElement(message);
+      if (!card) {
+        throw new Error("Invalid JSX element: must be a Card element");
+      }
+      postable = card;
+    } else {
+      postable = message;
+    }
+    if (!this.adapter.scheduleMessage) {
+      throw new NotImplementedError(
+        "Scheduled messages are not supported by this adapter",
+        "scheduling"
+      );
+    }
+    return this.adapter.scheduleMessage(this.id, postable, options);
+  }
   /**
    * Handle streaming from an AsyncIterable.
    * Normalizes the stream (supports both textStream and fullStream from AI SDK),
@@ -1149,11 +1282,15 @@ var ThreadImpl = class _ThreadImpl {
         }
       };
       const raw = await this.adapter.stream(this.id, wrappedStream, options);
-      return this.createSentMessage(
+      const sent = this.createSentMessage(
         raw.id,
         { markdown: accumulated },
         raw.threadId
       );
+      if (this._messageHistory) {
+        await this._messageHistory.append(this.id, new Message(sent));
+      }
+      return sent;
     }
     const textOnlyStream = {
       [Symbol.asyncIterator]: () => {
@@ -1265,15 +1402,28 @@ var ThreadImpl = class _ThreadImpl {
         markdown: accumulated
       });
     }
-    return this.createSentMessage(
+    const sent = this.createSentMessage(
       msg.id,
       { markdown: accumulated },
       threadIdForEdits
     );
+    if (this._messageHistory) {
+      await this._messageHistory.append(this.id, new Message(sent));
+    }
+    return sent;
   }
   async refresh() {
     const result = await this.adapter.fetchMessages(this.id, { limit: 50 });
-    this._recentMessages = result.messages;
+    if (result.messages.length > 0) {
+      this._recentMessages = result.messages;
+    } else if (this._messageHistory) {
+      this._recentMessages = await this._messageHistory.getMessages(
+        this.id,
+        50
+      );
+    } else {
+      this._recentMessages = [];
+    }
   }
   mentionUser(userId) {
     return `<@${userId}>`;
@@ -1529,7 +1679,10 @@ var Chat = class {
   _streamingUpdateIntervalMs;
   _fallbackStreamingPlaceholderText;
   _dedupeTtlMs;
+  _onLockConflict;
+  _messageHistory;
   mentionHandlers = [];
+  directMessageHandlers = [];
   messagePatterns = [];
   subscribedMessageHandlers = [];
   reactionHandlers = [];
@@ -1557,6 +1710,11 @@ var Chat = class {
     this._streamingUpdateIntervalMs = config.streamingUpdateIntervalMs ?? 500;
     this._fallbackStreamingPlaceholderText = config.fallbackStreamingPlaceholderText !== void 0 ? config.fallbackStreamingPlaceholderText : "...";
     this._dedupeTtlMs = config.dedupeTtlMs ?? DEDUPE_TTL_MS;
+    this._onLockConflict = config.onLockConflict;
+    this._messageHistory = new MessageHistoryCache(
+      this._stateAdapter,
+      config.messageHistory
+    );
     if (typeof config.logger === "string") {
       this.logger = new ConsoleLogger(config.logger);
     } else {
@@ -1663,6 +1821,27 @@ var Chat = class {
     this.mentionHandlers.push(handler);
     this.logger.debug("Registered mention handler");
   }
+  /**
+   * 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.
+   *
+   * @param handler - Handler called for DM messages
+   *
+   * @example
+   * ```typescript
+   * chat.onDirectMessage(async (thread, message) => {
+   *   await thread.subscribe();
+   *   await thread.post("Thanks for the DM!");
+   * });
+   * ```
+   */
+  onDirectMessage(handler) {
+    this.directMessageHandlers.push(handler);
+    this.logger.debug("Registered direct message handler");
+  }
   /**
    * Register a handler for messages matching a regex pattern.
    *
@@ -2489,15 +2668,34 @@ var Chat = class {
       });
       return;
     }
-    const lock = await this._stateAdapter.acquireLock(
+    if (adapter.persistMessageHistory) {
+      const channelId = adapter.channelIdFromThreadId(threadId);
+      const appends = [this._messageHistory.append(threadId, message)];
+      if (channelId !== threadId) {
+        appends.push(this._messageHistory.append(channelId, message));
+      }
+      await Promise.all(appends);
+    }
+    let lock = await this._stateAdapter.acquireLock(
       threadId,
       DEFAULT_LOCK_TTL_MS
     );
     if (!lock) {
-      this.logger.warn("Could not acquire lock on thread", { threadId });
-      throw new LockError(
-        `Could not acquire lock on thread ${threadId}. Another instance may be processing.`
-      );
+      const resolution = typeof this._onLockConflict === "function" ? await this._onLockConflict(threadId, message) : this._onLockConflict ?? "drop";
+      if (resolution === "force") {
+        this.logger.info("Force-releasing lock on thread", { threadId });
+        await this._stateAdapter.forceReleaseLock(threadId);
+        lock = await this._stateAdapter.acquireLock(
+          threadId,
+          DEFAULT_LOCK_TTL_MS
+        );
+      }
+      if (!lock) {
+        this.logger.warn("Could not acquire lock on thread", { threadId });
+        throw new LockError(
+          `Could not acquire lock on thread ${threadId}. Another instance may be processing.`
+        );
+      }
     }
     this.logger.debug("Lock acquired", { threadId, token: lock.token });
     try {
@@ -2514,6 +2712,21 @@ var Chat = class {
         message,
         isSubscribed
       );
+      const isDM = adapter.isDM?.(threadId) ?? false;
+      if (isDM && this.directMessageHandlers.length > 0) {
+        this.logger.debug("Direct message received - calling handlers", {
+          threadId,
+          handlerCount: this.directMessageHandlers.length
+        });
+        const channel = thread.channel;
+        for (const handler of this.directMessageHandlers) {
+          await handler(thread, message, channel);
+        }
+        return;
+      }
+      if (isDM) {
+        message.isMention = true;
+      }
       if (isSubscribed) {
         this.logger.debug("Message in subscribed thread - calling handlers", {
           threadId,
@@ -2576,7 +2789,8 @@ var Chat = class {
       isDM,
       currentMessage: initialMessage,
       streamingUpdateIntervalMs: this._streamingUpdateIntervalMs,
-      fallbackStreamingPlaceholderText: this._fallbackStreamingPlaceholderText
+      fallbackStreamingPlaceholderText: this._fallbackStreamingPlaceholderText,
+      messageHistory: adapter.persistMessageHistory ? this._messageHistory : void 0
     });
   }
   /**
@@ -2875,6 +3089,8 @@ function convertEmojiPlaceholders(text2, platform, resolver = defaultEmojiResolv
         return resolver.toGChat(emojiName);
       case "linear":
         return resolver.toGChat(emojiName);
+      case "whatsapp":
+        return resolver.toGChat(emojiName);
       default:
         return resolver.toGChat(emojiName);
     }
@@ -3054,6 +3270,7 @@ export {
   LinkButton2 as LinkButton,
   LockError,
   Message,
+  MessageHistoryCache,
   Modal2 as Modal,
   NotImplementedError,
   RadioSelect2 as RadioSelect,
@@ -3110,6 +3327,7 @@ export {
   tableElementToAscii,
   tableToAscii,
   text,
+  toAiMessages,
   toCardElement2 as toCardElement,
   toModalElement2 as toModalElement,
   toPlainText,