@theowlops/channelhub 1.0.0 → 1.1.0

package/dist/index.js

@@ -20519,9 +20519,9 @@ var require_websocket_server = __commonJS(function(exports, module) {
 });
 
 // node_modules/ws/wrapper.mjs
-var import_stream, import_extension, import_permessage_deflate, import_receiver, import_sender, import_subprotocol, import_websocket, import_websocket_server, wrapper_default;
+var import_stream2, import_extension, import_permessage_deflate, import_receiver, import_sender, import_subprotocol, import_websocket, import_websocket_server, wrapper_default;
 var init_wrapper = __esm(() => {
-  import_stream = __toESM(require_stream(), 1);
+  import_stream2 = __toESM(require_stream(), 1);
   import_extension = __toESM(require_extension(), 1);
   import_permessage_deflate = __toESM(require_permessage_deflate(), 1);
   import_receiver = __toESM(require_receiver(), 1);
@@ -37499,6 +37499,126 @@ class ChannelEventBus extends EventEmitter2 {
     return this.emit("status", status);
   }
 }
+// src/core/stream.ts
+class SmartStreamer {
+  adapter;
+  options;
+  constructor(adapter, options = {}) {
+    this.adapter = adapter;
+    this.options = {
+      editDebounceMs: 1000,
+      typingIntervalMs: 4000,
+      chunkMode: "sentence",
+      minSentenceLength: 60,
+      initialPlaceholder: "...",
+      ...options
+    };
+  }
+  async stream(chatId, tokenStream, sendOptions) {
+    let typingActive = true;
+    const triggerTyping = async () => {
+      if (this.adapter.sendTyping) {
+        try {
+          await this.adapter.sendTyping(chatId);
+        } catch {}
+      }
+    };
+    await triggerTyping();
+    const typingTimer = setInterval(() => {
+      if (typingActive)
+        triggerTyping();
+    }, this.options.typingIntervalMs);
+    try {
+      if (typeof this.adapter.editText === "function") {
+        return await this.streamWithEdit(chatId, tokenStream, sendOptions);
+      } else {
+        return await this.streamWithoutEdit(chatId, tokenStream, sendOptions);
+      }
+    } finally {
+      typingActive = false;
+      clearInterval(typingTimer);
+    }
+  }
+  async streamWithEdit(chatId, tokenStream, sendOptions) {
+    let accumulated = "";
+    let sentMsg = null;
+    let lastEditTime = 0;
+    let pendingEditTimeout = null;
+    const performEdit = async (text) => {
+      if (sentMsg && this.adapter.editText) {
+        await this.adapter.editText(chatId, sentMsg.messageId, text);
+        lastEditTime = Date.now();
+      }
+    };
+    for await (const chunk of tokenStream) {
+      accumulated += chunk;
+      if (!sentMsg) {
+        sentMsg = await this.adapter.sendText(chatId, accumulated.trim() || this.options.initialPlaceholder, sendOptions);
+        lastEditTime = Date.now();
+        continue;
+      }
+      const now = Date.now();
+      const elapsed = now - lastEditTime;
+      if (elapsed >= this.options.editDebounceMs) {
+        if (pendingEditTimeout) {
+          clearTimeout(pendingEditTimeout);
+          pendingEditTimeout = null;
+        }
+        await performEdit(accumulated);
+      } else if (!pendingEditTimeout) {
+        pendingEditTimeout = setTimeout(async () => {
+          pendingEditTimeout = null;
+          await performEdit(accumulated);
+        }, this.options.editDebounceMs - elapsed);
+      }
+    }
+    if (pendingEditTimeout) {
+      clearTimeout(pendingEditTimeout);
+      pendingEditTimeout = null;
+    }
+    if (sentMsg && accumulated) {
+      await performEdit(accumulated);
+      return [sentMsg];
+    } else if (!sentMsg && accumulated) {
+      const res = await this.adapter.sendText(chatId, accumulated, sendOptions);
+      return [res];
+    }
+    return sentMsg ? [sentMsg] : [];
+  }
+  async streamWithoutEdit(chatId, tokenStream, sendOptions) {
+    const results = [];
+    if (this.options.chunkMode === "accumulate") {
+      let accumulated = "";
+      for await (const chunk of tokenStream) {
+        accumulated += chunk;
+      }
+      if (accumulated.trim()) {
+        const res = await this.adapter.sendText(chatId, accumulated, sendOptions);
+        results.push(res);
+      }
+      return results;
+    }
+    let buffer = "";
+    const sentenceEndRegex = /[.?!;\n]\s*$/;
+    for await (const chunk of tokenStream) {
+      buffer += chunk;
+      if (buffer.length >= this.options.minSentenceLength && sentenceEndRegex.test(buffer.trimEnd())) {
+        const textToSend = buffer.trim();
+        if (textToSend) {
+          const res = await this.adapter.sendText(chatId, textToSend, sendOptions);
+          results.push(res);
+          buffer = "";
+        }
+      }
+    }
+    if (buffer.trim()) {
+      const res = await this.adapter.sendText(chatId, buffer.trim(), sendOptions);
+      results.push(res);
+    }
+    return results;
+  }
+}
+
 // src/core/context.ts
 function createMessageContext(message, channel) {
   return {
@@ -37516,6 +37636,17 @@ function createMessageContext(message, channel) {
       if (channel.addReaction) {
         await channel.addReaction(message.chat.id, message.id, emoji);
       }
+    },
+    sendTyping: async () => {
+      if (channel.sendTyping) {
+        await channel.sendTyping(message.chat.id);
+      }
+    },
+    stream: async (tokenStream, options) => {
+      const streamer = new SmartStreamer(channel, options);
+      return await streamer.stream(message.chat.id, tokenStream, {
+        replyToId: message.id
+      });
     }
   };
 }
@@ -37563,14 +37694,47 @@ class ChannelHub {
   }
 }
 // src/channels/zalo/adapter.ts
