openAgent

1import { test, expect, describe } from "bun:test"
2import { SessionV1 } from "@opencode-ai/core/v1/session"
3import { extractResponseText, formatPromptTooLargeError } from "../../src/cli/cmd/github"
4import type { MessageV2 } from "../../src/session/message-v2"
5import { SessionID, MessageID, PartID } from "../../src/session/schema"
6 
7// Helper to create minimal valid parts
8function createTextPart(text: string): SessionV1.Part {
9  return {
10    id: PartID.ascending(),
11    sessionID: SessionID.make("ses_test"),
12    messageID: MessageID.make("msg_test"),
13    type: "text" as const,
14    text,
15  }
16}
17 
18function createReasoningPart(text: string): SessionV1.Part {
19  return {
20    id: PartID.ascending(),
21    sessionID: SessionID.make("ses_test"),
22    messageID: MessageID.make("msg_test"),
23    type: "reasoning" as const,
24    text,
25    time: { start: 0 },
26  }
27}
28 
29function createToolPart(tool: string, title: string, status: "completed" | "running" = "completed"): SessionV1.Part {
30  if (status === "completed") {
31    return {
32      id: PartID.ascending(),
33      sessionID: SessionID.make("ses_test"),
34      messageID: MessageID.make("msg_test"),
35      type: "tool" as const,
36      callID: "c1",
37      tool,
38      state: {
39        status: "completed",
40        input: {},
41        output: "",
42        title,
43        metadata: {},
44        time: { start: 0, end: 1 },
45      },
46    }
47  }
48  return {
49    id: PartID.ascending(),
50    sessionID: SessionID.make("ses_test"),
51    messageID: MessageID.make("msg_test"),
52    type: "tool" as const,
53    callID: "c1",
54    tool,
55    state: {
56      status: "running",
57      input: {},
58      time: { start: 0 },
59    },
60  }
61}
62 
63function createStepStartPart(): SessionV1.Part {
64  return {
65    id: PartID.ascending(),
66    sessionID: SessionID.make("ses_test"),
67    messageID: MessageID.make("msg_test"),
68    type: "step-start" as const,
69  }
70}
71 
72function createStepFinishPart(): SessionV1.Part {
73  return {
74    id: PartID.ascending(),
75    sessionID: SessionID.make("ses_test"),
76    messageID: MessageID.make("msg_test"),
77    type: "step-finish" as const,
78    reason: "done",
79    cost: 0,
80    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
81  }
82}
83 
84describe("extractResponseText", () => {
85  test("returns text from text part", () => {
86    const parts = [createTextPart("Hello world")]
87    expect(extractResponseText(parts)).toBe("Hello world")
88  })
89 
90  test("returns last text part when multiple exist", () => {
91    const parts = [createTextPart("First"), createTextPart("Last")]
92    expect(extractResponseText(parts)).toBe("Last")
93  })
94 
95  test("returns text even when tool parts follow", () => {
96    const parts = [createTextPart("I'll help with that."), createToolPart("todowrite", "3 todos")]
97    expect(extractResponseText(parts)).toBe("I'll help with that.")
98  })
99 
100  test("returns null for reasoning-only response (signals summary needed)", () => {
101    const parts = [createReasoningPart("Let me think about this...")]
102    expect(extractResponseText(parts)).toBeNull()
103  })
104 
105  test("returns null for tool-only response (signals summary needed)", () => {
106    // This is the exact scenario from the bug report - todowrite with no text
107    const parts = [createToolPart("todowrite", "8 todos")]
108    expect(extractResponseText(parts)).toBeNull()
109  })
110 
111  test("returns null for multiple completed tools", () => {
112    const parts = [
113      createToolPart("read", "src/file.ts"),
114      createToolPart("edit", "src/file.ts"),
115      createToolPart("bash", "bun test"),
116    ]
117    expect(extractResponseText(parts)).toBeNull()
118  })
119 
120  test("returns null for running tool parts (signals summary needed)", () => {
121    const parts = [createToolPart("bash", "", "running")]
122    expect(extractResponseText(parts)).toBeNull()
123  })
124 
125  test("throws on empty array", () => {
126    expect(() => extractResponseText([])).toThrow("no parts returned")
127  })
128 
129  test("returns null for step-start only", () => {
130    const parts = [createStepStartPart()]
131    expect(extractResponseText(parts)).toBeNull()
132  })
133 
134  test("returns null for step-finish only", () => {
135    const parts = [createStepFinishPart()]
136    expect(extractResponseText(parts)).toBeNull()
137  })
138 
139  test("returns null for step-start and step-finish", () => {
140    const parts = [createStepStartPart(), createStepFinishPart()]
141    expect(extractResponseText(parts)).toBeNull()
142  })
143 
144  test("returns text from multi-step response", () => {
145    const parts = [
146      createStepStartPart(),
147      createToolPart("read", "src/file.ts"),
148      createTextPart("Done"),
149      createStepFinishPart(),
150    ]
151    expect(extractResponseText(parts)).toBe("Done")
152  })
153 
154  test("prefers text over reasoning when both present", () => {
155    const parts = [createReasoningPart("Internal thinking..."), createTextPart("Final answer")]
156    expect(extractResponseText(parts)).toBe("Final answer")
157  })
158 
159  test("prefers text over tools when both present", () => {
160    const parts = [createToolPart("read", "src/file.ts"), createTextPart("Here's what I found")]
161    expect(extractResponseText(parts)).toBe("Here's what I found")
162  })
163})
164 
165describe("formatPromptTooLargeError", () => {
166  test("formats error without files", () => {
167    const result = formatPromptTooLargeError([])
168    expect(result).toBe("PROMPT_TOO_LARGE: The prompt exceeds the model's context limit.")
169  })
170 
171  test("formats error with files (base64 content)", () => {
172    // Base64 is ~33% larger than original, so we multiply by 0.75 to get original size
173    // 400 KB base64 = 300 KB original, 200 KB base64 = 150 KB original
174    const files = [
175      { filename: "screenshot.png", content: "a".repeat(400 * 1024) },
176      { filename: "diagram.png", content: "b".repeat(200 * 1024) },
177    ]
178    const result = formatPromptTooLargeError(files)
179 
180    expect(result).toStartWith("PROMPT_TOO_LARGE: The prompt exceeds the model's context limit.")
181    expect(result).toInclude("Files in prompt:")
182    expect(result).toInclude("screenshot.png (300 KB)")
183    expect(result).toInclude("diagram.png (150 KB)")
184  })
185 
186  test("lists all files when multiple present", () => {
187    // Base64 sizes: 4KB -> 3KB, 8KB -> 6KB, 12KB -> 9KB
188    const files = [
189      { filename: "img1.png", content: "x".repeat(4 * 1024) },
190      { filename: "img2.jpg", content: "y".repeat(8 * 1024) },
191      { filename: "img3.gif", content: "z".repeat(12 * 1024) },
192    ]
193    const result = formatPromptTooLargeError(files)
194 
195    expect(result).toInclude("img1.png (3 KB)")
196    expect(result).toInclude("img2.jpg (6 KB)")
197    expect(result).toInclude("img3.gif (9 KB)")
198  })
199})
200