@nextclaw/channel-runtime 0.1.29 → 0.1.31

package/dist/index.d.ts

@@ -232,6 +232,7 @@ declare class TelegramChannel extends BaseChannel<Config["channels"]["telegram"]
     private botUserId;
     private botUsername;
     private readonly typingController;
+    private readonly streamPreview;
     private transcriber;
     constructor(config: Config["channels"]["telegram"], bus: MessageBus, groqApiKey?: string, sessionManager?: SessionManager | undefined);
     start(): Promise<void>;

package/dist/index.js

@@ -3010,14 +3010,230 @@ var GroqTranscriptionProvider = class {
 // src/channels/telegram.ts
 import { join as join3 } from "path";
 import { mkdirSync as mkdirSync3 } from "fs";
-import { isTypingStopControlMessage as isTypingStopControlMessage2 } from "@nextclaw/core";
+import {
+  isAssistantStreamResetControlMessage,
+  isTypingStopControlMessage as isTypingStopControlMessage2,
+  readAssistantStreamDelta
+} from "@nextclaw/core";
 var TYPING_HEARTBEAT_MS2 = 6e3;
 var TYPING_AUTO_STOP_MS2 = 12e4;
+var TELEGRAM_TEXT_LIMIT = 4096;
+var STREAM_PREVIEW_MIN_CHARS = 30;
+var STREAM_PREVIEW_PARTIAL_MIN_INTERVAL_MS = 700;
+var STREAM_PREVIEW_BLOCK_MIN_INTERVAL_MS = 1200;
+var STREAM_PREVIEW_BLOCK_MIN_GROWTH = 120;
 var BOT_COMMANDS = [
   { command: "start", description: "Start the bot" },
   { command: "reset", description: "Reset conversation history" },
   { command: "help", description: "Show available commands" }
 ];
+var TelegramStreamPreviewController = class {
+  constructor(params) {
+    this.params = params;
+  }
+  states = /* @__PURE__ */ new Map();
+  async handleReset(msg) {
+    const chatId = String(msg.chatId);
+    this.dispose(chatId);
+    if (this.params.resolveMode() === "off") {
+      return;
+    }
+    const replyToMessageId = readReplyToMessageId(msg.metadata);
+    this.states.set(chatId, {
+      chatId,
+      rawText: "",
+      lastRenderedText: "",
+      messageId: void 0,
+      replyToMessageId,
+      silent: msg.metadata?.silent === true,
+      lastSentAt: 0,
+      lastEmittedChars: 0,
+      inFlight: false,
+      pending: false,
+      timer: null
+    });
+  }
+  async handleDelta(msg, delta) {
+    if (!delta) {
+      return;
+    }
+    if (this.params.resolveMode() === "off") {
+      return;
+    }
+    const chatId = String(msg.chatId);
+    const state = this.ensureState(chatId);
+    state.rawText += delta;
+    this.scheduleFlush(state);
+  }
+  async finalizeWithFinalMessage(msg) {
+    if (this.params.resolveMode() === "off") {
+      return false;
+    }
+    const chatId = String(msg.chatId);
+    const state = this.states.get(chatId);
+    if (!state) {
+      return false;
+    }
+    state.rawText = msg.content ?? "";
+    const replyToMessageId = msg.replyTo ? Number(msg.replyTo) : state.replyToMessageId;
+    state.silent = msg.metadata?.silent === true || state.silent;
+    if (!state.rawText.trim()) {
+      this.dispose(chatId);
+      return false;
+    }
+    const handled = await this.flushNow(state, {
+      force: true,
+      allowInitialBelowThreshold: true,
+      replyToMessageId,
+      silent: state.silent
+    });
+    this.dispose(chatId);
+    return handled;
+  }
+  stopAll() {
+    for (const chatId of this.states.keys()) {
+      this.dispose(chatId);
+    }
+  }
+  ensureState(chatId) {
+    const existing = this.states.get(chatId);
+    if (existing) {
+      return existing;
+    }
+    const created = {
+      chatId,
+      rawText: "",
+      lastRenderedText: "",
+      messageId: void 0,
+      replyToMessageId: void 0,
+      silent: false,
+      lastSentAt: 0,
+      lastEmittedChars: 0,
+      inFlight: false,
+      pending: false,
+      timer: null
+    };
+    this.states.set(chatId, created);
+    return created;
+  }
+  scheduleFlush(state) {
+    if (state.timer) {
+      return;
+    }
+    const minInterval = this.params.resolveMode() === "block" ? STREAM_PREVIEW_BLOCK_MIN_INTERVAL_MS : STREAM_PREVIEW_PARTIAL_MIN_INTERVAL_MS;
+    const delay = Math.max(0, minInterval - (Date.now() - state.lastSentAt));
+    state.timer = setTimeout(() => {
+      state.timer = null;
+      void this.flushScheduled(state);
+    }, delay);
+  }
+  async flushScheduled(state) {
+    const current = this.states.get(state.chatId);
+    if (current !== state) {
+      return;
+    }
+    if (state.inFlight) {
+      state.pending = true;
+      return;
+    }
+    state.inFlight = true;
+    try {
+      await this.flushNow(state, {
+        force: false,
+        allowInitialBelowThreshold: false,
+        replyToMessageId: state.replyToMessageId,
+        silent: state.silent
+      });
+    } finally {
+      state.inFlight = false;
+      if (state.pending) {
+        state.pending = false;
+        this.scheduleFlush(state);
+      }
+    }
+  }
+  async flushNow(state, opts) {
+    const bot = this.params.getBot();
+    if (!bot) {
+      return false;
+    }
+    const plainText = state.rawText.trimEnd();
+    if (!plainText) {
+      return false;
+    }
+    const mode = this.params.resolveMode();
+    if (mode === "block" && !opts.force && plainText.length - state.lastEmittedChars < STREAM_PREVIEW_BLOCK_MIN_GROWTH) {
+      return typeof state.messageId === "number";
+    }
+    if (typeof state.messageId !== "number" && !opts.allowInitialBelowThreshold && plainText.length < STREAM_PREVIEW_MIN_CHARS) {
+      return false;
+    }
+    const renderedText = markdownToTelegramHtml(plainText).trimEnd();
+    if (!renderedText) {
+      return false;
+    }
+    const limitedRenderedText = renderedText.slice(0, TELEGRAM_TEXT_LIMIT);
+    if (limitedRenderedText === state.lastRenderedText) {
+      return typeof state.messageId === "number";
+    }
+    if (typeof state.messageId === "number") {
+      try {
+        await bot.editMessageText(limitedRenderedText, {
+          chat_id: Number(state.chatId),
+          message_id: state.messageId,
+          parse_mode: "HTML"
+        });
+      } catch {
+        try {
+          await bot.editMessageText(plainText.slice(0, TELEGRAM_TEXT_LIMIT), {
+            chat_id: Number(state.chatId),
+            message_id: state.messageId
+          });
+        } catch {
+          return false;
+        }
+      }
+      state.lastRenderedText = limitedRenderedText;
+      state.lastSentAt = Date.now();
+      state.lastEmittedChars = plainText.length;
+      return true;
+    }
+    const sendOptions = {
+      parse_mode: "HTML",
+      ...opts.replyToMessageId ? { reply_to_message_id: opts.replyToMessageId } : {},
+      ...opts.silent ? { disable_notification: true } : {}
+    };
+    try {
+      const sent = await bot.sendMessage(Number(state.chatId), limitedRenderedText, sendOptions);
+      if (typeof sent.message_id === "number") {
+        state.messageId = sent.message_id;
+      }
+    } catch {
+      const sent = await bot.sendMessage(Number(state.chatId), plainText.slice(0, TELEGRAM_TEXT_LIMIT), {
+        ...opts.replyToMessageId ? { reply_to_message_id: opts.replyToMessageId } : {},
+        ...opts.silent ? { disable_notification: true } : {}
+      });
+      if (typeof sent.message_id === "number") {
+        state.messageId = sent.message_id;
+      }
+    }
+    state.lastRenderedText = limitedRenderedText;
+    state.lastSentAt = Date.now();
+    state.lastEmittedChars = plainText.length;
+    return true;
+  }
+  dispose(chatId) {
+    const state = this.states.get(chatId);
+    if (!state) {
+      return;
+    }
+    if (state.timer) {
+      clearTimeout(state.timer);
+      state.timer = null;
+    }
+    this.states.delete(chatId);
+  }
+};
 var TelegramChannel = class extends BaseChannel {
   constructor(config, bus, groqApiKey, sessionManager) {
     super(config, bus);
@@ -3030,12 +3246,17 @@ var TelegramChannel = class extends BaseChannel {
         await this.bot?.sendChatAction(Number(chatId), "typing");
       }
     });
+    this.streamPreview = new TelegramStreamPreviewController({
+      resolveMode: () => resolveTelegramStreamingMode(this.config),
+      getBot: () => this.bot
+    });
   }
   name = "telegram";
   bot = null;
   botUserId = null;
   botUsername = null;
   typingController;
