chat 4.4.0 → 4.5.0

package/dist/index.js

@@ -22,6 +22,153 @@ import {
   toModalElement
 } from "./chunk-VJ2RPXCK.js";
 
+// src/chat-singleton.ts
+var _singleton = null;
+function setChatSingleton(chat) {
+  _singleton = chat;
+}
+function getChatSingleton() {
+  if (!_singleton) {
+    throw new Error(
+      "No Chat singleton registered. Call chat.registerSingleton() first."
+    );
+  }
+  return _singleton;
+}
+function hasChatSingleton() {
+  return _singleton !== null;
+}
+
+// src/message.ts
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from "@workflow/serde";
+var Message = class _Message {
+  /** Unique message ID */
+  id;
+  /** Thread this message belongs to */
+  threadId;
+  /** Plain text content (all formatting stripped) */
+  text;
+  /**
+   * Structured formatting as an AST (mdast Root).
+   * This is the canonical representation - use this for processing.
+   * Use `stringifyMarkdown(message.formatted)` to get markdown string.
+   */
+  formatted;
+  /** Platform-specific raw payload (escape hatch) */
+  raw;
+  /** Message author */
+  author;
+  /** Message metadata */
+  metadata;
+  /** Attachments */
+  attachments;
+  /**
+   * Whether the bot is @-mentioned in this message.
+   *
+   * This is set by the Chat SDK before passing the message to handlers.
+   * It checks for `@username` in the message text using the adapter's
+   * configured `userName` and optional `botUserId`.
+   *
+   * @example
+   * ```typescript
+   * chat.onSubscribedMessage(async (thread, message) => {
+   *   if (message.isMention) {
+   *     await thread.post("You mentioned me!");
+   *   }
+   * });
+   * ```
+   */
+  isMention;
+  constructor(data) {
+    this.id = data.id;
+    this.threadId = data.threadId;
+    this.text = data.text;
+    this.formatted = data.formatted;
+    this.raw = data.raw;
+    this.author = data.author;
+    this.metadata = data.metadata;
+    this.attachments = data.attachments;
+    this.isMention = data.isMention;
+  }
+  /**
+   * Serialize the message to a plain JSON object.
+   * Use this to pass message data to external systems like workflow engines.
+   *
+   * Note: Attachment `data` (Buffer) and `fetchData` (function) are omitted
+   * as they're not serializable.
+   */
+  toJSON() {
+    return {
+      _type: "chat:Message",
+      id: this.id,
+      threadId: this.threadId,
+      text: this.text,
+      formatted: this.formatted,
+      raw: this.raw,
+      author: {
+        userId: this.author.userId,
+        userName: this.author.userName,
+        fullName: this.author.fullName,
+        isBot: this.author.isBot,
+        isMe: this.author.isMe
+      },
+      metadata: {
+        dateSent: this.metadata.dateSent.toISOString(),
+        edited: this.metadata.edited,
+        editedAt: this.metadata.editedAt?.toISOString()
+      },
+      attachments: this.attachments.map((att) => ({
+        type: att.type,
+        url: att.url,
+        name: att.name,
+        mimeType: att.mimeType,
+        size: att.size,
+        width: att.width,
+        height: att.height
+      })),
+      isMention: this.isMention
+    };
+  }
+  /**
+   * Reconstruct a Message from serialized JSON data.
+   * Converts ISO date strings back to Date objects.
+   */
+  static fromJSON(json) {
+    return new _Message({
+      id: json.id,
+      threadId: json.threadId,
+      text: json.text,
+      formatted: json.formatted,
+      raw: json.raw,
+      author: json.author,
+      metadata: {
+        dateSent: new Date(json.metadata.dateSent),
+        edited: json.metadata.edited,
+        editedAt: json.metadata.editedAt ? new Date(json.metadata.editedAt) : void 0
+      },
+      attachments: json.attachments,
+      isMention: json.isMention
+    });
+  }
+  /**
+   * Serialize a Message instance for @workflow/serde.
+   * This static method is automatically called by workflow serialization.
+   */
+  static [WORKFLOW_SERIALIZE](instance) {
+    return instance.toJSON();
+  }
+  /**
+   * Deserialize a Message from @workflow/serde.
+   * This static method is automatically called by workflow deserialization.
+   */
+  static [WORKFLOW_DESERIALIZE](data) {
+    return _Message.fromJSON(data);
+  }
+};
+
+// src/thread.ts
+import { WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2, WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2 } from "@workflow/serde";
+
 // src/markdown.ts
 import { toString } from "mdast-util-to-string";
 import remarkGfm from "remark-gfm";
