openAgent

1import { describe, expect, test } from "bun:test"
2import type { ToolPart } from "@opencode-ai/sdk/v2"
3import { entryBody, entryCanStream, entryDone } from "@/cli/cmd/run/entry.body"
4import type { StreamCommit, ToolSnapshot } from "@/cli/cmd/run/types"
5 
6function commit(input: Partial<StreamCommit> & Pick<StreamCommit, "kind" | "text" | "phase" | "source">): StreamCommit {
7  return input
8}
9 
10function toolPart(tool: string, state: ToolPart["state"], id = `${tool}-1`, messageID = `msg-${tool}`): ToolPart {
11  return {
12    id,
13    sessionID: "session-1",
14    messageID,
15    type: "tool",
16    callID: `call-${id}`,
17    tool,
18    state,
19  } as ToolPart
20}
21 
22function toolCommit(input: {
23  tool: string
24  state: ToolPart["state"]
25  phase?: StreamCommit["phase"]
26  toolState?: StreamCommit["toolState"]
27  text?: string
28  id?: string
29  messageID?: string
30}) {
31  return commit({
32    kind: "tool",
33    text: input.text ?? "",
34    phase: input.phase ?? "final",
35    source: "tool",
36    tool: input.tool,
37    toolState: input.toolState ?? "completed",
38    part: toolPart(input.tool, input.state, input.id, input.messageID),
39  })
40}
41 
42function structured(next: StreamCommit) {
43  const body = entryBody(next)
44  expect(body.type).toBe("structured")
45  if (body.type !== "structured") {
46    throw new Error("expected structured body")
47  }
48 
49  return body.snapshot
50}
51 
52describe("run entry body", () => {
53  test("renders assistant, reasoning, and user entries in their display formats", () => {
54    expect(
55      entryBody(
56        commit({
57          kind: "assistant",
58          text: "# Title\n\nHello **world**",
59          phase: "progress",
60          source: "assistant",
61          partID: "part-1",
62        }),
63      ),
64    ).toEqual({
65      type: "markdown",
66      content: "# Title\n\nHello **world**",
67    })
68 
69    const reasoning = entryBody(
70      commit({
71        kind: "reasoning",
72        text: "Thinking: plan next steps",
73        phase: "progress",
74        source: "reasoning",
75        partID: "reason-1",
76      }),
77    )
78    expect(reasoning).toEqual({
79      type: "code",
80      filetype: "markdown",
81      content: "_Thinking:_ plan next steps",
82    })
83    expect(
84      entryCanStream(
85        commit({
86          kind: "reasoning",
87          text: "Thinking: plan next steps",
88          phase: "progress",
89          source: "reasoning",
90        }),
91        reasoning,
92      ),
93    ).toBe(true)
94 
95    expect(
96      entryBody(
97        commit({
98          kind: "user",
99          text: "Inspect footer tabs",
100          phase: "start",
101          source: "system",
102        }),
103      ),
104    ).toEqual({
105      type: "text",
106      content: "› Inspect footer tabs",
107    })
108  })
109 
110  for (const item of [
111    {
112      name: "keeps completed write tool finals structured",
113      commit: toolCommit({
114        tool: "write",
115        state: {
116          status: "completed",
117          input: {
118            filePath: "src/a.ts",
119            content: "const x = 1\n",
120          },
121          output: "",
122          title: "",
123          metadata: {},
124          time: { start: 1, end: 2 },
125        },
126      }),
127      snapshot: {
128        kind: "code",
129        title: "# Wrote src/a.ts",
130        content: "const x = 1\n",
131        file: "src/a.ts",
132      },
133    },
134    {
135      name: "keeps completed edit tool finals structured",
136      commit: toolCommit({
137        tool: "edit",
138        state: {
139          status: "completed",
140          input: {
141            filePath: "src/a.ts",
142          },
143          output: "",
144          title: "",
145          metadata: {
146            diff: "@@ -1 +1 @@\n-old\n+new\n",
147          },
148          time: { start: 1, end: 2 },
149        },
150      }),
151      snapshot: {
152        kind: "diff",
153        items: [
154          {
155            title: "# Edited src/a.ts",
156            diff: "@@ -1 +1 @@\n-old\n+new\n",
157            file: "src/a.ts",
158          },
159        ],
160      },
161    },
162    {
163      name: "keeps completed apply_patch tool finals structured",
164      commit: toolCommit({
165        tool: "apply_patch",
166        state: {
167          status: "completed",
168          input: {},
169          output: "",
170          title: "",
171          metadata: {
172            files: [
173              {
174                type: "update",
175                filePath: "src/a.ts",
176                relativePath: "src/a.ts",
177                patch: "@@ -1 +1 @@\n-old\n+new\n",
178              },
179            ],
180          },
181          time: { start: 1, end: 2 },
182        },
183      }),
184      snapshot: {
185        kind: "diff",
186        items: [
187          {
188            title: "# Patched src/a.ts",
189            diff: "@@ -1 +1 @@\n-old\n+new\n",
190            file: "src/a.ts",
191            deletions: 0,
192          },
193        ],
194      },
195    },
196  ] satisfies Array<{ name: string; commit: StreamCommit; snapshot: ToolSnapshot }>) {
197    test(item.name, () => {
198      expect(structured(item.commit)).toEqual(item.snapshot)
199    })
200  }
201 
202  test("keeps running task tool state out of scrollback", () => {
203    expect(
204      entryBody(
205        toolCommit({
206          tool: "task",
207          phase: "start",
208          toolState: "running",
209          text: "running inspect reducer",
210          state: {
211            status: "running",
212            input: {
213              description: "Inspect reducer",
214              subagent_type: "explore",
215            },
216            time: { start: 1 },
217          },
218        }),
219      ),
220    ).toEqual({
221      type: "none",
222    })
223  })
224 
225  test("promotes task results to markdown and falls back to structured task summaries", () => {
226    expect(
227      entryBody(
228        toolCommit({
229          tool: "task",
230          state: {
231            status: "completed",
232            input: {
233              description: "Inspect reducer",
234              subagent_type: "explore",
235            },
236            title: "",
237            output: [
238              '<task id="child-1" state="completed">',
239              "<task_result>",
240              "# Findings\n\n- Footer stays live",
241              "</task_result>",
242              "</task>",
243            ].join("\n"),
244            metadata: {
245              sessionId: "child-1",
246            },
247            time: { start: 1, end: 2 },
248          },
249        }),
250      ),
251    ).toEqual({
252      type: "markdown",
253      content: "# Findings\n\n- Footer stays live",
254    })
255 
256    expect(
257      structured(
258        toolCommit({
259          tool: "task",
260          state: {
261            status: "completed",
262            input: {
263              description: "Inspect reducer",
264              subagent_type: "explore",
265            },
266            title: "",
267            output: ['<task id="child-1" state="completed">', "<task_result>", "", "</task_result>", "</task>"].join(
268              "\n",
269            ),
270            metadata: {
271              sessionId: "child-1",
272            },
273            time: { start: 1, end: 2 },
274          },
275        }),
276      ),
277    ).toEqual({
278      kind: "task",
279      title: "# Explore Task",
280      rows: ["Inspect reducer"],
281      tail: "",
282    })
283  })
284 
285  test("streams tool progress text and treats completed progress as done", () => {
286    const body = entryBody(
287      commit({
288        kind: "tool",
289        text: "partial output",
290        phase: "progress",
291        source: "tool",
292        tool: "bash",
293        partID: "tool-2",
294      }),
295    )
296 
297    expect(body).toEqual({
298      type: "text",
299      content: "partial output",
300    })
301    expect(
302      entryCanStream(
303        commit({
304          kind: "tool",
305          text: "partial output",
306          phase: "progress",
307          source: "tool",
308          tool: "bash",
309        }),
310        body,
311      ),
312    ).toBe(true)
313    expect(
314      entryDone(
315        commit({
316          kind: "tool",
317          text: "output",
318          phase: "progress",
319          source: "tool",
320          tool: "bash",
321          toolState: "completed",
322        }),
323      ),
324    ).toBe(true)
325  })
326 
327  test("formats completed bash output with a blank line after the command and no trailing blank row", () => {
328    expect(
329      entryBody(
330        toolCommit({
331          tool: "bash",
332          phase: "progress",
333          toolState: "completed",
334          text: ["/tmp/demo", "git status", "On branch demo", "nothing to commit, working tree clean", ""].join("\n"),
335          state: {
336            status: "completed",
337            input: {
338              command: "git status",
339              workdir: "/tmp/demo",
340            },
341            output: ["/tmp/demo", "git status", "On branch demo", "nothing to commit, working tree clean", ""].join(
342              "\n",
343            ),
344            title: "git status",
345            metadata: {
346              exitCode: 0,
347            },
348            time: { start: 1, end: 2 },
349          },
350        }),
351      ),
352    ).toEqual({
353      type: "text",
354      content: "\nOn branch demo\nnothing to commit, working tree clean",
355    })
356  })
357 
358  test("renders command-only bash starts without the shell header", () => {
359    expect(
360      entryBody(
361        toolCommit({
362          tool: "bash",
363          phase: "start",
364          toolState: "running",
365          text: "running shell",
366          state: {
367            status: "running",
368            input: {
369              command: "ls",
370            },
371            time: { start: 1 },
372          },
373        }),
374      ),
375    ).toEqual({
376      type: "text",
377      content: "$ ls",
378    })
379  })
380 
381  test("renders direct shell commits without a synthetic shell header", () => {
382    expect(
383      entryBody(
384        commit({
385          kind: "tool",
386          text: "running shell",
387          phase: "start",
388          source: "tool",
389          tool: "bash",
390          partID: "shell:call-1",
391          toolState: "running",
392          shell: {
393            callID: "call-1",
394            command: "pwd",
395          },
396        }),
397      ),
398    ).toEqual({
399      type: "text",
400      content: "$ pwd",
401    })
402 
403    expect(
404      entryBody(
405        commit({
406          kind: "tool",
407          text: "/tmp/demo\n",
408          phase: "progress",
409          source: "tool",
410          tool: "bash",
411          partID: "shell:call-1",
412          toolState: "completed",
413          shell: {
414            callID: "call-1",
415            command: "pwd",
416          },
417        }),
418      ),
419    ).toEqual({
420      type: "text",
421      content: "\n/tmp/demo",
422    })
423  })
424 
425  test("falls back to patch summary when apply_patch has no visible diff items", () => {
426    expect(
427      entryBody(
428        toolCommit({
429          tool: "apply_patch",
430          state: {
431            status: "completed",
432            input: {
433              patchText: "*** Begin Patch\n*** End Patch",
434            },
435            output: "",
436            title: "",
437            metadata: {
438              files: [
439                {
440                  type: "update",
441                  filePath: "src/a.ts",
442                  relativePath: "src/a.ts",
443                  diff: "@@ -1 +1 @@\n-old\n+new\n",
444                },
445              ],
446            },
447            time: { start: 1, end: 2 },
448          },
449        }),
450      ),
451    ).toEqual({
452      type: "text",
453      content: "~ Patched src/a.ts",
454    })
455  })
456 
457  test("suppresses redundant patched rows when apply_patch also created a file", () => {
458    expect(
459      entryBody(
460        toolCommit({
461          tool: "apply_patch",
462          state: {
463            status: "completed",
464            input: {
465              patchText: "*** Begin Patch\n*** End Patch",
466            },
467            output: "",
468            title: "",
469            metadata: {
470              files: [
471                {
472                  type: "update",
473                  filePath: "src/a.ts",
474                  relativePath: "src/a.ts",
475                  diff: "@@ -1 +1 @@\n-old\n+new\n",
476                },
477                {
478                  type: "add",
479                  filePath: "README-demo.md",
480                  relativePath: "README-demo.md",
481                },
482              ],
483            },
484            time: { start: 1, end: 2 },
485          },
486        }),
487      ),
488    ).toEqual({
489      type: "text",
490      content: "+ Created README-demo.md",
491    })
492  })
493 
494  test("renders glob failures as the raw error under the existing header", () => {
495    expect(
496      entryBody(
497        toolCommit({
498          tool: "glob",
499          phase: "final",
500          toolState: "error",
501          state: {
502            status: "error",
503            input: {
504              pattern: "**/*tool*",
505              path: "/tmp/demo/run",
506            },
507            error: "No such file or directory: '/tmp/demo/run'",
508            metadata: {},
509            time: { start: 1, end: 2 },
510          },
511        }),
512      ),
513    ).toEqual({
514      type: "text",
515      content: "No such file or directory: '/tmp/demo/run'",
516    })
517  })
518 
519  test("renders interrupted assistant finals as text", () => {
520    expect(
521      entryBody(
522        commit({
523          kind: "assistant",
524          text: "",
525          phase: "final",
526          source: "assistant",
527          interrupted: true,
528          partID: "part-1",
529        }),
530      ),
531    ).toEqual({
532      type: "text",
533      content: "assistant interrupted",
534    })
535  })
536})
537