+  streamPreview;
   transcriber;
   async start() {
     if (!this.config.token) {
@@ -3129,17 +3350,27 @@ Just send me a text message to chat!`;
   async stop() {
     this.running = false;
     this.typingController.stopAll();
+    this.streamPreview.stopAll();
     if (this.bot) {
       await this.bot.stopPolling();
       this.bot = null;
     }
   }
   async handleControlMessage(msg) {
-    if (!isTypingStopControlMessage2(msg)) {
-      return false;
+    if (isTypingStopControlMessage2(msg)) {
+      this.stopTyping(msg.chatId);
+      return true;
     }
-    this.stopTyping(msg.chatId);
-    return true;
+    if (isAssistantStreamResetControlMessage(msg)) {
+      await this.streamPreview.handleReset(msg);
+      return true;
+    }
+    const delta = readAssistantStreamDelta(msg);
+    if (delta !== null) {
+      await this.streamPreview.handleDelta(msg, delta);
+      return true;
+    }
+    return false;
   }
   async send(msg) {
     if (isTypingStopControlMessage2(msg)) {
@@ -3150,6 +3381,9 @@ Just send me a text message to chat!`;
       return;
     }
     this.stopTyping(msg.chatId);
+    if (await this.streamPreview.finalizeWithFinalMessage(msg)) {
+      return;
+    }
     const htmlContent = markdownToTelegramHtml(msg.content ?? "");
     const silent = msg.metadata?.silent === true;
     const replyTo = msg.replyTo ? Number(msg.replyTo) : void 0;
@@ -3438,6 +3672,35 @@ function shouldSendAckReaction(params) {
   }
   return false;
 }
