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}