xonecas.io
6312
Ga

go-opencode-ai-zen-sdk / files

go-opencode-ai-zen-sdk / parse_test.go

18.9 KB
1package zen
2
3import (
4	"context"
5	"encoding/json"
6	"net/http"
7	"net/http/httptest"
8	"testing"
9)
10
11// ---------------------------------------------------------------------------
12// Test helpers
13// ---------------------------------------------------------------------------
14
15func testCtx(t *testing.T) context.Context {
16	t.Helper()
17	return context.Background()
18}
19
20// helper: build a UnifiedEvent with the given endpoint and JSON body.
21func makeEvent(endpoint EndpointType, data string) UnifiedEvent {
22	return UnifiedEvent{Endpoint: endpoint, Data: json.RawMessage(data)}
23}
24
25// helper: build a UnifiedEvent that also carries an SSE event name.
26func makeEventNamed(endpoint EndpointType, event, data string) UnifiedEvent {
27	return UnifiedEvent{Endpoint: endpoint, Event: event, Data: json.RawMessage(data)}
28}
29
30// newSSETestServer creates a test server that serves the given SSE body for all
31// requests.
32func newSSETestServer(t *testing.T, sse string) (*httptest.Server, *Client) {
33	t.Helper()
34	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
35		w.Header().Set("Content-Type", "text/event-stream")
36		_, _ = w.Write([]byte(sse))
37	}))
38	c, err := NewClient(Config{APIKey: "key", BaseURL: server.URL})
39	if err != nil {
40		t.Fatalf("NewClient: %v", err)
41	}
42	return server, c
43}
44
45func assertDeltaSequence(t *testing.T, got []NormalizedDelta, want ...NormalizedDeltaType) {
46	t.Helper()
47	if len(got) != len(want) {
48		types := make([]NormalizedDeltaType, len(got))
49		for i, d := range got {
50			types[i] = d.Type
51		}
52		t.Fatalf("delta count mismatch: want %v, got %v", want, types)
53	}
54	for i, w := range want {
55		if got[i].Type != w {
56			t.Fatalf("delta[%d]: want %s, got %s", i, w, got[i].Type)
57		}
58	}
59}
60
61// ---------------------------------------------------------------------------
62// chat/completions
63// ---------------------------------------------------------------------------
64
65func TestParseChatCompletionsText(t *testing.T) {
66	ev := makeEvent(EndpointChatCompletions, `{"choices":[{"delta":{"content":"Hello"}}]}`)
67	deltas := ParseNormalizedEvent(ev)
68	if len(deltas) != 1 || deltas[0].Type != DeltaText || deltas[0].Content != "Hello" {
69		t.Fatalf("expected text delta 'Hello', got %+v", deltas)
70	}
71}
72
73func TestParseChatCompletionsReasoning(t *testing.T) {
74	ev := makeEvent(EndpointChatCompletions, `{"choices":[{"delta":{"reasoning_content":"thinking..."}}]}`)
75	deltas := ParseNormalizedEvent(ev)
76	if len(deltas) != 1 || deltas[0].Type != DeltaReasoning || deltas[0].Content != "thinking..." {
77		t.Fatalf("expected reasoning delta, got %+v", deltas)
78	}
79}
80
81func TestParseChatCompletionsReasoningThenText(t *testing.T) {
82	ev := makeEvent(EndpointChatCompletions, `{"choices":[{"delta":{"reasoning_content":"think","content":"answer"}}]}`)
83	deltas := ParseNormalizedEvent(ev)
84	if len(deltas) != 2 {
85		t.Fatalf("expected 2 deltas, got %d: %+v", len(deltas), deltas)
86	}
87	if deltas[0].Type != DeltaReasoning {
88		t.Fatalf("expected first delta to be reasoning, got %s", deltas[0].Type)
89	}
90	if deltas[1].Type != DeltaText {
91		t.Fatalf("expected second delta to be text, got %s", deltas[1].Type)
92	}
93}
94
95func TestParseChatCompletionsToolCall(t *testing.T) {
96	ev := makeEvent(EndpointChatCompletions, `{"choices":[{"delta":{"tool_calls":[{"index":0,"id":"call_1","type":"function","function":{"name":"get_weather","arguments":""}}]}}]}`)
97	deltas := ParseNormalizedEvent(ev)
98	if len(deltas) != 1 || deltas[0].Type != DeltaToolCallBegin {
99		t.Fatalf("expected tool_call_begin, got %+v", deltas)
100	}
101	if deltas[0].ToolCallID != "call_1" || deltas[0].ToolCallName != "get_weather" {
102		t.Fatalf("tool call fields wrong: %+v", deltas[0])
103	}
104}
105
106func TestParseChatCompletionsToolCallArguments(t *testing.T) {
107	ev := makeEvent(EndpointChatCompletions, `{"choices":[{"delta":{"tool_calls":[{"index":0,"function":{"arguments":"{\"city\":"}}]}}]}`)
108	deltas := ParseNormalizedEvent(ev)
109	if len(deltas) != 1 || deltas[0].Type != DeltaToolCallArgumentsDelta {
110		t.Fatalf("expected tool_call_arguments_delta, got %+v", deltas)
111	}
112	if deltas[0].ArgumentsDelta != `{"city":` {
113		t.Fatalf("arguments delta wrong: %q", deltas[0].ArgumentsDelta)
114	}
115}
116
117func TestParseChatCompletionsDone(t *testing.T) {
118	ev := makeEvent(EndpointChatCompletions, `{"choices":[{"delta":{},"finish_reason":"stop"}]}`)
119	deltas := ParseNormalizedEvent(ev)
120	if len(deltas) != 1 || deltas[0].Type != DeltaDone {
121		t.Fatalf("expected done delta, got %+v", deltas)
122	}
123}
124
125func TestParseChatCompletionsUsageOnFinishChunk(t *testing.T) {
126	// Usage included on the same chunk as finish_reason (OpenAI default).
127	ev := makeEvent(EndpointChatCompletions, `{"choices":[{"delta":{},"finish_reason":"stop"}],"usage":{"prompt_tokens":120,"completion_tokens":45}}`)
128	deltas := ParseNormalizedEvent(ev)
129	assertDeltaSequence(t, deltas, DeltaUsage, DeltaDone)
130	if deltas[0].InputTokens != 120 || deltas[0].OutputTokens != 45 {
131		t.Fatalf("usage tokens wrong: %+v", deltas[0])
132	}
133}
134
135func TestParseChatCompletionsUsageOnSplitChunk(t *testing.T) {
136	// Usage on a separate chunk with empty choices (stream_options providers).
137	ev := makeEvent(EndpointChatCompletions, `{"choices":[],"usage":{"prompt_tokens":80,"completion_tokens":30}}`)
138	deltas := ParseNormalizedEvent(ev)
139	assertDeltaSequence(t, deltas, DeltaUsage)
140	if deltas[0].InputTokens != 80 || deltas[0].OutputTokens != 30 {
141		t.Fatalf("usage tokens wrong: %+v", deltas[0])
142	}
143}
144
145// ---------------------------------------------------------------------------
146// responses (OpenAI Responses API)
147// ---------------------------------------------------------------------------
148
149func TestParseResponsesText(t *testing.T) {
150	ev := makeEventNamed(EndpointResponses, "response.output_text.delta", `{"type":"response.output_text.delta","delta":"Hi"}`)
151	deltas := ParseNormalizedEvent(ev)
152	if len(deltas) != 1 || deltas[0].Type != DeltaText || deltas[0].Content != "Hi" {
153		t.Fatalf("expected text delta 'Hi', got %+v", deltas)
154	}
155}
156
157func TestParseResponsesReasoningSummary(t *testing.T) {
158	ev := makeEventNamed(EndpointResponses, "response.reasoning_summary_text.delta", `{"type":"response.reasoning_summary_text.delta","delta":"reasoning..."}`)
159	deltas := ParseNormalizedEvent(ev)
160	if len(deltas) != 1 || deltas[0].Type != DeltaReasoning || deltas[0].Content != "reasoning..." {
161		t.Fatalf("expected reasoning delta, got %+v", deltas)
162	}
163}
164
165func TestParseResponsesReasoningDelta(t *testing.T) {
166	// Also accept the older response.reasoning.delta event name.
167	ev := makeEventNamed(EndpointResponses, "response.reasoning.delta", `{"type":"response.reasoning.delta","delta":"thought"}`)
168	deltas := ParseNormalizedEvent(ev)
169	if len(deltas) != 1 || deltas[0].Type != DeltaReasoning || deltas[0].Content != "thought" {
170		t.Fatalf("expected reasoning delta, got %+v", deltas)
171	}
172}
173
174func TestParseResponsesToolCallBegin(t *testing.T) {
175	ev := makeEvent(EndpointResponses, `{"type":"response.output_item.added","output_index":0,"item":{"type":"function_call","id":"call_abc","name":"search"}}`)
176	deltas := ParseNormalizedEvent(ev)
177	if len(deltas) != 1 || deltas[0].Type != DeltaToolCallBegin {
178		t.Fatalf("expected tool_call_begin, got %+v", deltas)
179	}
180	if deltas[0].ToolCallID != "call_abc" || deltas[0].ToolCallName != "search" {
181		t.Fatalf("tool call fields wrong: %+v", deltas[0])
182	}
183}
184
185func TestParseResponsesToolCallArgumentsDelta(t *testing.T) {
186	ev := makeEvent(EndpointResponses, `{"type":"response.function_call_arguments_delta","output_index":1,"delta":"{\"q\":"}`)
187	deltas := ParseNormalizedEvent(ev)
188	if len(deltas) != 1 || deltas[0].Type != DeltaToolCallArgumentsDelta {
189		t.Fatalf("expected tool_call_arguments_delta, got %+v", deltas)
190	}
191	if deltas[0].ArgumentsDelta != `{"q":` {
192		t.Fatalf("arguments delta wrong: %q", deltas[0].ArgumentsDelta)
193	}
194	if deltas[0].ToolCallIndex != 1 {
195		t.Fatalf("tool call index wrong: %d", deltas[0].ToolCallIndex)
196	}
197}
198
199func TestParseResponsesDone(t *testing.T) {
200	ev := makeEvent(EndpointResponses, `{"type":"response.completed"}`)
201	deltas := ParseNormalizedEvent(ev)
202	if len(deltas) != 1 || deltas[0].Type != DeltaDone {
203		t.Fatalf("expected done delta, got %+v", deltas)
204	}
205}
206
207func TestParseResponsesUsage(t *testing.T) {
208	ev := makeEvent(EndpointResponses, `{"type":"response.completed","response":{"usage":{"input_tokens":120,"output_tokens":45}}}`)
209	deltas := ParseNormalizedEvent(ev)
210	assertDeltaSequence(t, deltas, DeltaUsage, DeltaDone)
211	if deltas[0].InputTokens != 120 || deltas[0].OutputTokens != 45 {
212		t.Fatalf("usage tokens wrong: %+v", deltas[0])
213	}
214}
215
216// ---------------------------------------------------------------------------
217// messages (Anthropic)
218// ---------------------------------------------------------------------------
219
220func TestParseMessagesText(t *testing.T) {
221	ev := makeEventNamed(EndpointMessages, "content_block_delta", `{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello"}}`)
222	deltas := ParseNormalizedEvent(ev)
223	if len(deltas) != 1 || deltas[0].Type != DeltaText || deltas[0].Content != "Hello" {
224		t.Fatalf("expected text delta, got %+v", deltas)
225	}
226}
227
228func TestParseMessagesThinkingDelta(t *testing.T) {
229	ev := makeEventNamed(EndpointMessages, "content_block_delta", `{"type":"content_block_delta","index":0,"delta":{"type":"thinking_delta","thinking":"I need to think..."}}`)
230	deltas := ParseNormalizedEvent(ev)
231	if len(deltas) != 1 || deltas[0].Type != DeltaReasoning || deltas[0].Content != "I need to think..." {
232		t.Fatalf("expected reasoning delta, got %+v", deltas)
233	}
234}
235
236func TestParseMessagesToolUseStart(t *testing.T) {
237	ev := makeEventNamed(EndpointMessages, "content_block_start", `{"type":"content_block_start","index":1,"content_block":{"type":"tool_use","id":"toolu_abc","name":"calculator"}}`)
238	deltas := ParseNormalizedEvent(ev)
239	if len(deltas) != 1 || deltas[0].Type != DeltaToolCallBegin {
240		t.Fatalf("expected tool_call_begin, got %+v", deltas)
241	}
242	if deltas[0].ToolCallID != "toolu_abc" || deltas[0].ToolCallName != "calculator" {
243		t.Fatalf("tool call fields wrong: %+v", deltas[0])
244	}
245	if deltas[0].ToolCallIndex != 1 {
246		t.Fatalf("tool call index wrong: %d", deltas[0].ToolCallIndex)
247	}
248}
249
250func TestParseMessagesToolInputDelta(t *testing.T) {
251	ev := makeEventNamed(EndpointMessages, "content_block_delta", `{"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":"{\"x\":"}}`)
252	deltas := ParseNormalizedEvent(ev)
253	if len(deltas) != 1 || deltas[0].Type != DeltaToolCallArgumentsDelta {
254		t.Fatalf("expected tool_call_arguments_delta, got %+v", deltas)
255	}
256	if deltas[0].ArgumentsDelta != `{"x":` {
257		t.Fatalf("arguments delta wrong: %q", deltas[0].ArgumentsDelta)
258	}
259}
260
261func TestParseMessagesStop(t *testing.T) {
262	ev := makeEventNamed(EndpointMessages, "message_stop", `{"type":"message_stop"}`)
263	deltas := ParseNormalizedEvent(ev)
264	if len(deltas) != 1 || deltas[0].Type != DeltaDone {
265		t.Fatalf("expected done delta, got %+v", deltas)
266	}
267}
268
269func TestParseMessagesUsageStart(t *testing.T) {
270	// message_start carries input tokens.
271	ev := makeEventNamed(EndpointMessages, "message_start", `{"type":"message_start","message":{"usage":{"input_tokens":120}}}`)
272	deltas := ParseNormalizedEvent(ev)
273	assertDeltaSequence(t, deltas, DeltaUsage)
274	if deltas[0].InputTokens != 120 || deltas[0].OutputTokens != 0 {
275		t.Fatalf("usage tokens wrong: %+v", deltas[0])
276	}
277}
278
279func TestParseMessagesUsageDelta(t *testing.T) {
280	// message_delta carries output tokens at the top-level usage field.
281	ev := makeEventNamed(EndpointMessages, "message_delta", `{"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"output_tokens":45}}`)
282	deltas := ParseNormalizedEvent(ev)
283	assertDeltaSequence(t, deltas, DeltaUsage)
284	if deltas[0].OutputTokens != 45 || deltas[0].InputTokens != 0 {
285		t.Fatalf("usage tokens wrong: %+v", deltas[0])
286	}
287}
288
289// ---------------------------------------------------------------------------
290// models (Gemini)
291// ---------------------------------------------------------------------------
292
293func TestParseGeminiText(t *testing.T) {
294	ev := makeEvent(EndpointModels, `{"candidates":[{"content":{"parts":[{"text":"Hello"}]}}]}`)
295	deltas := ParseNormalizedEvent(ev)
296	if len(deltas) != 1 || deltas[0].Type != DeltaText || deltas[0].Content != "Hello" {
297		t.Fatalf("expected text delta 'Hello', got %+v", deltas)
298	}
299}
300
301func TestParseGeminiThought(t *testing.T) {
302	ev := makeEvent(EndpointModels, `{"candidates":[{"content":{"parts":[{"text":"thinking...","thought":true}]}}]}`)
303	deltas := ParseNormalizedEvent(ev)
304	if len(deltas) != 1 || deltas[0].Type != DeltaReasoning || deltas[0].Content != "thinking..." {
305		t.Fatalf("expected reasoning delta, got %+v", deltas)
306	}
307}
308
309func TestParseGeminiThoughtThenText(t *testing.T) {
310	ev := makeEvent(EndpointModels, `{"candidates":[{"content":{"parts":[{"text":"I'm thinking","thought":true},{"text":"Here is the answer"}]}}]}`)
311	deltas := ParseNormalizedEvent(ev)
312	if len(deltas) != 2 {
313		t.Fatalf("expected 2 deltas, got %d: %+v", len(deltas), deltas)
314	}
315	if deltas[0].Type != DeltaReasoning {
316		t.Fatalf("expected first delta reasoning, got %s", deltas[0].Type)
317	}
318	if deltas[1].Type != DeltaText {
319		t.Fatalf("expected second delta text, got %s", deltas[1].Type)
320	}
321}
322
323func TestParseGeminiFunctionCall(t *testing.T) {
324	ev := makeEvent(EndpointModels, `{"candidates":[{"content":{"parts":[{"functionCall":{"name":"get_weather","args":{"city":"Paris"}}}]}}]}`)
325	deltas := ParseNormalizedEvent(ev)
326	// Expect DeltaToolCallBegin + DeltaToolCallArgumentsDelta + DeltaToolCallDone
327	if len(deltas) != 3 {
328		t.Fatalf("expected 3 deltas, got %d: %+v", len(deltas), deltas)
329	}
330	if deltas[0].Type != DeltaToolCallBegin || deltas[0].ToolCallName != "get_weather" {
331		t.Fatalf("expected tool_call_begin with name get_weather, got %+v", deltas[0])
332	}
333	if deltas[1].Type != DeltaToolCallArgumentsDelta {
334		t.Fatalf("expected tool_call_arguments_delta, got %+v", deltas[1])
335	}
336	if deltas[2].Type != DeltaToolCallDone {
337		t.Fatalf("expected tool_call_done, got %+v", deltas[2])
338	}
339}
340
341func TestParseGeminiDone(t *testing.T) {
342	ev := makeEvent(EndpointModels, `{"candidates":[{"content":{"parts":[{"text":"done"}]},"finishReason":"STOP"}]}`)
343	deltas := ParseNormalizedEvent(ev)
344	// text delta + done delta
345	if len(deltas) != 2 {
346		t.Fatalf("expected 2 deltas (text+done), got %d: %+v", len(deltas), deltas)
347	}
348	if deltas[len(deltas)-1].Type != DeltaDone {
349		t.Fatalf("last delta should be done, got %s", deltas[len(deltas)-1].Type)
350	}
351}
352
353func TestParseGeminiUsageOnFinalChunk(t *testing.T) {
354	// Usage alongside candidates (most common case).
355	ev := makeEvent(EndpointModels, `{"candidates":[{"content":{"parts":[{"text":"hi"}]},"finishReason":"STOP"}],"usageMetadata":{"promptTokenCount":120,"candidatesTokenCount":45}}`)
356	deltas := ParseNormalizedEvent(ev)
357	assertDeltaSequence(t, deltas, DeltaUsage, DeltaText, DeltaDone)
358	if deltas[0].InputTokens != 120 || deltas[0].OutputTokens != 45 {
359		t.Fatalf("usage tokens wrong: %+v", deltas[0])
360	}
361}
362
363func TestParseGeminiUsageOnCandidatelessChunk(t *testing.T) {
364	// Trailing chunk with no candidates, only usageMetadata.
365	ev := makeEvent(EndpointModels, `{"usageMetadata":{"promptTokenCount":120,"candidatesTokenCount":45}}`)
366	deltas := ParseNormalizedEvent(ev)
367	assertDeltaSequence(t, deltas, DeltaUsage)
368	if deltas[0].InputTokens != 120 || deltas[0].OutputTokens != 45 {
369		t.Fatalf("usage tokens wrong: %+v", deltas[0])
370	}
371}
372
373// ---------------------------------------------------------------------------
374// Integration: Stream end-to-end with a mock server
375// ---------------------------------------------------------------------------
376
377func TestStreamChatCompletions(t *testing.T) {
378	sse := "data: {\"choices\":[{\"delta\":{\"reasoning_content\":\"thinking\"}}]}\n\n" +
379		"data: {\"choices\":[{\"delta\":{\"content\":\"answer\"}}]}\n\n" +
380		"data: {\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\"}]}\n\n" +
381		"data: [DONE]\n\n"
382
383	server, client := newSSETestServer(t, sse)
384	defer server.Close()
385
386	req := NormalizedRequest{
387		Model:    "kimi-k2",
388		Messages: []NormalizedMessage{{Role: "user", Content: "hi"}},
389		Stream:   true,
390	}
391	deltaCh, errCh, err := client.Stream(testCtx(t), req)
392	if err != nil {
393		t.Fatalf("Stream: %v", err)
394	}
395
396	var deltas []NormalizedDelta
397	for d := range deltaCh {
398		deltas = append(deltas, d)
399	}
400	if err := <-errCh; err != nil {
401		t.Fatalf("stream error: %v", err)
402	}
403
404	assertDeltaSequence(t, deltas, DeltaReasoning, DeltaText, DeltaDone)
405	if deltas[0].Content != "thinking" {
406		t.Fatalf("reasoning content: want 'thinking', got %q", deltas[0].Content)
407	}
408	if deltas[1].Content != "answer" {
409		t.Fatalf("text content: want 'answer', got %q", deltas[1].Content)
410	}
411}
412
413func TestStreamMessages(t *testing.T) {
414	sse := "event: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"thinking_delta\",\"thinking\":\"hmm\"}}\n\n" +
415		"event: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":1,\"delta\":{\"type\":\"text_delta\",\"text\":\"ok\"}}\n\n" +
416		"event: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
417
418	server, client := newSSETestServer(t, sse)
419	defer server.Close()
420
421	req := NormalizedRequest{
422		Model:    "claude-sonnet-4-6",
423		Messages: []NormalizedMessage{{Role: "user", Content: "hi"}},
424		Stream:   true,
425	}
426	deltaCh, errCh, err := client.Stream(testCtx(t), req)
427	if err != nil {
428		t.Fatalf("Stream: %v", err)
429	}
430
431	var deltas []NormalizedDelta
432	for d := range deltaCh {
433		deltas = append(deltas, d)
434	}
435	if err := <-errCh; err != nil {
436		t.Fatalf("stream error: %v", err)
437	}
438
439	assertDeltaSequence(t, deltas, DeltaReasoning, DeltaText, DeltaDone)
440}
441
442func TestStreamResponses(t *testing.T) {
443	sse := "event: response.reasoning_summary_text.delta\ndata: {\"type\":\"response.reasoning_summary_text.delta\",\"delta\":\"reasoning\"}\n\n" +
444		"event: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"delta\":\"text\"}\n\n" +
445		"event: response.completed\ndata: {\"type\":\"response.completed\"}\n\n"
446
447	server, client := newSSETestServer(t, sse)
448	defer server.Close()
449
450	req := NormalizedRequest{
451		Model:    "gpt-5.1",
452		Messages: []NormalizedMessage{{Role: "user", Content: "hi"}},
453		Stream:   true,
454	}
455	deltaCh, errCh, err := client.Stream(testCtx(t), req)
456	if err != nil {
457		t.Fatalf("Stream: %v", err)
458	}
459
460	var deltas []NormalizedDelta
461	for d := range deltaCh {
462		deltas = append(deltas, d)
463	}
464	if err := <-errCh; err != nil {
465		t.Fatalf("stream error: %v", err)
466	}
467
468	assertDeltaSequence(t, deltas, DeltaReasoning, DeltaText, DeltaDone)
469}
470
471func TestStreamGemini(t *testing.T) {
472	sse := "data: {\"candidates\":[{\"content\":{\"parts\":[{\"text\":\"thinking\",\"thought\":true}]}}]}\n\n" +
473		"data: {\"candidates\":[{\"content\":{\"parts\":[{\"text\":\"answer\"}]},\"finishReason\":\"STOP\"}]}\n\n"
474
475	server, client := newSSETestServer(t, sse)
476	defer server.Close()
477
478	req := NormalizedRequest{
479		Model:    "gemini-3-flash",
480		Messages: []NormalizedMessage{{Role: "user", Content: "hi"}},
481		Stream:   true,
482	}
483	deltaCh, errCh, err := client.Stream(testCtx(t), req)
484	if err != nil {
485		t.Fatalf("Stream: %v", err)
486	}
487
488	var deltas []NormalizedDelta
489	for d := range deltaCh {
490		deltas = append(deltas, d)
491	}
492	if err := <-errCh; err != nil {
493		t.Fatalf("stream error: %v", err)
494	}
495
496	assertDeltaSequence(t, deltas, DeltaReasoning, DeltaText, DeltaDone)
497}