chat 4.19.0 → 4.20.1

package/dist/index.js

@@ -59,7 +59,132 @@ import {
   toModalElement,
   toPlainText,
   walkAst
-} from "./chunk-WAB7KMH4.js";
+} from "./chunk-JW7GYSMH.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)
+  );
+}
+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
+        };
+      } catch (error) {
+        console.error("toAiMessages: failed to fetch image data", error);
+        return null;
+      }
+    }
+    return null;
+  }
+  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 null;
+  }
+  return null;
+}
+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.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 };
+    })
+  );
+  return results.filter(
+    (r) => r.result != null
+  ).map((r) => r.result);
+}
 
 // src/channel.ts
 import { WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2, WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2 } from "@workflow/serde";
@@ -81,6 +206,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 {
@@ -121,6 +282,8 @@ var Message = class _Message {
    * ```
    */
   isMention;
+  /** Links found in the message */
+  links;
   constructor(data) {
     this.id = data.id;
     this.threadId = data.threadId;
@@ -131,6 +294,7 @@ var Message = class _Message {
     this.metadata = data.metadata;
     this.attachments = data.attachments;
     this.isMention = data.isMention;
+    this.links = data.links ?? [];
   }
   /**
    * Serialize the message to a plain JSON object.
@@ -168,7 +332,14 @@ var Message = class _Message {
         width: att.width,
         height: att.height
       })),
-      isMention: this.isMention
+      isMention: this.isMention,
+      links: this.links.length > 0 ? this.links.map((link2) => ({
+        url: link2.url,
+        title: link2.title,
+        description: link2.description,
+        imageUrl: link2.imageUrl,
+        siteName: link2.siteName
+      })) : void 0
     };
   }
   /**
@@ -189,7 +360,8 @@ var Message = class _Message {
         editedAt: json.metadata.editedAt ? new Date(json.metadata.editedAt) : void 0
       },
       attachments: json.attachments,
-      isMention: json.isMention
+      isMention: json.isMention,
+      links: json.links
     });
   }
   /**
@@ -301,6 +473,7 @@ var ChannelImpl = class _ChannelImpl {
   _adapterName;
   _stateAdapterInstance;
   _name = null;
+  _messageHistory;
   constructor(config) {
     this.id = config.id;
     this.isDM = config.isDM ?? false;
@@ -309,6 +482,7 @@ var ChannelImpl = class _ChannelImpl {
     } else {
       this._adapter = config.adapter;
       this._stateAdapterInstance = config.stateAdapter;
+      this._messageHistory = config.messageHistory;
     }
   }
   get adapter() {
@@ -362,14 +536,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 +554,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 +605,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 +624,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;
@@ -545,6 +738,7 @@ var ChannelImpl = class _ChannelImpl {
         edited: false
       },
       attachments,
+      links: [],
       toJSON() {
         return new Message(this).toJSON();
       },
@@ -625,45 +819,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 {
@@ -917,12 +1115,16 @@ var ThreadImpl = class _ThreadImpl {
   _fallbackStreamingPlaceholderText;
   /** Cached channel instance */
   _channel;
+  /** Message history cache (set only for adapters with persistMessageHistory) */
+  _messageHistory;
+  _logger;
   constructor(config) {
     this.id = config.id;
     this.channelId = config.channelId;
     this.isDM = config.isDM ?? false;
     this._isSubscribedContext = config.isSubscribedContext ?? false;
     this._currentMessage = config.currentMessage;
+    this._logger = config.logger;
     this._streamingUpdateIntervalMs = config.streamingUpdateIntervalMs ?? 500;
     this._fallbackStreamingPlaceholderText = config.fallbackStreamingPlaceholderText !== void 0 ? config.fallbackStreamingPlaceholderText : "...";
     if (isLazyConfig2(config)) {
@@ -930,6 +1132,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];
@@ -1008,7 +1211,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;
@@ -1020,9 +1224,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,
@@ -1030,6 +1236,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) {
@@ -1037,15 +1244,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,
@@ -1053,6 +1268,7 @@ var ThreadImpl = class _ThreadImpl {
             direction: "forward"
           });
           for (const message of result.messages) {
+            yieldedAny = true;
             yield message;
           }
           if (!result.nextCursor || result.messages.length === 0) {
@@ -1060,6 +1276,12 @@ var ThreadImpl = class _ThreadImpl {
           }
           cursor = result.nextCursor;
         }
+        if (!yieldedAny && messageHistory) {
+          const cached = await messageHistory.getMessages(threadId);
+          for (const message of cached) {
+            yield message;
+          }
+        }
       }
     };
   }
@@ -1096,6 +1318,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) {
@@ -1183,11 +1408,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]: () => {
@@ -1252,7 +1481,8 @@ var ThreadImpl = class _ThreadImpl {
             markdown: content
           });
           lastEditContent = content;
-        } catch {
+        } catch (error) {
+          this._logger?.warn("fallbackStream edit failed", error);
         }
       }
       if (!stopped) {
@@ -1299,15 +1529,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}>`;
@@ -1389,6 +1632,7 @@ var ThreadImpl = class _ThreadImpl {
       formatted,
       raw: null,
       // Will be populated if needed
+      links: [],
       author: {
         userId: "self",
         userName: adapter.userName,
@@ -1442,6 +1686,7 @@ var ThreadImpl = class _ThreadImpl {
       author: message.author,
       metadata: message.metadata,
       attachments: message.attachments,
+      links: message.links,
       isMention: message.isMention,
       toJSON() {
         return message.toJSON();
@@ -1564,7 +1809,9 @@ var Chat = class {
   _fallbackStreamingPlaceholderText;
   _dedupeTtlMs;
   _onLockConflict;
+  _messageHistory;
   mentionHandlers = [];
+  directMessageHandlers = [];
   messagePatterns = [];
   subscribedMessageHandlers = [];
   reactionHandlers = [];
@@ -1593,6 +1840,10 @@ var Chat = class {
     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 {
@@ -1699,6 +1950,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.
    *
@@ -2525,6 +2797,14 @@ var Chat = class {
       });
       return;
     }
+    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
@@ -2561,6 +2841,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,
@@ -2622,8 +2917,10 @@ var Chat = class {
       isSubscribedContext,
       isDM,
       currentMessage: initialMessage,
+      logger: this.logger,
       streamingUpdateIntervalMs: this._streamingUpdateIntervalMs,
-      fallbackStreamingPlaceholderText: this._fallbackStreamingPlaceholderText
+      fallbackStreamingPlaceholderText: this._fallbackStreamingPlaceholderText,
+      messageHistory: adapter.persistMessageHistory ? this._messageHistory : void 0
     });
   }
   /**
@@ -2922,6 +3219,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);
     }
@@ -3101,6 +3400,7 @@ export {
   LinkButton2 as LinkButton,
   LockError,
   Message,
+  MessageHistoryCache,
   Modal2 as Modal,
   NotImplementedError,
   RadioSelect2 as RadioSelect,
@@ -3157,6 +3457,7 @@ export {
   tableElementToAscii,
   tableToAscii,
   text,
+  toAiMessages,
   toCardElement2 as toCardElement,
   toModalElement2 as toModalElement,
   toPlainText,