@moxxy/plugin-telegram 0.44.0 → 0.45.0

package/src/render.test.ts

@@ -151,6 +151,23 @@ describe('TurnRenderer', () => {
     expect(frame.diffHtml).not.toContain('<Foo');
   });
 
+  it("says in the footer that the agent's limit is used up and when it resets, as the desktop does", () => {
+    const r = new TurnRenderer();
+    const out = r.accept(
+      baseEvent(
+        {
+          type: 'plugin_event',
+          source: 'system',
+          pluginId: asPluginId('@moxxy/agent-connection'),
+          subtype: 'account_limit',
+          payload: { provider: 'codex-agent', agent: 'Codex', limit: { state: 'reached', windowMinutes: 10080 } },
+        },
+        0,
+      ),
+    );
+    expect(out.errorHtml).toBe("⛔ <b>Codex's weekly limit is used up</b>");
+  });
+
   it('appends an error footer when an error event arrives', () => {
     const r = new TurnRenderer();
     const out = r.accept(baseEvent({ type: 'error', kind: 'fatal', message: 'boom', source: 'system' }, 0));
@@ -176,9 +193,88 @@ describe('TurnRenderer', () => {
     return r;
   };
 
+  const stepList = (steps: ReadonlyArray<{ text: string; status: string }>) => ({
+    forModel: 'list updated',
+    display: { kind: 'step-list', steps },
+  });
+
+  it('folds every step-list tool result into one list of the latest steps', () => {
+    const r = new TurnRenderer();
+    const first = asToolCallId('s1');
+    const second = asToolCallId('s2');
+    r.accept(baseEvent({ type: 'tool_call_requested', callId: first, name: 'TodoWrite', input: {}, source: 'model' }, 0));
+    r.accept(baseEvent({
+      type: 'tool_result', callId: first, ok: true, source: 'tool',
+      output: stepList([{ text: 'Read the logs', status: 'in_progress' }, { text: 'Fix <the> bug', status: 'pending' }]),
+    }, 1));
+    r.accept(baseEvent({ type: 'tool_call_requested', callId: second, name: 'TodoWrite', input: {}, source: 'model' }, 2));
+    const frame = r.accept(baseEvent({
+      type: 'tool_result', callId: second, ok: true, source: 'tool',
+      output: stepList([
+        { text: 'Read the logs', status: 'completed' },
+        { text: 'Fix <the> bug', status: 'in_progress' },
+        { text: 'Run the tests', status: 'pending' },
+        { text: 'Ask for review', status: 'cancelled' },
+      ]),
+    }, 3));
+
+    expect(frame.activityHtml).toContain('<b>Steps · 2 of 4 done</b>');
+    expect(frame.activityHtml).toContain('✓ Read the logs');
+    expect(frame.activityHtml).toContain('● <b>Fix &lt;the&gt; bug</b>');
+    expect(frame.activityHtml).toContain('○ Run the tests');
+    expect(frame.activityHtml).toContain('✗ <s>Ask for review</s>');
+    expect(frame.activityHtml.match(/Steps ·/g)).toHaveLength(1);
+    expect(frame.activityHtml).not.toContain('<code>TodoWrite</code>');
+  });
+
+  it('does not count step-list calls as steps of the collapsed trace', () => {
+    const r = withTools(4);
+    const id = asToolCallId('list');
+    r.accept(baseEvent({ type: 'tool_call_requested', callId: id, name: 'update_plan', input: {}, source: 'model' }, 20));
+    r.accept(baseEvent({
+      type: 'tool_result', callId: id, ok: true, source: 'tool',
+      output: stepList([{ text: 'One', status: 'completed' }]),
+    }, 21));
+    expect(r.snapshot({ final: true }).activityHtml).toContain('🔧 <b>4 steps</b>');
+  });
+
+  it('names how many images the tools returned and keeps each image once', () => {
+    const r = new TurnRenderer();
+    const shot = { mediaType: 'image/png', base64: 'AAAA' };
+    for (const [i, output] of [
+      { forModel: 'screen', ...shot, moreImages: [{ mediaType: 'image/jpeg', base64: 'BBBB' }] },
+      { forModel: 'screen again', ...shot },
+    ].entries()) {
+      const id = asToolCallId(`shot${i}`);
+      r.accept(baseEvent({ type: 'tool_call_requested', callId: id, name: 'screenshot', input: {}, source: 'model' }, i * 2));
+      r.accept(baseEvent({ type: 'tool_result', callId: id, ok: true, output, source: 'tool' }, i * 2 + 1));
+    }
+    expect(r.images()).toEqual([shot, { mediaType: 'image/jpeg', base64: 'BBBB' }]);
+    expect(r.snapshot().activityHtml).toContain('🖼 2 images came back');
+  });
+
+  it('says while the turn runs that the agent of a connection is using the computer, and how to stop it', () => {
+    const r = new TurnRenderer({ agentName: () => 'Codex' });
+    const frame = r.accept(baseEvent({
+      type: 'tool_call_requested', callId: c1, name: 'mcp__computer-use__click', input: { app: 'Arc' },
+      executedBy: 'provider', source: 'model',
+    }, 0));
+    expect(frame.activityHtml).toContain('🖥 <b>Codex is using your computer · Arc</b> — send /cancel to stop');
+    // The turn is over on the final frame: nothing is using the computer any more.
+    expect(r.snapshot({ final: true }).activityHtml).not.toContain('using your computer');
+  });
+
+  it('does not report Moxxy’s own computer tools as an agent using the computer', () => {
+    const r = new TurnRenderer({ agentName: () => 'Codex' });
+    const frame = r.accept(baseEvent({
+      type: 'tool_call_requested', callId: c1, name: 'mcp__computer-use__click', input: { app: 'Arc' }, source: 'model',
+    }, 0));
+    expect(frame.activityHtml).not.toContain('using your computer');
+  });
+
   it('folds a long activity trace into an expandable box with a summary on the final frame', () => {
     const r = withTools(4);
-    const snap = r.snapshot({ collapse: true });
+    const snap = r.snapshot({ final: true });
     expect(snap.activityHtml).toContain('<blockquote expandable>');
     expect(snap.activityHtml).toContain('🔧 <b>4 steps</b>');
     // The tool lines are still in the (collapsed) box.
@@ -187,7 +283,7 @@ describe('TurnRenderer', () => {
 
   it('keeps the activity open (no expandable) while streaming', () => {
     const r = withTools(5);
-    const snap = r.snapshot(); // default collapse=false
+    const snap = r.snapshot(); // streaming frame
     expect(snap.activityHtml).toContain('<blockquote>');
     expect(snap.activityHtml).not.toContain('expandable');
     expect(snap.activityHtml).not.toContain('🔧');
@@ -195,7 +291,7 @@ describe('TurnRenderer', () => {
 
   it('keeps a short activity trace inline even on the final frame', () => {
     const r = withTools(2); // below the collapse threshold
-    const snap = r.snapshot({ collapse: true });
+    const snap = r.snapshot({ final: true });
     expect(snap.activityHtml).toContain('<blockquote>');
     expect(snap.activityHtml).not.toContain('expandable');
   });
@@ -210,7 +306,7 @@ describe('TurnRenderer', () => {
     r.accept(baseEvent({ type: 'tool_result', callId: id, ok: true, output: 'ok', source: 'tool' }, 2));
     r.accept(baseEvent({ type: 'skill_created', name: 's1', source: 'system' }, 3));
     r.accept(baseEvent({ type: 'skill_created', name: 's2', source: 'system' }, 4));
-    const snap = r.snapshot({ collapse: true });
+    const snap = r.snapshot({ final: true });
     expect(snap.activityHtml).toContain('<blockquote expandable>');
     expect(snap.activityHtml).toContain('🔧 <b>1 step</b>');
   });

package/src/render.ts

@@ -1,11 +1,21 @@
-import type { MoxxyEvent } from '@moxxy/sdk';
+import type { MoxxyEvent, StepListDisplay } from '@moxxy/sdk';
 import {
   assertDefined,
   fileDiffSummary,
   fileDiffVerb,
   isFileDiffDisplay,
   type FileDiffDisplay,
+  type ToolImage,
 } from '@moxxy/sdk';
+import {
+  STEP_MARKS,
+  TurnAgentWork,
+  agentComputerText,
+  imagesLine,
+  stepListHeading,
+  unifiedDiffText,
+  usedUpLimitText,
+} from '@moxxy/channel-kit';
 
 const TELEGRAM_MESSAGE_LIMIT = 4000; // 4096 minus a safety margin
 
@@ -74,6 +84,11 @@ interface SkillEntry {
   readonly toolCount: number;
 }
 
+export interface TurnRendererOptions {
+  /** The name of the agent of the session's active agent connection ("Codex"), read when a frame is drawn. */
+  readonly agentName?: () => string | undefined;
+}
+
 export class TurnRenderer {
   private chunks: string[] = [];
   /** In-flight + completed tool calls keyed by callId, in arrival order. */
@@ -84,9 +99,17 @@ export class TurnRenderer {
   private errorLine: string | null = null;
   /** Pre-formatted HTML diff blocks, one per file-diff tool result, in arrival order. */
   private diffBlocks: string[] = [];
+  /** The step list, images and computer use of the turn, as every channel reads them. */
+  private readonly work = new TurnAgentWork();
+  private readonly agentName: () => string | undefined;
   private lastFrame = '';
 
+  constructor(opts: TurnRendererOptions = {}) {
+    this.agentName = opts.agentName ?? (() => undefined);
+  }
+
   accept(event: MoxxyEvent): RenderedFrame {
+    this.work.accept(event);
     switch (event.type) {
       case 'assistant_chunk':
         this.chunks.push(event.delta);
@@ -143,13 +166,17 @@ export class TurnRenderer {
       case 'skill_created':
         this.notices.push(`💡 created skill: <b>${escape(event.name)}</b>`);
         break;
-      case 'plugin_event':
+      case 'plugin_event': {
         if (event.pluginId === '@moxxy/subagents' && event.subtype === 'subagent_started') {
           const payload = (event.payload ?? {}) as Record<string, unknown>;
           const label = typeof payload.label === 'string' ? payload.label : 'agent';
           this.notices.push(`🤖 spawned agent <b>${escape(label)}</b>`);
         }
+        // The agent's used-up account limit ends the turn in place of an error.
+        const limit = usedUpLimitText(event);
+        if (limit) this.errorLine = `⛔ <b>${escape(limit)}</b>`;
         break;
+      }
       case 'error':
         this.errorLine = `❗ <b>${escape(event.kind)}</b>: ${escape(event.message)}`;
         break;
@@ -164,13 +191,14 @@ export class TurnRenderer {
   }
 
   /**
-   * Compose the current frame. `collapse` (set on the final flush) folds a
-   * long tool-activity trace into an expandable box so the finished message
-   * leads with the answer; during streaming it's left false so the activity
+   * Compose the current frame. `final` (set on the last flush, once the turn is
+   * over) folds a long tool-activity trace into an expandable box so the
+   * finished message leads with the answer, and drops what is only true while
+   * the turn runs (the agent using the computer); during streaming the activity
    * stays fully visible while work is in flight.
    */
-  snapshot(opts: { collapse?: boolean } = {}): RenderedFrame {
-    const activityHtml = this.renderActivity(opts.collapse ?? false) ?? '';
+  snapshot(opts: { final?: boolean } = {}): RenderedFrame {
+    const activityHtml = this.renderActivity(opts.final ?? false) ?? '';
     const body = this.finalAssistant ?? this.chunks.join('');
     const diffHtml = this.diffBlocks.join('\n\n');
     const errorHtml = this.errorLine ?? '';
@@ -187,18 +215,25 @@ export class TurnRenderer {
    * the fence/inline placeholder dance). Use `__inert__` markers so
    * already-formed HTML doesn't get re-escaped.
    *
-   * When `collapse` is set (final frame) and the trace ran long, fold it
+   * On the final frame, when the trace ran long, fold it
    * into a `<blockquote expandable>` topped by a one-line summary — the
    * tool noise becomes a tap-to-open box and the assistant's answer leads.
    */
-  private renderActivity(collapse: boolean): string | null {
+  private renderActivity(final: boolean): string | null {
     const lines: string[] = [];
+    const computer = this.work.computerUse;
+    if (computer && !final) {
+      lines.push(`🖥 <b>${escape(agentComputerText(computer, this.agentName()))}</b> — send /cancel to stop`);
+    }
     if (this.skillBanner) {
       lines.push(`💡 <b>${escape(this.skillBanner.name)}</b>`);
     }
+    const steps = this.work.stepList;
+    if (steps) lines.push(...stepListLines(steps));
     // Show last N tool entries to keep the message compact when a turn
     // makes many calls. Most-recent at the bottom (matches chronology).
-    const tools = [...this.tools.values()];
+    // A call that changed the list of steps shows in the list, not here.
+    const tools = [...this.tools.values()].filter((t) => !this.work.isStepListCall(t.id));
     const visible = tools.slice(-10);
     const hidden = tools.length - visible.length;
     if (hidden > 0) {
@@ -207,9 +242,11 @@ export class TurnRenderer {
     for (const t of visible) {
       lines.push(`• <code>${escape(t.name)}</code>(${escape(t.inputPreview)}) ${statusBadge(t.status)}`);
     }
+    const images = this.work.images.length;
+    if (images > 0) lines.push(`🖼 ${imagesLine(images)}`);
     for (const n of this.notices.slice(-5)) lines.push(n);
     if (lines.length === 0) return null;
-    if (collapse && lines.length >= COLLAPSE_ACTIVITY_LINES) {
+    if (final && lines.length >= COLLAPSE_ACTIVITY_LINES) {
       const summary = activitySummary(tools.length);
       const inner = summary ? `${summary}\n${lines.join('\n')}` : lines.join('\n');
       return `<blockquote expandable>${inner}</blockquote>`;
@@ -217,7 +254,13 @@ export class TurnRenderer {
     return `<blockquote>${lines.join('\n')}</blockquote>`;
   }
 
+  /** The images tools returned this turn, each once, for the channel to send after the reply. */
+  images(): ReadonlyArray<ToolImage> {
+    return this.work.images;
+  }
+
   reset(): void {
+    this.work.reset();
     this.chunks = [];
     this.tools.clear();
     this.skillBanner = null;
@@ -239,6 +282,18 @@ function activitySummary(toolCount: number): string {
   return `🔧 <b>${toolCount} step${toolCount === 1 ? '' : 's'}</b>`;
 }
 
+/** An agent's list of steps: its heading, an optional reason it changed, then one marked line per step. */
+function stepListLines(list: StepListDisplay): string[] {
+  const lines = [`📋 <b>${escape(stepListHeading(list))}</b>`];
+  if (list.explanation) lines.push(`<i>${escape(list.explanation)}</i>`);
+  for (const step of list.steps) {
+    const text = escape(step.text);
+    const shown = step.status === 'in_progress' ? `<b>${text}</b>` : step.status === 'cancelled' ? `<s>${text}</s>` : text;
+    lines.push(`${STEP_MARKS[step.status]} ${shown}`);
+  }
+  return lines;
+}
+
 function statusBadge(status: ToolStatus): string {
   // Pair the glyph with a text word ('done'/'error') so the pass/fail
   // distinction survives screen-reader announcement / glyph-stripping —
@@ -288,27 +343,6 @@ function renderFileDiff(d: FileDiffDisplay): string {
   );
 }
 
-/**
- * Build a classic unified-diff body from a file-diff display: a
- * `@@ -oldStart,oldLines +newStart,newLines @@` header per hunk, then each
- * line prefixed with ` `/`+`/`-`. Hunks are separated by a blank line.
- * Returns '' when there are no hunks.
- */
-function unifiedDiffText(d: FileDiffDisplay): string {
-  const blocks: string[] = [];
-  for (const hunk of d.hunks) {
-    const lines: string[] = [
-      `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`,
-    ];
-    for (const line of hunk.lines) {
-      const marker = line.kind === 'add' ? '+' : line.kind === 'del' ? '-' : ' ';
-      lines.push(`${marker}${line.text}`);
-    }
-    blocks.push(lines.join('\n'));
-  }
-  return blocks.join('\n\n');
-}
-
 function truncJson(value: unknown, max = 60): string {
   const s = typeof value === 'string' ? value : JSON.stringify(value) ?? '';
   if (s.length <= max) return s;