chat 4.25.0 → 4.27.0

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-AN7MRAVW.js";
 
 // src/ai.ts
 var TEXT_MIME_PREFIXES = [
@@ -330,7 +331,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) => ({
@@ -729,7 +731,7 @@ var ChannelImpl = class _ChannelImpl {
     return {
       _type: "chat:Channel",
       id: this.id,
-      adapterName: this.adapter.name,
+      adapterName: this._adapterName ?? this.adapter.name,
       channelVisibility: this.channelVisibility,
       isDM: this.isDM
     };
@@ -1338,6 +1340,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 +1370,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;
     }
@@ -1444,13 +1469,14 @@ var ThreadImpl = class _ThreadImpl {
    * 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.
    */
-  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 = "";
@@ -1508,6 +1534,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);
   }
@@ -1541,7 +1592,7 @@ var ThreadImpl = class _ThreadImpl {
         return;
       }
       const content = renderer.render();
-      if (content !== lastEditContent) {
+      if (content.trim() && content !== lastEditContent) {
         try {
           await this.adapter.editMessage(threadIdForEdits, msg.id, {
             markdown: content
@@ -1563,12 +1614,14 @@ var ThreadImpl = class _ThreadImpl {
         renderer.push(chunk);
         if (!msg) {
           const content = renderer.render();
-          msg = await this.adapter.postMessage(this.id, {
-            markdown: content
-          });
-          threadIdForEdits = msg.threadId || this.id;
-          lastEditContent = content;
-          scheduleNextEdit();
+          if (content.trim()) {
+            msg = await this.adapter.postMessage(this.id, {
+              markdown: content
+            });
+            threadIdForEdits = msg.threadId || this.id;
+            lastEditContent = content;
+            scheduleNextEdit();
+          }
         }
       }
     } finally {
@@ -1585,12 +1638,12 @@ var ThreadImpl = class _ThreadImpl {
     const finalContent = renderer.finish();
     if (!msg) {
       msg = await this.adapter.postMessage(this.id, {
-        markdown: accumulated
+        markdown: accumulated.trim() ? accumulated : " "
       });
       threadIdForEdits = msg.threadId || this.id;
       lastEditContent = accumulated;
     }
-    if (finalContent !== lastEditContent) {
+    if (finalContent.trim() && finalContent !== lastEditContent) {
       await this.adapter.editMessage(threadIdForEdits, msg.id, {
         markdown: accumulated
       });
@@ -1642,7 +1695,7 @@ var ThreadImpl = class _ThreadImpl {
       channelVisibility: this.channelVisibility,
       currentMessage: this._currentMessage?.toJSON(),
       isDM: this.isDM,
-      adapterName: this.adapter.name
+      adapterName: this._adapterName ?? this.adapter.name
     };
   }
   /**
@@ -1832,13 +1885,32 @@ function extractMessageContent2(message) {
   throw new Error("Invalid PostableMessage format");
 }
 
+// src/reviver.ts
+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:Channel") {
+      return ChannelImpl.fromJSON(value);
+    }
+    if (typed._type === "chat:Message") {
+      return Message.fromJSON(value);
+    }
+  }
+  return value;
+}
+
 // 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 {
@@ -1883,6 +1955,7 @@ var Chat = class {
   _messageHistory;
   _concurrencyStrategy;
   _concurrencyConfig;
+  _concurrentSlots = /* @__PURE__ */ new Map();
   _lockScope;
   mentionHandlers = [];
   directMessageHandlers = [];
@@ -1890,6 +1963,7 @@ var Chat = class {
   subscribedMessageHandlers = [];
   reactionHandlers = [];
   actionHandlers = [];
+  optionsLoadHandlers = [];
   modalSubmitHandlers = [];
   modalCloseHandlers = [];
   slashCommandHandlers = [];
@@ -1915,6 +1989,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") {
@@ -1927,6 +2006,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,
@@ -1950,11 +2039,6 @@ var Chat = class {
       this._stateAdapter,
       config.messageHistory
     );
-    if (typeof config.logger === "string") {
-      this.logger = new ConsoleLogger(config.logger);
-    } else {
-      this.logger = config.logger || new ConsoleLogger("info");
-    }
     const webhooks = {};
     for (const [name, adapter] of Object.entries(config.adapters)) {
       this.adapters.set(name, adapter);
@@ -2161,6 +2245,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({
@@ -2248,21 +2345,7 @@ var Chat = class {
    */
   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:Channel") {
-          return ChannelImpl.fromJSON(value);
-        }
-        if (typed._type === "chat:Message") {
-          return Message.fromJSON(value);
-        }
-      }
-      return value;
-    };
+    return reviver;
   }
   // ChatInstance interface implementations
   /**
@@ -2314,6 +2397,29 @@ var Chat = class {
     }
     return task;
   }
+  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 { relatedThread, relatedMessage, relatedChannel } = await this.retrieveModalContext(event.adapter.name, contextId);
     const fullEvent = {
@@ -2813,6 +2919,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.
    *
@@ -2860,6 +2993,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.
    */
@@ -2876,20 +3040,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"
     );
   }
@@ -3111,7 +3299,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,
@@ -3150,7 +3338,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 {
@@ -3185,10 +3373,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
@@ -3333,35 +3561,44 @@ 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) {
       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 ?? []
+      });
+    }
+    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) {
@@ -3489,13 +3726,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;
     }
@@ -3584,6 +3825,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) {
@@ -3994,6 +4267,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;
@@ -4013,6 +4287,7 @@ export {
   DEFAULT_EMOJI_MAP,
   Divider2 as Divider,
   EmojiResolver,
+  ExternalSelect2 as ExternalSelect,
   Field2 as Field,
   Fields2 as Fields,
   Image2 as Image,
@@ -4029,6 +4304,7 @@ export {
   Select2 as Select,
   SelectOption2 as SelectOption,
   StreamingMarkdownRenderer,
+  StreamingPlan,
   THREAD_STATE_TTL_MS,
   Table2 as Table,
   TextInput2 as TextInput,
@@ -4071,6 +4347,7 @@ export {
   markdownToPlainText,
   paragraph,
   parseMarkdown,
+  reviver,
   root,
   strikethrough,
   stringifyMarkdown,