+var EMOJI_TO_ZALO = {
+  "❤️": "HEART",
+  "\uD83D\uDC96": "HEART",
+  "\uD83D\uDC4D": "LIKE",
+  "\uD83D\uDE06": "HAHA",
+  "\uD83D\uDE02": "TEARS_OF_JOY",
+  "\uD83D\uDE2E": "WOW",
+  "\uD83D\uDE2D": "CRY",
+  "\uD83D\uDE21": "ANGRY",
+  "\uD83D\uDE18": "KISS",
+  "\uD83D\uDCA9": "SHIT",
+  "\uD83C\uDF39": "ROSE",
+  "\uD83D\uDC94": "BROKEN_HEART",
+  "\uD83D\uDC4E": "DISLIKE",
+  "\uD83D\uDE0D": "LOVE",
+  "\uD83E\uDD14": "CONFUSED",
+  "\uD83D\uDE09": "WINK",
+  heart: "HEART",
+  like: "LIKE",
+  haha: "HAHA",
+  wow: "WOW",
+  cry: "CRY",
+  angry: "ANGRY"
+};
+
 class ZaloChannelAdapter extends BaseChannel {
   name = "zalo";
   api;
   ownId;
   config;
+  threadTypeCache = new Map;
+  messageCache = new Map;
+  sendQueue = Promise.resolve();
   constructor(config = {}) {
     super();
-    this.config = config;
+    this.config = {
+      minDelayMs: 300,
+      maxDelayMs: 800,
+      cacheLimit: 1000,
+      ...config
+    };
     if (config.api) {
       this.api = config.api;
     }
@@ -37605,17 +37769,101 @@ class ZaloChannelAdapter extends BaseChannel {
     if (!this.api?.listener?.on)
       return;
     this.api.listener.on("message", (raw) => {
+      this.recordInbound(raw);
       const unified = this.normalizeMessage(raw);
       if (unified) {
         this.emit("message", unified);
       }
     });
+    const onSessionDrop = (err) => {
+      this.emit("session:expired", {
+        reason: "SESSION_EXPIRED_OR_DROPPED",
+        raw: err,
+        requiresQrScan: true
+      });
+      this.setConnected(false);
+    };
+    this.api.listener.on("closed", onSessionDrop);
+    this.api.listener.on("error", (err) => {
+      const msg = String(err?.message || err);
+      if (msg.includes("1002") || msg.includes("session") || msg.includes("auth")) {
+        onSessionDrop(err);
+      }
+    });
     if (this.api.listener.start) {
       try {
         this.api.listener.start();
       } catch {}
     }
   }
+  recordInbound(raw) {
+    if (!raw)
+      return;
+    const data = raw.data || raw;
+    const isGroup = raw.type === 1 || raw.type === "group" || Boolean(raw.isGroup);
+    const chatId = String(raw.threadId || data.idTo || data.threadId || "");
+    const msgId = String(data.msgId || raw.msgId || "");
+    const cliMsgId = data.cliMsgId ? String(data.cliMsgId) : undefined;
+    const uidFrom = String(data.uidFrom || raw.senderId || "");
+    const content = typeof data.content === "string" ? data.content : data.msg || "";
+    if (chatId) {
+      this.threadTypeCache.set(chatId, isGroup ? 1 : 0);
+    }
+    const cached = {
+      msgId,
+      cliMsgId,
+      uidFrom,
+      content,
+      threadId: chatId,
+      isGroup
+    };
+    const limit = this.config.cacheLimit || 1000;
+    if (this.messageCache.size >= limit) {
+      const firstKey = this.messageCache.keys().next().value;
+      if (firstKey)
+        this.messageCache.delete(firstKey);
+    }
+    if (msgId)
+      this.messageCache.set(msgId, cached);
+    if (cliMsgId)
+      this.messageCache.set(cliMsgId, cached);
+  }
+  resolveThreadType(chatId) {
+    if (this.threadTypeCache.has(chatId)) {
+      return this.threadTypeCache.get(chatId);
+    }
+    return this.config.defaultIsGroup ?? true ? 1 : 0;
+  }
+  resolveQuote(replyToId) {
+    if (!replyToId)
+      return;
+    const cached = this.messageCache.get(replyToId);
+    if (cached) {
+      return {
+        msgId: cached.msgId,
+        cliMsgId: cached.cliMsgId,
+        uidFrom: cached.uidFrom,
+        content: cached.content
+      };
+    }
+    return replyToId;
+  }
+  async enqueueSend(operation) {
+    const minDelay = this.config.minDelayMs ?? 300;
+    const maxDelay = this.config.maxDelayMs ?? 800;
+    const execute = async () => {
+      if (maxDelay > 0) {
+        const jitter = Math.floor(minDelay + Math.random() * Math.max(0, maxDelay - minDelay));
+        if (jitter > 0) {
+          await new Promise((r) => setTimeout(r, jitter));
+        }
+      }
+      return await operation();
+    };
+    const next = this.sendQueue.then(execute, execute);
+    this.sendQueue = next.catch(() => {});
+    return next;
+  }
   normalizeMessage(raw) {
     if (!raw)
       return null;
@@ -37649,41 +37897,60 @@ class ZaloChannelAdapter extends BaseChannel {
   async sendText(chatId, text, options) {
     if (!this.api)
       throw new Error("Zalo adapter is not connected.");
-    const isGroup = this.config.defaultIsGroup ?? true;
-    const threadType = isGroup ? 1 : 0;
-    const payload = { msg: text, quote: options?.replyToId };
-    const res = await this.api.sendMessage(payload, chatId, threadType);
-    const resMsgId = res?.message?.msgId || res?.msgId || `z-${Date.now()}`;
-    return {
-      messageId: String(resMsgId),
-      chatId,
-      timestamp: Date.now()
-    };
+    const threadType = this.resolveThreadType(chatId);
+    const quote = this.resolveQuote(options?.replyToId);
+    const payload = { msg: text, quote };
+    return await this.enqueueSend(async () => {
+      const res = await this.api.sendMessage(payload, chatId, threadType);
+      const resMsgId = res?.message?.msgId || res?.msgId || `z-${Date.now()}`;
+      return {
+        messageId: String(resMsgId),
+        chatId,
+        timestamp: Date.now()
+      };
+    });
   }
-  async sendMedia(chatId, media, _options) {
+  async sendMedia(chatId, media, options) {
     if (!this.api)
       throw new Error("Zalo adapter is not connected.");
-    const isGroup = this.config.defaultIsGroup ?? true;
-    const threadType = isGroup ? 1 : 0;
-    let res;
-    if (media.type === "image") {
-      res = await this.api.sendMessage({ msg: media.caption || "", attachments: [media.source] }, chatId, threadType);
-    } else if (media.type === "video" && this.api.sendVideo) {
-      res = await this.api.sendVideo({ video: media.source, msg: media.caption || "" }, chatId, threadType);
-    } else {
-      res = await this.api.sendMessage({ msg: media.caption || "", attachments: [media.source] }, chatId, threadType);
-    }
-    const resMsgId = res?.message?.msgId || res?.msgId || `z-${Date.now()}`;
-    return {
-      messageId: String(resMsgId),
-      chatId,
-      timestamp: Date.now()
-    };
+    const threadType = this.resolveThreadType(chatId);
+    const quote = this.resolveQuote(options?.replyToId);
+    return await this.enqueueSend(async () => {
+      let res;
+      if (media.type === "image") {
+        res = await this.api.sendMessage({ msg: media.caption || "", attachments: [media.source], quote }, chatId, threadType);
+      } else if (media.type === "video" && this.api.sendVideo) {
+        res = await this.api.sendVideo({ video: media.source, msg: media.caption || "", quote }, chatId, threadType);
+      } else {
+        res = await this.api.sendMessage({ msg: media.caption || "", attachments: [media.source], quote }, chatId, threadType);
+      }
+      const resMsgId = res?.message?.msgId || res?.msgId || `z-${Date.now()}`;
+      return {
+        messageId: String(resMsgId),
+        chatId,
+        timestamp: Date.now()
+      };
+    });
   }
   async addReaction(chatId, messageId, emoji) {
-    if (this.api?.addReaction) {
-      await this.api.addReaction(chatId, messageId, emoji);
-    }
+    if (!this.api?.addReaction)
+      return;
+    const threadType = this.resolveThreadType(chatId);
+    const isGroup = threadType === 1;
+    const reactionCode = EMOJI_TO_ZALO[emoji] || emoji;
+    const cached = this.messageCache.get(messageId);
+    const cliMsgId = cached?.cliMsgId || messageId;
+    await this.enqueueSend(async () => {
+      await this.api.addReaction(chatId, messageId, cliMsgId, reactionCode, threadType);
+    });
+  }
+  async sendTyping(chatId) {
+    if (!this.api?.sendTypingEvent)
+      return;
+    const threadType = this.resolveThreadType(chatId);
+    try {
+      await this.api.sendTypingEvent(chatId, true, threadType);
+    } catch {}
   }
 }
 // src/personal/client.ts
@@ -38561,6 +38828,24 @@ class TelegramChannelAdapter extends BaseChannel {
       reaction: [{ type: "emoji", emoji }]
     });
   }
+  async sendTyping(chatId) {
+    await this.callApi("sendChatAction", {
+      chat_id: chatId,
+      action: "typing"
+    });
+  }
+  async editText(chatId, messageId, text) {
+    const res = await this.callApi("editMessageText", {
+      chat_id: chatId,
+      message_id: Number(messageId),
+      text
+    });
+    return {
+      messageId: String(res.message_id || messageId),
+      chatId,
+      timestamp: Date.now()
+    };
+  }
 }
 // src/channels/discord/adapter.ts
 class DiscordChannelAdapter extends BaseChannel {
@@ -38671,6 +38956,19 @@ class DiscordChannelAdapter extends BaseChannel {
     const encoded = encodeURIComponent(emoji);
     await this.callApi("PUT", `/channels/${chatId}/messages/${messageId}/reactions/${encoded}/@me`);
   }
+  async sendTyping(chatId) {
+    await this.callApi("POST", `/channels/${chatId}/typing`, {});
+  }
+  async editText(chatId, messageId, text) {
+    const res = await this.callApi("PATCH", `/channels/${chatId}/messages/${messageId}`, {
+      content: text
+    });
+    return {
+      messageId: String(res.id || messageId),
+      chatId,
+      timestamp: Date.now()
+    };
+  }
 }
 // src/channels/slack/adapter.ts
 class SlackChannelAdapter extends BaseChannel {
@@ -38773,6 +39071,19 @@ class SlackChannelAdapter extends BaseChannel {
       name: cleanName
     });
   }
+  async sendTyping(chatId) {}
+  async editText(chatId, messageId, text) {
+    const res = await this.callApi("chat.update", {
+      channel: chatId,
+      ts: messageId,
+      text
+    });
+    return {
+      messageId: String(res.ts || messageId),
+      chatId,
+      timestamp: Date.now()
+    };
+  }
 }
 // src/bridges/mcp/index.ts
 function getChannelHubMcpTools() {
@@ -39177,6 +39488,7 @@ export {
   CommandRouter,
   DiscordChannelAdapter,
   SlackChannelAdapter,
+  SmartStreamer,
   TelegramChannelAdapter,
   WebhookBridge,
   Zalo,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theowlops/channelhub",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "ChannelHub SDK - Unified multi-channel messaging toolkit (Zalo, Telegram, Discord, Slack) for AI agents, standalone bots, and enterprise automation.",
   "module": "dist/index.js",
   "main": "dist/index.cjs",