+function readReplyToMessageId(metadata) {
+  const raw = metadata.message_id;
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return Math.trunc(raw);
+  }
+  if (typeof raw === "string") {
+    const parsed = Number(raw);
+    if (Number.isFinite(parsed)) {
+      return Math.trunc(parsed);
+    }
+  }
+  return void 0;
+}
+function resolveTelegramStreamingMode(config) {
+  const raw = config.streaming;
+  if (raw === true) {
+    return "partial";
+  }
+  if (raw === false || raw === void 0 || raw === null) {
+    return "off";
+  }
+  if (raw === "progress") {
+    return "partial";
+  }
+  if (raw === "partial" || raw === "block" || raw === "off") {
+    return raw;
+  }
+  return "off";
+}
 function markdownToTelegramHtml(text) {
   if (!text) {
     return "";
@@ -3857,12 +4120,16 @@ var BUILTIN_CHANNEL_RUNTIMES = {
   telegram: {
     id: "telegram",
     isEnabled: (config) => config.channels.telegram.enabled,
-    createChannel: (context) => new TelegramChannel(
-      context.config.channels.telegram,
-      context.bus,
-      context.config.providers.groq.apiKey,
-      context.sessionManager
-    )
+    createChannel: (context) => {
+      const providers = context.config.providers;
+      const groqApiKey = providers.groq?.apiKey;
+      return new TelegramChannel(
+        context.config.channels.telegram,
+        context.bus,
+        groqApiKey,
+        context.sessionManager
+      );
+    }
   },
   whatsapp: {
     id: "whatsapp",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/channel-runtime",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "private": false,
   "description": "Runtime implementations for NextClaw builtin channel plugins.",
   "type": "module",
@@ -15,7 +15,6 @@
   ],
   "dependencies": {
     "@larksuiteoapi/node-sdk": "^1.58.0",
-    "@nextclaw/core": "^0.7.0",
     "@slack/socket-mode": "^1.3.3",
     "@slack/web-api": "^7.6.0",
     "dingtalk-stream": "^2.1.4",
@@ -28,7 +27,8 @@
     "socket.io-client": "^4.7.5",
     "undici": "^6.21.0",
     "ws": "^8.18.0",
-    "socket.io-msgpack-parser": "^3.0.2"
+    "socket.io-msgpack-parser": "^3.0.2",
+    "@nextclaw/core": "0.7.3"
   },
   "devDependencies": {
     "@types/mailparser": "^3.4.6",