xonecas.io
62159
Sy

symb / files

symb / internal / provider / zen.go

6.6 KB
1package provider
2
3import (
4	"context"
5	"encoding/json"
6	"errors"
7	"strings"
8
9	"github.com/rs/zerolog/log"
10	zen "github.com/sacenox/go-opencode-ai-zen-sdk"
11)
12
13type ZenProvider struct {
14	name        string
15	client      *zen.Client
16	model       string
17	temperature float64
18}
19
20func NewZen(name, apiKey, baseURL, model string, temperature float64) (*ZenProvider, error) {
21	cfg := zen.Config{
22		APIKey:  apiKey,
23		BaseURL: baseURL,
24	}
25	client, err := zen.NewClient(cfg)
26	if err != nil {
27		return nil, err
28	}
29
30	return &ZenProvider{
31		name:        name,
32		client:      client,
33		model:       model,
34		temperature: temperature,
35	}, nil
36}
37
38func (p *ZenProvider) Name() string {
39	return p.name
40}
41
42func (p *ZenProvider) ChatStream(ctx context.Context, messages []Message, tools []Tool) (<-chan StreamEvent, error) {
43	system, rest := splitSystem(messages)
44
45	req := zen.NormalizedRequest{
46		Model:      p.model,
47		System:     system,
48		Messages:   toZenMessages(rest),
49		Tools:      toZenTools(tools),
50		Reasoning:  &zen.NormalizedReasoning{Effort: "low"},
51		ToolChoice: &zen.NormalizedToolChoice{Type: zen.ToolChoiceAuto},
52	}
53
54	if p.temperature > 0 {
55		req.Temperature = &p.temperature
56	}
57
58	deltas, errs, err := p.client.Stream(ctx, req)
59	if err != nil {
60		var apiErr *zen.APIError
61		if errors.As(err, &apiErr) {
62			log.Error().
63				Int("status", apiErr.StatusCode).
64				Str("body", string(apiErr.Body)).
65				Str("model", p.model).
66				Msg("zen: Stream failed")
67		}
68		return nil, err
69	}
70
71	ch := make(chan StreamEvent)
72	go func() {
73		defer close(ch)
74		for d := range deltas {
75			var evt StreamEvent
76			switch d.Type {
77			case zen.DeltaText:
78				evt = StreamEvent{Type: EventContentDelta, Content: d.Content}
79			case zen.DeltaReasoning:
80				evt = StreamEvent{Type: EventReasoningDelta, Content: d.Content}
81			case zen.DeltaToolCallBegin:
82				evt = StreamEvent{
83					Type:              EventToolCallBegin,
84					ToolCallIndex:     d.ToolCallIndex,
85					ToolCallID:        d.ToolCallID,
86					ToolCallName:      d.ToolCallName,
87					ToolCallSignature: d.ToolCallSignature,
88				}
89			case zen.DeltaToolCallArgumentsDelta:
90				evt = StreamEvent{
91					Type:          EventToolCallDelta,
92					ToolCallIndex: d.ToolCallIndex,
93					ToolCallArgs:  d.ArgumentsDelta,
94				}
95			case zen.DeltaToolCallDone:
96				// The accumulator in the caller handles final args; skip.
97				continue
98			case zen.DeltaUsage:
99				evt = StreamEvent{
100					Type:         EventUsage,
101					InputTokens:  d.InputTokens,
102					OutputTokens: d.OutputTokens,
103				}
104			case zen.DeltaDone:
105				evt = StreamEvent{Type: EventDone}
106			default:
107				continue
108			}
109			if !trySend(ctx, ch, evt) {
110				// Context cancelled: drain the delta channel so SDK goroutines
111				// can exit, then drain the error channel before returning.
112				go func() {
113					for range deltas {
114					}
115					<-errs
116				}()
117				return
118			}
119		}
120		if err := <-errs; err != nil {
121			var apiErr *zen.APIError
122			if errors.As(err, &apiErr) {
123				log.Error().
124					Int("status", apiErr.StatusCode).
125					Str("body", string(apiErr.Body)).
126					Msg("zen: stream API error")
127			}
128			trySend(ctx, ch, StreamEvent{Type: EventError, Err: err})
129		}
130	}()
131
132	return ch, nil
133}
134
135func (p *ZenProvider) ListModels(ctx context.Context) ([]Model, error) {
136	resp, err := p.client.ListModels(ctx)
137	if err != nil {
138		log.Error().Err(err).Str("provider", p.name).Msg("ListModels failed")
139		return nil, err
140	}
141
142	models := make([]Model, len(resp.Data))
143	for i, m := range resp.Data {
144		models[i] = Model{Name: m.ID}
145	}
146	log.Debug().Int("count", len(models)).Msg("ListModels success")
147	return models, nil
148}
149
150func (p *ZenProvider) Close() error {
151	return nil
152}
153
154// splitSystem separates system/developer messages from the rest.
155// The Zen SDK takes system content as a top-level field on NormalizedRequest.
156func splitSystem(messages []Message) (system string, rest []Message) {
157	var parts []string
158	for _, m := range messages {
159		if strings.EqualFold(m.Role, "system") || strings.EqualFold(m.Role, "developer") {
160			if s := strings.TrimSpace(m.Content); s != "" {
161				parts = append(parts, s)
162			}
163		} else {
164			rest = append(rest, m)
165		}
166	}
167	return strings.Join(parts, "\n\n"), rest
168}
169
170func toZenMessages(messages []Message) []zen.NormalizedMessage {
171	result := make([]zen.NormalizedMessage, len(messages))
172	for i, m := range messages {
173		nm := zen.NormalizedMessage{
174			Role:         m.Role,
175			Content:      m.Content,
176			ToolCallID:   m.ToolCallID,
177			FunctionName: m.FunctionName,
178		}
179		if len(m.ToolCalls) > 0 {
180			nm.ToolCalls = make([]zen.NormalizedToolCall, len(m.ToolCalls))
181			for j, tc := range m.ToolCalls {
182				nm.ToolCalls[j] = zen.NormalizedToolCall{
183					ID:               tc.ID,
184					Name:             tc.Name,
185					Arguments:        tc.Arguments,
186					ThoughtSignature: tc.ThoughtSignature,
187				}
188			}
189		}
190		result[i] = nm
191	}
192	return result
193}
194
195func toZenTools(tools []Tool) []zen.NormalizedTool {
196	if len(tools) == 0 {
197		return nil
198	}
199	result := make([]zen.NormalizedTool, len(tools))
200	for i, t := range tools {
201		params := t.Parameters
202		if len(params) == 0 {
203			params = []byte(`{"type":"object","properties":{}}`)
204		} else {
205			params = stripSchemaKeys(params)
206		}
207		result[i] = zen.NormalizedTool{
208			Name:        t.Name,
209			Description: t.Description,
210			Parameters:  params,
211		}
212	}
213	return result
214}
215
216// stripSchemaKeys removes JSON Schema meta-keys that Gemini rejects as unknown
217// fields ($schema, $id, $defs, definitions, additionalProperties).
218// It operates on the top-level object only, which is where MCP tools place them.
219func stripSchemaKeys(raw []byte) []byte {
220	var m map[string]json.RawMessage
221	if err := json.Unmarshal(raw, &m); err != nil {
222		return raw // not a JSON object, return as-is
223	}
224	changed := false
225	for _, key := range []string{"$schema", "$id", "$defs", "definitions", "additionalProperties"} {
226		if _, ok := m[key]; ok {
227			delete(m, key)
228			changed = true
229		}
230	}
231	if !changed {
232		return raw
233	}
234	out, err := json.Marshal(m)
235	if err != nil {
236		return raw
237	}
238	return out
239}
240
241type ZenFactory struct {
242	name    string
243	apiKey  string
244	baseURL string
245}
246
247func NewZenFactory(name, apiKey, baseURL string) *ZenFactory {
248	return &ZenFactory{
249		name:    name,
250		apiKey:  apiKey,
251		baseURL: baseURL,
252	}
253}
254
255func (f *ZenFactory) Name() string { return f.name }
256
257func (f *ZenFactory) Create(model string, opts Options) Provider {
258	baseURL := f.baseURL
259	if baseURL == "" {
260		baseURL = "https://opencode.ai/zen/v1"
261	}
262	baseURL = strings.TrimRight(baseURL, "/")
263
264	log.Info().
265		Str("factory", f.name).
266		Str("model", model).
267		Bool("has_api_key", f.apiKey != "").
268		Str("base_url", baseURL).
269		Msg("ZenFactory.Create")
270
271	p, err := NewZen(f.name, f.apiKey, baseURL, model, opts.Temperature)
272	if err != nil {
273		panic("zen: failed to create provider: " + err.Error())
274	}
275	return p
276}