openAgent

1import { describe, expect, test } from "bun:test"
2import {
3  createSession,
4  sessionHistory,
5  sessionVariant,
6  type RunSession,
7  type SessionMessages,
8} from "@/cli/cmd/run/session.shared"
9 
10type Message = SessionMessages[number]
11type Part = Message["parts"][number]
12type TextPart = Extract<Part, { type: "text" }>
13type AgentPart = Extract<Part, { type: "agent" }>
14type FilePart = Extract<Part, { type: "file" }>
15 
16const model = {
17  providerID: "openai",
18  modelID: "gpt-5",
19}
20 
21function userMessage(id: string, parts: Message["parts"], variant = "high"): Message {
22  return {
23    info: {
24      id,
25      sessionID: "session-1",
26      role: "user",
27      time: {
28        created: 1,
29      },
30      agent: "build",
31      model: {
32        ...model,
33        variant,
34      },
35    },
36    parts,
37  }
38}
39 
40function assistantMessage(id: string, parts: Message["parts"]): Message {
41  return {
42    info: {
43      id,
44      sessionID: "session-1",
45      role: "assistant",
46      time: {
47        created: 1,
48      },
49      parentID: "msg-user-1",
50      modelID: "gpt-5",
51      providerID: "openai",
52      mode: "chat",
53      agent: "build",
54      path: {
55        cwd: "/tmp",
56        root: "/tmp",
57      },
58      cost: 0,
59      tokens: {
60        input: 1,
61        output: 1,
62        reasoning: 0,
63        cache: {
64          read: 0,
65          write: 0,
66        },
67      },
68    },
69    parts,
70  }
71}
72 
73function textPart(id: string, messageID: string, text: string, input: Partial<TextPart> = {}): TextPart {
74  return {
75    id,
76    sessionID: "session-1",
77    messageID,
78    type: "text",
79    text,
80    synthetic: input.synthetic,
81  }
82}
83 
84function agentPart(id: string, messageID: string, name: string, source?: AgentPart["source"]): AgentPart {
85  return {
86    id,
87    sessionID: "session-1",
88    messageID,
89    type: "agent",
90    name,
91    source,
92  }
93}
94 
95function filePart(id: string, messageID: string, url: string, input: Partial<FilePart> = {}): FilePart {
96  return {
97    id,
98    sessionID: "session-1",
99    messageID,
100    type: "file",
101    mime: input.mime ?? "text/plain",
102    filename: input.filename,
103    url,
104    source: input.source,
105  }
106}
107 
108describe("run session shared", () => {
109  test("builds user prompt text from text, file, and agent parts", () => {
110    const msgs: SessionMessages = [
111      assistantMessage("msg-assistant-1", [textPart("txt-assistant-1", "msg-assistant-1", "ignore me")]),
112      userMessage("msg-user-1", [
113        textPart("txt-user-1", "msg-user-1", "look @scan"),
114        textPart("txt-user-2", "msg-user-1", "hidden", { synthetic: true }),
115        agentPart("agent-user-1", "msg-user-1", "scan", {
116          start: 5,
117          end: 10,
118          value: "@scan",
119        }),
120        filePart("file-user-1", "msg-user-1", "file:///tmp/note.ts"),
121      ]),
122    ]
123 
124    const out = createSession(msgs)
125    expect(out.first).toBe(false)
126    expect(out.turns).toHaveLength(1)
127    expect(out.turns[0]?.prompt.text).toBe("look @scan @note.ts")
128    expect(out.turns[0]?.prompt.parts).toEqual([
129      {
130        type: "agent",
131        name: "scan",
132        source: {
133          start: 5,
134          end: 10,
135          value: "@scan",
136        },
137      },
138      {
139        type: "file",
140        mime: "text/plain",
141        filename: undefined,
142        url: "file:///tmp/note.ts",
143        source: {
144          type: "file",
145          path: "file:///tmp/note.ts",
146          text: {
147            start: 11,
148            end: 19,
149            value: "@note.ts",
150          },
151        },
152      },
153    ])
154  })
155 
156  test("reuses existing mentions when file and agent parts have no source", () => {
157    const out = createSession([
158      userMessage("msg-user-1", [
159        textPart("txt-user-1", "msg-user-1", "look @scan @note.ts"),
160        agentPart("agent-user-1", "msg-user-1", "scan"),
161        filePart("file-user-1", "msg-user-1", "file:///tmp/note.ts"),
162      ]),
163    ])
164 
165    expect(out.turns[0]?.prompt).toEqual({
166      text: "look @scan @note.ts",
167      parts: [
168        {
169          type: "agent",
170          name: "scan",
171          source: {
172            start: 5,
173            end: 10,
174            value: "@scan",
175          },
176        },
177        {
178          type: "file",
179          mime: "text/plain",
180          filename: undefined,
181          url: "file:///tmp/note.ts",
182          source: {
183            type: "file",
184            path: "file:///tmp/note.ts",
185            text: {
186              start: 11,
187              end: 19,
188              value: "@note.ts",
189            },
190          },
191        },
192      ],
193    })
194  })
195 
196  test("dedupes consecutive history entries, drops blanks, and copies prompt parts", () => {
197    const parts = [
198      {
199        type: "agent" as const,
200        name: "scan",
201        source: {
202          start: 0,
203          end: 5,
204          value: "@scan",
205        },
206      },
207    ]
208    const session: RunSession = {
209      first: false,
210      turns: [
211        { prompt: { text: "one", parts }, provider: "openai", model: "gpt-5", variant: "high" },
212        { prompt: { text: "one", parts: structuredClone(parts) }, provider: "openai", model: "gpt-5", variant: "high" },
213        { prompt: { text: "   ", parts: [] }, provider: "openai", model: "gpt-5", variant: "high" },
214        { prompt: { text: "two", parts: [] }, provider: "openai", model: "gpt-5", variant: undefined },
215      ],
216    }
217 
218    const out = sessionHistory(session)
219 
220    expect(out.map((item) => item.text)).toEqual(["one", "two"])
221    expect(out[0]?.parts).toEqual(parts)
222    expect(out[0]?.parts).not.toBe(parts)
223    expect(out[0]?.parts[0]).not.toBe(parts[0])
224  })
225 
226  test("returns the latest matching variant for the active model", () => {
227    const session: RunSession = {
228      first: false,
229      turns: [
230        { prompt: { text: "one", parts: [] }, provider: "openai", model: "gpt-5", variant: "high" },
231        { prompt: { text: "two", parts: [] }, provider: "anthropic", model: "sonnet", variant: "max" },
232        { prompt: { text: "three", parts: [] }, provider: "openai", model: "gpt-5", variant: undefined },
233      ],
234    }
235 
236    expect(sessionVariant(session, model)).toBeUndefined()
237 
238    session.turns.push({
239      prompt: { text: "four", parts: [] },
240      provider: "openai",
241      model: "gpt-5",
242      variant: "minimal",
243    })
244 
245    expect(sessionVariant(session, model)).toBe("minimal")
246  })
247})
248