@nopeek/agent-bridge 0.7.20 → 0.7.22

package/dist/backends.js

@@ -620,6 +620,10 @@ export function hermesBrain(cfg) {
             const reply = await http(text, ctx, hooks);
             if (reply)
                 return reply;
+            // A mid-turn abort is intentional (user follow-up). Do not spawn a
+            // second Hermes CLI job — that is how empty "…" bubbles stacked up.
+            if (ctx.signal?.aborted)
+                return "";
             console.error(`[brain:hermes:@${ctx.botHandle.replace(/^@/, "")}] API returned empty — falling back to CLI`);
         }
         return cli(text, ctx, hooks);

package/dist/bot.d.ts

@@ -64,6 +64,8 @@ export declare class BotRunner {
     /** Fire-and-forget: runs the connect loop in the background, isolated. */
     start(): void;
     stop(): void;
+    /** Crash/restart must not leave Hermes running against a dead socket. */
+    private abortLiveTurns;
     private mintSession;
     /** Fetch (or refresh) the set of users allowed to talk to this bot. Called on
      *  connect and whenever a grant changes. Best-effort: on failure we keep the
@@ -96,6 +98,13 @@ export declare class BotRunner {
     private ownerIsChannelMember;
     private run;
     private connectOnce;
+    /**
+     * A bridge restart mid-stream leaves `{streaming:true}` bubbles with a live
+     * caret forever. On connect, finalize our own orphan streams and tell the
+     * human we got cut off — Telegram never sits on a typing caret for hours.
+     */
+    private settleAllOrphans;
+    private settleOrphanStreams;
     /** Runtime sessions expire; reconnect with a fresh one shortly before that. */
     private scheduleRefresh;
     private reconnect;

package/dist/bot.js

@@ -8,7 +8,7 @@ import { FALLBACK_REPLY, resolveBrain } from "./brain.js";
 import { beginTurn, finishTurn, lastTurnFor } from "./last-turn.js";
 import { FileStore } from "./storage.js";
 import { TurnPublisher } from "./tool-progress.js";
-import { ChannelTurn, coalesceFollowups, isStopRequest, wrapInterruptedFollowup, } from "./mid-turn.js";
+import { ChannelTurn, coalesceFollowups, isBotEcho, isPlaceholderText, isStopRequest, wrapInterruptedFollowup, } from "./mid-turn.js";
 import { buildInboundPrompt, describeStructured, hasInboundWork, isControlType, parseAttachments, saveInboundFiles, } from "./inbound-files.js";
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 const MAX_BACKOFF_MS = 60_000;
@@ -116,6 +116,7 @@ export class BotRunner {
         if (this.stopped)
             return; // truly stopped (unpair) — never resurrect
         this.lastForcedRestart = Date.now();
+        this.abortLiveTurns();
         if (this.refreshTimer)
             clearTimeout(this.refreshTimer);
         this.refreshTimer = null;
@@ -143,6 +144,7 @@ export class BotRunner {
     }
     stop() {
         this.stopped = true;
+        this.abortLiveTurns();
         if (this.refreshTimer)
             clearTimeout(this.refreshTimer);
         try {
@@ -154,6 +156,13 @@ export class BotRunner {
         this.np = null;
         this.connected = false;
     }
+    /** Crash/restart must not leave Hermes running against a dead socket. */
+    abortLiveTurns() {
+        for (const turn of this.turns.values()) {
+            if (turn.active)
+                turn.abort.abort();
+        }
+    }
     async mintSession() {
         const res = await fetch(`${this.pairing.apiUrl}/v1/apps/${this.pairing.appId}/bots/${this.info.userId}/runtime-session`, {
             method: "POST",
@@ -378,6 +387,10 @@ export class BotRunner {
         np.on("member.joined", onRosterChange);
         np.on("member.left", onRosterChange);
         np.on("message", ((m) => {
+            // Own stream() placeholders echo back as message.new. Never interrupt
+            // or answer those — that loop is what left "…" edited bubbles.
+            if (isBotEcho(m, this.info.userId))
+                return;
             const live = this.turns.get(m.channelId);
             if (live?.active) {
                 live.interrupt({ id: m.messageId, message: m });
@@ -397,6 +410,68 @@ export class BotRunner {
         }));
         await this.refreshAccess(); // load the allow list before we answer anyone
         this.scheduleRefresh(session.expiresAt);
+        void this.settleAllOrphans();
+    }
+    /**
+     * A bridge restart mid-stream leaves `{streaming:true}` bubbles with a live
+     * caret forever. On connect, finalize our own orphan streams and tell the
+     * human we got cut off — Telegram never sits on a typing caret for hours.
+     */
+    async settleAllOrphans() {
+        if (!this.np || this.stopped)
+            return;
+        let channels;
+        try {
+            channels = await this.np.channels.list();
+        }
+        catch (err) {
+            this.logErr(`orphan scan list failed: ${err.message}`);
+            return;
+        }
+        for (const ch of channels) {
+            if (this.stopped)
+                return;
+            if (this.turns.get(ch.channelId)?.active)
+                continue;
+            try {
+                const n = await this.settleOrphanStreams(ch);
+                if (n > 0) {
+                    this.log(`${ch.channelId} finalized ${n} orphan stream(s)`);
+                    await ch.send({
+                        text: "I got cut off mid-turn. Send another message and I'll pick up.",
+                    }).catch((err) => this.notePostFailure(ch.channelId, err));
+                }
+            }
+            catch (err) {
+                this.logErr(`orphan settle ${ch.channelId}: ${err.message}`);
+            }
+        }
+    }
+    async settleOrphanStreams(ch) {
+        try {
+            await ch.ensureKey();
+        }
+        catch {
+            return 0;
+        }
+        const recent = await ch.history({ limit: 40 });
+        let n = 0;
+        for (const m of recent) {
+            if (m.senderUserId !== this.info.userId)
+                continue;
+            const body = m.body;
+            if (!body || body.streaming !== true)
+                continue;
+            const text = typeof body.text === "string" ? body.text : "";
+            if (!text.trim() || isPlaceholderText(text)) {
+                await ch.recall(m.messageId).catch(() => { });
+            }
+            else {
+                await ch.edit(m.messageId, { text, streaming: false }).catch(() => { });
+            }
+            n += 1;
+        }
+        return n;
     }
     /** Runtime sessions expire; reconnect with a fresh one shortly before that. */
     scheduleRefresh(expiresAt) {
@@ -731,7 +806,7 @@ export class BotRunner {
         };
     }
     async ingestFollowup(m) {
-        if (m.senderUserId === this.info.userId)
+        if (isBotEcho(m, this.info.userId))
             return null;
         if (this.cantPost.has(m.channelId))
             return null;

package/dist/bridge.d.ts

@@ -1,5 +1,5 @@
 import type { BridgeConfig, Pairing, BrainSpec, BrainBackend } from "./config.js";
-export declare const VERSION = "0.7.14";
+export declare const VERSION = "0.7.22";
 export interface PairRequest {
     pairingSecret: string;
     appId: string;

package/dist/bridge.js

@@ -19,7 +19,7 @@ import { reportCapabilities } from "./capabilities.js";
 import { lastHermesApiHealth, probeHermesApi } from "./hermes-http.js";
 import { lastTurnGlobal, turnSnapshot } from "./last-turn.js";
 import { isBrainBackend } from "./config.js";
-export const VERSION = "0.7.14";
+export const VERSION = "0.7.22";
 function hermesApiStatus(cfg) {
     const api = lastHermesApiHealth();
     return {

package/dist/inbound-files.js

@@ -56,7 +56,7 @@ export function hasInboundWork(body) {
     const b = body;
     if (isControlType(b.type))
         return false;
-    if (typeof b.text === "string" && b.text.trim())
+    if (typeof b.text === "string" && b.text.trim() && b.text.trim() !== "…" && b.text.trim() !== "...")
         return true;
     if (parseAttachments(body).length > 0)
         return true;

package/dist/mid-turn.d.ts

@@ -4,6 +4,21 @@ export interface FollowupDecision {
     text: string;
 }
 export declare function isStopRequest(text: string): boolean;
+/** Bare stream() placeholder. Must never count as a user follow-up. */
+export declare function isPlaceholderText(text: string): boolean;
+/**
+ * Own stream() posts come back as message.new on the same socket. If we treat
+ * those as mid-turn interrupts, the bot aborts itself on every "…" bubble,
+ * Hermes HTTP returns empty, CLI fallback starts a second job, and the chat
+ * fills with edited dots. Telegram never sees the bot's own outbound messages.
+ */
+export declare function isBotEcho(m: {
+    senderUserId?: string;
+    body?: {
+        text?: unknown;
+        streaming?: unknown;
+    } | null;
+}, botUserId: string): boolean;
 export declare function coalesceFollowups(texts: string[]): FollowupDecision;
 export declare function wrapInterruptedFollowup(text: string): string;
 export declare function hermesSessionId(channelId: string): string;

package/dist/mid-turn.js

@@ -11,6 +11,27 @@ const STOP_RE = /^(?:\/)?(?:please\s+)?stop(?:\s+please)?[.!]?$/i;
 export function isStopRequest(text) {
     return STOP_RE.test((text || "").trim());
 }
+/** Bare stream() placeholder. Must never count as a user follow-up. */
+export function isPlaceholderText(text) {
+    const t = (text || "").trim();
+    return t === "…" || t === "...";
+}
+/**
+ * Own stream() posts come back as message.new on the same socket. If we treat
+ * those as mid-turn interrupts, the bot aborts itself on every "…" bubble,
+ * Hermes HTTP returns empty, CLI fallback starts a second job, and the chat
+ * fills with edited dots. Telegram never sees the bot's own outbound messages.
+ */
+export function isBotEcho(m, botUserId) {
+    if (botUserId && m.senderUserId === botUserId)
+        return true;
+    const body = m.body;
+    if (body && body.streaming === true)
+        return true;
+    if (typeof body?.text === "string" && isPlaceholderText(body.text))
+        return true;
+    return false;
+}
 export function coalesceFollowups(texts) {
     const cleaned = texts.map((t) => (t || "").trim()).filter(Boolean);
     if (cleaned.length === 0)

package/package.json

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