@theowlops/channelhub 1.0.0 → 1.1.0

package/dist/channels/discord/adapter.d.ts

@@ -21,4 +21,6 @@ export declare class DiscordChannelAdapter extends BaseChannel {
     sendText(chatId: string, text: string, options?: SendOptions): Promise<SentMessageResult>;
     sendMedia(chatId: string, media: MediaPayload, options?: SendOptions): Promise<SentMessageResult>;
     addReaction(chatId: string, messageId: string, emoji: string): Promise<void>;
+    sendTyping(chatId: string): Promise<void>;
+    editText(chatId: string, messageId: string, text: string): Promise<SentMessageResult>;
 }

package/dist/channels/discord/index.js

@@ -124,6 +124,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()
+    };
+  }
 }
 export {
   DiscordChannelAdapter

package/dist/channels/slack/adapter.d.ts

@@ -17,4 +17,6 @@ export declare class SlackChannelAdapter extends BaseChannel {
     sendText(chatId: string, text: string, options?: SendOptions): Promise<SentMessageResult>;
     sendMedia(chatId: string, media: MediaPayload, options?: SendOptions): Promise<SentMessageResult>;
     addReaction(chatId: string, messageId: string, emoji: string): Promise<void>;
+    sendTyping(chatId: string): Promise<void>;
+    editText(chatId: string, messageId: string, text: string): Promise<SentMessageResult>;
 }

package/dist/channels/slack/index.js

@@ -116,6 +116,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()
+    };
+  }
 }
 export {
   SlackChannelAdapter

package/dist/channels/telegram/adapter.d.ts

@@ -18,4 +18,6 @@ export declare class TelegramChannelAdapter extends BaseChannel {
     sendText(chatId: string, text: string, options?: SendOptions): Promise<SentMessageResult>;
     sendMedia(chatId: string, media: MediaPayload, options?: SendOptions): Promise<SentMessageResult>;
     addReaction(chatId: string, messageId: string, emoji: string): Promise<void>;
+    sendTyping(chatId: string): Promise<void>;
+    editText(chatId: string, messageId: string, text: string): Promise<SentMessageResult>;
 }

package/dist/channels/telegram/index.js

@@ -173,6 +173,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()
+    };
+  }
 }
 export {
   TelegramChannelAdapter

package/dist/channels/zalo/adapter.d.ts

@@ -5,18 +5,30 @@ export interface ZaloAdapterConfig {
     credentialsPath?: string;
     ownId?: string;
     defaultIsGroup?: boolean;
+    minDelayMs?: number;
+    maxDelayMs?: number;
+    cacheLimit?: number;
 }
+export declare const EMOJI_TO_ZALO: Record<string, string>;
 export declare class ZaloChannelAdapter extends BaseChannel {
     readonly name: ChannelType;
     private api;
     private ownId?;
     private config;
+    private threadTypeCache;
+    private messageCache;
+    private sendQueue;
     constructor(config?: ZaloAdapterConfig);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     private setupEventListener;
+    private recordInbound;
+    private resolveThreadType;
+    private resolveQuote;
+    private enqueueSend;
     private normalizeMessage;
     sendText(chatId: string, text: string, options?: SendOptions): Promise<SentMessageResult>;
-    sendMedia(chatId: string, media: MediaPayload, _options?: SendOptions): Promise<SentMessageResult>;
+    sendMedia(chatId: string, media: MediaPayload, options?: SendOptions): Promise<SentMessageResult>;
     addReaction(chatId: string, messageId: string, emoji: string): Promise<void>;
+    sendTyping(chatId: string): Promise<void>;
 }

package/dist/channels/zalo/index.js

@@ -37488,14 +37488,47 @@ class BaseChannel extends EventEmitter {
 }
 
 // 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;
     }
@@ -37530,17 +37563,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;
@@ -37574,41 +37691,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
@@ -38329,6 +38465,7 @@ function initOABot() {
   return new ZaloOABot;
 }
 export {
+  EMOJI_TO_ZALO,
   ZaloChannelAdapter,
   ZaloOABot,
   ZaloPersonalBot,

package/dist/core/context.d.ts

@@ -1,9 +1,12 @@
 import type { IChannelAdapter, MediaPayload, SendOptions, SentMessageResult, UnifiedMessage } from "./types";
+import { type StreamOptions } from "./stream";
 export interface MessageContext {
     message: UnifiedMessage;
     channel: IChannelAdapter;
     reply: (text: string, options?: SendOptions) => Promise<SentMessageResult>;
     replyMedia: (media: MediaPayload, options?: SendOptions) => Promise<SentMessageResult>;
     react: (emoji: string) => Promise<void>;
+    sendTyping: () => Promise<void>;
+    stream: (tokenStream: AsyncIterable<string>, options?: StreamOptions) => Promise<SentMessageResult[]>;
 }
 export declare function createMessageContext(message: UnifiedMessage, channel: IChannelAdapter): MessageContext;

package/dist/core/index.d.ts

@@ -3,3 +3,4 @@ export * from "./adapter";
 export * from "./bus";
 export * from "./context";
 export * from "./hub";
+export * from "./stream";

package/dist/core/index.js

@@ -28,6 +28,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 {
@@ -45,6 +165,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
+      });
     }
   };
 }
@@ -95,5 +226,6 @@ export {
   BaseChannel,
   ChannelEventBus,
   ChannelHub,
+  SmartStreamer,
   createMessageContext
 };

package/dist/core/stream.d.ts

@@ -0,0 +1,16 @@
+import type { IChannelAdapter, SendOptions, SentMessageResult } from "./types";
+export interface StreamOptions {
+    editDebounceMs?: number;
+    typingIntervalMs?: number;
+    chunkMode?: "sentence" | "accumulate";
+    minSentenceLength?: number;
+    initialPlaceholder?: string;
+}
+export declare class SmartStreamer {
+    private adapter;
+    private options;
+    constructor(adapter: IChannelAdapter, options?: StreamOptions);
+    stream(chatId: string, tokenStream: AsyncIterable<string>, sendOptions?: SendOptions): Promise<SentMessageResult[]>;
+    private streamWithEdit;
+    private streamWithoutEdit;
+}

package/dist/core/types.d.ts

@@ -57,6 +57,8 @@ export interface IChannelAdapter {
     sendText(chatId: string, text: string, options?: SendOptions): Promise<SentMessageResult>;
     sendMedia(chatId: string, media: MediaPayload, options?: SendOptions): Promise<SentMessageResult>;
     addReaction?(chatId: string, messageId: string, emoji: string): Promise<void>;
+    sendTyping?(chatId: string): Promise<void>;
+    editText?(chatId: string, messageId: string, text: string): Promise<SentMessageResult>;
     on(event: "message", handler: (msg: UnifiedMessage) => Promise<void> | void): this;
     on(event: "error", handler: (err: Error) => void): this;
     on(event: "status", handler: (status: ChannelStatus) => void): this;