@theowlops/channelhub 1.0.1 → 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

@@ -30,4 +30,5 @@ export declare class ZaloChannelAdapter 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>;
 }

package/dist/channels/zalo/index.js

@@ -37738,6 +37738,14 @@ class ZaloChannelAdapter extends BaseChannel {
       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
 init_dist();

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;

package/dist/index.cjs

@@ -20548,9 +20548,9 @@ var require_websocket_server = __commonJS(function(exports2, module2) {
 });
 
 // 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);
@@ -37520,6 +37520,7 @@ __export(exports_src, {
   CommandRouter: () => CommandRouter,
   DiscordChannelAdapter: () => DiscordChannelAdapter,
   SlackChannelAdapter: () => SlackChannelAdapter,
+  SmartStreamer: () => SmartStreamer,
   TelegramChannelAdapter: () => TelegramChannelAdapter,
   WebhookBridge: () => WebhookBridge,
   Zalo: () => Zalo,
@@ -37563,6 +37564,126 @@ class ChannelEventBus extends import_node_events2.EventEmitter {
     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 {
@@ -37580,6 +37701,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
+      });
     }
   };
 }
@@ -37877,6 +38009,14 @@ class ZaloChannelAdapter extends BaseChannel {
       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
 init_dist();
@@ -38753,6 +38893,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 {
@@ -38863,6 +39021,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 {
@@ -38965,6 +39136,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() {

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
+      });
     }
   };
 }
@@ -37813,6 +37944,14 @@ class ZaloChannelAdapter extends BaseChannel {
       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
 init_dist();
@@ -38689,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 {
@@ -38799,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 {
@@ -38901,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() {
@@ -39305,6 +39488,7 @@ export {
   CommandRouter,
   DiscordChannelAdapter,
   SlackChannelAdapter,
+  SmartStreamer,
   TelegramChannelAdapter,
   WebhookBridge,
   Zalo,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theowlops/channelhub",
-  "version": "1.0.1",
+  "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",