@nopeek/agent-bridge 0.7.11 → 0.7.15

package/dist/tool-progress.js

@@ -1,9 +1,13 @@
 // Telegram-style tool progress for NoPeek bots.
 //
-// Hermes emits `hermes.tool.progress` SSE events while it works. Telegram
-// already shows those as short status messages (a few tools, then a new
-// message after a quiet gap). We do the same in the encrypted chat so the
-// human can see the bot is actually taking action.
+// Hermes emits `hermes.tool.progress` SSE events while it works, interleaved
+// with assistant text deltas (the "Skills are loaded. Next I'll…" lines).
+// On Telegram the gateway posts each commentary as its own message and starts
+// a fresh progress bubble underneath. This publisher matches that:
+//   1. Tool lines edit a single live bubble (roll to a new one if it gets long).
+//   2. Commentary after a tool batch finalizes that bubble and is posted below.
+//   3. The next tool batch opens a NEW progress bubble under the commentary.
+//   4. The recap is whatever text is still unpublished at finish().
 const FALLBACK_EMOJI = {
     read_file: "📖",
     write_file: "✍️",
@@ -44,62 +48,361 @@ function tidyLabel(raw) {
         return "";
     return s.length > 80 ? `${s.slice(0, 77)}...` : s;
 }
+/** Hint so Hermes ends a tool-using turn with a recap, like Telegram. */
+export const RECAP_HINT = "When this turn used tools (read/write files, commands, skills, memory), end your reply with a short recap: what was going on, what you did, and the result. Skip the recap for simple chat with no tools. No em dashes.";
+/** Text in `full` that has not already been posted as commentary. */
+export function unpublishedTail(full, published) {
+    const f = full.trim();
+    const p = published.trim();
+    if (!f)
+        return "";
+    if (!p)
+        return f;
+    if (f === p)
+        return "";
+    const nf = f.replace(/\s+/g, " ");
+    const np = p.replace(/\s+/g, " ");
+    if (nf === np || np.includes(nf))
+        return "";
+    if (full.startsWith(published))
+        return full.slice(published.length).trim();
+    if (f.startsWith(p))
+        return f.slice(p.length).trim();
+    if (nf.startsWith(np))
+        return "";
+    const idx = f.indexOf(p);
+    if (idx >= 0)
+        return (f.slice(0, idx) + f.slice(idx + p.length)).trim();
+    return f;
+}
+const DEFAULT_MAX_BUBBLE = 480;
+/** Unified diffs / `| review` dumps should never land in the chat. */
+export function isToolDump(text) {
+    const t = text.trim();
+    if (!t)
+        return false;
+    if (/^\|\s*(review|read|search|terminal|patch|write)\b/i.test(t))
+        return true;
+    if (/^@@\s+-\d+/.test(t))
+        return true;
+    if (/^\*\*\*\s+(Begin|Update|Add|Delete) Patch/m.test(t))
+        return true;
+    if (/^diff --git /m.test(t) && /^@@ /m.test(t))
+        return true;
+    const lines = t.split("\n");
+    if (lines.length >= 6) {
+        const diffy = lines.filter((l) => /^(@@ |[+-](?![+-])|\| )/.test(l)).length;
+        if (diffy / lines.length >= 0.4)
+            return true;
+    }
+    return false;
+}
+/** Split a reply into short chat bubbles. Drops tool-dump paragraphs. */
+export function splitBubbles(text, max = DEFAULT_MAX_BUBBLE) {
+    const cleaned = text.replace(/\r\n/g, "\n").trim();
+    if (!cleaned)
+        return [];
+    const paras = cleaned.split(/\n{2,}/).map((p) => p.trim()).filter(Boolean);
+    const out = [];
+    for (const p of paras) {
+        if (isToolDump(p))
+            continue;
+        if (p.length <= max) {
+            out.push(p);
+            continue;
+        }
+        let buf = "";
+        for (const line of p.split("\n")) {
+            const next = buf ? `${buf}\n${line}` : line;
+            if (next.length > max && buf) {
+                out.push(buf);
+                buf = line.length > max ? "" : line;
+                if (line.length > max) {
+                    for (const piece of hardWrap(line, max))
+                        out.push(piece);
+                }
+            }
+            else if (next.length > max) {
+                for (const piece of hardWrap(next, max))
+                    out.push(piece);
+                buf = "";
+            }
+            else {
+                buf = next;
+            }
+        }
+        if (buf.trim())
+            out.push(buf.trim());
+    }
+    return out;
+}
+function hardWrap(s, max) {
+    const out = [];
+    let rest = s.trim();
+    while (rest.length > max) {
+        let at = rest.lastIndexOf(" ", max);
+        if (at < max * 0.5)
+            at = max;
+        out.push(rest.slice(0, at).trim());
+        rest = rest.slice(at).trim();
+    }
+    if (rest)
+        out.push(rest);
+    return out;
+}
 /**
- * Collect tool lines and flush them as short chat messages.
- * Flush when we have `maxLines` tools, or after `gapMs` of quiet.
+ * One chat turn: live tool progress (edited in place) with commentary
+ * messages in between tool batches, then any leftover recap below.
+ * All channel writes run on a single promise chain so bubbles stay in order.
  */
-export class ToolProgressFlusher {
-    send;
-    gapMs;
-    maxLines;
-    lines = [];
-    timer = null;
-    chain = Promise.resolve();
+export class TurnPublisher {
+    sink;
+    opts;
+    write = Promise.resolve();
+    progressP = null;
+    progress = null;
+    progressLines = [];
+    textP = null;
+    textBuf = "";
+    held = "";
+    published = "";
+    toolsUsed = false;
+    startTimer = null;
     seen = new Set();
-    constructor(send, gapMs = 2200, maxLines = 4) {
-        this.send = send;
-        this.gapMs = gapMs;
-        this.maxLines = maxLines;
+    startDelayMs;
+    maxProgressLines;
+    maxBubbleChars;
+    constructor(sink, opts) {
+        this.sink = sink;
+        this.opts = opts;
+        this.startDelayMs = opts.startDelayMs ?? 400;
+        this.maxProgressLines = opts.maxProgressLines ?? 8;
+        this.maxBubbleChars = opts.maxBubbleChars ?? DEFAULT_MAX_BUBBLE;
     }
-    get pending() {
-        return this.lines.length;
+    onChunk(delta) {
+        if (!delta)
+            return;
+        if (this.toolsUsed) {
+            this.cancelStart();
+            this.enqueue(() => this.appendCommentary(delta));
+            return;
+        }
+        if (this.textP) {
+            this.enqueue(() => this.appendCommentary(delta));
+            return;
+        }
+        this.held += delta;
+        if (this.startTimer)
+            return;
+        this.startTimer = setTimeout(() => {
+            this.startTimer = null;
+            if (this.toolsUsed || this.textP || !this.held)
+                return;
+            const chunk = this.held;
+            this.held = "";
+            this.enqueue(() => this.appendCommentary(chunk));
+        }, this.startDelayMs);
     }
-    push(ev) {
+    onTool(ev) {
         const line = formatToolLine(ev);
         if (!line)
             return;
-        if (this.lines[this.lines.length - 1] === line)
+        if (this.progressLines[this.progressLines.length - 1] === line)
             return;
-        if (this.seen.has(line) && this.lines.includes(line))
+        if (this.seen.has(line) && this.progressLines.includes(line))
             return;
         this.seen.add(line);
-        this.lines.push(line);
-        if (this.lines.length >= this.maxLines) {
-            void this.flush();
+        this.toolsUsed = true;
+        if (this.startTimer) {
+            clearTimeout(this.startTimer);
+            this.startTimer = null;
+        }
+        this.enqueue(async () => {
+            const pending = this.held;
+            this.held = "";
+            await this.commitText(pending);
+            await this.addProgressLine(line);
+        });
+    }
+    async finish(reply) {
+        this.cancelStart();
+        await this.write;
+        await this.closeProgress();
+        const trimmed = reply.trim();
+        if (this.textP && !this.toolsUsed) {
+            const s = await this.textP.catch(() => null);
+            this.textP = null;
+            if (s) {
+                const parts = splitBubbles(trimmed || this.textBuf, this.maxBubbleChars);
+                const first = parts[0] || trimmed;
+                await s.done(first || undefined);
+                this.published += first || "";
+                for (const extra of parts.slice(1)) {
+                    this.opts.stopTyping();
+                    await this.sink.send(extra);
+                    this.published += `\n\n${extra}`;
+                }
+                return first ? "streamed" : "empty";
+            }
+        }
+        await this.commitText(this.held);
+        const rest = unpublishedTail(trimmed, this.published);
+        if (!rest)
+            return this.published.trim() ? "streamed" : "empty";
+        this.opts.stopTyping();
+        const sent = await this.sendBubbles(rest);
+        return sent ? "sent" : this.published.trim() ? "streamed" : "empty";
+    }
+    async fail(text) {
+        this.cancelStart();
+        await this.write;
+        await this.closeProgress();
+        if (this.textP) {
+            const s = await this.textP.catch(() => null);
+            this.textP = null;
+            this.textBuf = "";
+            this.held = "";
+            if (s) {
+                await s.fail(text);
+                return;
+            }
+        }
+        this.opts.stopTyping();
+        await this.sink.send(text);
+    }
+    cancelStart() {
+        if (!this.startTimer)
+            return;
+        clearTimeout(this.startTimer);
+        this.startTimer = null;
+    }
+    enqueue(fn) {
+        this.write = this.write.then(fn).catch((err) => {
+            console.error(`[turn] ${err.message}`);
+        });
+    }
+    /** Open or append the current commentary/answer stream with this chunk only. */
+    async appendCommentary(chunk) {
+        if (!chunk)
+            return;
+        if (this.toolsUsed) {
+            await this.closeProgress();
+            this.held += chunk;
+            const cut = this.held.lastIndexOf("\n\n");
+            if (cut >= 0) {
+                const ready = this.held.slice(0, cut);
+                this.held = this.held.slice(cut + 2);
+                this.opts.stopTyping();
+                await this.sendBubbles(ready);
+            }
+            else if (this.held.length >= this.maxBubbleChars) {
+                const ready = this.held;
+                this.held = "";
+                this.opts.stopTyping();
+                await this.sendBubbles(ready);
+            }
+            return;
+        }
+        this.opts.stopTyping();
+        if (!this.textP) {
+            this.textP = this.sink.stream();
+            try {
+                const s = await this.textP;
+                s.append(chunk);
+                this.textBuf += chunk;
+            }
+            catch (err) {
+                this.textP = null;
+                this.opts.onStreamError(err);
+                await this.sink.send(chunk).catch(() => { });
+                this.published += chunk;
+            }
             return;
         }
-        this.arm();
+        try {
+            const s = await this.textP;
+            s.append(chunk);
+            this.textBuf += chunk;
+        }
+        catch (err) {
+            this.textP = null;
+            this.opts.onStreamError(err);
+            await this.sink.send(this.textBuf + chunk).catch(() => { });
+            this.published += this.textBuf + chunk;
+            this.textBuf = "";
+        }
     }
-    async flush() {
-        if (this.timer) {
-            clearTimeout(this.timer);
-            this.timer = null;
+    /** Finalize the current commentary so later tools land below it. */
+    async commitText(pending = "") {
+        if (this.textP) {
+            const s = await this.textP.catch(() => null);
+            this.textP = null;
+            const extra = pending;
+            const final = this.textBuf + extra;
+            this.textBuf = "";
+            if (s && final) {
+                if (extra)
+                    s.append(extra);
+                await s.done(final).catch(() => { });
+                this.published += final;
+                return;
+            }
+            if (final.trim()) {
+                this.opts.stopTyping();
+                await this.sendBubbles(final);
+            }
+            return;
         }
-        if (this.lines.length === 0)
+        if (!pending.trim())
             return;
-        const text = this.lines.join("\n");
-        this.lines = [];
-        this.chain = this.chain.then(() => this.send(text).catch(() => { }));
-        await this.chain;
+        this.opts.stopTyping();
+        await this.sendBubbles(pending);
+    }
+    async sendBubbles(text) {
+        const parts = splitBubbles(text, this.maxBubbleChars);
+        if (!parts.length)
+            return false;
+        for (const part of parts) {
+            await this.sink.send(part);
+            this.published += this.published ? `\n\n${part}` : part;
+        }
+        return true;
     }
-    arm() {
-        if (this.timer)
-            clearTimeout(this.timer);
-        this.timer = setTimeout(() => {
-            this.timer = null;
-            void this.flush();
-        }, this.gapMs);
+    async addProgressLine(line) {
+        this.opts.stopTyping();
+        if (this.progressLines.length >= this.maxProgressLines && this.progressP) {
+            await this.closeProgress();
+        }
+        this.progressLines.push(line);
+        const body = this.progressLines.join("\n");
+        if (!this.progressP) {
+            this.progressP = this.sink.stream();
+            try {
+                this.progress = await this.progressP;
+                this.progress.replace(body);
+            }
+            catch (err) {
+                this.progressP = null;
+                this.progress = null;
+                this.opts.onStreamError(err);
+                await this.sink.send(body).catch(() => { });
+            }
+            return;
+        }
+        this.progress?.replace(body);
+    }
+    async closeProgress() {
+        if (!this.progressP) {
+            this.progressLines = [];
+            this.progress = null;
+            return;
+        }
+        const s = await this.progressP.catch(() => null);
+        this.progressP = null;
+        this.progress = null;
+        const text = this.progressLines.join("\n");
+        this.progressLines = [];
+        if (s && text)
+            await s.done(text).catch(() => { });
     }
 }
-/** Hint so Hermes ends a tool-using turn with a recap, like Telegram. */
-export const RECAP_HINT = "When this turn used tools (read/write files, commands, skills, memory), end your reply with a short recap: what was going on, what you did, and the result. Skip the recap for simple chat with no tools. No em dashes.";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nopeek/agent-bridge",
-  "version": "0.7.11",
+  "version": "0.7.15",
   "description": "Run your own agents as E2EE NoPeek bots. Pairs with one-time codes (multiple accounts per computer), runs every bot each account owns, and pipes messages to any command or webhook.",
   "type": "module",
   "license": "MIT",
@@ -22,15 +22,8 @@
   "engines": {
     "node": ">=22"
   },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "prepack": "tsc -p tsconfig.json",
-    "start": "node dist/cli.js",
-    "dev": "tsx src/cli.ts",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
-  },
   "dependencies": {
-    "@nopeek/chat": "workspace:^0.2.4"
+    "@nopeek/chat": "^0.2.4"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",
@@ -47,5 +40,12 @@
   ],
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/cli.js",
+    "dev": "tsx src/cli.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "tsx --test --test-concurrency=1 src/tool-progress.test.ts src/inbound-files.test.ts src/mid-turn.test.ts"
   }
-}
+}