chat

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// Regression coverage for grouping using the real chat modules.
// Fixtures exercise the same behavior and assertions as the JavaScript tests.
import { item as fixtureItem, entryItems } from "./ui-for-tests.test.ts";
import assert from "node:assert/strict";
import test from "node:test";

import { foldItems, groupTitle, editStats } from "./grouping.ts";
const tool = (id: string, kind: string, content: import("convergence").ToolContent[] = []) =>
  fixtureItem({ id, role: "tool", call: { id, kind, content } });
const flatten = (groups: import("./grouping.ts").FoldEntry[]) =>
  groups.flatMap((entry) => (entry.kind === "item" ? [entry.item] : entry.items));

test("all tool types and leading or intervening reasoning form one consecutive group", () => {
  const items = [
    fixtureItem({ id: "thought", role: "reasoning" }),
    ...[
      "read",
      "edit",
      "search",
      "execute",
      "delete",
      "move",
      "fetch",
      "think",
      "task",
      "switch_mode",
      "other",
      "future_kind",
    ].flatMap((kind) => [tool(kind, kind), fixtureItem({ id: `thought-${kind}`, role: "reasoning" })]),
  ];
  assert.deepEqual(foldItems(items), [{ kind: "tools", id: "tools-thought", items }]);
});

test("user and assistant messages each split groups and preserve chronological order", () => {
  const items = [
    tool("one", "read"),
    fixtureItem({ id: "assistant", role: "assistant" }),
    tool("two", "edit"),
    fixtureItem({ id: "user", role: "user" }),
    fixtureItem({ id: "thought", role: "reasoning" }),
    tool("three", "execute"),
  ];
  const groups = foldItems(items);
  assert.deepEqual(
    groups.map((entry) => (entry.kind === "item" ? entry.item.id : entry.id)),
    ["tools-one", "assistant", "tools-two", "user", "tools-thought"],
  );
  assert.deepEqual(flatten(groups), items);
  assert.deepEqual(entryItems(groups[4]), items.slice(4));
});

test("compaction and other standalone entries are boundaries, not group contents", () => {
  for (const role of ["compaction", "plan", "task", "notice"] as const) {
    const items = [tool("one", "edit"), fixtureItem({ id: "boundary", role }), tool("two", "edit")];
    const groups = foldItems(items);
    assert.deepEqual(
      groups.map((entry) => (entry.kind === "item" ? entry.item.id : entry.id)),
      ["tools-one", "boundary", "tools-two"],
    );
    assert.deepEqual(flatten(groups), items);
  }
  assert.deepEqual(foldItems([]), []);
  const messages = [fixtureItem({ id: "u", role: "user" }), fixtureItem({ id: "a", role: "assistant" })];
  assert.deepEqual(
    foldItems(messages),
    messages.map((item) => ({ kind: "item", item })),
  );
});

test("streaming keeps group identity stable from reasoning through mixed tool calls", () => {
  const items: import("convergence").TranscriptItem[] = [fixtureItem({ id: "reason", role: "reasoning" })];
  const first = foldItems(items)[0];
  assert.ok(first.kind === "tools");
  const id = first.id;
  assert.equal(groupTitle(items), "Reasoning");
  items.push(
    tool("first", "execute"),
    tool("second", "edit", [{ type: "diff", path: "file", diff: "+new\n-old\n" }]),
    tool("third", "edit"),
  );
  const group = foldItems(items)[0];
  assert.equal(group.kind === "tools" ? group.id : "", id);
  assert.equal(groupTitle(entryItems(group)), "1 Run, 2 Edits");
  assert.deepEqual(editStats(entryItems(group)), { added: 1, removed: 1 });
});