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}