acp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91// Ported from the Rust plugin's throttle.rs tests.
import { test } from "node:test";
import assert from "node:assert/strict";
import type { ToolCallUpdate, ToolContent } from "convergence/protocol";
import { MAX_CHARS, ToolStream, bound } from "./throttle.ts";

const textUpdate = (text: string): ToolCallUpdate => ({
  id: "t1",
  status: "running",
  content: [{ type: "text", text }],
});

test("long output keeps its newest part", () => {
  const content = [{ type: "text", text: `${"x".repeat(MAX_CHARS * 2)}TAIL` }] satisfies ToolContent[];
  bound(content);
  assert.ok(content[0].text.endsWith("TAIL"), "the newest output was dropped");
  assert.ok(content[0].text.startsWith("[Earlier output truncated]"));
  assert.ok([...content[0].text].length <= MAX_CHARS + 64);
});

test("terminal output is capped, a diff is not", () => {
  const long = "y".repeat(MAX_CHARS + 10);
  const content = [
    { type: "terminal", command: "ls", output: long },
    { type: "diff", path: "/a", newText: long },
  ] satisfies ToolContent[];
  const [terminal, diff] = content;
  assert.ok(terminal);
  assert.ok(diff);
  bound(content);
  assert.ok(terminal.output);
  assert.ok(terminal.output.length < long.length + 40 && terminal.output.startsWith("[Earlier"));
  assert.equal(diff.newText, long);
});

test("short output is untouched", () => {
  const content = [{ type: "text", text: "hello" }] satisfies ToolContent[];
  bound(content);
  assert.deepEqual(content, [{ type: "text", text: "hello" }]);
});

// A tool that resends its whole output on every tick must not produce one
// event per tick.
test("small repeated updates are coalesced", () => {
  const stream = new ToolStream();
  assert.ok(stream.push(textUpdate("start")), "the first update always goes out");
  let emitted = 0;
  for (let index = 0; index < 9; index += 1) if (stream.push(textUpdate(`start${"y".repeat(index)}`))) emitted += 1;
  assert.equal(emitted, 0, "small growth should have been held back");
  // The tenth withheld update is released even without growth.
  assert.ok(stream.push(textUpdate("start-again")));
});

test("real growth goes out at once", () => {
  const stream = new ToolStream();
  assert.ok(stream.push(textUpdate("start")));
  assert.ok(stream.push(textUpdate("z".repeat(600))), "a big chunk must not wait");
});

test("a finished call is always reported", () => {
  const stream = new ToolStream();
  assert.ok(stream.push(textUpdate("start")));
  assert.ok(stream.push({ id: "t1", status: "completed" }));
});

// Whatever is withheld must survive: the merged patch carries the fields of
// every update it stands for.
test("withheld updates are merged, not lost", () => {
  const stream = new ToolStream();
  assert.ok(stream.push(textUpdate("start")));
  stream.push({ id: "t1", outputDelta: "a" });
  stream.push({ id: "t1", outputDelta: "b" });
  const flushed = stream.flush();
  assert.ok(flushed);
  // Both deltas survive the wait, in order.
  assert.equal(flushed.outputDelta, "ab");
  assert.equal(stream.flush(), null);
});

// A field set by a withheld update must reach the host in the patch that
// finally goes out.
test("a withheld field reaches the emitted patch", () => {
  const stream = new ToolStream();
  assert.ok(stream.push(textUpdate("start")));
  // Held back: too little growth to go out on its own.
  assert.equal(stream.push({ id: "t1", locations: [{ path: "/w/a.rs", line: 3 }] }), null);
  const done = stream.push({ id: "t1", status: "completed" });
  assert.ok(done?.locations);
  assert.equal(done.status, "completed");
  assert.equal(done.locations.length, 1, "the held location was lost");
});