@mulmobridge/telegram 1.3.0 → 1.3.1

package/dist/router.js

@@ -3,6 +3,7 @@
 // Telegram API, no real MulmoClaude socket, no env reads). The
 // entrypoint in index.ts is then just: read env → wire real deps →
 // drive the polling loop.
+import { createReplyStream } from "./stream.js";
 import { parseDataUrl, replyAfterProcessingIndicator } from "@mulmobridge/client";
 // Telegram caps a single message at 4096 chars. We split long
 // replies naively; pretty formatting (preserve markdown, break on
@@ -24,52 +25,22 @@ export function createMessageRouter(deps) {
     const log = deps.log ?? defaultLog;
     // One denial reply per chat per bridge lifetime — restart clears.
     const deniedAlreadyNotified = new Set();
-    // Streaming state: while a relay is in flight, chunks accumulate
-    // here. A timer periodically flushes them via editMessageText.
-    let streamChatId = null;
-    let streamMessageId = null;
-    let streamAccumulated = "";
-    let streamDirty = false;
-    let streamTimer = null;
-    function startStream(chatId) {
-        streamChatId = chatId;
-        streamMessageId = null;
-        streamAccumulated = "";
-        streamDirty = false;
-        streamTimer = setInterval(flushStream, STREAM_EDIT_INTERVAL_MS);
-    }
-    function stopStream() {
-        if (streamTimer !== null) {
-            clearInterval(streamTimer);
-            streamTimer = null;
+    // The reply stream of the request in flight. Chunks carry no chat id; the
+    // polling loop handles one message at a time, so they belong to this one.
+    const inFlight = { stream: null };
+    /** Runs `work` while its streamed chunks are mirrored into the chat. The
+     *  timer is stopped even when `work` throws. */
+    async function streamWhile(chatId, work) {
+        const stream = createReplyStream(api, chatId, log, STREAM_EDIT_INTERVAL_MS);
+        inFlight.stream = stream;
+        try {
+            const result = await work();
+            return { result, streamedMessageId: await stream.finish() };
         }
-        streamChatId = null;
-        streamMessageId = null;
-        streamAccumulated = "";
-        streamDirty = false;
-    }
-    function flushStream() {
-        if (!streamDirty || streamChatId === null)
-            return;
-        streamDirty = false;
-        const chatId = streamChatId;
-        const text = streamAccumulated || "…";
-        if (streamMessageId === null) {
-            // First flush: send a new message
-            api
-                .sendMessage(chatId, text)
-                .then((msgId) => {
-                streamMessageId = msgId;
-            })
-                .catch((err) => {
-                log.error(`[telegram] stream sendMessage failed: ${String(err)}`);
-            });
-        }
-        else {
-            // Subsequent flushes: edit existing message
-            api.editMessageText(chatId, streamMessageId, text).catch((err) => {
-                log.error(`[telegram] stream editMessage failed: ${String(err)}`);
-            });
+        finally {
+            stream.stop();
+            if (inFlight.stream === stream)
+                inFlight.stream = null;
         }
     }
     // Download all media from a message. Telegram messages are usually
@@ -149,26 +120,17 @@ export function createMessageRouter(deps) {
         }
         // Surface the attachment failure so the user knows the file was lost.
         const messageText = resolveMessageText(text, failed);
-        // Start streaming: chunks will arrive via handleTextChunk and
-        // be sent/edited in the Telegram chat in real time.
-        startStream(chatId);
-        const ack = await sendToMulmo(String(chatId), messageText, attachments.length > 0 ? attachments : undefined);
-        // Final flush + capture the message id before stopStream clears it.
-        flushStream();
-        const sentMsgId = streamMessageId;
-        stopStream();
-        return () => deliverFinal(chatId, sentMsgId, ack);
+        const { result: ack, streamedMessageId } = await streamWhile(chatId, () => sendToMulmo(String(chatId), messageText, attachments.length > 0 ? attachments : undefined));
+        return () => deliverFinal(chatId, streamedMessageId, ack);
     }
-    // If streaming sent the text, do a final edit with the full ack
-    // to catch any trailing chunks. If no streaming happened,
-    // send the full reply as a new message.
-    async function deliverFinal(chatId, sentMsgId, ack) {
-        if (sentMsgId !== null && ack.ok) {
-            await api.editMessageText(chatId, sentMsgId, ack.reply ?? "").catch(() => { });
-        }
-        else if (sentMsgId === null) {
-            await sendReply(chatId, ack);
+    // A streamed reply is completed in place; an error after streaming is sent
+    // as its own message so the partial text is not the last word.
+    async function deliverFinal(chatId, streamedMessageId, ack) {
+        if (streamedMessageId !== null && ack.ok) {
+            await api.editMessageText(chatId, streamedMessageId, ack.reply ?? "").catch(() => { });
+            return;
         }
+        await sendReply(chatId, ack);
     }
     async function handleDenied(msg) {
         const chatId = msg.chat.id;
@@ -210,10 +172,7 @@ export function createMessageRouter(deps) {
             }
         },
         handleTextChunk(chunk) {
-            if (streamChatId === null)
-                return;
-            streamAccumulated += chunk;
-            streamDirty = true;
+            inFlight.stream?.append(chunk);
         },
         deniedAlreadyNotified() {
             return deniedAlreadyNotified;

package/dist/stream.d.ts

@@ -0,0 +1,14 @@
+import type { TelegramApi } from "./api.js";
+interface StreamLog {
+    error: (msg: string) => void;
+}
+export interface ReplyStream {
+    append(chunk: string): void;
+    /** Stops the timer, sends what is pending, and resolves to the id of the
+     *  streamed message — or null when nothing was streamed. */
+    finish(): Promise<number | null>;
+    /** Stops the timer without sending anything more. Safe to call twice. */
+    stop(): void;
+}
+export declare function createReplyStream(api: TelegramApi, chatId: number, log: StreamLog, interval_ms: number): ReplyStream;
+export {};

package/dist/stream.js

@@ -0,0 +1,50 @@
+// One streamed reply: chunks accumulate here and a timer mirrors them into a
+// single Telegram message (sent once, then edited). Created per request so a
+// failed request cannot leave its timer or text behind for the next one.
+export function createReplyStream(api, chatId, log, interval_ms) {
+    const state = { accumulated: "", dirty: false, messageId: null, flushChain: Promise.resolve(), timer: null };
+    async function sendOrEdit(text) {
+        if (state.messageId === null) {
+            state.messageId = await api.sendMessage(chatId, text);
+            return;
+        }
+        await api.editMessageText(chatId, state.messageId, text);
+    }
+    async function flushPending() {
+        if (!state.dirty)
+            return;
+        state.dirty = false;
+        const action = state.messageId === null ? "sendMessage" : "editMessage";
+        try {
+            await sendOrEdit(state.accumulated || "…");
+        }
+        catch (err) {
+            log.error(`[telegram] stream ${action} failed: ${String(err)}`);
+        }
+    }
+    function flush() {
+        state.flushChain = state.flushChain.then(flushPending);
+        return state.flushChain;
+    }
+    function stop() {
+        if (state.timer === null)
+            return;
+        clearInterval(state.timer);
+        state.timer = null;
+    }
+    state.timer = setInterval(() => void flush(), interval_ms);
+    return {
+        append(chunk) {
+            if (state.timer === null)
+                return;
+            state.accumulated += chunk;
+            state.dirty = true;
+        },
+        async finish() {
+            stop();
+            await flush();
+            return state.messageId;
+        },
+        stop,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mulmobridge/telegram",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Telegram bridge for MulmoBridge — connect a Telegram bot to MulmoClaude",
   "type": "module",
   "main": "./dist/index.js",