chat 4.0.1 → 4.1.0

package/dist/index.js

@@ -163,22 +163,97 @@ var BaseFormatConverter = class {
   }
 };
 
+// src/types.ts
+var ConsoleLogger = class _ConsoleLogger {
+  constructor(level = "info", prefix = "chat-sdk") {
+    this.level = level;
+    this.prefix = prefix;
+  }
+  prefix;
+  shouldLog(level) {
+    const levels = ["debug", "info", "warn", "error", "silent"];
+    return levels.indexOf(level) >= levels.indexOf(this.level);
+  }
+  child(prefix) {
+    return new _ConsoleLogger(this.level, `${this.prefix}:${prefix}`);
+  }
+  // eslint-disable-next-line no-console
+  debug(message, ...args) {
+    if (this.shouldLog("debug"))
+      console.debug(`[${this.prefix}] ${message}`, ...args);
+  }
+  // eslint-disable-next-line no-console
+  info(message, ...args) {
+    if (this.shouldLog("info"))
+      console.info(`[${this.prefix}] ${message}`, ...args);
+  }
+  // eslint-disable-next-line no-console
+  warn(message, ...args) {
+    if (this.shouldLog("warn"))
+      console.warn(`[${this.prefix}] ${message}`, ...args);
+  }
+  // eslint-disable-next-line no-console
+  error(message, ...args) {
+    if (this.shouldLog("error"))
+      console.error(`[${this.prefix}] ${message}`, ...args);
+  }
+};
+var THREAD_STATE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+var ChatError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "ChatError";
+  }
+};
+var RateLimitError = class extends ChatError {
+  constructor(message, retryAfterMs, cause) {
+    super(message, "RATE_LIMITED", cause);
+    this.retryAfterMs = retryAfterMs;
+    this.name = "RateLimitError";
+  }
+};
+var LockError = class extends ChatError {
+  constructor(message, cause) {
+    super(message, "LOCK_FAILED", cause);
+    this.name = "LockError";
+  }
+};
+var NotImplementedError = class extends ChatError {
+  constructor(message, feature, cause) {
+    super(message, "NOT_IMPLEMENTED", cause);
+    this.feature = feature;
+    this.name = "NotImplementedError";
+  }
+};
+
 // src/thread.ts
