xonecas.io
6312
Ga

go-opencode-ai-zen-sdk / commit 60d8777

fix: unified Gemini routing, Anthropic max_tokens default, and streaming test coverage

xonecas2026-02-19 60d87771a3cc7af92b7c844a34236b10eeaf5ba4 parent be38230

4 files changed

cmd/test_models/main.go+206−41
@@ -11,6 +11,9 @@ import (
1111 zen "github.com/sacenox/go-opencode-ai-zen-sdk"
1212 )
1313
14+// One representative model per endpoint type.
15+var probeModels = []string{"gpt-5.1", "claude-sonnet-4-6", "gemini-3-flash", "glm-5"}
16+
1417 type testResult struct {
1518 Model string
1619 Endpoint string
@@ -19,6 +22,7 @@ type testResult struct {
1922 Latency time.Duration
2023 Request string
2124 Response string
25+ Stream bool
2226 }
2327
2428 func main() {
@@ -37,36 +41,44 @@ func main() {
3741 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
3842 defer cancel()
3943
40- fmt.Println("Fetching available models...")
41- models, err := client.ListModels(ctx)
42- if err != nil {
43- fmt.Fprintf(os.Stderr, "Failed to list models: %v\n", err)
44- os.Exit(1)
45- }
46-
47- fmt.Printf("Found %d models\n\n", len(models.Data))
48-
4944 var results []testResult
5045
51- for _, model := range models.Data {
52- result := testModel(ctx, client, model.ID)
53- results = append(results, result)
54- printResult(result)
46+ sections := []struct {
47+ name string
48+ fn func(context.Context, *zen.Client, string) testResult
49+ }{
50+ {"Non-Streaming", testModel},
51+ {"Streaming", testModelStream},
52+ {"UnifiedCreate", testUnifiedCreate},
53+ {"UnifiedStream", testUnifiedStream},
54+ {"UnifiedCreateNormalized", testUnifiedCreateNormalized},
55+ {"UnifiedStreamNormalized", testUnifiedStreamNormalized},
56+ }
57+
58+ for _, s := range sections {
59+ fmt.Printf("=== %s ===\n", s.name)
60+ for _, modelID := range probeModels {
61+ r := s.fn(ctx, client, modelID)
62+ results = append(results, r)
63+ printResult(r)
64+ }
65+ fmt.Println()
5566 }
5667
57- fmt.Println("\n=== Summary ===")
5868 successCount := 0
5969 for _, r := range results {
6070 if r.Success {
6171 successCount++
6272 }
6373 }
64- fmt.Printf("Total: %d, Success: %d, Failed: %d\n", len(results), successCount, len(results)-successCount)
65-
74+ fmt.Printf("=== Summary: %d/%d passed ===\n", successCount, len(results))
6675 for _, r := range results {
6776 if !r.Success {
68- fmt.Printf("FAILED: %s (%s) - %s\n", r.Model, r.Endpoint, r.Error)
69- fmt.Printf(" Request: %s\n", truncate(r.Request, 200))
77+ mode := "non-stream"
78+ if r.Stream {
79+ mode = "stream"
80+ }
81+ fmt.Printf(" FAILED [%s] %s (%s): %s\n", mode, r.Model, r.Endpoint, r.Error)
7082 }
7183 }
7284 }
@@ -81,25 +93,20 @@ func testModel(ctx context.Context, client *zen.Client, modelID string) testResu
8193
8294 switch endpoint {
8395 case "responses":
84- body := map[string]any{
85- "model": modelID,
86- "input": "Say ok",
87- }
96+ body := map[string]any{"model": modelID, "input": "Say ok"}
8897 reqBody, _ = json.Marshal(body)
8998 resp, err = client.CreateResponse(ctx, body, nil)
9099 case "messages":
91100 body := map[string]any{
92101 "model": modelID,
93102 "messages": []map[string]string{{"role": "user", "content": "Say ok"}},
94- "max_tokens": 10,
103+ "max_tokens": 64,
95104 }
96105 reqBody, _ = json.Marshal(body)
97106 resp, err = client.CreateMessage(ctx, body, nil)
98107 case "models":
99108 req := zen.GeminiRequest{
100- Contents: []zen.GeminiContent{
101- {Role: "user", Parts: []zen.GeminiPart{{Text: "Say ok"}}},
102- },
109+ Contents: []zen.GeminiContent{{Role: "user", Parts: []zen.GeminiPart{{Text: "Say ok"}}}},
103110 }
104111 reqBody, _ = json.Marshal(req)
105112 resp, err = client.CreateModelContentTyped(ctx, modelID, req)
@@ -112,23 +119,181 @@ func testModel(ctx context.Context, client *zen.Client, modelID string) testResu
112119 resp, err = client.CreateChatCompletion(ctx, body, nil)
113120 }
114121
115- latency := time.Since(start)
122+ return makeResult(modelID, endpoint, false, string(reqBody), string(resp), err, time.Since(start))
123+}
124+
125+func testModelStream(ctx context.Context, client *zen.Client, modelID string) testResult {
126+ endpoint := routeForModel(modelID)
127+ start := time.Now()
128+
129+ var eventCh <-chan zen.StreamEvent
130+ var errCh <-chan error
131+ var err error
132+ var reqBody []byte
133+
134+ switch endpoint {
135+ case "responses":
136+ body := map[string]any{"model": modelID, "input": "Say ok", "stream": true}
137+ reqBody, _ = json.Marshal(body)
138+ eventCh, errCh, err = client.StreamResponse(ctx, body, nil)
139+ case "messages":
140+ body := map[string]any{
141+ "model": modelID,
142+ "messages": []map[string]string{{"role": "user", "content": "Say ok"}},
143+ "max_tokens": 64,
144+ "stream": true,
145+ }
146+ reqBody, _ = json.Marshal(body)
147+ eventCh, errCh, err = client.StreamMessage(ctx, body, nil)
148+ case "models":
149+ req := zen.GeminiRequest{
150+ Contents: []zen.GeminiContent{{Role: "user", Parts: []zen.GeminiPart{{Text: "Say ok"}}}},
151+ }
152+ reqBody, _ = json.Marshal(req)
153+ eventCh, errCh, err = client.StreamModelContentTyped(ctx, modelID, req)
154+ default:
155+ body := map[string]any{
156+ "model": modelID,
157+ "messages": []map[string]string{{"role": "user", "content": "Say ok"}},
158+ "stream": true,
159+ }
160+ reqBody, _ = json.Marshal(body)
161+ eventCh, errCh, err = client.StreamChatCompletion(ctx, body, nil)
162+ }
163+
164+ return drainStream(modelID, endpoint, string(reqBody), eventCh, errCh, err, start)
165+}
166+
167+func unifiedBody(modelID string) (any, string) {
168+ m := strings.ToLower(strings.TrimSpace(modelID))
169+ switch {
170+ case strings.HasPrefix(m, "gpt-"):
171+ return map[string]any{"model": modelID, "input": "Say ok"}, "responses"
172+ case strings.HasPrefix(m, "claude-"):
173+ return map[string]any{
174+ "model": modelID,
175+ "messages": []map[string]string{{"role": "user", "content": "Say ok"}},
176+ "max_tokens": 64,
177+ }, "messages"
178+ case strings.HasPrefix(m, "gemini-"):
179+ return zen.GeminiRequest{
180+ Contents: []zen.GeminiContent{{Role: "user", Parts: []zen.GeminiPart{{Text: "Say ok"}}}},
181+ }, "models"
182+ default:
183+ return map[string]any{
184+ "model": modelID,
185+ "messages": []map[string]string{{"role": "user", "content": "Say ok"}},
186+ }, "chat_completions"
187+ }
188+}
189+
190+func testUnifiedCreate(ctx context.Context, client *zen.Client, modelID string) testResult {
191+ body, endpoint := unifiedBody(modelID)
192+ start := time.Now()
193+ reqBody, _ := json.Marshal(body)
194+
195+ resp, err := client.UnifiedCreate(ctx, zen.UnifiedRequest{Model: modelID, Body: body})
196+ if err != nil {
197+ return makeResult(modelID, endpoint, false, string(reqBody), "", err, time.Since(start))
198+ }
199+ return makeResult(modelID, string(resp.Endpoint), false, string(reqBody), truncate(string(resp.Body), 100), nil, time.Since(start))
200+}
201+
202+func testUnifiedStream(ctx context.Context, client *zen.Client, modelID string) testResult {
203+ body, endpoint := unifiedBody(modelID)
204+ start := time.Now()
205+ reqBody, _ := json.Marshal(body)
206+
207+ eventCh, errCh, err := client.UnifiedStream(ctx, zen.UnifiedRequest{Model: modelID, Body: body, Stream: true})
208+ return drainUnifiedStream(modelID, endpoint, string(reqBody), eventCh, errCh, err, start)
209+}
116210
117- result := testResult{
211+func testUnifiedCreateNormalized(ctx context.Context, client *zen.Client, modelID string) testResult {
212+ req := zen.NormalizedRequest{
118213 Model: modelID,
119- Endpoint: endpoint,
120- Latency: latency,
121- Request: string(reqBody),
214+ Messages: []zen.NormalizedMessage{{Role: "user", Content: "Say ok"}},
122215 }
216+ start := time.Now()
217+ reqBody, _ := json.Marshal(req)
123218
219+ resp, err := client.UnifiedCreateNormalized(ctx, req)
124220 if err != nil {
125- result.Error = err.Error()
126- return result
221+ return makeResult(modelID, "auto", false, string(reqBody), "", err, time.Since(start))
222+ }
223+ return makeResult(modelID, string(resp.Endpoint), false, string(reqBody), truncate(string(resp.Body), 100), nil, time.Since(start))
224+}
225+
226+func testUnifiedStreamNormalized(ctx context.Context, client *zen.Client, modelID string) testResult {
227+ req := zen.NormalizedRequest{
228+ Model: modelID,
229+ Messages: []zen.NormalizedMessage{{Role: "user", Content: "Say ok"}},
230+ Stream: true,
231+ }
232+ start := time.Now()
233+ reqBody, _ := json.Marshal(req)
234+
235+ eventCh, errCh, err := client.UnifiedStreamNormalized(ctx, req)
236+ return drainUnifiedStream(modelID, "auto", string(reqBody), eventCh, errCh, err, start)
237+}
238+
239+// drainStream consumes a StreamEvent channel and builds a testResult.
240+func drainStream(modelID, endpoint, reqBody string, eventCh <-chan zen.StreamEvent, errCh <-chan error, initErr error, start time.Time) testResult {
241+ if initErr != nil {
242+ return makeResult(modelID, endpoint, true, reqBody, "", initErr, time.Since(start))
243+ }
244+ var count int
245+ var last string
246+ for ev := range eventCh {
247+ count++
248+ if len(ev.Data) > 0 {
249+ last = string(ev.Data)
250+ }
251+ }
252+ if err := <-errCh; err != nil {
253+ return makeResult(modelID, endpoint, true, reqBody, "", err, time.Since(start))
254+ }
255+ return makeResult(modelID, endpoint, true, reqBody, fmt.Sprintf("events=%d last=%s", count, truncate(last, 80)), nil, time.Since(start))
256+}
257+
258+// drainUnifiedStream consumes a UnifiedEvent channel and builds a testResult.
259+func drainUnifiedStream(modelID, endpoint, reqBody string, eventCh <-chan zen.UnifiedEvent, errCh <-chan error, initErr error, start time.Time) testResult {
260+ if initErr != nil {
261+ return makeResult(modelID, endpoint, true, reqBody, "", initErr, time.Since(start))
262+ }
263+ var count int
264+ var last string
265+ var resolved string
266+ for ev := range eventCh {
267+ count++
268+ resolved = string(ev.Endpoint)
269+ if len(ev.Data) > 0 {
270+ last = string(ev.Data)
271+ }
127272 }
273+ if err := <-errCh; err != nil {
274+ return makeResult(modelID, endpoint, true, reqBody, "", err, time.Since(start))
275+ }
276+ if resolved != "" {
277+ endpoint = resolved
278+ }
279+ return makeResult(modelID, endpoint, true, reqBody, fmt.Sprintf("events=%d last=%s", count, truncate(last, 80)), nil, time.Since(start))
280+}
128281
129- result.Success = true
130- result.Response = string(resp)
131- return result
282+func makeResult(modelID, endpoint string, stream bool, req, resp string, err error, latency time.Duration) testResult {
283+ r := testResult{
284+ Model: modelID,
285+ Endpoint: endpoint,
286+ Stream: stream,
287+ Latency: latency,
288+ Request: req,
289+ Response: resp,
290+ }
291+ if err != nil {
292+ r.Error = err.Error()
293+ } else {
294+ r.Success = true
295+ }
296+ return r
132297 }
133298
134299 func routeForModel(model string) string {
@@ -150,11 +315,11 @@ func printResult(r testResult) {
150315 if !r.Success {
151316 status = "✗"
152317 }
153- fmt.Printf("%s %-30s [%-15s] %v\n", status, r.Model, r.Endpoint, r.Latency)
154-}
155-
156-func intPtr(i int) *int {
157- return &i
318+ mode := "non-stream"
319+ if r.Stream {
320+ mode = "stream"
321+ }
322+ fmt.Printf(" %s %-25s [%-15s] [%-10s] %v\n", status, r.Model, r.Endpoint, mode, r.Latency)
158323 }
159324
160325 func truncate(s string, max int) string {
normalized.go+10−1
@@ -140,12 +140,21 @@ func (r NormalizedRequest) ToChatCompletionsRequest() (*ChatCompletionsRequest,
140140
141141 func (r NormalizedRequest) ToMessagesRequest() (*MessagesRequest, error) {
142142 system, messages := normalizeAnthropicMessages(r.System, r.Messages)
143+
144+ // Anthropic's messages API requires max_tokens; apply a default when the
145+ // caller did not specify one so the normalized path works out of the box.
146+ maxTokens := r.MaxTokens
147+ if maxTokens == nil {
148+ defaultMax := 1024
149+ maxTokens = &defaultMax
150+ }
151+
143152 req := &MessagesRequest{
144153 Model: r.Model,
145154 System: system,
146155 Messages: messages,
147156 Temperature: r.Temperature,
148- MaxTokens: r.MaxTokens,
157+ MaxTokens: maxTokens,
149158 Stream: r.Stream,
150159 Extra: r.Extra,
151160 }
types_gemini.go+2−3
@@ -66,9 +66,8 @@ func (r GeminiRequest) MarshalJSON() ([]byte, error) {
6666 if r.ToolConfig != nil {
6767 base["toolConfig"] = r.ToolConfig
6868 }
69- if r.Stream {
70- base["stream"] = r.Stream
71- }
69+ // Note: Gemini streaming is controlled by the URL (:streamGenerateContent?alt=sse),
70+ // not a body field. The Stream field is intentionally omitted here.
7271
7372 return marshalWithExtra(base, r.Extra)
7473 }
unified.go+36−0
@@ -48,6 +48,16 @@ func (c *Client) UnifiedCreate(ctx context.Context, req UnifiedRequest) (*Unifie
4848 return nil, err
4949 }
5050
51+ // Gemini model endpoints require the SSE path even for non-streaming requests;
52+ // delegate to CreateModelContent which handles the SSE collect-last-chunk pattern.
53+ if endpoint == EndpointModels && strings.TrimSpace(req.Model) != "" {
54+ data, err := c.CreateModelContent(ctx, req.Model, req.Body, req.Raw)
55+ if err != nil {
56+ return nil, err
57+ }
58+ return &UnifiedResponse{Endpoint: endpoint, Body: data}, nil
59+ }
60+
5161 var payload []byte
5262 if req.Body != nil || req.Raw != nil || strings.ToUpper(method) != "GET" {
5363 var err error
@@ -79,6 +89,32 @@ func (c *Client) UnifiedStream(ctx context.Context, req UnifiedRequest) (<-chan
7989 return nil, nil, err
8090 }
8191
92+ // Gemini model endpoints require the SSE URL scheme; delegate to StreamModelContent.
93+ if endpoint == EndpointModels && strings.TrimSpace(req.Model) != "" {
94+ evCh, errCh, err := c.StreamModelContent(ctx, req.Model, req.Body, req.Raw)
95+ if err != nil {
96+ return nil, nil, err
97+ }
98+ events := make(chan UnifiedEvent)
99+ errs := make(chan error, 1)
100+ go func() {
101+ defer close(events)
102+ defer close(errs)
103+ for ev := range evCh {
104+ events <- UnifiedEvent{
105+ Endpoint: endpoint,
106+ Event: ev.Event,
107+ Data: ev.Data,
108+ Raw: ev.Raw,
109+ }
110+ }
111+ if streamErr := <-errCh; streamErr != nil {
112+ errs <- streamErr
113+ }
114+ }()
115+ return events, errs, nil
116+ }
117+
82118 var payload []byte
83119 if req.Body != nil || req.Raw != nil || strings.ToUpper(method) != "GET" {
84120 var err error