xonecas.io
6312
Ga

go-opencode-ai-zen-sdk / files

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

4.1 KB
1package zen
2
3import (
4	"context"
5	"encoding/json"
6	"errors"
7	"strings"
8)
9
10type EndpointType string
11
12const (
13	EndpointAuto            EndpointType = ""
14	EndpointResponses       EndpointType = "responses"
15	EndpointMessages        EndpointType = "messages"
16	EndpointChatCompletions EndpointType = "chat_completions"
17	EndpointModels          EndpointType = "models"
18)
19
20type UnifiedEvent struct {
21	Endpoint EndpointType
22	Event    string
23	Data     json.RawMessage
24	Raw      string
25}
26
27// StreamEvents is the unified streaming API. It routes the request based on
28// the normalized model id and returns raw SSE events with the resolved endpoint.
29func (c *Client) StreamEvents(ctx context.Context, req NormalizedRequest) (<-chan UnifiedEvent, <-chan error, error) {
30	req.Model = stripOpencodePrefix(req.Model)
31	endpoint, path, err := resolveStreamEndpoint(req)
32	if err != nil {
33		return nil, nil, err
34	}
35
36	req.Stream = true
37
38	var body any
39	switch endpoint {
40	case EndpointResponses:
41		payload, err := req.ToResponsesRequest()
42		if err != nil {
43			return nil, nil, err
44		}
45		body = payload
46	case EndpointMessages:
47		payload, err := req.ToMessagesRequest()
48		if err != nil {
49			return nil, nil, err
50		}
51		body = payload
52	case EndpointChatCompletions:
53		payload, err := req.ToChatCompletionsRequest()
54		if err != nil {
55			return nil, nil, err
56		}
57		body = payload
58	case EndpointModels:
59		payload, err := req.ToGeminiRequest()
60		if err != nil {
61			return nil, nil, err
62		}
63		body = payload
64	default:
65		return nil, nil, errors.New("zen: unsupported endpoint")
66	}
67
68	payload, err := jsonBody(body, nil)
69	if err != nil {
70		return nil, nil, err
71	}
72
73	stream, err := c.startStream(ctx, endpoint, "POST", path, payload)
74	if err != nil {
75		return nil, nil, err
76	}
77
78	out := make(chan UnifiedEvent)
79	errCh := make(chan error, 1)
80
81	go func() {
82		defer close(out)
83		defer close(errCh)
84		defer func() { _ = stream.Close() }()
85
86		for ev := range stream.Events {
87			out <- UnifiedEvent{
88				Endpoint: endpoint,
89				Event:    ev.Event,
90				Data:     ev.Data,
91				Raw:      ev.Raw,
92			}
93		}
94		if stream.Err != nil {
95			errCh <- stream.Err
96		}
97	}()
98
99	return out, errCh, nil
100}
101
102// Stream parses unified SSE events into normalized deltas.
103func (c *Client) Stream(ctx context.Context, req NormalizedRequest) (<-chan NormalizedDelta, <-chan error, error) {
104	evCh, errCh, err := c.StreamEvents(ctx, req)
105	if err != nil {
106		return nil, nil, err
107	}
108
109	out := make(chan NormalizedDelta)
110	outErr := make(chan error, 1)
111
112	go func() {
113		defer close(out)
114		defer close(outErr)
115		for ev := range evCh {
116			for _, delta := range ParseNormalizedEvent(ev) {
117				out <- delta
118			}
119		}
120		if streamErr := <-errCh; streamErr != nil {
121			outErr <- streamErr
122		}
123	}()
124
125	return out, outErr, nil
126}
127
128func resolveStreamEndpoint(req NormalizedRequest) (EndpointType, string, error) {
129	endpoint := req.Endpoint
130	if endpoint == EndpointAuto {
131		endpoint = routeForModel(req.Model)
132	}
133
134	switch endpoint {
135	case EndpointResponses:
136		return endpoint, "/responses", nil
137	case EndpointMessages:
138		return endpoint, "/messages", nil
139	case EndpointChatCompletions:
140		return endpoint, "/chat/completions", nil
141	case EndpointModels:
142		model := strings.TrimSpace(stripOpencodePrefix(req.Model))
143		if model == "" {
144			return endpoint, "", errors.New("zen: model is required for model streaming")
145		}
146		return endpoint, "/models/" + model + ":streamGenerateContent?alt=sse", nil
147	default:
148		return endpoint, "", errors.New("zen: unsupported endpoint")
149	}
150}
151
152func routeForModel(model string) EndpointType {
153	m := normalizeModelID(model)
154	switch {
155	case strings.HasPrefix(m, "gpt-"):
156		return EndpointResponses
157	case strings.HasPrefix(m, "claude-"):
158		return EndpointMessages
159	case strings.HasPrefix(m, "gemini-"):
160		return EndpointModels
161	default:
162		return EndpointChatCompletions
163	}
164}
165
166func normalizeModelID(model string) string {
167	m := strings.ToLower(strings.TrimSpace(model))
168	if strings.HasPrefix(m, "opencode/") {
169		m = strings.TrimPrefix(m, "opencode/")
170	}
171	return m
172}
173
174func stripOpencodePrefix(model string) string {
175	m := strings.TrimSpace(model)
176	if strings.HasPrefix(strings.ToLower(m), "opencode/") {
177		return m[len("opencode/"):]
178	}
179	return m
180}