@@ -41,24 +41,18 @@ func main() {
4141 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
4242 defer cancel()
4343
44- var results []testResult
45-
4644 sections := []struct {
4745 name string
4846 fn func(context.Context, *zen.Client, string) testResult
4947 }{
50- {"Non-Streaming", testModel},
51- {"Streaming", testModelStream},
52- {"UnifiedCreate", testUnifiedCreate},
53- {"UnifiedStream", testUnifiedStream},
54- {"UnifiedCreateNormalized", testUnifiedCreateNormalized},
55- {"UnifiedStreamNormalized", testUnifiedStreamNormalized},
56- {"ToolHistory (normalized)", testToolHistoryNormalized},
57- {"ToolHistory (stream)", testToolHistoryNormalizedStream},
58- {"Reasoning (normalized)", testReasoningNormalized},
59- {"Reasoning (stream)", testReasoningNormalizedStream},
48+ {"StreamEvents", testStreamEvents},
49+ {"StreamParsed", testStreamParsed},
50+ {"ToolHistory (stream)", testToolHistoryStream},
51+ {"Reasoning (stream)", testReasoningStream},
6052 }
6153
54+ var results []testResult
55+
6256 for _, s := range sections {
6357 fmt.Printf("=== %s ===\n", s.name)
6458 for _, modelID := range probeModels {
@@ -78,173 +72,60 @@ func main() {
7872 fmt.Printf("=== Summary: %d/%d passed ===\n", successCount, len(results))
7973 for _, r := range results {
8074 if !r.Success {
81- mode := "non-stream"
82- if r.Stream {
83- mode = "stream"
84- }
85- fmt.Printf(" FAILED [%s] %s (%s): %s\n", mode, r.Model, r.Endpoint, r.Error)
75+ fmt.Printf(" FAILED [stream] %s (%s): %s\n", r.Model, r.Endpoint, r.Error)
8676 }
8777 }
8878 }
8979
90-func testModel(ctx context.Context, client *zen.Client, modelID string) testResult {
91- endpoint := routeForModel(modelID)
80+func testStreamEvents(ctx context.Context, client *zen.Client, modelID string) testResult {
9281 start := time.Now()
93-
94- var resp json.RawMessage
95- var err error
96- var reqBody []byte
97-
98- switch endpoint {
99- case "responses":
100- body := map[string]any{"model": modelID, "input": "Say ok"}
101- reqBody, _ = json.Marshal(body)
102- resp, err = client.CreateResponse(ctx, body, nil)
103- case "messages":
104- body := map[string]any{
105- "model": modelID,
106- "messages": []map[string]string{{"role": "user", "content": "Say ok"}},
107- "max_tokens": 64,
108- }
109- reqBody, _ = json.Marshal(body)
110- resp, err = client.CreateMessage(ctx, body, nil)
111- case "models":
112- req := zen.GeminiRequest{
113- Contents: []zen.GeminiContent{{Role: "user", Parts: []zen.GeminiPart{{Text: "Say ok"}}}},
114- }
115- reqBody, _ = json.Marshal(req)
116- resp, err = client.CreateModelContentTyped(ctx, modelID, req)
117- default:
118- body := map[string]any{
119- "model": modelID,
120- "messages": []map[string]string{{"role": "user", "content": "Say ok"}},
121- }
122- reqBody, _ = json.Marshal(body)
123- resp, err = client.CreateChatCompletion(ctx, body, nil)
124- }
125-
126- return makeResult(modelID, endpoint, false, string(reqBody), string(resp), err, time.Since(start))
127-}
128-
129-func testModelStream(ctx context.Context, client *zen.Client, modelID string) testResult {
13082 endpoint := routeForModel(modelID)
131- start := time.Now()
132-
133- var eventCh <-chan zen.StreamEvent
134- var errCh <-chan error
135- var err error
136- var reqBody []byte
137-
138- switch endpoint {
139- case "responses":
140- body := map[string]any{"model": modelID, "input": "Say ok", "stream": true}
141- reqBody, _ = json.Marshal(body)
142- eventCh, errCh, err = client.StreamResponse(ctx, body, nil)
143- case "messages":
144- body := map[string]any{
145- "model": modelID,
146- "messages": []map[string]string{{"role": "user", "content": "Say ok"}},
147- "max_tokens": 64,
148- "stream": true,
149- }
150- reqBody, _ = json.Marshal(body)
151- eventCh, errCh, err = client.StreamMessage(ctx, body, nil)
152- case "models":
153- req := zen.GeminiRequest{
154- Contents: []zen.GeminiContent{{Role: "user", Parts: []zen.GeminiPart{{Text: "Say ok"}}}},
155- }
156- reqBody, _ = json.Marshal(req)
157- eventCh, errCh, err = client.StreamModelContentTyped(ctx, modelID, req)
158- default:
159- body := map[string]any{
160- "model": modelID,
161- "messages": []map[string]string{{"role": "user", "content": "Say ok"}},
162- "stream": true,
163- }
164- reqBody, _ = json.Marshal(body)
165- eventCh, errCh, err = client.StreamChatCompletion(ctx, body, nil)
166- }
167-
168- return drainStream(modelID, endpoint, string(reqBody), eventCh, errCh, err, start)
169-}
170-
171-func unifiedBody(modelID string) (any, string) {
172- m := strings.ToLower(strings.TrimSpace(modelID))
173- switch {
174- case strings.HasPrefix(m, "gpt-"):
175- return map[string]any{"model": modelID, "input": "Say ok"}, "responses"
176- case strings.HasPrefix(m, "claude-"):
177- return map[string]any{
178- "model": modelID,
179- "messages": []map[string]string{{"role": "user", "content": "Say ok"}},
180- "max_tokens": 64,
181- }, "messages"
182- case strings.HasPrefix(m, "gemini-"):
183- return zen.GeminiRequest{
184- Contents: []zen.GeminiContent{{Role: "user", Parts: []zen.GeminiPart{{Text: "Say ok"}}}},
185- }, "models"
186- default:
187- return map[string]any{
188- "model": modelID,
189- "messages": []map[string]string{{"role": "user", "content": "Say ok"}},
190- }, "chat_completions"
191- }
192-}
193-
194-func testUnifiedCreate(ctx context.Context, client *zen.Client, modelID string) testResult {
195- body, endpoint := unifiedBody(modelID)
196- start := time.Now()
197- reqBody, _ := json.Marshal(body)
198-
199- resp, err := client.UnifiedCreate(ctx, zen.UnifiedRequest{Model: modelID, Body: body})
200- if err != nil {
201- return makeResult(modelID, endpoint, false, string(reqBody), "", err, time.Since(start))
83+ req := zen.NormalizedRequest{
84+ Model: modelID,
85+ Messages: []zen.NormalizedMessage{{Role: "user", Content: "Say ok"}},
20286 }
203- return makeResult(modelID, string(resp.Endpoint), false, string(reqBody), truncate(string(resp.Body), 100), nil, time.Since(start))
204-}
205-
206-func testUnifiedStream(ctx context.Context, client *zen.Client, modelID string) testResult {
207- body, endpoint := unifiedBody(modelID)
208- start := time.Now()
209- reqBody, _ := json.Marshal(body)
87+ reqBody, _ := json.Marshal(req)
21088
211- eventCh, errCh, err := client.UnifiedStream(ctx, zen.UnifiedRequest{Model: modelID, Body: body, Stream: true})
89+ eventCh, errCh, err := client.StreamEvents(ctx, req)
21290 return drainUnifiedStream(modelID, endpoint, string(reqBody), eventCh, errCh, err, start)
21391 }
21492
215-func testUnifiedCreateNormalized(ctx context.Context, client *zen.Client, modelID string) testResult {
93+func testStreamParsed(ctx context.Context, client *zen.Client, modelID string) testResult {
94+ start := time.Now()
95+ endpoint := routeForModel(modelID)
21696 req := zen.NormalizedRequest{
21797 Model: modelID,
21898 Messages: []zen.NormalizedMessage{{Role: "user", Content: "Say ok"}},
21999 }
220- start := time.Now()
221100 reqBody, _ := json.Marshal(req)
222101
223- resp, err := client.UnifiedCreateNormalized(ctx, req)
102+ deltaCh, errCh, err := client.Stream(ctx, req)
224103 if err != nil {
225- return makeResult(modelID, "auto", false, string(reqBody), "", err, time.Since(start))
104+ return makeResult(modelID, endpoint, true, string(reqBody), "", err, time.Since(start))
226105 }
227- return makeResult(modelID, string(resp.Endpoint), false, string(reqBody), truncate(string(resp.Body), 100), nil, time.Since(start))
228-}
229106
230-func testUnifiedStreamNormalized(ctx context.Context, client *zen.Client, modelID string) testResult {
231- req := zen.NormalizedRequest{
232- Model: modelID,
233- Messages: []zen.NormalizedMessage{{Role: "user", Content: "Say ok"}},
234- Stream: true,
107+ var textBuf, reasoningBuf strings.Builder
108+ var count int
109+ for d := range deltaCh {
110+ count++
111+ switch d.Type {
112+ case zen.DeltaText:
113+ textBuf.WriteString(d.Content)
114+ case zen.DeltaReasoning:
115+ reasoningBuf.WriteString(d.Content)
116+ }
117+ }
118+ if streamErr := <-errCh; streamErr != nil {
119+ return makeResult(modelID, endpoint, true, string(reqBody), "", streamErr, time.Since(start))
235120 }
236- start := time.Now()
237- reqBody, _ := json.Marshal(req)
238121
239- eventCh, errCh, err := client.UnifiedStreamNormalized(ctx, req)
240- return drainUnifiedStream(modelID, "auto", string(reqBody), eventCh, errCh, err, start)
122+ resp := fmt.Sprintf("deltas=%d text=%s reasoning=%s", count, truncate(textBuf.String(), 40), truncate(reasoningBuf.String(), 40))
123+ return makeResult(modelID, endpoint, true, string(reqBody), resp, nil, time.Since(start))
241124 }
242125
243126 // toolHistory returns a pre-built two-turn tool-use conversation:
244127 //
245128 // user → assistant+tool_call → tool_result → user follow-up
246-//
247-// The model is expected to incorporate the tool result in its reply.
248129 func toolHistory() []zen.NormalizedMessage {
249130 return []zen.NormalizedMessage{
250131 {Role: "user", Content: "What is 3 + 4?"},
@@ -259,7 +140,9 @@ func toolHistory() []zen.NormalizedMessage {
259140 }
260141 }
261142
262-func testToolHistoryNormalized(ctx context.Context, client *zen.Client, modelID string) testResult {
143+func testToolHistoryStream(ctx context.Context, client *zen.Client, modelID string) testResult {
144+ start := time.Now()
145+ endpoint := routeForModel(modelID)
263146 req := zen.NormalizedRequest{
264147 Model: modelID,
265148 System: "You are a calculator assistant. When given a tool result, use it to answer the user.",
@@ -272,80 +155,46 @@ func testToolHistoryNormalized(ctx context.Context, client *zen.Client, modelID
272155 },
273156 },
274157 }
275- start := time.Now()
276158 reqBody, _ := json.Marshal(req)
277159
278- resp, err := client.UnifiedCreateNormalized(ctx, req)
160+ deltaCh, errCh, err := client.Stream(ctx, req)
279161 if err != nil {
280- return makeResult(modelID, "auto", false, string(reqBody), "", err, time.Since(start))
162+ return makeResult(modelID, endpoint, true, string(reqBody), "", err, time.Since(start))
281163 }
282- return makeResult(modelID, string(resp.Endpoint), false, string(reqBody), truncate(string(resp.Body), 100), nil, time.Since(start))
283-}
284164
285-func testToolHistoryNormalizedStream(ctx context.Context, client *zen.Client, modelID string) testResult {
286- req := zen.NormalizedRequest{
287- Model: modelID,
288- System: "You are a calculator assistant. When given a tool result, use it to answer the user.",
289- Messages: toolHistory(),
290- Tools: []zen.NormalizedTool{
291- {
292- Name: "add",
293- Description: "Adds two numbers",
294- Parameters: json.RawMessage(`{"type":"object","properties":{"a":{"type":"number"},"b":{"type":"number"}},"required":["a","b"]}`),
295- },
296- },
297- Stream: true,
165+ var textBuf strings.Builder
166+ var count int
167+ for d := range deltaCh {
168+ count++
169+ if d.Type == zen.DeltaText {
170+ textBuf.WriteString(d.Content)
171+ }
298172 }
299- start := time.Now()
300- reqBody, _ := json.Marshal(req)
301-
302- eventCh, errCh, err := client.UnifiedStreamNormalized(ctx, req)
303- return drainUnifiedStream(modelID, "auto", string(reqBody), eventCh, errCh, err, start)
304-}
305-
306-func testReasoningNormalized(ctx context.Context, client *zen.Client, modelID string) testResult {
307- req := zen.NormalizedRequest{
308- Model: modelID,
309- Messages: []zen.NormalizedMessage{{Role: "user", Content: "What is 2 + 2? Think step by step."}},
310- Reasoning: &zen.NormalizedReasoning{Effort: "low"},
173+ if streamErr := <-errCh; streamErr != nil {
174+ return makeResult(modelID, endpoint, true, string(reqBody), "", streamErr, time.Since(start))
311175 }
312- start := time.Now()
313- reqBody, _ := json.Marshal(req)
314176
315- resp, err := client.UnifiedCreateNormalized(ctx, req)
316- if err != nil {
317- return makeResult(modelID, "auto", false, string(reqBody), "", err, time.Since(start))
318- }
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))
177+ resp := fmt.Sprintf("deltas=%d text=%s", count, truncate(textBuf.String(), 60))
178+ return makeResult(modelID, endpoint, true, string(reqBody), resp, nil, time.Since(start))
329179 }
330180
331-func testReasoningNormalizedStream(ctx context.Context, client *zen.Client, modelID string) testResult {
181+func testReasoningStream(ctx context.Context, client *zen.Client, modelID string) testResult {
182+ start := time.Now()
183+ endpoint := routeForModel(modelID)
332184 req := zen.NormalizedRequest{
333185 Model: modelID,
334186 Messages: []zen.NormalizedMessage{{Role: "user", Content: "What is 2 + 2? Think step by step."}},
335187 Reasoning: &zen.NormalizedReasoning{Effort: "low"},
336- Stream: true,
337188 }
338- start := time.Now()
339189 reqBody, _ := json.Marshal(req)
340190
341- deltaCh, errCh, err := client.UnifiedStreamNormalizedParsed(ctx, req)
191+ deltaCh, errCh, err := client.Stream(ctx, req)
342192 if err != nil {
343- return makeResult(modelID, "auto", true, string(reqBody), "", err, time.Since(start))
193+ return makeResult(modelID, endpoint, true, string(reqBody), "", err, time.Since(start))
344194 }
345195
346196 var textBuf, reasoningBuf strings.Builder
347197 var deltaCount int
348- var resolvedEndpoint string
349198 for d := range deltaCh {
350199 deltaCount++
351200 switch d.Type {
@@ -356,17 +205,16 @@ func testReasoningNormalizedStream(ctx context.Context, client *zen.Client, mode
356205 }
357206 }
358207 if streamErr := <-errCh; streamErr != nil {
359- return makeResult(modelID, "auto", true, string(reqBody), "", streamErr, time.Since(start))
208+ return makeResult(modelID, endpoint, true, string(reqBody), "", streamErr, time.Since(start))
360209 }
361- _ = resolvedEndpoint
362210
363211 if reasoningBuf.Len() == 0 {
364- return makeResult(modelID, "auto", true, string(reqBody),
212+ return makeResult(modelID, endpoint, true, string(reqBody),
365213 fmt.Sprintf("deltas=%d text=%s", deltaCount, truncate(textBuf.String(), 60)),
366214 fmt.Errorf("model %s: stream contained no reasoning/thinking deltas", modelID),
367215 time.Since(start))
368216 }
369- return makeResult(modelID, "auto", true, string(reqBody),
217+ return makeResult(modelID, endpoint, true, string(reqBody),
370218 fmt.Sprintf("deltas=%d reasoning=%s text=%s",
371219 deltaCount,
372220 truncate(reasoningBuf.String(), 40),
@@ -374,45 +222,6 @@ func testReasoningNormalizedStream(ctx context.Context, client *zen.Client, mode
374222 nil, time.Since(start))
375223 }
376224
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"`)
395-}
396-
397-// drainStream consumes a StreamEvent channel and builds a testResult.
398-func drainStream(modelID, endpoint, reqBody string, eventCh <-chan zen.StreamEvent, errCh <-chan error, initErr error, start time.Time) testResult {
399- if initErr != nil {
400- return makeResult(modelID, endpoint, true, reqBody, "", initErr, time.Since(start))
401- }
402- var count int
403- var last string
404- for ev := range eventCh {
405- count++
406- if len(ev.Data) > 0 {
407- last = string(ev.Data)
408- }
409- }
410- if err := <-errCh; err != nil {
411- return makeResult(modelID, endpoint, true, reqBody, "", err, time.Since(start))
412- }
413- return makeResult(modelID, endpoint, true, reqBody, fmt.Sprintf("events=%d last=%s", count, truncate(last, 80)), nil, time.Since(start))
414-}
415-
416225 // drainUnifiedStream consumes a UnifiedEvent channel and builds a testResult.
417226 func drainUnifiedStream(modelID, endpoint, reqBody string, eventCh <-chan zen.UnifiedEvent, errCh <-chan error, initErr error, start time.Time) testResult {
418227 if initErr != nil {
@@ -456,6 +265,9 @@ func makeResult(modelID, endpoint string, stream bool, req, resp string, err err
456265
457266 func routeForModel(model string) string {
458267 m := strings.ToLower(strings.TrimSpace(model))
268+ if strings.HasPrefix(m, "opencode/") {
269+ m = strings.TrimPrefix(m, "opencode/")
270+ }
459271 switch {
460272 case strings.HasPrefix(m, "gpt-"):
461273 return "responses"
@@ -473,10 +285,7 @@ func printResult(r testResult) {
473285 if !r.Success {
474286 status = "✗"
475287 }
476- mode := "non-stream"
477- if r.Stream {
478- mode = "stream"
479- }
288+ mode := "stream"
480289 fmt.Printf(" %s %-25s [%-15s] [%-10s] %v\n", status, r.Model, r.Endpoint, mode, r.Latency)
481290 }
482291