@nopeek/agent-bridge 0.7.15 → 0.7.17

package/dist/tool-progress.d.ts

@@ -7,7 +7,9 @@ export type ToolProgressEvent = {
 /** One Telegram-style line. Running events only; completed is silent. */
 export declare function formatToolLine(ev: ToolProgressEvent): string | null;
 /** Hint so Hermes ends a tool-using turn with a recap, like Telegram. */
-export declare 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.";
+export declare const RECAP_HINT = "When this turn used tools, your LAST message must be a short phone briefing: (1) what was wrong, (2) what you did, (3) the solution / current state. Never end on a tool list, a diff, code, or \"tasks completed\". Skip the briefing only for simple chat with no tools. No em dashes.";
+/** Posted when tools ran but the model never wrote a human recap. */
+export declare const MISSING_BRIEFING = "Done. I finished that work. Ask if you want the recap: what was wrong, what I did, and where things stand.";
 export interface StreamHandle {
     append(chunk: string): void;
     replace(full: string): void;
@@ -27,12 +29,19 @@ export type TurnPublisherOpts = {
     maxProgressLines?: number;
     /** Split commentary/recap into a new bubble after this many chars. */
     maxBubbleChars?: number;
+    /** If nothing arrives for this long, the next chunk is a new message. 0 = off. */
+    bubbleGapMs?: number;
 };
 export type TurnFinishKind = "streamed" | "sent" | "empty";
 /** Text in `full` that has not already been posted as commentary. */
 export declare function unpublishedTail(full: string, published: string): string;
 /** Unified diffs / `| review` dumps should never land in the chat. */
+export declare function isDumpLine(line: string): boolean;
+/** True when the text has a user-readable recap, not just tools/dumps. */
+export declare function isHumanBriefing(text: string): boolean;
 export declare function isToolDump(text: string): boolean;
+/** Drop dump lines from a live chunk without swallowing normal punctuation. */
+export declare function stripDumps(text: string): string;
 /** Split a reply into short chat bubbles. Drops tool-dump paragraphs. */
 export declare function splitBubbles(text: string, max?: number): string[];
 /**
@@ -53,16 +62,21 @@ export declare class TurnPublisher {
     private published;
     private toolsUsed;
     private startTimer;
+    private gapTimer;
     private seen;
     private readonly startDelayMs;
     private readonly maxProgressLines;
     private readonly maxBubbleChars;
+    private readonly bubbleGapMs;
     constructor(sink: TurnSink, opts: TurnPublisherOpts);
     onChunk(delta: string): void;
     onTool(ev: ToolProgressEvent): void;
     finish(reply: string): Promise<TurnFinishKind>;
     fail(text: string): Promise<void>;
     private cancelStart;
+    private cancelGap;
+    /** After `bubbleGapMs` of silence, seal the current bubble. Next text is new. */
+    private armGap;
     private enqueue;
     /** Open or append the current commentary/answer stream with this chunk only. */
     private appendCommentary;

package/dist/tool-progress.js

@@ -49,7 +49,9 @@ function tidyLabel(raw) {
     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.";
+export const RECAP_HINT = "When this turn used tools, your LAST message must be a short phone briefing: (1) what was wrong, (2) what you did, (3) the solution / current state. Never end on a tool list, a diff, code, or \"tasks completed\". Skip the briefing only for simple chat with no tools. No em dashes.";
+/** Posted when tools ran but the model never wrote a human recap. */
+export const MISSING_BRIEFING = "Done. I finished that work. Ask if you want the recap: what was wrong, what I did, and where things stand.";
 /** Text in `full` that has not already been posted as commentary. */
 export function unpublishedTail(full, published) {
     const f = full.trim();
@@ -77,26 +79,82 @@ export function unpublishedTail(full, published) {
 }
 const DEFAULT_MAX_BUBBLE = 480;
 /** Unified diffs / `| review` dumps should never land in the chat. */
+export function isDumpLine(line) {
+    const l = line.trim();
+    if (!l)
+        return false;
+    if (/^review diff\b/i.test(l))
+        return true;
+    if (/^\|\s*(review|read|search|terminal|patch|write)\b/i.test(l))
+        return true;
+    if (/^@@\s+-/.test(l))
+        return true;
+    if (/^diff --git /.test(l))
+        return true;
+    if (/^\*\*\*\s+(Begin|Update|Add|Delete|End)\b/.test(l))
+        return true;
+    if (/^[ab]:?\/{1,2}Volumes\//.test(l))
+        return true;
+    if (/^index [0-9a-f]+\.\.[0-9a-f]+/.test(l))
+        return true;
+    // Unified-diff / review lines: "+    const x =" not "+1 country".
+    if (/^[+-]\s{2,}\S/.test(l))
+        return true;
+    if (/^[+-]\s*(import |from |export |const |let |function |class |def |if cmd\b|return )/.test(l))
+        return true;
+    if (/^[+-]\s*["'`{]/.test(l))
+        return true;
+    return false;
+}
+function isToolProgressLine(line) {
+    const l = line.trim();
+    if (!l)
+        return false;
+    return /^.+ \S+: ".+"$/.test(l) || /^.+ \S+\.\.\.$/.test(l);
+}
+/** True when the text has a user-readable recap, not just tools/dumps. */
+export function isHumanBriefing(text) {
+    const prose = text
+        .split("\n")
+        .filter((l) => {
+        const t = l.trim();
+        return Boolean(t) && !isDumpLine(t) && !isToolProgressLine(t);
+    })
+        .join("\n")
+        .trim();
+    if (!prose || isToolDump(prose))
+        return false;
+    return true;
+}
 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))
+    if (isDumpLine(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)
+        const dumpy = lines.filter((l) => isDumpLine(l) || /^(@@ |[+-](?![+-])|\| )/.test(l)).length;
+        if (dumpy / lines.length >= 0.4)
             return true;
     }
     return false;
 }
+/** Drop dump lines from a live chunk without swallowing normal punctuation. */
+export function stripDumps(text) {
+    if (!text)
+        return text;
+    if (!text.includes("\n"))
+        return isDumpLine(text) ? "" : text;
+    if (isToolDump(text))
+        return "";
+    return text
+        .split("\n")
+        .filter((l) => !isDumpLine(l))
+        .join("\n");
+}
 /** 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();
@@ -168,39 +226,44 @@ export class TurnPublisher {
     published = "";
     toolsUsed = false;
     startTimer = null;
+    gapTimer = null;
     seen = new Set();
     startDelayMs;
     maxProgressLines;
     maxBubbleChars;
+    bubbleGapMs;
     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;
+        this.bubbleGapMs = opts.bubbleGapMs ?? 2000;
     }
     onChunk(delta) {
-        if (!delta)
+        const chunk = stripDumps(delta);
+        if (!chunk)
             return;
+        this.armGap();
         if (this.toolsUsed) {
             this.cancelStart();
-            this.enqueue(() => this.appendCommentary(delta));
+            this.enqueue(() => this.appendCommentary(chunk));
             return;
         }
         if (this.textP) {
-            this.enqueue(() => this.appendCommentary(delta));
+            this.enqueue(() => this.appendCommentary(chunk));
             return;
         }
-        this.held += delta;
+        this.held += chunk;
         if (this.startTimer)
             return;
         this.startTimer = setTimeout(() => {
             this.startTimer = null;
             if (this.toolsUsed || this.textP || !this.held)
                 return;
-            const chunk = this.held;
+            const ready = this.held;
             this.held = "";
-            this.enqueue(() => this.appendCommentary(chunk));
+            this.enqueue(() => this.appendCommentary(ready));
         }, this.startDelayMs);
     }
     onTool(ev) {
@@ -213,10 +276,8 @@ export class TurnPublisher {
             return;
         this.seen.add(line);
         this.toolsUsed = true;
-        if (this.startTimer) {
-            clearTimeout(this.startTimer);
-            this.startTimer = null;
-        }
+        this.cancelStart();
+        this.cancelGap();
         this.enqueue(async () => {
             const pending = this.held;
             this.held = "";
@@ -226,35 +287,27 @@ export class TurnPublisher {
     }
     async finish(reply) {
         this.cancelStart();
+        this.cancelGap();
         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";
+        this.held = "";
+        const rest = unpublishedTail(reply.trim(), this.published);
+        if (rest) {
+            this.opts.stopTyping();
+            await this.sendBubbles(rest);
+        }
+        if (this.toolsUsed && reply.trim() && !isHumanBriefing(this.published)) {
+            this.opts.stopTyping();
+            await this.sendBubbles(MISSING_BRIEFING);
+        }
+        if (!this.published.trim())
+            return "empty";
+        return rest || this.toolsUsed ? "sent" : "streamed";
     }
     async fail(text) {
         this.cancelStart();
+        this.cancelGap();
         await this.write;
         await this.closeProgress();
         if (this.textP) {
@@ -276,6 +329,26 @@ export class TurnPublisher {
         clearTimeout(this.startTimer);
         this.startTimer = null;
     }
+    cancelGap() {
+        if (!this.gapTimer)
+            return;
+        clearTimeout(this.gapTimer);
+        this.gapTimer = null;
+    }
+    /** After `bubbleGapMs` of silence, seal the current bubble. Next text is new. */
+    armGap() {
+        this.cancelGap();
+        if (this.bubbleGapMs <= 0)
+            return;
+        this.gapTimer = setTimeout(() => {
+            this.gapTimer = null;
+            this.enqueue(async () => {
+                const pending = this.held;
+                this.held = "";
+                await this.commitText(pending);
+            });
+        }, this.bubbleGapMs);
+    }
     enqueue(fn) {
         this.write = this.write.then(fn).catch((err) => {
             console.error(`[turn] ${err.message}`);
@@ -343,8 +416,19 @@ export class TurnPublisher {
             if (s && final) {
                 if (extra)
                     s.append(extra);
-                await s.done(final).catch(() => { });
-                this.published += final;
+                const parts = splitBubbles(final, this.maxBubbleChars);
+                if (!parts.length) {
+                    await s.done("…").catch(() => { });
+                    return;
+                }
+                const first = parts[0];
+                await s.done(first).catch(() => { });
+                this.published += first;
+                for (const more of parts.slice(1)) {
+                    this.opts.stopTyping();
+                    await this.sink.send(more);
+                    this.published += `\n\n${more}`;
+                }
                 return;
             }
             if (final.trim()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nopeek/agent-bridge",
-  "version": "0.7.15",
+  "version": "0.7.17",
   "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",