xonecas.io
62159
Sy

symb / commit 5d6a1d0

feat: new zen provider, with model switching support

xonecas2026-02-19 5d6a1d01c351bb05945a8aa68dc5db3568510089 parent 85c907d

8 files changed

cmd/symb/main.go+9−2
@@ -148,10 +148,17 @@ func main() {
148148 }
149149 }
150150
151-func buildRegistry(cfg *config.Config, _ *config.Credentials) *provider.Registry {
151+func buildRegistry(cfg *config.Config, creds *config.Credentials) *provider.Registry {
152152 registry := provider.NewRegistry()
153153 for name, providerCfg := range cfg.Providers {
154- registry.RegisterFactory(name, provider.NewOllamaFactory(name, providerCfg.Endpoint))
154+ apiKey := creds.GetAPIKey(name)
155+ if apiKey != "" {
156+ log.Info().Str("provider", name).Bool("has_api_key", true).Msg("Registering ZenFactory")
157+ registry.RegisterFactory(name, provider.NewZenFactory(name, apiKey, providerCfg.Endpoint))
158+ } else {
159+ log.Info().Str("provider", name).Bool("has_api_key", false).Msg("Registering OllamaFactory")
160+ registry.RegisterFactory(name, provider.NewOllamaFactory(name, providerCfg.Endpoint))
161+ }
155162 }
156163 return registry
157164 }
config.toml+3−0
@@ -8,6 +8,9 @@ default_provider = "ollama-qwen"
88 endpoint = "http://localhost:11434"
99 model = "qwen3:8b"
1010
11+[providers.zen]
12+model = "claude-sonnet-4-6"
13+
1114 [ui]
1215 # TODO
1316
go.mod+1−1
@@ -13,7 +13,7 @@ require (
1313 github.com/charmbracelet/x/powernap v0.0.0-20260209132835-6b065b8ba62c
1414 github.com/hexops/gotextdiff v1.0.3
1515 github.com/rs/zerolog v1.34.0
16- github.com/sashabaranov/go-openai v1.41.2
16+ github.com/sacenox/go-opencode-ai-zen-sdk v0.0.2
1717 github.com/smacker/go-tree-sitter v0.0.0-20240827094217-dd81d9e9be82
1818 golang.org/x/net v0.50.0
1919 modernc.org/sqlite v1.45.0
go.sum+8−2
@@ -92,8 +92,14 @@ github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7
9292 github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
9393 github.com/rs/zerolog v1.34.0 h1:k43nTLIwcTVQAncfCw4KZ2VY6ukYoZaBPNOE8txlOeY=
9494 github.com/rs/zerolog v1.34.0/go.mod h1:bJsvje4Z08ROH4Nhs5iH600c3IkWhwp44iRc54W6wYQ=
95-github.com/sashabaranov/go-openai v1.41.2 h1:vfPRBZNMpnqu8ELsclWcAvF19lDNgh1t6TVfFFOPiSM=
96-github.com/sashabaranov/go-openai v1.41.2/go.mod h1:lj5b/K+zjTSFxVLijLSTDZuP7adOgerWeFyZLUhAKRg=
95+github.com/sacenox/go-opencode-ai-zen-sdk v0.0.0-20260217230320-035924957efe h1:A5+tr2aMC9eLLknAOSEmtrzwqJE3oBAMtniY/jgzdLo=
96+github.com/sacenox/go-opencode-ai-zen-sdk v0.0.0-20260217230320-035924957efe/go.mod h1:MK7Zno/U0BRk1/YDHKisc3ZXoQhcTyGnU9SbEuQ/c34=
97+github.com/sacenox/go-opencode-ai-zen-sdk v0.0.0-20260218233948-be38230e6c9a h1:Pnr+ikm8pNBFb7HQpFKQW/p1N5MuuqRDZDjaSFZFfTg=
98+github.com/sacenox/go-opencode-ai-zen-sdk v0.0.0-20260218233948-be38230e6c9a/go.mod h1:MK7Zno/U0BRk1/YDHKisc3ZXoQhcTyGnU9SbEuQ/c34=
99+github.com/sacenox/go-opencode-ai-zen-sdk v0.0.1 h1:i0S5jrvDdsjr7+F7CeP88ahkZkq901nLg5leWj/jrf4=
100+github.com/sacenox/go-opencode-ai-zen-sdk v0.0.1/go.mod h1:MK7Zno/U0BRk1/YDHKisc3ZXoQhcTyGnU9SbEuQ/c34=
101+github.com/sacenox/go-opencode-ai-zen-sdk v0.0.2 h1:V6SOmoYmYLpQDxiqubKiGOQsG5pwBPj4uTdwlMcT8Go=
102+github.com/sacenox/go-opencode-ai-zen-sdk v0.0.2/go.mod h1:MK7Zno/U0BRk1/YDHKisc3ZXoQhcTyGnU9SbEuQ/c34=
97103 github.com/smacker/go-tree-sitter v0.0.0-20240827094217-dd81d9e9be82 h1:6C8qej6f1bStuePVkLSFxoU22XBS165D3klxlzRg8F4=
98104 github.com/smacker/go-tree-sitter v0.0.0-20240827094217-dd81d9e9be82/go.mod h1:xe4pgH49k4SsmkQq5OT8abwhWmnzkhpgnXeekbx2efw=
99105 github.com/sourcegraph/jsonrpc2 v0.2.1 h1:2GtljixMQYUYCmIg7W9aF2dFmniq/mOr2T9tFRh6zSQ=
internal/provider/provider.go+4−0
@@ -6,6 +6,8 @@ import (
66 "encoding/json"
77 "errors"
88 "time"
9+
10+ "github.com/rs/zerolog/log"
911 )
1012
1113 // ErrProviderNotFound is returned when a requested provider doesn't exist.
@@ -139,8 +141,10 @@ func (r *Registry) RegisterFactory(name string, f Factory) {
139141 func (r *Registry) Create(name, model string, opts Options) (Provider, error) {
140142 f, ok := r.factories[name]
141143 if !ok {
144+ log.Error().Str("name", name).Str("model", model).Msg("Registry.Create: factory not found")
142145 return nil, ErrProviderNotFound
143146 }
147+ log.Info().Str("name", name).Str("model", model).Str("factory_type", "unknown").Msg("Registry.Create: calling factory")
144148 return f.Create(model, opts), nil
145149 }
146150
internal/provider/zen.go+538−0
@@ -0,0 +1,538 @@
1+package provider
2+
3+import (
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+
13+type ZenProvider struct {
14+ name string
15+ client *zen.Client
16+ model string
17+ temperature float64
18+}
19+
20+func 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+
38+func (p *ZenProvider) Name() string {
39+ return p.name
40+}
41+
42+func (p *ZenProvider) ChatStream(ctx context.Context, messages []Message, tools []Tool) (<-chan StreamEvent, error) {
43+ system, rest := splitSystem(messages)
44+ req := zen.NormalizedRequest{
45+ Model: p.model,
46+ System: system,
47+ Messages: toZenMessages(rest),
48+ Tools: toZenTools(tools),
49+ Stream: true,
50+ }
51+
52+ if p.temperature > 0 {
53+ req.Temperature = &p.temperature
54+ }
55+
56+ maxTokens := 16000
57+ req.MaxTokens = &maxTokens
58+
59+ events, errs, err := p.client.UnifiedStreamNormalized(ctx, req)
60+ if err != nil {
61+ return nil, err
62+ }
63+
64+ ch := make(chan StreamEvent)
65+ go func() {
66+ defer close(ch)
67+ for {
68+ select {
69+ case ev, ok := <-events:
70+ if !ok {
71+ return
72+ }
73+ if !p.emitEvent(ctx, ch, ev) {
74+ return
75+ }
76+ case err, ok := <-errs:
77+ if ok && err != nil {
78+ var apiErr *zen.APIError
79+ if errors.As(err, &apiErr) {
80+ log.Error().
81+ Int("status", apiErr.StatusCode).
82+ Str("body", string(apiErr.Body)).
83+ Msg("zen: stream API error")
84+ }
85+ trySend(ctx, ch, StreamEvent{Type: EventError, Err: err})
86+ }
87+ return
88+ case <-ctx.Done():
89+ return
90+ }
91+ }
92+ }()
93+
94+ return ch, nil
95+}
96+
97+func (p *ZenProvider) emitEvent(ctx context.Context, ch chan<- StreamEvent, ev zen.UnifiedEvent) bool {
98+ data := ev.Data
99+ if len(data) == 0 || string(data) == "[DONE]" {
100+ return trySend(ctx, ch, StreamEvent{Type: EventDone})
101+ }
102+
103+ switch ev.Endpoint {
104+ case zen.EndpointMessages:
105+ return p.emitAnthropicEvent(ctx, ch, ev.Event, data)
106+ case zen.EndpointModels:
107+ return p.emitGeminiEvent(ctx, ch, data)
108+ case zen.EndpointResponses:
109+ return p.emitResponsesEvent(ctx, ch, ev.Event, data)
110+ default:
111+ return p.emitChatCompletionsEvent(ctx, ch, data)
112+ }
113+}
114+
115+// emitChatCompletionsEvent handles OpenAI chat completions SSE chunks.
116+func (p *ZenProvider) emitChatCompletionsEvent(ctx context.Context, ch chan<- StreamEvent, data json.RawMessage) bool {
117+ var chunk map[string]any
118+ if err := json.Unmarshal(data, &chunk); err != nil {
119+ return true
120+ }
121+
122+ if usage, ok := chunk["usage"].(map[string]any); ok {
123+ if !trySend(ctx, ch, StreamEvent{
124+ Type: EventUsage,
125+ InputTokens: getIntOrZero(usage, "prompt_tokens"),
126+ OutputTokens: getIntOrZero(usage, "completion_tokens"),
127+ }) {
128+ return false
129+ }
130+ }
131+
132+ choices, _ := chunk["choices"].([]any)
133+ if len(choices) == 0 {
134+ delta, _ := chunk["delta"].(map[string]any)
135+ if delta != nil {
136+ return p.emitDelta(ctx, ch, delta)
137+ }
138+ return true
139+ }
140+
141+ choice, _ := choices[0].(map[string]any)
142+ delta, _ := choice["delta"].(map[string]any)
143+ if delta == nil {
144+ return true
145+ }
146+
147+ return p.emitDelta(ctx, ch, delta)
148+}
149+
150+// emitAnthropicEvent handles Anthropic Messages SSE chunks.
151+// Relevant event types:
152+// - content_block_start: carries tool_use id/name
153+// - content_block_delta: text_delta or input_json_delta
154+// - message_delta: usage
155+func (p *ZenProvider) emitAnthropicEvent(ctx context.Context, ch chan<- StreamEvent, event string, data json.RawMessage) bool {
156+ var chunk map[string]any
157+ if err := json.Unmarshal(data, &chunk); err != nil {
158+ return true
159+ }
160+
161+ switch event {
162+ case "content_block_start":
163+ cb, _ := chunk["content_block"].(map[string]any)
164+ if getStringOrEmpty(cb, "type") == "tool_use" {
165+ idx := getIntOrZero(chunk, "index")
166+ if !trySend(ctx, ch, StreamEvent{
167+ Type: EventToolCallBegin,
168+ ToolCallIndex: idx,
169+ ToolCallID: getStringOrEmpty(cb, "id"),
170+ ToolCallName: getStringOrEmpty(cb, "name"),
171+ }) {
172+ return false
173+ }
174+ }
175+
176+ case "content_block_delta":
177+ idx := getIntOrZero(chunk, "index")
178+ delta, _ := chunk["delta"].(map[string]any)
179+ switch getStringOrEmpty(delta, "type") {
180+ case "text_delta":
181+ if text := getStringOrEmpty(delta, "text"); text != "" {
182+ if !trySend(ctx, ch, StreamEvent{Type: EventContentDelta, Content: text}) {
183+ return false
184+ }
185+ }
186+ case "thinking_delta":
187+ if thinking := getStringOrEmpty(delta, "thinking"); thinking != "" {
188+ if !trySend(ctx, ch, StreamEvent{Type: EventReasoningDelta, Content: thinking}) {
189+ return false
190+ }
191+ }
192+ case "input_json_delta":
193+ if args := getStringOrEmpty(delta, "partial_json"); args != "" {
194+ if !trySend(ctx, ch, StreamEvent{
195+ Type: EventToolCallDelta,
196+ ToolCallIndex: idx,
197+ ToolCallArgs: args,
198+ }) {
199+ return false
200+ }
201+ }
202+ }
203+
204+ case "message_delta":
205+ if usage, ok := chunk["usage"].(map[string]any); ok {
206+ in := getIntOrZero(usage, "input_tokens")
207+ out := getIntOrZero(usage, "output_tokens")
208+ if in > 0 || out > 0 {
209+ if !trySend(ctx, ch, StreamEvent{
210+ Type: EventUsage,
211+ InputTokens: in,
212+ OutputTokens: out,
213+ }) {
214+ return false
215+ }
216+ }
217+ }
218+ }
219+
220+ return true
221+}
222+
223+// emitGeminiEvent handles Gemini SSE chunks.
224+// Each chunk has candidates[0].content.parts[].{text,functionCall}.
225+func (p *ZenProvider) emitGeminiEvent(ctx context.Context, ch chan<- StreamEvent, data json.RawMessage) bool {
226+ var chunk map[string]any
227+ if err := json.Unmarshal(data, &chunk); err != nil {
228+ return true
229+ }
230+
231+ candidates, _ := chunk["candidates"].([]any)
232+ if len(candidates) == 0 {
233+ return true
234+ }
235+ candidate, _ := candidates[0].(map[string]any)
236+ content, _ := candidate["content"].(map[string]any)
237+ parts, _ := content["parts"].([]any)
238+
239+ for idx, p2 := range parts {
240+ part, _ := p2.(map[string]any)
241+ if text := getStringOrEmpty(part, "text"); text != "" {
242+ if !trySend(ctx, ch, StreamEvent{Type: EventContentDelta, Content: text}) {
243+ return false
244+ }
245+ }
246+ if fc, ok := part["functionCall"].(map[string]any); ok {
247+ name := getStringOrEmpty(fc, "name")
248+ if name != "" {
249+ if !trySend(ctx, ch, StreamEvent{
250+ Type: EventToolCallBegin,
251+ ToolCallIndex: idx,
252+ ToolCallName: name,
253+ }) {
254+ return false
255+ }
256+ }
257+ if args, ok := fc["args"]; ok {
258+ argsJSON, err := json.Marshal(args)
259+ if err == nil {
260+ if !trySend(ctx, ch, StreamEvent{
261+ Type: EventToolCallDelta,
262+ ToolCallIndex: idx,
263+ ToolCallArgs: string(argsJSON),
264+ }) {
265+ return false
266+ }
267+ }
268+ }
269+ }
270+ }
271+
272+ if meta, ok := chunk["usageMetadata"].(map[string]any); ok {
273+ in := getIntOrZero(meta, "promptTokenCount")
274+ out := getIntOrZero(meta, "candidatesTokenCount")
275+ if in > 0 || out > 0 {
276+ if !trySend(ctx, ch, StreamEvent{
277+ Type: EventUsage,
278+ InputTokens: in,
279+ OutputTokens: out,
280+ }) {
281+ return false
282+ }
283+ }
284+ }
285+
286+ return true
287+}
288+
289+// emitResponsesEvent handles OpenAI Responses API SSE chunks.
290+// Relevant event types: response.output_text.delta, response.function_call_arguments.delta,
291+// response.output_item.added (carries tool call id/name), response.completed (usage).
292+func (p *ZenProvider) emitResponsesEvent(ctx context.Context, ch chan<- StreamEvent, event string, data json.RawMessage) bool {
293+ var chunk map[string]any
294+ if err := json.Unmarshal(data, &chunk); err != nil {
295+ return true
296+ }
297+
298+ switch event {
299+ case "response.output_text.delta":
300+ if delta := getStringOrEmpty(chunk, "delta"); delta != "" {
301+ if !trySend(ctx, ch, StreamEvent{Type: EventContentDelta, Content: delta}) {
302+ return false
303+ }
304+ }
305+
306+ case "response.output_item.added":
307+ item, _ := chunk["item"].(map[string]any)
308+ if getStringOrEmpty(item, "type") == "function_call" {
309+ idx := getIntOrZero(chunk, "output_index")
310+ if !trySend(ctx, ch, StreamEvent{
311+ Type: EventToolCallBegin,
312+ ToolCallIndex: idx,
313+ ToolCallID: getStringOrEmpty(item, "call_id"),
314+ ToolCallName: getStringOrEmpty(item, "name"),
315+ }) {
316+ return false
317+ }
318+ }
319+
320+ case "response.function_call_arguments.delta":
321+ idx := getIntOrZero(chunk, "output_index")
322+ if delta := getStringOrEmpty(chunk, "delta"); delta != "" {
323+ if !trySend(ctx, ch, StreamEvent{
324+ Type: EventToolCallDelta,
325+ ToolCallIndex: idx,
326+ ToolCallArgs: delta,
327+ }) {
328+ return false
329+ }
330+ }
331+
332+ case "response.completed":
333+ resp, _ := chunk["response"].(map[string]any)
334+ if usage, ok := resp["usage"].(map[string]any); ok {
335+ if !trySend(ctx, ch, StreamEvent{
336+ Type: EventUsage,
337+ InputTokens: getIntOrZero(usage, "input_tokens"),
338+ OutputTokens: getIntOrZero(usage, "output_tokens"),
339+ }) {
340+ return false
341+ }
342+ }
343+ }
344+
345+ return true
346+}
347+
348+func (p *ZenProvider) emitDelta(ctx context.Context, ch chan<- StreamEvent, delta map[string]any) bool {
349+ if reasoning := getStringOrEmpty(delta, "reasoning"); reasoning != "" {
350+ if !trySend(ctx, ch, StreamEvent{Type: EventReasoningDelta, Content: reasoning}) {
351+ return false
352+ }
353+ }
354+ if reasoning := getStringOrEmpty(delta, "reasoning_content"); reasoning != "" {
355+ if !trySend(ctx, ch, StreamEvent{Type: EventReasoningDelta, Content: reasoning}) {
356+ return false
357+ }
358+ }
359+ if content := getStringOrEmpty(delta, "content"); content != "" {
360+ if !trySend(ctx, ch, StreamEvent{Type: EventContentDelta, Content: content}) {
361+ return false
362+ }
363+ }
364+
365+ toolCalls, _ := delta["tool_calls"].([]any)
366+ for _, tc := range toolCalls {
367+ toolCall, _ := tc.(map[string]any)
368+ idx := getIntOrZero(toolCall, "index")
369+ id := getStringOrEmpty(toolCall, "id")
370+ fn, _ := toolCall["function"].(map[string]any)
371+ name := getStringOrEmpty(fn, "name")
372+ args := getStringOrEmpty(fn, "arguments")
373+
374+ if name != "" {
375+ if !trySend(ctx, ch, StreamEvent{
376+ Type: EventToolCallBegin,
377+ ToolCallIndex: idx,
378+ ToolCallID: id,
379+ ToolCallName: name,
380+ }) {
381+ return false
382+ }
383+ }
384+ if args != "" {
385+ if !trySend(ctx, ch, StreamEvent{
386+ Type: EventToolCallDelta,
387+ ToolCallIndex: idx,
388+ ToolCallArgs: args,
389+ }) {
390+ return false
391+ }
392+ }
393+ }
394+
395+ return true
396+}
397+
398+func (p *ZenProvider) ListModels(ctx context.Context) ([]Model, error) {
399+ resp, err := p.client.ListModels(ctx)
400+ if err != nil {
401+ log.Error().Err(err).Str("provider", p.name).Msg("ListModels failed")
402+ return nil, err
403+ }
404+
405+ models := make([]Model, len(resp.Data))
406+ for i, m := range resp.Data {
407+ models[i] = Model{
408+ Name: m.ID,
409+ }
410+ }
411+ log.Debug().Int("count", len(models)).Msg("ListModels success")
412+ return models, nil
413+}
414+
415+func (p *ZenProvider) Close() error {
416+ return nil
417+}
418+
419+func splitSystem(messages []Message) (system string, rest []Message) {
420+ var parts []string
421+ for _, m := range messages {
422+ if strings.EqualFold(m.Role, "system") || strings.EqualFold(m.Role, "developer") {
423+ if s := strings.TrimSpace(m.Content); s != "" {
424+ parts = append(parts, s)
425+ }
426+ } else {
427+ rest = append(rest, m)
428+ }
429+ }
430+ return strings.Join(parts, "\n\n"), rest
431+}
432+
433+func toZenMessages(messages []Message) []zen.NormalizedMessage {
434+ result := make([]zen.NormalizedMessage, len(messages))
435+ for i, m := range messages {
436+ nm := zen.NormalizedMessage{
437+ Role: m.Role,
438+ Content: m.Content,
439+ ToolCallID: m.ToolCallID,
440+ }
441+ if len(m.ToolCalls) > 0 {
442+ nm.ToolCalls = make([]zen.NormalizedToolCall, len(m.ToolCalls))
443+ for j, tc := range m.ToolCalls {
444+ nm.ToolCalls[j] = zen.NormalizedToolCall{
445+ ID: tc.ID,
446+ Name: tc.Name,
447+ Arguments: tc.Arguments,
448+ }
449+ }
450+ }
451+ result[i] = nm
452+ }
453+ return result
454+}
455+
456+func toZenTools(tools []Tool) []zen.NormalizedTool {
457+ if len(tools) == 0 {
458+ return nil
459+ }
460+ result := make([]zen.NormalizedTool, len(tools))
461+ for i, t := range tools {
462+ params := t.Parameters
463+ if len(params) == 0 {
464+ params = json.RawMessage(`{"type":"object","properties":{}}`)
465+ }
466+ result[i] = zen.NormalizedTool{
467+ Name: t.Name,
468+ Description: t.Description,
469+ Parameters: params,
470+ }
471+ }
472+ return result
473+}
474+
475+func getStringOrEmpty(m map[string]any, key string) string {
476+ if v, ok := m[key]; ok {
477+ if s, ok := v.(string); ok {
478+ return s
479+ }
480+ }
481+ return ""
482+}
483+
484+func getIntOrZero(m map[string]any, key string) int {
485+ if v, ok := m[key]; ok {
486+ switch n := v.(type) {
487+ case int:
488+ return n
489+ case int64:
490+ return int(n)
491+ case float64:
492+ return int(n)
493+ case json.Number:
494+ if i, err := n.Int64(); err == nil {
495+ return int(i)
496+ }
497+ }
498+ }
499+ return 0
500+}
501+
502+type ZenFactory struct {
503+ name string
504+ apiKey string
505+ baseURL string
506+}
507+
508+func NewZenFactory(name, apiKey, baseURL string) *ZenFactory {
509+ return &ZenFactory{
510+ name: name,
511+ apiKey: apiKey,
512+ baseURL: baseURL,
513+ }
514+}
515+
516+func (f *ZenFactory) Name() string { return f.name }
517+
518+func (f *ZenFactory) Create(model string, opts Options) Provider {
519+ baseURL := f.baseURL
520+ if baseURL == "" {
521+ baseURL = "https://opencode.ai/zen/v1"
522+ }
523+ baseURL = strings.TrimRight(baseURL, "/")
524+
525+ log.Info().
526+ Str("factory", f.name).
527+ Str("model", model).
528+ Bool("has_api_key", f.apiKey != "").
529+ Int("api_key_len", len(f.apiKey)).
530+ Str("base_url", baseURL).
531+ Msg("ZenFactory.Create")
532+
533+ p, err := NewZen(f.name, f.apiKey, baseURL, model, opts.Temperature)
534+ if err != nil {
535+ panic("zen: failed to create provider: " + err.Error())
536+ }
537+ return p
538+}
internal/tui/update_keypress.go+2−0
@@ -2,6 +2,7 @@ package tui
22
33 import (
44 tea "charm.land/bubbletea/v2"
5+ "github.com/rs/zerolog/log"
56 )
67
78 // handleKeyPress processes key events. Returns (model, cmd, true) if handled.
@@ -97,6 +98,7 @@ func (m *Model) handleCtrlH() (Model, tea.Cmd, bool) {
9798 }
9899
99100 func (m *Model) handleCtrlM() (Model, tea.Cmd, bool) {
101+ log.Info().Bool("turnCancel", m.turnCancel != nil).Bool("turnPending", m.turnPending).Bool("undoInFlight", m.undoInFlight).Msg("handleCtrlM")
100102 if m.turnCancel != nil || m.turnPending || m.undoInFlight {
101103 return *m, nil, false
102104 }
internal/tui/update_modals.go+11−0
@@ -5,6 +5,7 @@ import (
55 "strings"
66
77 tea "charm.land/bubbletea/v2"
8+ "github.com/rs/zerolog/log"
89 "github.com/xonecas/symb/internal/filesearch"
910 "github.com/xonecas/symb/internal/provider"
1011 "github.com/xonecas/symb/internal/tui/modal"
@@ -139,7 +140,13 @@ func (m *Model) updateFileModal(msg tea.Msg) (Model, tea.Cmd, bool) {
139140
140141 func (m *Model) fetchModelsCmd() tea.Cmd {
141142 return func() tea.Msg {
143+ log.Info().Str("provider", m.provider.Name()).Msg("fetchModelsCmd called")
142144 models, err := m.provider.ListModels(context.Background())
145+ if err != nil {
146+ log.Error().Err(err).Msg("ListModels error")
147+ } else {
148+ log.Info().Int("count", len(models)).Msg("ListModels returned")
149+ }
143150 return modelsFetchedMsg{models: models, err: err}
144151 }
145152 }
@@ -216,6 +223,7 @@ func (m *Model) switchModelCmd(modelName string) tea.Cmd {
216223 if registry == nil {
217224 return modelSwitchedMsg{err: provider.ErrProviderNotFound}
218225 }
226+ log.Info().Str("provider", providerConfigName).Str("model", modelName).Msg("switchModelCmd")
219227 newProv, err := registry.Create(providerConfigName, modelName, providerOpts)
220228 if err != nil {
221229 return modelSwitchedMsg{err: err}
@@ -229,13 +237,16 @@ func (m *Model) switchModelCmd(modelName string) tea.Cmd {
229237
230238 func (m *Model) handleModelsFetched(msg modelsFetchedMsg) tea.Model {
231239 if msg.err != nil {
240+ log.Error().Err(msg.err).Msg("handleModelsFetched error")
232241 m.lastNetError = "Failed to list models: " + msg.err.Error()
233242 return m
234243 }
235244 if len(msg.models) == 0 {
245+ log.Warn().Msg("handleModelsFetched: no models")
236246 m.lastNetError = "No models available"
237247 return m
238248 }
249+ log.Info().Int("count", len(msg.models)).Msg("handleModelsFetched opening modal")
239250 m.openModelsModal(msg.models)
240251 return m
241252 }