+var THREAD_STATE_KEY_PREFIX = "thread-state:";
+function isAsyncIterable(value) {
+  return value !== null && typeof value === "object" && Symbol.asyncIterator in value;
+}
 var ThreadImpl = class {
   id;
   adapter;
   channelId;
   isDM;
-  state;
+  _stateAdapter;
   _recentMessages = [];
   _isSubscribedContext;
+  /** Current message context for streaming - provides userId/teamId */
+  _currentMessage;
+  /** Update interval for fallback streaming */
+  _streamingUpdateIntervalMs;
   constructor(config) {
     this.id = config.id;
     this.adapter = config.adapter;
     this.channelId = config.channelId;
     this.isDM = config.isDM ?? false;
-    this.state = config.state;
+    this._stateAdapter = config.stateAdapter;
     this._isSubscribedContext = config.isSubscribedContext ?? false;
+    this._currentMessage = config.currentMessage;
+    this._streamingUpdateIntervalMs = config.streamingUpdateIntervalMs ?? 500;
     if (config.initialMessage) {
       this._recentMessages = [config.initialMessage];
     }
@@ -189,6 +264,29 @@ var ThreadImpl = class {
   set recentMessages(messages) {
     this._recentMessages = messages;
   }
+  /**
+   * Get the current thread state.
+   * Returns null if no state has been set.
+   */
+  get state() {
+    return this._stateAdapter.get(
+      `${THREAD_STATE_KEY_PREFIX}${this.id}`
+    );
+  }
+  /**
+   * Set the thread state. Merges with existing state by default.
+   * State is persisted for 30 days.
+   */
+  async setState(newState, options) {
+    const key = `${THREAD_STATE_KEY_PREFIX}${this.id}`;
+    if (options?.replace) {
+      await this._stateAdapter.set(key, newState, THREAD_STATE_TTL_MS);
+    } else {
+      const existing = await this._stateAdapter.get(key);
+      const merged = { ...existing, ...newState };
+      await this._stateAdapter.set(key, merged, THREAD_STATE_TTL_MS);
+    }
+  }
   get allMessages() {
     const adapter = this.adapter;
     const threadId = this.id;
@@ -220,18 +318,21 @@ var ThreadImpl = class {
     if (this._isSubscribedContext) {
       return true;
     }
-    return this.state.isSubscribed(this.id);
+    return this._stateAdapter.isSubscribed(this.id);
   }
   async subscribe() {
-    await this.state.subscribe(this.id);
+    await this._stateAdapter.subscribe(this.id);
     if (this.adapter.onThreadSubscribe) {
       await this.adapter.onThreadSubscribe(this.id);
     }
   }
   async unsubscribe() {
-    await this.state.unsubscribe(this.id);
+    await this._stateAdapter.unsubscribe(this.id);
   }
   async post(message) {
+    if (isAsyncIterable(message)) {
+      return this.handleStream(message);
+    }
     let postable = message;
     if (isJSX(message)) {
       const card = toCardElement(message);
@@ -243,9 +344,93 @@ var ThreadImpl = class {
     const rawMessage = await this.adapter.postMessage(this.id, postable);
     return this.createSentMessage(rawMessage.id, postable);
   }
+  /**
+   * Handle streaming from an AsyncIterable.
+   * Uses adapter's native streaming if available, otherwise falls back to post+edit.
+   */
+  async handleStream(textStream) {
+    const options = {};
+    if (this._currentMessage) {
+      options.recipientUserId = this._currentMessage.author.userId;
+      const raw = this._currentMessage.raw;
+      options.recipientTeamId = raw?.team_id ?? raw?.team;
+    }
+    if (this.adapter.stream) {
+      let accumulated = "";
+      const wrappedStream = {
+        [Symbol.asyncIterator]: () => {
+          const iterator = textStream[Symbol.asyncIterator]();
+          return {
+            async next() {
+              const result = await iterator.next();
+              if (!result.done) {
+                accumulated += result.value;
+              }
+              return result;
+            }
+          };
+        }
+      };
+      const raw = await this.adapter.stream(this.id, wrappedStream, options);
+      return this.createSentMessage(raw.id, accumulated);
+    }
+    return this.fallbackStream(textStream, options);
+  }
   async startTyping() {
     await this.adapter.startTyping(this.id);
   }
+  /**
+   * Fallback streaming implementation using post + edit.
+   * Used when adapter doesn't support native streaming.
+   * Uses recursive setTimeout to send updates every intervalMs (default 500ms).
+   * Schedules next update only after current edit completes to avoid overwhelming slow services.
+   */
+  async fallbackStream(textStream, options) {
+    const intervalMs = options?.updateIntervalMs ?? this._streamingUpdateIntervalMs;
+    const msg = await this.adapter.postMessage(this.id, "...");
+    let accumulated = "";
+    let lastEditContent = "...";
+    let stopped = false;
+    let pendingEdit = null;
+    let timerId = null;
+    const doEditAndReschedule = async () => {
+      if (stopped) return;
+      if (accumulated !== lastEditContent) {
+        const content = accumulated;
+        try {
+          await this.adapter.editMessage(this.id, msg.id, content);
+          lastEditContent = content;
+        } catch {
+        }
+      }
+      if (!stopped) {
+        timerId = setTimeout(() => {
+          pendingEdit = doEditAndReschedule();
+        }, intervalMs);
+      }
+    };
+    timerId = setTimeout(() => {
+      pendingEdit = doEditAndReschedule();
+    }, intervalMs);
+    try {
+      for await (const chunk of textStream) {
+        accumulated += chunk;
+      }
+    } finally {
+      stopped = true;
+      if (timerId) {
+        clearTimeout(timerId);
+        timerId = null;
+      }
+    }
+    if (pendingEdit) {
+      await pendingEdit;
+    }
+    if (accumulated !== lastEditContent) {
+      await this.adapter.editMessage(this.id, msg.id, accumulated);
+    }
+    return this.createSentMessage(msg.id, accumulated);
+  }
   async refresh() {
     const messages = await this.adapter.fetchMessages(this.id, { limit: 50 });
     this._recentMessages = messages;
@@ -351,78 +536,15 @@ function extractMessageContent(message) {
   throw new Error("Invalid PostableMessage format");
 }
 
-// src/types.ts
-var ConsoleLogger = class _ConsoleLogger {
-  constructor(level = "info", prefix = "chat-sdk") {
-    this.level = level;
-    this.prefix = prefix;
-  }
-  prefix;
-  shouldLog(level) {
-    const levels = ["debug", "info", "warn", "error", "silent"];
-    return levels.indexOf(level) >= levels.indexOf(this.level);
-  }
-  child(prefix) {
-    return new _ConsoleLogger(this.level, `${this.prefix}:${prefix}`);
-  }
-  // eslint-disable-next-line no-console
-  debug(message, ...args) {
-    if (this.shouldLog("debug"))
-      console.debug(`[${this.prefix}] ${message}`, ...args);
-  }
-  // eslint-disable-next-line no-console
-  info(message, ...args) {
-    if (this.shouldLog("info"))
-      console.info(`[${this.prefix}] ${message}`, ...args);
-  }
-  // eslint-disable-next-line no-console
-  warn(message, ...args) {
-    if (this.shouldLog("warn"))
-      console.warn(`[${this.prefix}] ${message}`, ...args);
-  }
-  // eslint-disable-next-line no-console
-  error(message, ...args) {
-    if (this.shouldLog("error"))
-      console.error(`[${this.prefix}] ${message}`, ...args);
-  }
-};
-var ChatError = class extends Error {
-  constructor(message, code, cause) {
-    super(message);
-    this.code = code;
-    this.cause = cause;
-    this.name = "ChatError";
-  }
-};
-var RateLimitError = class extends ChatError {
-  constructor(message, retryAfterMs, cause) {
-    super(message, "RATE_LIMITED", cause);
-    this.retryAfterMs = retryAfterMs;
-    this.name = "RateLimitError";
-  }
-};
-var LockError = class extends ChatError {
-  constructor(message, cause) {
-    super(message, "LOCK_FAILED", cause);
-    this.name = "LockError";
-  }
-};
-var NotImplementedError = class extends ChatError {
-  constructor(message, feature, cause) {
-    super(message, "NOT_IMPLEMENTED", cause);
-    this.feature = feature;
-    this.name = "NotImplementedError";
-  }
-};
-
 // src/chat.ts
 var DEFAULT_LOCK_TTL_MS = 3e4;
 var DEDUPE_TTL_MS = 6e4;
 var Chat = class {
   adapters;
-  state;
+  _stateAdapter;
   userName;
   logger;
+  _streamingUpdateIntervalMs;
   mentionHandlers = [];
   messagePatterns = [];
   subscribedMessageHandlers = [];
@@ -439,8 +561,9 @@ var Chat = class {
   webhooks;
   constructor(config) {
     this.userName = config.userName;
-    this.state = config.state;
+    this._stateAdapter = config.state;
     this.adapters = /* @__PURE__ */ new Map();
+    this._streamingUpdateIntervalMs = config.streamingUpdateIntervalMs ?? 500;
     if (!config.logger) {
       this.logger = new ConsoleLogger("info");
     } else if (typeof config.logger === "string") {
@@ -485,7 +608,7 @@ var Chat = class {
   }
   async doInitialize() {
     this.logger.info("Initializing chat instance...");
-    await this.state.connect();
+    await this._stateAdapter.connect();
     this.logger.debug("State connected");
     const initPromises = Array.from(this.adapters.values()).map(
       async (adapter) => {
@@ -506,7 +629,7 @@ var Chat = class {
    */
   async shutdown() {
     this.logger.info("Shutting down chat instance...");
-    await this.state.disconnect();
+    await this._stateAdapter.disconnect();
     this.initialized = false;
     this.initPromise = null;
     this.logger.info("Chat instance shut down");
@@ -682,7 +805,7 @@ var Chat = class {
       });
       return;
     }
-    const isSubscribed = await this.state.isSubscribed(event.threadId);
+    const isSubscribed = await this._stateAdapter.isSubscribed(event.threadId);
     const thread = await this.createThread(
       event.adapter,
       event.threadId,
@@ -734,7 +857,7 @@ var Chat = class {
       this.logger.error("Reaction event missing adapter");
       return;
     }
-    const isSubscribed = await this.state.isSubscribed(event.threadId);
+    const isSubscribed = await this._stateAdapter.isSubscribed(event.threadId);
     const thread = await this.createThread(
       event.adapter,
       event.threadId,
@@ -776,7 +899,7 @@ var Chat = class {
     }
   }
   getState() {
-    return this.state;
+    return this._stateAdapter;
   }
   getUserName() {
     return this.userName;
@@ -876,7 +999,7 @@ var Chat = class {
       return;
     }
     const dedupeKey = `dedupe:${adapter.name}:${message.id}`;
-    const alreadyProcessed = await this.state.get(dedupeKey);
+    const alreadyProcessed = await this._stateAdapter.get(dedupeKey);
     if (alreadyProcessed) {
       this.logger.debug("Skipping duplicate message", {
         adapter: adapter.name,
@@ -884,8 +1007,11 @@ var Chat = class {
       });
       return;
     }
-    await this.state.set(dedupeKey, true, DEDUPE_TTL_MS);
-    const lock = await this.state.acquireLock(threadId, DEFAULT_LOCK_TTL_MS);
+    await this._stateAdapter.set(dedupeKey, true, DEDUPE_TTL_MS);
+    const 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(
@@ -895,7 +1021,7 @@ var Chat = class {
     this.logger.debug("Lock acquired", { threadId, token: lock.token });
     try {
       message.isMention = this.detectMention(adapter, message);
-      const isSubscribed = await this.state.isSubscribed(threadId);
+      const isSubscribed = await this._stateAdapter.isSubscribed(threadId);
       this.logger.debug("Subscription check", {
         threadId,
         isSubscribed,
@@ -951,7 +1077,7 @@ var Chat = class {
         });
       }
     } finally {
-      await this.state.releaseLock(lock);
+      await this._stateAdapter.releaseLock(lock);
       this.logger.debug("Lock released", { threadId });
     }
   }
@@ -963,10 +1089,12 @@ var Chat = class {
       id: threadId,
       adapter,
       channelId,
-      state: this.state,
+      stateAdapter: this._stateAdapter,
       initialMessage,
       isSubscribedContext,
-      isDM
+      isDM,
+      currentMessage: initialMessage,
+      streamingUpdateIntervalMs: this._streamingUpdateIntervalMs
     });
   }
   /**
@@ -1405,6 +1533,7 @@ export {
   NotImplementedError,
   RateLimitError,
   Section2 as Section,
+  THREAD_STATE_TTL_MS,
   blockquote,
   codeBlock,
   convertEmojiPlaceholders,