xonecas.io
6312
Ga

go-opencode-ai-zen-sdk / commit 0975b2e

fix: normalized responses to fix reasoning issues.

xonecas2026-02-19 0975b2e4e38f81ef45fe978f208363acefa27fd8 parent 9af6c03

5 files changed

cmd/test_models/main.go+64−3
@@ -316,7 +316,16 @@ func testReasoningNormalized(ctx context.Context, client *zen.Client, modelID st
316316 if err != nil {
317317 return makeResult(modelID, "auto", false, string(reqBody), "", err, time.Since(start))
318318 }
319- return makeResult(modelID, string(resp.Endpoint), false, string(reqBody), truncate(string(resp.Body), 100), nil, time.Since(start))
319+ // Parse the response body to check for reasoning content.
320+ hasReasoning := responseHasReasoning(resp.Body)
321+ summary := truncate(string(resp.Body), 100)
322+ if !hasReasoning {
323+ return makeResult(modelID, string(resp.Endpoint), false, string(reqBody),
324+ "no reasoning content in response: "+summary,
325+ fmt.Errorf("model %s: response contained no reasoning/thinking content", modelID),
326+ time.Since(start))
327+ }
328+ return makeResult(modelID, string(resp.Endpoint), false, string(reqBody), summary, nil, time.Since(start))
320329 }
321330
322331 func testReasoningNormalizedStream(ctx context.Context, client *zen.Client, modelID string) testResult {
@@ -329,8 +338,60 @@ func testReasoningNormalizedStream(ctx context.Context, client *zen.Client, mode
329338 start := time.Now()
330339 reqBody, _ := json.Marshal(req)
331340
332- eventCh, errCh, err := client.UnifiedStreamNormalized(ctx, req)
333- return drainUnifiedStream(modelID, "auto", string(reqBody), eventCh, errCh, err, start)
341+ deltaCh, errCh, err := client.UnifiedStreamNormalizedParsed(ctx, req)
342+ if err != nil {
343+ return makeResult(modelID, "auto", true, string(reqBody), "", err, time.Since(start))
344+ }
345+
346+ var textBuf, reasoningBuf strings.Builder
347+ var deltaCount int
348+ var resolvedEndpoint string
349+ for d := range deltaCh {
350+ deltaCount++
351+ switch d.Type {
352+ case zen.DeltaText:
353+ textBuf.WriteString(d.Content)
354+ case zen.DeltaReasoning:
355+ reasoningBuf.WriteString(d.Content)
356+ }
357+ }
358+ if streamErr := <-errCh; streamErr != nil {
359+ return makeResult(modelID, "auto", true, string(reqBody), "", streamErr, time.Since(start))
360+ }
361+ _ = resolvedEndpoint
362+
363+ if reasoningBuf.Len() == 0 {
364+ return makeResult(modelID, "auto", true, string(reqBody),
365+ fmt.Sprintf("deltas=%d text=%s", deltaCount, truncate(textBuf.String(), 60)),
366+ fmt.Errorf("model %s: stream contained no reasoning/thinking deltas", modelID),
367+ time.Since(start))
368+ }
369+ return makeResult(modelID, "auto", true, string(reqBody),
370+ fmt.Sprintf("deltas=%d reasoning=%s text=%s",
371+ deltaCount,
372+ truncate(reasoningBuf.String(), 40),
373+ truncate(textBuf.String(), 40)),
374+ nil, time.Since(start))
375+}
376+
377+// responseHasReasoning checks whether a raw JSON response body from any endpoint
378+// contains reasoning or thinking content.
379+func responseHasReasoning(body json.RawMessage) bool {
380+ // Generic scan: look for non-empty reasoning/thinking fields across all formats.
381+ // chat_completions: choices[].message.reasoning_content
382+ // responses: output[].content[].type == "reasoning"
383+ // messages: content[].type == "thinking"
384+ // gemini: candidates[].content.parts[].thought == true
385+ var v map[string]json.RawMessage
386+ if err := json.Unmarshal(body, &v); err != nil {
387+ return false
388+ }
389+ raw := string(body)
390+ return strings.Contains(raw, `"reasoning_content"`) ||
391+ strings.Contains(raw, `"thinking"`) ||
392+ strings.Contains(raw, `"thought":true`) ||
393+ strings.Contains(raw, `"type":"reasoning"`) ||
394+ strings.Contains(raw, `"type":"thinking"`)
334395 }
335396
336397 // drainStream consumes a StreamEvent channel and builds a testResult.
docs/normalized-stream-parsing.md+72−0
@@ -0,0 +1,72 @@
1+# Normalized stream parsing
2+
3+## What changed
4+
5+A response parsing layer was added to complement the existing normalized request
6+layer. Two new public APIs are available:
7+
8+**`ParseNormalizedEvent(ev UnifiedEvent) []NormalizedDelta`**
9+Parses a single raw `UnifiedEvent` into one or more `NormalizedDelta` values.
10+Use this if you are already consuming `UnifiedStreamNormalized` and want to
11+parse events yourself.
12+
13+**`(c *Client) UnifiedStreamNormalizedParsed(...) (<-chan NormalizedDelta, ...)`**
14+All-in-one streaming API. Returns a channel of `NormalizedDelta` instead of raw
15+JSON events. This is the recommended way to consume streaming responses.
16+
17+## Migration
18+
19+Before this change, consumers of `UnifiedStreamNormalized` had to parse each
20+backend's SSE wire format manually to extract text and reasoning content:
21+
22+```go
23+// Before — caller must know each endpoint's wire format
24+for ev := range eventCh {
25+ var chunk map[string]any
26+ json.Unmarshal(ev.Data, &chunk)
27+ // ... manually dig out content / reasoning_content / thinking_delta / thought parts
28+}
29+```
30+
31+Switch to `UnifiedStreamNormalizedParsed` instead:
32+
33+```go
34+// After
35+deltaCh, errCh, err := client.UnifiedStreamNormalizedParsed(ctx, req)
36+for d := range deltaCh {
37+ switch d.Type {
38+ case zen.DeltaText:
39+ fmt.Print(d.Content)
40+ case zen.DeltaReasoning:
41+ fmt.Print("[thinking] ", d.Content)
42+ case zen.DeltaToolCallBegin:
43+ fmt.Println("tool call:", d.ToolCallName)
44+ case zen.DeltaDone:
45+ // stream finished
46+ }
47+}
48+if err := <-errCh; err != nil {
49+ log.Fatal(err)
50+}
51+```
52+
53+## NormalizedDelta fields
54+
55+| Field | Set on |
56+|---|---|
57+| `Type` | always |
58+| `Content` | `DeltaText`, `DeltaReasoning` |
59+| `ToolCallIndex` | `DeltaToolCallBegin`, `DeltaToolCallArgumentsDelta`, `DeltaToolCallDone` |
60+| `ToolCallID` | `DeltaToolCallBegin`, `DeltaToolCallDone` |
61+| `ToolCallName` | `DeltaToolCallBegin`, `DeltaToolCallDone` |
62+| `ArgumentsDelta` | `DeltaToolCallArgumentsDelta` |
63+| `ArgumentsFull` | `DeltaToolCallDone` |
64+
65+## Reasoning field mapping per endpoint
66+
67+| Endpoint | Models | Wire field |
68+|---|---|---|
69+| `chat_completions` | Kimi, DeepSeek, etc. | `choices[0].delta.reasoning_content` |
70+| `responses` | `gpt-*` | `response.reasoning_summary_text.delta`, `response.reasoning.delta` |
71+| `messages` | `claude-*` | `content_block_delta` with `delta.type == "thinking_delta"` |
72+| `models` | `gemini-*` | `candidates[0].content.parts[].thought == true` |
parse.go+346−0
@@ -0,0 +1,346 @@
1+package zen
2+
3+import (
4+ "encoding/json"
5+ "strings"
6+)
7+
8+// NormalizedDeltaType identifies what kind of content a NormalizedDelta carries.
9+type NormalizedDeltaType string
10+
11+const (
12+ // DeltaText is a fragment of the assistant's visible reply.
13+ DeltaText NormalizedDeltaType = "text"
14+ // DeltaReasoning is a fragment of the model's reasoning / thinking output.
15+ DeltaReasoning NormalizedDeltaType = "reasoning"
16+ // DeltaToolCallBegin signals the start of a tool call (Name is set, ArgumentsDelta is empty).
17+ DeltaToolCallBegin NormalizedDeltaType = "tool_call_begin"
18+ // DeltaToolCallArgumentsDelta is an incremental JSON fragment of a tool call's arguments.
19+ DeltaToolCallArgumentsDelta NormalizedDeltaType = "tool_call_arguments_delta"
20+ // DeltaToolCallDone signals that a tool call is complete (ID, Name, Arguments all set).
21+ DeltaToolCallDone NormalizedDeltaType = "tool_call_done"
22+ // DeltaDone signals that the stream has finished (no content fields are set).
23+ DeltaDone NormalizedDeltaType = "done"
24+ // DeltaUnknown is emitted for events that carry no recognized content.
25+ DeltaUnknown NormalizedDeltaType = "unknown"
26+)
27+
28+// NormalizedDelta is a single parsed increment from a streaming response, endpoint-agnostic.
29+type NormalizedDelta struct {
30+ Type NormalizedDeltaType
31+
32+ // Text/Reasoning content (set for DeltaText and DeltaReasoning).
33+ Content string
34+
35+ // Tool call fields.
36+ ToolCallIndex int // index within this response (0-based)
37+ ToolCallID string // set on DeltaToolCallBegin / DeltaToolCallDone
38+ ToolCallName string // set on DeltaToolCallBegin / DeltaToolCallDone
39+ ArgumentsDelta string // set on DeltaToolCallArgumentsDelta
40+ ArgumentsFull string // set on DeltaToolCallDone (fully accumulated)
41+}
42+
43+// ParseNormalizedEvent parses a single UnifiedEvent into zero or more NormalizedDelta values.
44+// Callers should call this for every event emitted by UnifiedStreamNormalized and accumulate
45+// the results. Multiple deltas can be returned from a single event (e.g. Anthropic emits a
46+// content_block_start followed by content_block_delta in separate events, but a Gemini chunk
47+// may carry both a thought part and a text part).
48+func ParseNormalizedEvent(ev UnifiedEvent) []NormalizedDelta {
49+ if len(ev.Data) == 0 {
50+ return nil
51+ }
52+
53+ switch ev.Endpoint {
54+ case EndpointChatCompletions:
55+ return parseChatCompletionsDelta(ev)
56+ case EndpointResponses:
57+ return parseResponsesDelta(ev)
58+ case EndpointMessages:
59+ return parseMessagesDelta(ev)
60+ case EndpointModels:
61+ return parseGeminiDelta(ev)
62+ default:
63+ return nil
64+ }
65+}
66+
67+// ---------------------------------------------------------------------------
68+// chat/completions
69+// ---------------------------------------------------------------------------
70+
71+// chatCompletionChunk is the minimal shape of a streaming chat completion chunk.
72+type chatCompletionChunk struct {
73+ Choices []struct {
74+ Delta struct {
75+ Role string `json:"role"`
76+ Content string `json:"content"`
77+ ReasoningContent string `json:"reasoning_content"`
78+ ToolCalls []struct {
79+ Index int `json:"index"`
80+ ID string `json:"id"`
81+ Type string `json:"type"`
82+ Function struct {
83+ Name string `json:"name"`
84+ Arguments string `json:"arguments"`
85+ } `json:"function"`
86+ } `json:"tool_calls"`
87+ } `json:"delta"`
88+ FinishReason string `json:"finish_reason"`
89+ } `json:"choices"`
90+}
91+
92+func parseChatCompletionsDelta(ev UnifiedEvent) []NormalizedDelta {
93+ var chunk chatCompletionChunk
94+ if err := json.Unmarshal(ev.Data, &chunk); err != nil {
95+ return nil
96+ }
97+ if len(chunk.Choices) == 0 {
98+ return nil
99+ }
100+
101+ delta := chunk.Choices[0].Delta
102+ var out []NormalizedDelta
103+
104+ if delta.ReasoningContent != "" {
105+ out = append(out, NormalizedDelta{Type: DeltaReasoning, Content: delta.ReasoningContent})
106+ }
107+ if delta.Content != "" {
108+ out = append(out, NormalizedDelta{Type: DeltaText, Content: delta.Content})
109+ }
110+ for _, tc := range delta.ToolCalls {
111+ if tc.Function.Name != "" || tc.ID != "" {
112+ out = append(out, NormalizedDelta{
113+ Type: DeltaToolCallBegin,
114+ ToolCallIndex: tc.Index,
115+ ToolCallID: tc.ID,
116+ ToolCallName: tc.Function.Name,
117+ })
118+ }
119+ if tc.Function.Arguments != "" {
120+ out = append(out, NormalizedDelta{
121+ Type: DeltaToolCallArgumentsDelta,
122+ ToolCallIndex: tc.Index,
123+ ArgumentsDelta: tc.Function.Arguments,
124+ })
125+ }
126+ }
127+
128+ if chunk.Choices[0].FinishReason != "" {
129+ out = append(out, NormalizedDelta{Type: DeltaDone})
130+ }
131+
132+ return out
133+}
134+
135+// ---------------------------------------------------------------------------
136+// responses (OpenAI Responses API)
137+// ---------------------------------------------------------------------------
138+
139+// responsesEvent is the minimal shape of a typed Responses API SSE payload.
140+type responsesEvent struct {
141+ Type string `json:"type"`
142+ Delta string `json:"delta"`
143+ // For tool call events.
144+ Item struct {
145+ Type string `json:"type"`
146+ ID string `json:"id"`
147+ Name string `json:"name"`
148+ } `json:"item"`
149+ OutputIndex int `json:"output_index"`
150+ Name string `json:"name"`
151+ CallID string `json:"call_id"`
152+ Arguments string `json:"arguments"`
153+}
154+
155+func parseResponsesDelta(ev UnifiedEvent) []NormalizedDelta {
156+ var e responsesEvent
157+ if err := json.Unmarshal(ev.Data, &e); err != nil {
158+ return nil
159+ }
160+
161+ switch e.Type {
162+ case "response.output_text.delta":
163+ if e.Delta != "" {
164+ return []NormalizedDelta{{Type: DeltaText, Content: e.Delta}}
165+ }
166+ case "response.reasoning_summary_text.delta", "response.reasoning.delta", "response.reasoning_text.delta":
167+ if e.Delta != "" {
168+ return []NormalizedDelta{{Type: DeltaReasoning, Content: e.Delta}}
169+ }
170+ case "response.function_call_arguments_delta":
171+ if e.Delta != "" {
172+ return []NormalizedDelta{{
173+ Type: DeltaToolCallArgumentsDelta,
174+ ToolCallIndex: e.OutputIndex,
175+ ArgumentsDelta: e.Delta,
176+ }}
177+ }
178+ case "response.function_call_arguments_done":
179+ return []NormalizedDelta{{
180+ Type: DeltaToolCallDone,
181+ ToolCallIndex: e.OutputIndex,
182+ ToolCallID: e.CallID,
183+ ToolCallName: e.Name,
184+ ArgumentsFull: e.Arguments,
185+ }}
186+ case "response.output_item.added":
187+ if e.Item.Type == "function_call" {
188+ return []NormalizedDelta{{
189+ Type: DeltaToolCallBegin,
190+ ToolCallIndex: e.OutputIndex,
191+ ToolCallID: e.Item.ID,
192+ ToolCallName: e.Item.Name,
193+ }}
194+ }
195+ case "response.completed", "response.done":
196+ return []NormalizedDelta{{Type: DeltaDone}}
197+ }
198+
199+ return nil
200+}
201+
202+// ---------------------------------------------------------------------------
203+// messages (Anthropic)
204+// ---------------------------------------------------------------------------
205+
206+// anthropicStreamEvent is the minimal shape of an Anthropic SSE payload.
207+type anthropicStreamEvent struct {
208+ Type string `json:"type"`
209+ Index int `json:"index"`
210+ Delta struct {
211+ Type string `json:"type"`
212+ Text string `json:"text"`
213+ Thinking string `json:"thinking"`
214+ // For tool use input deltas.
215+ PartialJSON string `json:"partial_json"`
216+ } `json:"delta"`
217+ ContentBlock struct {
218+ Type string `json:"type"`
219+ ID string `json:"id"`
220+ Name string `json:"name"`
221+ Input string `json:"input"`
222+ } `json:"content_block"`
223+}
224+
225+func parseMessagesDelta(ev UnifiedEvent) []NormalizedDelta {
226+ // Anthropic uses the SSE "event:" line for the type, but also includes
227+ // "type" in the JSON body. Both are supported.
228+ var e anthropicStreamEvent
229+ if err := json.Unmarshal(ev.Data, &e); err != nil {
230+ return nil
231+ }
232+
233+ // Prefer the JSON body "type" field; fall back to the SSE event name.
234+ evType := e.Type
235+ if evType == "" {
236+ evType = ev.Event
237+ }
238+
239+ switch evType {
240+ case "content_block_start":
241+ if e.ContentBlock.Type == "tool_use" {
242+ return []NormalizedDelta{{
243+ Type: DeltaToolCallBegin,
244+ ToolCallIndex: e.Index,
245+ ToolCallID: e.ContentBlock.ID,
246+ ToolCallName: e.ContentBlock.Name,
247+ }}
248+ }
249+ case "content_block_delta":
250+ switch e.Delta.Type {
251+ case "text_delta":
252+ if e.Delta.Text != "" {
253+ return []NormalizedDelta{{Type: DeltaText, Content: e.Delta.Text}}
254+ }
255+ case "thinking_delta":
256+ if e.Delta.Thinking != "" {
257+ return []NormalizedDelta{{Type: DeltaReasoning, Content: e.Delta.Thinking}}
258+ }
259+ case "input_json_delta":
260+ if e.Delta.PartialJSON != "" {
261+ return []NormalizedDelta{{
262+ Type: DeltaToolCallArgumentsDelta,
263+ ToolCallIndex: e.Index,
264+ ArgumentsDelta: e.Delta.PartialJSON,
265+ }}
266+ }
267+ }
268+ case "content_block_stop":
269+ // No content; signal completion only for tool_use blocks would require
270+ // state from content_block_start. Consumers that need DeltaToolCallDone
271+ // should accumulate themselves. We emit nothing here.
272+ case "message_stop":
273+ return []NormalizedDelta{{Type: DeltaDone}}
274+ }
275+
276+ return nil
277+}
278+
279+// ---------------------------------------------------------------------------
280+// models (Gemini)
281+// ---------------------------------------------------------------------------
282+
283+// geminiChunk is the minimal shape of a Gemini SSE chunk.
284+type geminiChunk struct {
285+ Candidates []struct {
286+ Content struct {
287+ Parts []struct {
288+ Text string `json:"text"`
289+ Thought bool `json:"thought"`
290+ FunctionCall *geminiFC `json:"functionCall,omitempty"`
291+ } `json:"parts"`
292+ } `json:"content"`
293+ FinishReason string `json:"finishReason"`
294+ } `json:"candidates"`
295+}
296+
297+type geminiFC struct {
298+ Name string `json:"name"`
299+ Args json.RawMessage `json:"args"`
300+}
301+
302+func parseGeminiDelta(ev UnifiedEvent) []NormalizedDelta {
303+ var chunk geminiChunk
304+ if err := json.Unmarshal(ev.Data, &chunk); err != nil {
305+ return nil
306+ }
307+ if len(chunk.Candidates) == 0 {
308+ return nil
309+ }
310+
311+ cand := chunk.Candidates[0]
312+ var out []NormalizedDelta
313+
314+ for i, part := range cand.Content.Parts {
315+ if part.FunctionCall != nil {
316+ out = append(out, NormalizedDelta{
317+ Type: DeltaToolCallBegin,
318+ ToolCallIndex: i,
319+ ToolCallName: part.FunctionCall.Name,
320+ })
321+ if len(part.FunctionCall.Args) > 0 {
322+ out = append(out, NormalizedDelta{
323+ Type: DeltaToolCallArgumentsDelta,
324+ ToolCallIndex: i,
325+ ArgumentsDelta: string(part.FunctionCall.Args),
326+ })
327+ }
328+ continue
329+ }
330+ text := strings.TrimRight(part.Text, "")
331+ if text == "" {
332+ continue
333+ }
334+ if part.Thought {
335+ out = append(out, NormalizedDelta{Type: DeltaReasoning, Content: text})
336+ } else {
337+ out = append(out, NormalizedDelta{Type: DeltaText, Content: text})
338+ }
339+ }
340+
341+ if cand.FinishReason != "" && cand.FinishReason != "FINISH_REASON_UNSPECIFIED" {
342+ out = append(out, NormalizedDelta{Type: DeltaDone})
343+ }
344+
345+ return out
346+}
parse_test.go+425−0
@@ -0,0 +1,425 @@
1+package zen
2+
3+import (
4+ "context"
5+ "encoding/json"
6+ "net/http"
7+ "net/http/httptest"
8+ "testing"
9+)
10+
11+// ---------------------------------------------------------------------------
12+// Test helpers
13+// ---------------------------------------------------------------------------
14+
15+func 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.
21+func 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.
26+func 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.
32+func 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+
45+func 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+
65+func 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+
73+func 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+
81+func 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+
95+func 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+
106+func 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+
117+func 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+
125+// ---------------------------------------------------------------------------
126+// responses (OpenAI Responses API)
127+// ---------------------------------------------------------------------------
128+
129+func TestParseResponsesText(t *testing.T) {
130+ ev := makeEventNamed(EndpointResponses, "response.output_text.delta", `{"type":"response.output_text.delta","delta":"Hi"}`)
131+ deltas := ParseNormalizedEvent(ev)
132+ if len(deltas) != 1 || deltas[0].Type != DeltaText || deltas[0].Content != "Hi" {
133+ t.Fatalf("expected text delta 'Hi', got %+v", deltas)
134+ }
135+}
136+
137+func TestParseResponsesReasoningSummary(t *testing.T) {
138+ ev := makeEventNamed(EndpointResponses, "response.reasoning_summary_text.delta", `{"type":"response.reasoning_summary_text.delta","delta":"reasoning..."}`)
139+ deltas := ParseNormalizedEvent(ev)
140+ if len(deltas) != 1 || deltas[0].Type != DeltaReasoning || deltas[0].Content != "reasoning..." {
141+ t.Fatalf("expected reasoning delta, got %+v", deltas)
142+ }
143+}
144+
145+func TestParseResponsesReasoningDelta(t *testing.T) {
146+ // Also accept the older response.reasoning.delta event name.
147+ ev := makeEventNamed(EndpointResponses, "response.reasoning.delta", `{"type":"response.reasoning.delta","delta":"thought"}`)
148+ deltas := ParseNormalizedEvent(ev)
149+ if len(deltas) != 1 || deltas[0].Type != DeltaReasoning || deltas[0].Content != "thought" {
150+ t.Fatalf("expected reasoning delta, got %+v", deltas)
151+ }
152+}
153+
154+func TestParseResponsesToolCallBegin(t *testing.T) {
155+ ev := makeEvent(EndpointResponses, `{"type":"response.output_item.added","output_index":0,"item":{"type":"function_call","id":"call_abc","name":"search"}}`)
156+ deltas := ParseNormalizedEvent(ev)
157+ if len(deltas) != 1 || deltas[0].Type != DeltaToolCallBegin {
158+ t.Fatalf("expected tool_call_begin, got %+v", deltas)
159+ }
160+ if deltas[0].ToolCallID != "call_abc" || deltas[0].ToolCallName != "search" {
161+ t.Fatalf("tool call fields wrong: %+v", deltas[0])
162+ }
163+}
164+
165+func TestParseResponsesToolCallArgumentsDelta(t *testing.T) {
166+ ev := makeEvent(EndpointResponses, `{"type":"response.function_call_arguments_delta","output_index":1,"delta":"{\"q\":"}`)
167+ deltas := ParseNormalizedEvent(ev)
168+ if len(deltas) != 1 || deltas[0].Type != DeltaToolCallArgumentsDelta {
169+ t.Fatalf("expected tool_call_arguments_delta, got %+v", deltas)
170+ }
171+ if deltas[0].ArgumentsDelta != `{"q":` {
172+ t.Fatalf("arguments delta wrong: %q", deltas[0].ArgumentsDelta)
173+ }
174+ if deltas[0].ToolCallIndex != 1 {
175+ t.Fatalf("tool call index wrong: %d", deltas[0].ToolCallIndex)
176+ }
177+}
178+
179+func TestParseResponsesDone(t *testing.T) {
180+ ev := makeEvent(EndpointResponses, `{"type":"response.completed"}`)
181+ deltas := ParseNormalizedEvent(ev)
182+ if len(deltas) != 1 || deltas[0].Type != DeltaDone {
183+ t.Fatalf("expected done delta, got %+v", deltas)
184+ }
185+}
186+
187+// ---------------------------------------------------------------------------
188+// messages (Anthropic)
189+// ---------------------------------------------------------------------------
190+
191+func TestParseMessagesText(t *testing.T) {
192+ ev := makeEventNamed(EndpointMessages, "content_block_delta", `{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello"}}`)
193+ deltas := ParseNormalizedEvent(ev)
194+ if len(deltas) != 1 || deltas[0].Type != DeltaText || deltas[0].Content != "Hello" {
195+ t.Fatalf("expected text delta, got %+v", deltas)
196+ }
197+}
198+
199+func TestParseMessagesThinkingDelta(t *testing.T) {
200+ ev := makeEventNamed(EndpointMessages, "content_block_delta", `{"type":"content_block_delta","index":0,"delta":{"type":"thinking_delta","thinking":"I need to think..."}}`)
201+ deltas := ParseNormalizedEvent(ev)
202+ if len(deltas) != 1 || deltas[0].Type != DeltaReasoning || deltas[0].Content != "I need to think..." {
203+ t.Fatalf("expected reasoning delta, got %+v", deltas)
204+ }
205+}
206+
207+func TestParseMessagesToolUseStart(t *testing.T) {
208+ ev := makeEventNamed(EndpointMessages, "content_block_start", `{"type":"content_block_start","index":1,"content_block":{"type":"tool_use","id":"toolu_abc","name":"calculator"}}`)
209+ deltas := ParseNormalizedEvent(ev)
210+ if len(deltas) != 1 || deltas[0].Type != DeltaToolCallBegin {
211+ t.Fatalf("expected tool_call_begin, got %+v", deltas)
212+ }
213+ if deltas[0].ToolCallID != "toolu_abc" || deltas[0].ToolCallName != "calculator" {
214+ t.Fatalf("tool call fields wrong: %+v", deltas[0])
215+ }
216+ if deltas[0].ToolCallIndex != 1 {
217+ t.Fatalf("tool call index wrong: %d", deltas[0].ToolCallIndex)
218+ }
219+}
220+
221+func TestParseMessagesToolInputDelta(t *testing.T) {
222+ ev := makeEventNamed(EndpointMessages, "content_block_delta", `{"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":"{\"x\":"}}`)
223+ deltas := ParseNormalizedEvent(ev)
224+ if len(deltas) != 1 || deltas[0].Type != DeltaToolCallArgumentsDelta {
225+ t.Fatalf("expected tool_call_arguments_delta, got %+v", deltas)
226+ }
227+ if deltas[0].ArgumentsDelta != `{"x":` {
228+ t.Fatalf("arguments delta wrong: %q", deltas[0].ArgumentsDelta)
229+ }
230+}
231+
232+func TestParseMessagesStop(t *testing.T) {
233+ ev := makeEventNamed(EndpointMessages, "message_stop", `{"type":"message_stop"}`)
234+ deltas := ParseNormalizedEvent(ev)
235+ if len(deltas) != 1 || deltas[0].Type != DeltaDone {
236+ t.Fatalf("expected done delta, got %+v", deltas)
237+ }
238+}
239+
240+// ---------------------------------------------------------------------------
241+// models (Gemini)
242+// ---------------------------------------------------------------------------
243+
244+func TestParseGeminiText(t *testing.T) {
245+ ev := makeEvent(EndpointModels, `{"candidates":[{"content":{"parts":[{"text":"Hello"}]}}]}`)
246+ deltas := ParseNormalizedEvent(ev)
247+ if len(deltas) != 1 || deltas[0].Type != DeltaText || deltas[0].Content != "Hello" {
248+ t.Fatalf("expected text delta 'Hello', got %+v", deltas)
249+ }
250+}
251+
252+func TestParseGeminiThought(t *testing.T) {
253+ ev := makeEvent(EndpointModels, `{"candidates":[{"content":{"parts":[{"text":"thinking...","thought":true}]}}]}`)
254+ deltas := ParseNormalizedEvent(ev)
255+ if len(deltas) != 1 || deltas[0].Type != DeltaReasoning || deltas[0].Content != "thinking..." {
256+ t.Fatalf("expected reasoning delta, got %+v", deltas)
257+ }
258+}
259+
260+func TestParseGeminiThoughtThenText(t *testing.T) {
261+ ev := makeEvent(EndpointModels, `{"candidates":[{"content":{"parts":[{"text":"I'm thinking","thought":true},{"text":"Here is the answer"}]}}]}`)
262+ deltas := ParseNormalizedEvent(ev)
263+ if len(deltas) != 2 {
264+ t.Fatalf("expected 2 deltas, got %d: %+v", len(deltas), deltas)
265+ }
266+ if deltas[0].Type != DeltaReasoning {
267+ t.Fatalf("expected first delta reasoning, got %s", deltas[0].Type)
268+ }
269+ if deltas[1].Type != DeltaText {
270+ t.Fatalf("expected second delta text, got %s", deltas[1].Type)
271+ }
272+}
273+
274+func TestParseGeminiFunctionCall(t *testing.T) {
275+ ev := makeEvent(EndpointModels, `{"candidates":[{"content":{"parts":[{"functionCall":{"name":"get_weather","args":{"city":"Paris"}}}]}}]}`)
276+ deltas := ParseNormalizedEvent(ev)
277+ // Expect DeltaToolCallBegin + DeltaToolCallArgumentsDelta
278+ if len(deltas) != 2 {
279+ t.Fatalf("expected 2 deltas, got %d: %+v", len(deltas), deltas)
280+ }
281+ if deltas[0].Type != DeltaToolCallBegin || deltas[0].ToolCallName != "get_weather" {
282+ t.Fatalf("expected tool_call_begin with name get_weather, got %+v", deltas[0])
283+ }
284+ if deltas[1].Type != DeltaToolCallArgumentsDelta {
285+ t.Fatalf("expected tool_call_arguments_delta, got %+v", deltas[1])
286+ }
287+}
288+
289+func TestParseGeminiDone(t *testing.T) {
290+ ev := makeEvent(EndpointModels, `{"candidates":[{"content":{"parts":[{"text":"done"}]},"finishReason":"STOP"}]}`)
291+ deltas := ParseNormalizedEvent(ev)
292+ // text delta + done delta
293+ if len(deltas) != 2 {
294+ t.Fatalf("expected 2 deltas (text+done), got %d: %+v", len(deltas), deltas)
295+ }
296+ if deltas[len(deltas)-1].Type != DeltaDone {
297+ t.Fatalf("last delta should be done, got %s", deltas[len(deltas)-1].Type)
298+ }
299+}
300+
301+// ---------------------------------------------------------------------------
302+// Integration: UnifiedStreamNormalizedParsed end-to-end with a mock server
303+// ---------------------------------------------------------------------------
304+
305+func TestUnifiedStreamNormalizedParsedChatCompletions(t *testing.T) {
306+ sse := "data: {\"choices\":[{\"delta\":{\"reasoning_content\":\"thinking\"}}]}\n\n" +
307+ "data: {\"choices\":[{\"delta\":{\"content\":\"answer\"}}]}\n\n" +
308+ "data: {\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\"}]}\n\n" +
309+ "data: [DONE]\n\n"
310+
311+ server, client := newSSETestServer(t, sse)
312+ defer server.Close()
313+
314+ req := NormalizedRequest{
315+ Model: "kimi-k2",
316+ Messages: []NormalizedMessage{{Role: "user", Content: "hi"}},
317+ Stream: true,
318+ }
319+ deltaCh, errCh, err := client.UnifiedStreamNormalizedParsed(testCtx(t), req)
320+ if err != nil {
321+ t.Fatalf("UnifiedStreamNormalizedParsed: %v", err)
322+ }
323+
324+ var deltas []NormalizedDelta
325+ for d := range deltaCh {
326+ deltas = append(deltas, d)
327+ }
328+ if err := <-errCh; err != nil {
329+ t.Fatalf("stream error: %v", err)
330+ }
331+
332+ assertDeltaSequence(t, deltas, DeltaReasoning, DeltaText, DeltaDone)
333+ if deltas[0].Content != "thinking" {
334+ t.Fatalf("reasoning content: want 'thinking', got %q", deltas[0].Content)
335+ }
336+ if deltas[1].Content != "answer" {
337+ t.Fatalf("text content: want 'answer', got %q", deltas[1].Content)
338+ }
339+}
340+
341+func TestUnifiedStreamNormalizedParsedMessages(t *testing.T) {
342+ sse := "event: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"thinking_delta\",\"thinking\":\"hmm\"}}\n\n" +
343+ "event: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":1,\"delta\":{\"type\":\"text_delta\",\"text\":\"ok\"}}\n\n" +
344+ "event: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
345+
346+ server, client := newSSETestServer(t, sse)
347+ defer server.Close()
348+
349+ req := NormalizedRequest{
350+ Model: "claude-sonnet-4-6",
351+ Messages: []NormalizedMessage{{Role: "user", Content: "hi"}},
352+ Stream: true,
353+ }
354+ deltaCh, errCh, err := client.UnifiedStreamNormalizedParsed(testCtx(t), req)
355+ if err != nil {
356+ t.Fatalf("UnifiedStreamNormalizedParsed: %v", err)
357+ }
358+
359+ var deltas []NormalizedDelta
360+ for d := range deltaCh {
361+ deltas = append(deltas, d)
362+ }
363+ if err := <-errCh; err != nil {
364+ t.Fatalf("stream error: %v", err)
365+ }
366+
367+ assertDeltaSequence(t, deltas, DeltaReasoning, DeltaText, DeltaDone)
368+}
369+
370+func TestUnifiedStreamNormalizedParsedResponses(t *testing.T) {
371+ sse := "event: response.reasoning_summary_text.delta\ndata: {\"type\":\"response.reasoning_summary_text.delta\",\"delta\":\"reasoning\"}\n\n" +
372+ "event: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"delta\":\"text\"}\n\n" +
373+ "event: response.completed\ndata: {\"type\":\"response.completed\"}\n\n"
374+
375+ server, client := newSSETestServer(t, sse)
376+ defer server.Close()
377+
378+ req := NormalizedRequest{
379+ Model: "gpt-5.1",
380+ Messages: []NormalizedMessage{{Role: "user", Content: "hi"}},
381+ Stream: true,
382+ }
383+ deltaCh, errCh, err := client.UnifiedStreamNormalizedParsed(testCtx(t), req)
384+ if err != nil {
385+ t.Fatalf("UnifiedStreamNormalizedParsed: %v", err)
386+ }
387+
388+ var deltas []NormalizedDelta
389+ for d := range deltaCh {
390+ deltas = append(deltas, d)
391+ }
392+ if err := <-errCh; err != nil {
393+ t.Fatalf("stream error: %v", err)
394+ }
395+
396+ assertDeltaSequence(t, deltas, DeltaReasoning, DeltaText, DeltaDone)
397+}
398+
399+func TestUnifiedStreamNormalizedParsedGemini(t *testing.T) {
400+ sse := "data: {\"candidates\":[{\"content\":{\"parts\":[{\"text\":\"thinking\",\"thought\":true}]}}]}\n\n" +
401+ "data: {\"candidates\":[{\"content\":{\"parts\":[{\"text\":\"answer\"}]},\"finishReason\":\"STOP\"}]}\n\n"
402+
403+ server, client := newSSETestServer(t, sse)
404+ defer server.Close()
405+
406+ req := NormalizedRequest{
407+ Model: "gemini-3-flash",
408+ Messages: []NormalizedMessage{{Role: "user", Content: "hi"}},
409+ Stream: true,
410+ }
411+ deltaCh, errCh, err := client.UnifiedStreamNormalizedParsed(testCtx(t), req)
412+ if err != nil {
413+ t.Fatalf("UnifiedStreamNormalizedParsed: %v", err)
414+ }
415+
416+ var deltas []NormalizedDelta
417+ for d := range deltaCh {
418+ deltas = append(deltas, d)
419+ }
420+ if err := <-errCh; err != nil {
421+ t.Fatalf("stream error: %v", err)
422+ }
423+
424+ assertDeltaSequence(t, deltas, DeltaReasoning, DeltaText, DeltaDone)
425+}
unified.go+29−0
@@ -235,6 +235,35 @@ func (c *Client) UnifiedStreamNormalized(ctx context.Context, req NormalizedRequ
235235 }
236236 }
237237
238+// UnifiedStreamNormalizedParsed is like UnifiedStreamNormalized but parses each
239+// raw SSE event into one or more NormalizedDelta values before yielding them.
240+// This is the high-level streaming API: callers do not need to know the wire
241+// format of the underlying endpoint.
242+func (c *Client) UnifiedStreamNormalizedParsed(ctx context.Context, req NormalizedRequest) (<-chan NormalizedDelta, <-chan error, error) {
243+ evCh, errCh, err := c.UnifiedStreamNormalized(ctx, req)
244+ if err != nil {
245+ return nil, nil, err
246+ }
247+
248+ out := make(chan NormalizedDelta)
249+ outErr := make(chan error, 1)
250+
251+ go func() {
252+ defer close(out)
253+ defer close(outErr)
254+ for ev := range evCh {
255+ for _, delta := range ParseNormalizedEvent(ev) {
256+ out <- delta
257+ }
258+ }
259+ if streamErr := <-errCh; streamErr != nil {
260+ outErr <- streamErr
261+ }
262+ }()
263+
264+ return out, outErr, nil
265+}
266+
238267 func (c *Client) resolveEndpoint(req UnifiedRequest) (EndpointType, string, string, error) {
239268 endpoint := req.Endpoint
240269 if endpoint == EndpointAuto {