openAgent

1import { describe, expect, test } from "bun:test"
2import type { Event } from "@opencode-ai/sdk/v2"
3import { createSessionData, flushInterrupted, reduceSessionData } from "@/cli/cmd/run/session-data"
4import type { StreamCommit } from "@/cli/cmd/run/types"
5 
6function reduce(data: ReturnType<typeof createSessionData>, event: unknown, thinking = true) {
7  return reduceSessionData({
8    data,
9    event: event as Event,
10    sessionID: "session-1",
11    thinking,
12    limits: {},
13  })
14}
15 
16function assistant(id: string, extra: Record<string, unknown> = {}) {
17  return {
18    type: "message.updated",
19    properties: {
20      sessionID: "session-1",
21      info: {
22        id,
23        role: "assistant",
24        providerID: "openai",
25        modelID: "gpt-5",
26        tokens: {
27          input: 1,
28          output: 1,
29          reasoning: 0,
30          cache: { read: 0, write: 0 },
31        },
32        ...extra,
33      },
34    },
35  }
36}
37 
38function user(id: string) {
39  return {
40    type: "message.updated",
41    properties: {
42      sessionID: "session-1",
43      info: {
44        id,
45        role: "user",
46      },
47    },
48  }
49}
50 
51function text(input: { id: string; messageID: string; text: string; time?: Record<string, number> }) {
52  return {
53    type: "message.part.updated",
54    properties: {
55      part: {
56        id: input.id,
57        messageID: input.messageID,
58        sessionID: "session-1",
59        type: "text",
60        text: input.text,
61        ...(input.time ? { time: input.time } : {}),
62      },
63    },
64  }
65}
66 
67function reasoning(input: { id: string; messageID: string; text: string; time?: Record<string, number> }) {
68  return {
69    type: "message.part.updated",
70    properties: {
71      part: {
72        id: input.id,
73        messageID: input.messageID,
74        sessionID: "session-1",
75        type: "reasoning",
76        text: input.text,
77        ...(input.time ? { time: input.time } : {}),
78      },
79    },
80  }
81}
82 
83function delta(messageID: string, partID: string, value: string) {
84  return {
85    type: "message.part.delta",
86    properties: {
87      sessionID: "session-1",
88      messageID,
89      partID,
90      field: "text",
91      delta: value,
92    },
93  }
94}
95 
96function tool(input: { id: string; messageID: string; tool: string; state: Record<string, unknown>; callID?: string }) {
97  return {
98    type: "message.part.updated",
99    properties: {
100      part: {
101        id: input.id,
102        messageID: input.messageID,
103        sessionID: "session-1",
104        type: "tool",
105        tool: input.tool,
106        ...(input.callID ? { callID: input.callID } : {}),
107        state: input.state,
108      },
109    },
110  }
111}
112 
113describe("run session data", () => {
114  test("buffers delayed assistant text until the role is known", () => {
115    let data = createSessionData()
116    data = reduce(data, delta("msg-1", "txt-1", "hello")).data
117    data = reduce(data, assistant("msg-1")).data
118 
119    const out = reduce(
120      data,
121      text({
122        id: "txt-1",
123        messageID: "msg-1",
124        text: "",
125        time: { end: 1 },
126      }),
127    )
128 
129    expect(out.commits).toEqual([
130      expect.objectContaining({
131        kind: "assistant",
132        text: "hello",
133        partID: "txt-1",
134      }),
135    ])
136  })
137 
138  test("keeps leading whitespace buffered until real assistant content arrives", () => {
139    let data = createSessionData()
140    data = reduce(data, assistant("msg-1")).data
141    data = reduce(data, text({ id: "txt-1", messageID: "msg-1", text: "", time: { start: 1 } })).data
142 
143    let out = reduce(data, delta("msg-1", "txt-1", " "))
144    expect(out.commits).toEqual([])
145 
146    out = reduce(out.data, delta("msg-1", "txt-1", "Found"))
147    expect(out.commits).toEqual([
148      expect.objectContaining({
149        kind: "assistant",
150        text: " Found",
151      }),
152    ])
153  })
154 
155  test("drops delayed text once the message resolves to a user role", () => {
156    let data = createSessionData()
157    data = reduce(data, text({ id: "txt-user-1", messageID: "msg-user-1", text: "HELLO", time: { end: 1 } })).data
158 
159    const out = reduce(data, user("msg-user-1"))
160 
161    expect(out.commits).toEqual([])
162    expect(out.data.ids.has("txt-user-1")).toBe(true)
163  })
164 
165  test("suppresses reasoning commits when thinking is disabled", () => {
166    const out = reduce(
167      createSessionData(),
168      reasoning({
169        id: "reason-1",
170        messageID: "msg-1",
171        text: "hidden",
172        time: { end: 1 },
173      }),
174      false,
175    )
176 
177    expect(out.commits).toEqual([])
178    expect(out.data.ids.has("reason-1")).toBe(true)
179  })
180 
181  test("keeps permission precedence over queued questions", () => {
182    let data = createSessionData()
183    data = reduce(data, {
184      type: "permission.asked",
185      properties: {
186        id: "perm-1",
187        sessionID: "session-1",
188        permission: "read",
189        patterns: ["/tmp/file.txt"],
190        metadata: {},
191        always: [],
192      },
193    }).data
194 
195    const ask = reduce(data, {
196      type: "question.asked",
197      properties: {
198        id: "question-1",
199        sessionID: "session-1",
200        questions: [
201          {
202            question: "Mode?",
203            header: "Mode",
204            options: [{ label: "chunked", description: "Incremental output" }],
205            multiple: false,
206          },
207        ],
208      },
209    })
210 
211    expect(ask.footer).toEqual({
212      patch: { status: "awaiting permission" },
213      view: {
214        type: "permission",
215        request: expect.objectContaining({ id: "perm-1" }),
216      },
217    })
218 
219    expect(
220      reduce(ask.data, {
221        type: "permission.replied",
222        properties: {
223          sessionID: "session-1",
224          requestID: "perm-1",
225          reply: "reject",
226        },
227      }).footer,
228    ).toEqual({
229      patch: { status: "awaiting answer" },
230      view: {
231        type: "question",
232        request: expect.objectContaining({ id: "question-1" }),
233      },
234    })
235  })
236 
237  test("refreshes the active permission view when tool input arrives later", () => {
238    const data = reduce(createSessionData(), {
239      type: "permission.asked",
240      properties: {
241        id: "perm-1",
242        sessionID: "session-1",
243        permission: "bash",
244        patterns: ["src/**/*.ts"],
245        metadata: {},
246        always: [],
247        tool: {
248          messageID: "msg-1",
249          callID: "call-1",
250        },
251      },
252    }).data
253 
254    const out = reduce(
255      data,
256      tool({
257        id: "tool-1",
258        messageID: "msg-1",
259        callID: "call-1",
260        tool: "bash",
261        state: {
262          status: "running",
263          input: {
264            command: "git status --short",
265          },
266        },
267      }),
268    )
269 
270    expect(out.footer).toEqual({
271      view: {
272        type: "permission",
273        request: expect.objectContaining({
274          id: "perm-1",
275          metadata: expect.objectContaining({
276            input: {
277              command: "git status --short",
278            },
279          }),
280        }),
281      },
282    })
283  })
284 
285  test("strips bash echo only from the first assistant flush", () => {
286    let data = createSessionData()
287    data = reduce(data, assistant("msg-1")).data
288    data = reduce(
289      data,
290      tool({
291        id: "tool-1",
292        messageID: "msg-1",
293        tool: "bash",
294        state: {
295          status: "completed",
296          input: {
297            command: "printf hi",
298          },
299          output: "echoed\n",
300          time: { start: 1, end: 2 },
301        },
302      }),
303    ).data
304 
305    const first = reduce(
306      data,
307      text({
308        id: "txt-1",
309        messageID: "msg-1",
310        text: "echoed\nanswer",
311      }),
312    )
313 
314    expect(first.commits).toEqual([
315      expect.objectContaining({
316        kind: "assistant",
317        text: "answer",
318      }),
319    ])
320 
321    expect(reduce(first.data, delta("msg-1", "txt-1", "\nechoed\nagain")).commits).toEqual([
322      expect.objectContaining({
323        kind: "assistant",
324        text: "\nechoed\nagain",
325      }),
326    ])
327  })
328 
329  test("renders direct shell mode from first-class shell events", () => {
330    let data = createSessionData()
331    const started = reduce(data, {
332      type: "session.next.shell.started",
333      properties: {
334        sessionID: "session-1",
335        timestamp: 1,
336        callID: "call-1",
337        command: "pwd",
338      },
339    })
340 
341    expect(started.commits).toEqual([
342      expect.objectContaining({
343        kind: "tool",
344        phase: "start",
345        partID: "shell:call-1",
346        tool: "bash",
347        shell: {
348          callID: "call-1",
349          command: "pwd",
350        },
351      }),
352    ])
353 
354    data = started.data
355    const ended = reduce(data, {
356      type: "session.next.shell.ended",
357      properties: {
358        sessionID: "session-1",
359        timestamp: 2,
360        callID: "call-1",
361        output: "/tmp/demo\n",
362      },
363    })
364 
365    expect(ended.commits).toEqual([
366      expect.objectContaining({
367        kind: "tool",
368        phase: "progress",
369        partID: "shell:call-1",
370        tool: "bash",
371        text: "/tmp/demo\n",
372        toolState: "completed",
373        shell: {
374          callID: "call-1",
375          command: "pwd",
376        },
377      }),
378    ])
379  })
380 
381  test("suppresses legacy bash part updates once shell events claim the call", () => {
382    let data = reduce(createSessionData(), {
383      type: "session.next.shell.started",
384      properties: {
385        sessionID: "session-1",
386        timestamp: 1,
387        callID: "call-1",
388        command: "pwd",
389      },
390    }).data
391 
392    expect(
393      reduce(
394        data,
395        tool({
396          id: "tool-1",
397          messageID: "msg-1",
398          callID: "call-1",
399          tool: "bash",
400          state: {
401            status: "running",
402            input: {
403              command: "pwd",
404            },
405            time: { start: 1 },
406          },
407        }),
408      ).commits,
409    ).toEqual([])
410 
411    data = reduce(data, {
412      type: "session.next.shell.ended",
413      properties: {
414        sessionID: "session-1",
415        timestamp: 2,
416        callID: "call-1",
417        output: "/tmp/demo\n",
418      },
419    }).data
420 
421    expect(
422      reduce(
423        data,
424        tool({
425          id: "tool-1",
426          messageID: "msg-1",
427          callID: "call-1",
428          tool: "bash",
429          state: {
430            status: "completed",
431            input: {
432              command: "pwd",
433            },
434            output: "/tmp/demo\n",
435            title: "",
436            metadata: {
437              output: "/tmp/demo\n",
438            },
439            time: { start: 1, end: 2 },
440          },
441        }),
442      ).commits,
443    ).toEqual([])
444  })
445 
446  test("suppresses shell events when the legacy bash part claimed the call first", () => {
447    let data = reduce(
448      createSessionData(),
449      tool({
450        id: "tool-1",
451        messageID: "msg-1",
452        callID: "call-1",
453        tool: "bash",
454        state: {
455          status: "running",
456          input: {
457            command: "pwd",
458          },
459          time: { start: 1 },
460        },
461      }),
462    ).data
463 
464    expect(
465      reduce(data, {
466        type: "session.next.shell.started",
467        properties: {
468          sessionID: "session-1",
469          timestamp: 1,
470          callID: "call-1",
471          command: "pwd",
472        },
473      }).commits,
474    ).toEqual([])
475 
476    data = reduce(
477      data,
478      tool({
479        id: "tool-1",
480        messageID: "msg-1",
481        callID: "call-1",
482        tool: "bash",
483        state: {
484          status: "completed",
485          input: {
486            command: "pwd",
487          },
488          output: "/tmp/demo\n",
489          title: "",
490          metadata: {
491            output: "/tmp/demo\n",
492          },
493          time: { start: 1, end: 2 },
494        },
495      }),
496    ).data
497 
498    expect(
499      reduce(data, {
500        type: "session.next.shell.ended",
501        properties: {
502          sessionID: "session-1",
503          timestamp: 2,
504          callID: "call-1",
505          output: "/tmp/demo\n",
506        },
507      }).commits,
508    ).toEqual([])
509  })
510 
511  test("synthesizes a glob start before an error when the running update is missed", () => {
512    expect(
513      reduce(
514        createSessionData(),
515        tool({
516          id: "tool-1",
517          messageID: "msg-1",
518          tool: "glob",
519          state: {
520            status: "error",
521            input: {
522              pattern: "**/*tool*",
523              path: "/tmp/demo/run",
524            },
525            error: "No such file or directory: '/tmp/demo/run'",
526          },
527        }),
528      ).commits,
529    ).toEqual([
530      expect.objectContaining({
531        kind: "tool",
532        tool: "glob",
533        phase: "start",
534        partID: "tool-1",
535        text: "running glob",
536        toolState: "running",
537      }),
538      expect.objectContaining({
539        kind: "tool",
540        tool: "glob",
541        phase: "final",
542        partID: "tool-1",
543        text: "No such file or directory: '/tmp/demo/run'",
544        toolState: "error",
545        toolError: "No such file or directory: '/tmp/demo/run'",
546      }),
547    ])
548  })
549 
550  test("flushInterrupted emits one interrupted final per live part", () => {
551    const data = reduce(
552      createSessionData(),
553      text({
554        id: "txt-1",
555        messageID: "msg-1",
556        text: "unfinished",
557      }),
558    ).data
559 
560    const first: StreamCommit[] = []
561    flushInterrupted(data, first)
562    expect(first).toEqual([
563      expect.objectContaining({ kind: "assistant", text: "unfinished", phase: "progress" }),
564      expect.objectContaining({ kind: "assistant", phase: "final", interrupted: true }),
565    ])
566 
567    const next: StreamCommit[] = []
568    flushInterrupted(data, next)
569    expect(next).toEqual([])
570  })
571 
572  test("surfaces session errors as error commits", () => {
573    const out = reduce(createSessionData(), {
574      type: "session.error",
575      properties: {
576        sessionID: "session-1",
577        error: {
578          name: "UnknownError",
579          data: {
580            message: "permission denied",
581          },
582        },
583      },
584    })
585 
586    expect(out.commits).toEqual([
587      expect.objectContaining({
588        kind: "error",
589        text: "permission denied",
590      }),
591    ])
592  })
593})
594