@@ -301,16 +448,23 @@ var ConsoleLogger = class _ConsoleLogger {
 var THREAD_STATE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 
 // src/thread.ts
+function isLazyConfig(config) {
+  return "adapterName" in config && !("adapter" in config);
+}
 var THREAD_STATE_KEY_PREFIX = "thread-state:";
 function isAsyncIterable(value) {
   return value !== null && typeof value === "object" && Symbol.asyncIterator in value;
 }
-var ThreadImpl = class {
+var ThreadImpl = class _ThreadImpl {
   id;
-  adapter;
   channelId;
   isDM;
-  _stateAdapter;
+  /** Direct adapter instance (if provided) */
+  _adapter;
+  /** Adapter name for lazy resolution */
+  _adapterName;
+  /** Direct state adapter instance (if provided) */
+  _stateAdapterInstance;
   _recentMessages = [];
   _isSubscribedContext;
   /** Current message context for streaming - provides userId/teamId */
@@ -319,17 +473,54 @@ var ThreadImpl = class {
   _streamingUpdateIntervalMs;
   constructor(config) {
     this.id = config.id;
-    this.adapter = config.adapter;
     this.channelId = config.channelId;
     this.isDM = config.isDM ?? false;
-    this._stateAdapter = config.stateAdapter;
     this._isSubscribedContext = config.isSubscribedContext ?? false;
     this._currentMessage = config.currentMessage;
     this._streamingUpdateIntervalMs = config.streamingUpdateIntervalMs ?? 500;
+    if (isLazyConfig(config)) {
+      this._adapterName = config.adapterName;
+    } else {
+      this._adapter = config.adapter;
+      this._stateAdapterInstance = config.stateAdapter;
+    }
     if (config.initialMessage) {
       this._recentMessages = [config.initialMessage];
     }
   }
+  /**
+   * Get the adapter for this thread.
+   * If created with lazy config, resolves from Chat singleton on first access.
+   */
+  get adapter() {
+    if (this._adapter) {
+      return this._adapter;
+    }
+    if (!this._adapterName) {
+      throw new Error("Thread has no adapter configured");
+    }
+    const chat = getChatSingleton();
+    const adapter = chat.getAdapter(this._adapterName);
+    if (!adapter) {
+      throw new Error(
+        `Adapter "${this._adapterName}" not found in Chat singleton`
+      );
+    }
+    this._adapter = adapter;
+    return adapter;
+  }
+  /**
+   * Get the state adapter for this thread.
+   * If created with lazy config, resolves from Chat singleton on first access.
+   */
+  get _stateAdapter() {
+    if (this._stateAdapterInstance) {
+      return this._stateAdapterInstance;
+    }
+    const chat = getChatSingleton();
+    this._stateAdapterInstance = chat.getState();
+    return this._stateAdapterInstance;
+  }
   get recentMessages() {
     return this._recentMessages;
   }
@@ -412,6 +603,37 @@ var ThreadImpl = class {
     const rawMessage = await this.adapter.postMessage(this.id, postable);
     return this.createSentMessage(rawMessage.id, postable, rawMessage.threadId);
   }
+  async postEphemeral(user, message, options) {
+    const { fallbackToDM } = options;
+    const userId = typeof user === "string" ? user : user.userId;
+    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.postEphemeral) {
+      return this.adapter.postEphemeral(this.id, userId, postable);
+    }
+    if (!fallbackToDM) {
+      return null;
+    }
+    if (this.adapter.openDM) {
+      const dmThreadId = await this.adapter.openDM(userId);
+      const result = await this.adapter.postMessage(dmThreadId, postable);
+      return {
+        id: result.id,
+        threadId: dmThreadId,
+        usedFallback: true,
+        raw: result.raw
+      };
+    }
+    return null;
+  }
   /**
    * Handle streaming from an AsyncIterable.
    * Uses adapter's native streaming if available, otherwise falls back to post+edit.
@@ -507,6 +729,65 @@ var ThreadImpl = class {
   mentionUser(userId) {
     return `<@${userId}>`;
   }
+  /**
+   * Serialize the thread to a plain JSON object.
+   * Use this to pass thread data to external systems like workflow engines.
+   *
+   * @example
+   * ```typescript
+   * // Pass to a workflow
+   * await workflow.start("my-workflow", {
+   *   thread: thread.toJSON(),
+   *   message: serializeMessage(message),
+   * });
+   * ```
+   */
+  toJSON() {
+    return {
+      _type: "chat:Thread",
+      id: this.id,
+      channelId: this.channelId,
+      isDM: this.isDM,
+      adapterName: this.adapter.name
+    };
+  }
+  /**
+   * Reconstruct a Thread from serialized JSON data.
+   *
+   * Reconstructs a ThreadImpl from serialized data.
+   * Uses lazy resolution from Chat.getSingleton() for adapter and state.
+   *
+   * @param json - Serialized thread data
+   * @requires Call `chat.registerSingleton()` before deserializing threads
+   *
+   * @example
+   * ```typescript
+   * const thread = ThreadImpl.fromJSON(serializedThread);
+   * ```
+   */
+  static fromJSON(json) {
+    return new _ThreadImpl({
+      id: json.id,
+      adapterName: json.adapterName,
+      channelId: json.channelId,
+      isDM: json.isDM
+    });
+  }
+  /**
+   * Serialize a ThreadImpl instance for @workflow/serde.
+   * This static method is automatically called by workflow serialization.
+   */
+  static [WORKFLOW_SERIALIZE2](instance) {
+    return instance.toJSON();
+  }
+  /**
+   * Deserialize a ThreadImpl from @workflow/serde.
+   * Uses lazy adapter resolution from Chat.getSingleton().
+   * Requires chat.registerSingleton() to have been called.
+   */
+  static [WORKFLOW_DESERIALIZE2](data) {
+    return _ThreadImpl.fromJSON(data);
+  }
   createSentMessage(messageId, postable, threadIdOverride) {
     const adapter = this.adapter;
     const threadId = threadIdOverride || this.id;
@@ -531,6 +812,9 @@ var ThreadImpl = class {
         edited: false
       },
       attachments,
+      toJSON() {
+        return new Message(this).toJSON();
+      },
       async edit(newContent) {
         let postable2 = newContent;
         if (isJSX(newContent)) {
@@ -609,6 +893,36 @@ function extractMessageContent(message) {
 var DEFAULT_LOCK_TTL_MS = 3e4;
 var DEDUPE_TTL_MS = 6e4;
 var Chat = class {
+  /**
+   * Register this Chat instance as the global singleton.
+   * Required for Thread deserialization via @workflow/serde.
+   *
+   * @example
+   * ```typescript
+   * const chat = new Chat({ ... });
+   * chat.registerSingleton();
+   *
+   * // Now threads can be deserialized without passing chat explicitly
+   * const thread = ThreadImpl.fromJSON(serializedThread);
+   * ```
+   */
+  registerSingleton() {
+    setChatSingleton(this);
+    return this;
+  }
+  /**
+   * Get the registered singleton Chat instance.
+   * Throws if no singleton has been registered.
+   */
+  static getSingleton() {
+    return getChatSingleton();
+  }
+  /**
+   * Check if a singleton has been registered.
+   */
+  static hasSingleton() {
+    return hasChatSingleton();
+  }
   adapters;
   _stateAdapter;
   userName;
@@ -841,6 +1155,40 @@ var Chat = class {
   getAdapter(name) {
     return this.adapters.get(name);
   }
+  /**
+   * Get a JSON.parse reviver function that automatically deserializes
+   * chat:Thread and chat:Message objects.
+   *
+   * Use this when parsing JSON that contains serialized Thread or Message objects
+   * (e.g., from workflow engine payloads).
+   *
+   * @returns A reviver function for JSON.parse
+   *
+   * @example
+   * ```typescript
+   * // Parse workflow payload with automatic deserialization
+   * const data = JSON.parse(payload, chat.reviver());
+   *
+   * // data.thread is now a ThreadImpl instance
+   * // data.message is now a Message object with Date fields restored
+   * await data.thread.post("Hello from workflow!");
+   * ```
+   */
+  reviver() {
+    this.registerSingleton();
+    return function reviver(_key, value) {
+      if (value && typeof value === "object" && "_type" in value) {
+        const typed = value;
+        if (typed._type === "chat:Thread") {
+          return ThreadImpl.fromJSON(value);
+        }
+        if (typed._type === "chat:Message") {
+          return Message.fromJSON(value);
+        }
+      }
+      return value;
+    };
+  }
   // ChatInstance interface implementations
   /**
    * Process an incoming message from an adapter.
@@ -1728,6 +2076,7 @@ export {
   Fields2 as Fields,
   Image2 as Image,
   LockError,
+  Message,
   Modal2 as Modal,
   NotImplementedError,
   RateLimitError,