kiro-telegram-bot 1.6.0 → 1.7.2

package/src/stream/streamer.ts

@@ -13,6 +13,8 @@
 import type { Api } from "grammy";
 import { chunkMarkdown } from "../render/chunk.js";
 import { toTelegramMarkdown } from "../render/markdown.js";
+import { extractProgress, progressBar } from "../render/progress.js";
+import { estimateProgress } from "../render/progress-estimate.js";
 import { safeEdit, safeSend } from "../bot/telegram-io.js";
 
 const SOFT_LIMIT = 3500;
@@ -32,6 +34,16 @@ export class ResponseStreamer {
   private dirty = false;
   private flushing = false;
   private closed = false;
+  /** Latest task-progress % parsed from the agent's `{progress: N%}` markers
+   *  (sticky across flushes; rendered as a bar on the live message). */
+  private progress: number | undefined;
+  /** True once the agent emitted a real `{progress}` marker — from then on its
+   *  values are authoritative and the bot fallback stops contributing. */
+  private agentReported = false;
+  /** Real work signals for the fallback estimate (monotonic within a turn). */
+  private toolCalls = 0;
+  private outChars = 0;
+  private thoughtChars = 0;
 
   constructor(
     private readonly api: Api,
@@ -39,6 +51,11 @@ export class ResponseStreamer {
     private readonly throttleMs: number,
     private replyTo?: number,
     private footer?: string,
+    private readonly onProgress?: (pct: number) => void,
+    /** Show a bot-computed bar when the agent emits no marker. */
+    private readonly fallbackEnabled = false,
+    /** Turn start time, used by the fallback's elapsed-time signal. */
+    private readonly turnStartedAt = Date.now(),
   ) {}
 
   /** Replace the hashtag footer (used after a logical fork swaps the session id
@@ -52,6 +69,49 @@ export class ResponseStreamer {
     return this.footer ? `\n\n${this.footer}` : "";
   }
 
+  /** Strip `{progress: N%}` markers from rendered text, remembering the latest
+   *  value (sticky across flushes) and notifying the owner when it changes. */
+  private captureProgress(text: string): string {
+    const { value, cleaned } = extractProgress(text);
+    if (value !== undefined) this.setProgressValue(value, true);
+    return cleaned;
+  }
+
+  /** Record a progress value, enforcing global monotonicity (never decreases)
+   *  and notifying the owner on change. Agent markers are authoritative: once
+   *  one arrives, the bot fallback stops contributing. */
+  private setProgressValue(pct: number, fromAgent: boolean): void {
+    if (fromAgent) this.agentReported = true;
+    const next = Math.max(this.progress ?? 0, Math.round(pct));
+    if (next === this.progress) return;
+    this.progress = next;
+    try {
+      this.onProgress?.(next);
+    } catch {
+      /* non-fatal */
+    }
+  }
+
+  /** Advance the fallback estimate from real activity signals, but only while
+   *  the agent itself hasn't reported a value. No-op when fallback is off. */
+  private applyFallback(): void {
+    if (!this.fallbackEnabled || this.agentReported) return;
+    const est = estimateProgress({
+      toolCalls: this.toolCalls,
+      outputChars: this.outChars,
+      thoughtChars: this.thoughtChars,
+      elapsedMs: Date.now() - this.turnStartedAt,
+    });
+    if (est > 0) this.setProgressValue(est, false);
+  }
+
+  /** Called when the turn finishes successfully: if the agent never reported
+   *  its own progress, fill the fallback bar to 100. No-op otherwise. */
+  completeFallback(): void {
+    if (!this.fallbackEnabled || this.agentReported) return;
+    this.setProgressValue(100, false);
+  }
+
   /** reply_parameters threading EVERY message of the turn to the user's prompt,
    *  so the whole response (all bubbles, tool calls and continuations) stays in
    *  one thread — not just the first message. */
@@ -62,18 +122,21 @@ export class ResponseStreamer {
 
   appendOutput(text: string): void {
     if (!text) return;
+    this.outChars += text.length;
     this.merge("out", text);
     this.schedule();
   }
 
   appendThought(text: string): void {
     if (!text) return;
+    this.thoughtChars += text.length;
     this.merge("think", text);
     this.schedule();
   }
 
   addTool(rawMarkdown: string): void {
     if (!rawMarkdown) return;
+    this.toolCalls += 1;
     this.segs.push({ kind: "tool", text: rawMarkdown });
     this.schedule();
   }
@@ -117,11 +180,16 @@ export class ResponseStreamer {
     this.dirty = false;
     try {
       await this.sealOverflow();
-      const base = renderSegs(this.segs.slice(this.sealedIdx));
+      const base = this.captureProgress(renderSegs(this.segs.slice(this.sealedIdx)));
+      this.applyFallback();
+      // Never send an empty / progress-only bubble. The bar is appended only to
+      // real streamed content; the live status panel shows the standalone bar.
       if (!base.trim()) return;
-      // Every bubble — including the still-streaming live one — carries the
-      // hashtag footer so the thinking/first response is tagged immediately.
-      const src = `${base}${this.footerSuffix()}`;
+      // The live (still-streaming) bubble carries the hashtag footer AND a fresh
+      // progress bar at the bottom (sealed bubbles below get neither bar).
+      const parts: string[] = [base];
+      if (this.progress !== undefined) parts.push(progressBar(this.progress));
+      const src = `${parts.join("\n\n")}${this.footerSuffix()}`;
       const rendered = toTelegramMarkdown(src);
       const chunks = chunkMarkdown(rendered);
       const plain = chunkMarkdown(src);
@@ -158,7 +226,7 @@ export class ResponseStreamer {
   }
 
   private async seal(from: number, to: number): Promise<void> {
-    const base = renderSegs(this.segs.slice(from, to));
+    const base = this.captureProgress(renderSegs(this.segs.slice(from, to)));
     if (!base.trim()) return;
     // A sealed bubble is finished, so it carries the footer (hashtags).
     const src = `${base}${this.footerSuffix()}`;