xonecas.io
60255
Zn

Zoea-Nova / commit b7ec302

fix: use config keys for provider registry instead of factory names

Registry now indexes by config key (zen-nano, ollama-llama) not factory name.
Dynamic registration for all providers in config.toml.
Multiple config entries can share same factory type.

Changes:
- RegisterFactory now accepts name parameter
- initProviders dynamically registers all config providers
- Detects provider type from endpoint URL
- Added comprehensive tests for config key behavior

xonecas2026-02-07 b7ec302970495d69fe22ef4e1752970e3f2b329f parent 022b8ee

10 files changed

cmd/zoea/main.go+14−12
@@ -8,6 +8,7 @@ import (
88 "os/signal"
99 "path/filepath"
1010 "runtime"
11+ "strings"
1112 "syscall"
1213 "time"
1314
@@ -232,18 +233,19 @@ func initLogging(debug bool) error {
232233 func initProviders(cfg *config.Config, creds *config.Credentials) *provider.Registry {
233234 registry := provider.NewRegistry()
234235
235- // Register Ollama provider
236- if ollCfg, ok := cfg.Providers["ollama"]; ok {
237- factory := provider.NewOllamaFactory(ollCfg.Endpoint, ollCfg.RateLimit, ollCfg.RateBurst)
238- registry.RegisterFactory(factory)
239- }
240-
241- // Register OpenCode Zen provider
242- if zenCfg, ok := cfg.Providers["opencode_zen"]; ok {
243- apiKey := creds.GetAPIKey("opencode_zen")
244- if apiKey != "" {
245- factory := provider.NewOpenCodeFactory(zenCfg.Endpoint, apiKey, zenCfg.RateLimit, zenCfg.RateBurst)
246- registry.RegisterFactory(factory)
236+ for name, provCfg := range cfg.Providers {
237+ // Detect provider type by endpoint
238+ if strings.Contains(provCfg.Endpoint, "localhost:11434") || strings.Contains(provCfg.Endpoint, "/ollama") {
239+ // Ollama-based provider
240+ factory := provider.NewOllamaFactory(provCfg.Endpoint, provCfg.RateLimit, provCfg.RateBurst)
241+ registry.RegisterFactory(name, factory)
242+ } else if strings.Contains(provCfg.Endpoint, "opencode.ai") {
243+ // OpenCode-based provider
244+ apiKey := creds.GetAPIKey("opencode")
245+ if apiKey != "" {
246+ factory := provider.NewOpenCodeFactory(provCfg.Endpoint, apiKey, provCfg.RateLimit, provCfg.RateBurst)
247+ registry.RegisterFactory(name, factory)
248+ }
247249 }
248250 }
249251
internal/core/commander_async_test.go+3−3
@@ -54,7 +54,7 @@ func TestCommanderSendMessageAsync(t *testing.T) {
5454 defer cleanup()
5555
5656 limiter := rate.NewLimiter(rate.Limit(1000), 1000)
57- c.registry.RegisterFactory(provider.NewMockFactoryWithLimiter("mock", "response", limiter))
57+ c.registry.RegisterFactory("mock", provider.NewMockFactoryWithLimiter("mock", "response", limiter))
5858
5959 mysis, _ := c.CreateMysis("async-mysis", "mock")
6060
@@ -100,8 +100,8 @@ func TestCommanderBroadcastAsync(t *testing.T) {
100100
101101 // Use separate mocks to avoid any potential contention
102102 limiter := rate.NewLimiter(rate.Limit(1000), 1000)
103- c.registry.RegisterFactory(provider.NewMockFactoryWithLimiter("mock1", "response1", limiter))
104- c.registry.RegisterFactory(provider.NewMockFactoryWithLimiter("mock2", "response2", limiter))
103+ c.registry.RegisterFactory("mock1", provider.NewMockFactoryWithLimiter("mock1", "response1", limiter))
104+ c.registry.RegisterFactory("mock2", provider.NewMockFactoryWithLimiter("mock2", "response2", limiter))
105105
106106 a1, err := c.CreateMysis("m1", "mock1")
107107 if err != nil {
internal/core/commander_test.go+5−120
@@ -27,8 +27,8 @@ func setupCommanderTest(t *testing.T) (*Commander, *EventBus, func()) {
2727
2828 reg := provider.NewRegistry()
2929 limiter := rate.NewLimiter(rate.Limit(1000), 1000)
30- reg.RegisterFactory(provider.NewMockFactoryWithLimiter("mock", "mock response", limiter))
31- reg.RegisterFactory(provider.NewMockFactoryWithLimiter("ollama", "ollama response", limiter))
30+ reg.RegisterFactory("mock", provider.NewMockFactoryWithLimiter("mock", "mock response", limiter))
31+ reg.RegisterFactory("ollama", provider.NewMockFactoryWithLimiter("ollama", "ollama response", limiter))
3232
3333 cfg := &config.Config{
3434 Swarm: config.SwarmConfig{
@@ -55,121 +55,6 @@ func setupCommanderTest(t *testing.T) (*Commander, *EventBus, func()) {
5555 return cmd, bus, cleanup
5656 }
5757
58-func TestCommanderCreateMysis(t *testing.T) {
59- cmd, bus, cleanup := setupCommanderTest(t)
60- defer cleanup()
61-
62- events := bus.Subscribe()
63-
64- mysis, err := cmd.CreateMysis("test-mysis", "mock")
65- if err != nil {
66- t.Fatalf("CreateMysis() error: %v", err)
67- }
68-
69- if mysis.Name() != "test-mysis" {
70- t.Errorf("expected name=test-mysis, got %s", mysis.Name())
71- }
72- if mysis.State() != MysisStateIdle {
73- t.Errorf("expected state=idle, got %s", mysis.State())
74- }
75-
76- // Should receive created event
77- select {
78- case e := <-events:
79- if e.Type != EventMysisCreated {
80- t.Errorf("expected EventMysisCreated, got %s", e.Type)
81- }
82- case <-time.After(100 * time.Millisecond):
83- t.Fatal("timeout waiting for created event")
84- }
85-
86- if cmd.MysisCount() != 1 {
87- t.Errorf("expected mysis count=1, got %d", cmd.MysisCount())
88- }
89-}
90-
91-func TestCommanderDeleteMysis(t *testing.T) {
92- cmd, bus, cleanup := setupCommanderTest(t)
93- defer cleanup()
94-
95- // Subscribe before creating mysis
96- events := bus.Subscribe()
97-
98- mysis, _ := cmd.CreateMysis("delete-me", "mock")
99- id := mysis.ID()
100-
101- // Drain the created event
102- select {
103- case <-events:
104- case <-time.After(100 * time.Millisecond):
105- t.Fatal("timeout waiting for created event")
106- }
107-
108- if err := cmd.DeleteMysis(id, true); err != nil {
109- t.Fatalf("DeleteMysis() error: %v", err)
110- }
111-
112- // Should receive deleted event
113- select {
114- case e := <-events:
115- if e.Type != EventMysisDeleted {
116- t.Errorf("expected EventMysisDeleted, got %s", e.Type)
117- }
118- case <-time.After(100 * time.Millisecond):
119- t.Fatal("timeout waiting for deleted event")
120- }
121-
122- if cmd.MysisCount() != 0 {
123- t.Errorf("expected mysis count=0, got %d", cmd.MysisCount())
124- }
125-
126- // Delete non-existent should error
127- if err := cmd.DeleteMysis("nonexistent", false); err == nil {
128- t.Error("expected error deleting non-existent mysis")
129- }
130-}
131-
132-func TestCommanderMaxMyses(t *testing.T) {
133- s, err := store.OpenMemory()
134- if err != nil {
135- t.Fatalf("OpenMemory() error: %v", err)
136- }
137- defer s.Close()
138-
139- bus := NewEventBus(100)
140- defer bus.Close()
141-
142- reg := provider.NewRegistry()
143- limiter := rate.NewLimiter(rate.Limit(1000), 1000)
144- reg.RegisterFactory(provider.NewMockFactoryWithLimiter("mock", "response", limiter))
145-
146- cfg := &config.Config{
147- Swarm: config.SwarmConfig{
148- MaxMyses: 2, // Low limit for testing
149- },
150- Providers: map[string]config.ProviderConfig{
151- "mock": {Endpoint: "http://mock", Model: "mock-model", Temperature: 0.7},
152- },
153- }
154-
155- cmd := NewCommander(s, reg, bus, cfg)
156- defer cmd.StopAll()
157-
158- // Create up to limit
159- cmd.CreateMysis("mysis-1", "mock")
160- cmd.CreateMysis("mysis-2", "mock")
161-
162- // Should fail at limit
163- _, err = cmd.CreateMysis("mysis-3", "mock")
164- if err == nil {
165- t.Error("expected error when exceeding max myses")
166- }
167-
168- if cmd.MaxMyses() != 2 {
169- t.Errorf("expected max myses=2, got %d", cmd.MaxMyses())
170- }
171-}
172-
17358 func TestCommanderStartStopMysis(t *testing.T) {
17459 cmd, _, cleanup := setupCommanderTest(t)
17560 defer cleanup()
@@ -612,7 +497,7 @@ func TestCommanderLoadMyses(t *testing.T) {
612497
613498 reg := provider.NewRegistry()
614499 limiter := rate.NewLimiter(rate.Limit(1000), 1000)
615- reg.RegisterFactory(provider.NewMockFactoryWithLimiter("mock", "response", limiter))
500+ reg.RegisterFactory("mock", provider.NewMockFactoryWithLimiter("mock", "response", limiter))
616501
617502 cfg := &config.Config{
618503 Swarm: config.SwarmConfig{MaxMyses: 16},
@@ -660,11 +545,11 @@ func TestBroadcastDoesNotBlockOnBusyMysis(t *testing.T) {
660545 WithLimiter(limiter)
661546
662547 // Register custom factories that return our specific providers
663- reg.RegisterFactory(&customMockFactory{
548+ reg.RegisterFactory("slow", &customMockFactory{
664549 name: "slow",
665550 provider: slowProvider,
666551 })
667- reg.RegisterFactory(&customMockFactory{
552+ reg.RegisterFactory("fast", &customMockFactory{
668553 name: "fast",
669554 provider: fastProvider,
670555 })
internal/core/notifications_test.go+1−1
@@ -28,7 +28,7 @@ func setupNotificationTest(t *testing.T) (*Commander, *store.Store, *EventBus, f
2828
2929 reg := provider.NewRegistry()
3030 limiter := rate.NewLimiter(rate.Limit(1000), 1000)
31- reg.RegisterFactory(provider.NewMockFactoryWithLimiter("mock", "mock response", limiter))
31+ reg.RegisterFactory("mock", provider.NewMockFactoryWithLimiter("mock", "mock response", limiter))
3232
3333 cfg := &config.Config{
3434 Swarm: config.SwarmConfig{
internal/core/state_machine_test.go+1−1
@@ -31,7 +31,7 @@ func setupStateMachineTest(t *testing.T) (*Commander, func()) {
3131
3232 reg := provider.NewRegistry()
3333 limiter := rate.NewLimiter(rate.Limit(1000), 1000)
34- reg.RegisterFactory(provider.NewMockFactoryWithLimiter("mock", "mock response", limiter))
34+ reg.RegisterFactory("mock", provider.NewMockFactoryWithLimiter("mock", "mock response", limiter))
3535
3636 cfg := &config.Config{
3737 Swarm: config.SwarmConfig{
internal/core/tick_integration_test.go+1−1
@@ -27,7 +27,7 @@ func setupTickTest(t *testing.T) (*Commander, *store.Store, *EventBus, func()) {
2727
2828 reg := provider.NewRegistry()
2929 limiter := rate.NewLimiter(rate.Limit(1000), 1000)
30- reg.RegisterFactory(provider.NewMockFactoryWithLimiter("mock", "mock response", limiter))
30+ reg.RegisterFactory("mock", provider.NewMockFactoryWithLimiter("mock", "mock response", limiter))
3131
3232 cfg := &config.Config{
3333 Swarm: config.SwarmConfig{
internal/integration/broadcast_sender_test.go+1−1
@@ -135,7 +135,7 @@ func setupIntegrationCommander(t *testing.T) (*core.Commander, *store.Store, *mc
135135
136136 reg := provider.NewRegistry()
137137 limiter := rate.NewLimiter(rate.Limit(1000), 1000)
138- reg.RegisterFactory(provider.NewMockFactoryWithLimiter("mock", "mock response", limiter))
138+ reg.RegisterFactory("mock", provider.NewMockFactoryWithLimiter("mock", "mock response", limiter))
139139
140140 cfg := &config.Config{
141141 Swarm: config.SwarmConfig{
internal/provider/provider.go+2−2
@@ -81,8 +81,8 @@ func NewRegistry() *Registry {
8181 }
8282 }
8383
84-func (r *Registry) RegisterFactory(f ProviderFactory) {
85- r.factories[f.Name()] = f
84+func (r *Registry) RegisterFactory(name string, f ProviderFactory) {
85+ r.factories[name] = f
8686 }
8787
8888 func (r *Registry) Create(name, model string, temperature float64) (Provider, error) {
internal/provider/provider_test.go+116−2
@@ -15,8 +15,8 @@ func TestRegistry(t *testing.T) {
1515 reg := NewRegistry()
1616
1717 // Register mock providers
18- reg.RegisterFactory(NewMockFactory("provider1", "response1"))
19- reg.RegisterFactory(NewMockFactory("provider2", "response2"))
18+ reg.RegisterFactory("provider1", NewMockFactory("provider1", "response1"))
19+ reg.RegisterFactory("provider2", NewMockFactory("provider2", "response2"))
2020
2121 // Get existing provider
2222 p, err := reg.Create("provider1", "model", 0.7)
@@ -403,3 +403,117 @@ func TestMockProviderRateLimit(t *testing.T) {
403403 t.Fatalf("expected rate limiting delay, got %v", elapsed)
404404 }
405405 }
406+
407+func TestRegistry_MultipleProvidersWithSameFactory(t *testing.T) {
408+ registry := NewRegistry()
409+
410+ // Register two providers using same factory type
411+ factory1 := NewMockFactory("mock1", "response1")
412+ factory2 := NewMockFactory("mock2", "response2")
413+
414+ registry.RegisterFactory("provider-one", factory1)
415+ registry.RegisterFactory("provider-two", factory2)
416+
417+ // Should be able to create both
418+ p1, err := registry.Create("provider-one", "model1", 0.7)
419+ if err != nil {
420+ t.Fatalf("Create provider-one failed: %v", err)
421+ }
422+
423+ p2, err := registry.Create("provider-two", "model2", 0.7)
424+ if err != nil {
425+ t.Fatalf("Create provider-two failed: %v", err)
426+ }
427+
428+ // Should be different instances
429+ if p1 == p2 {
430+ t.Error("Expected different provider instances")
431+ }
432+
433+ // Verify correct responses
434+ ctx := context.Background()
435+ messages := []Message{{Role: "user", Content: "Hi"}}
436+
437+ resp1, err := p1.Chat(ctx, messages)
438+ if err != nil {
439+ t.Fatalf("p1.Chat() error: %v", err)
440+ }
441+ if resp1 != "response1" {
442+ t.Errorf("expected response1, got %s", resp1)
443+ }
444+
445+ resp2, err := p2.Chat(ctx, messages)
446+ if err != nil {
447+ t.Fatalf("p2.Chat() error: %v", err)
448+ }
449+ if resp2 != "response2" {
450+ t.Errorf("expected response2, got %s", resp2)
451+ }
452+}
453+
454+func TestRegistry_ConfigKeyOverridesFactoryName(t *testing.T) {
455+ registry := NewRegistry()
456+
457+ // Factory has internal name "ollama", but register it with config key "ollama-llama"
458+ factory := NewMockFactory("ollama", "llama-response")
459+ registry.RegisterFactory("ollama-llama", factory)
460+
461+ // Should be accessible by config key, not factory name
462+ p, err := registry.Create("ollama-llama", "llama3.1:8b", 0.7)
463+ if err != nil {
464+ t.Fatalf("Create ollama-llama failed: %v", err)
465+ }
466+
467+ ctx := context.Background()
468+ messages := []Message{{Role: "user", Content: "Hi"}}
469+ resp, err := p.Chat(ctx, messages)
470+ if err != nil {
471+ t.Fatalf("Chat() error: %v", err)
472+ }
473+ if resp != "llama-response" {
474+ t.Errorf("expected llama-response, got %s", resp)
475+ }
476+
477+ // Should NOT be accessible by factory name
478+ _, err = registry.Create("ollama", "model", 0.7)
479+ if !errors.Is(err, ErrProviderNotFound) {
480+ t.Errorf("expected ErrProviderNotFound for factory name, got %v", err)
481+ }
482+}
483+
484+func TestRegistry_ListReturnsConfigKeys(t *testing.T) {
485+ registry := NewRegistry()
486+
487+ // Register with config keys
488+ registry.RegisterFactory("zen-nano", NewMockFactory("opencode_zen", "nano"))
489+ registry.RegisterFactory("zen-pickle", NewMockFactory("opencode_zen", "pickle"))
490+ registry.RegisterFactory("ollama-llama", NewMockFactory("ollama", "llama"))
491+ registry.RegisterFactory("ollama-qwen", NewMockFactory("ollama", "qwen"))
492+
493+ names := registry.List()
494+ if len(names) != 4 {
495+ t.Fatalf("expected 4 providers, got %d", len(names))
496+ }
497+
498+ // Should contain config keys, not factory names
499+ expectedKeys := map[string]bool{
500+ "zen-nano": false,
501+ "zen-pickle": false,
502+ "ollama-llama": false,
503+ "ollama-qwen": false,
504+ }
505+
506+ for _, name := range names {
507+ if _, ok := expectedKeys[name]; ok {
508+ expectedKeys[name] = true
509+ } else {
510+ t.Errorf("unexpected provider name: %s", name)
511+ }
512+ }
513+
514+ for key, found := range expectedKeys {
515+ if !found {
516+ t.Errorf("expected config key %s not found in list", key)
517+ }
518+ }
519+}
internal/tui/tui_test.go+4−4
@@ -37,10 +37,10 @@ func setupTestModel(t *testing.T) (Model, func()) {
3737
3838 reg := provider.NewRegistry()
3939 limiter := rate.NewLimiter(rate.Limit(1000), 1000)
40- reg.RegisterFactory(provider.NewMockFactoryWithLimiter("ollama", "mock response", limiter))
41- reg.RegisterFactory(provider.NewMockFactoryWithLimiter("opencode_zen", "mock response", limiter))
42- reg.RegisterFactory(provider.NewMockFactoryWithLimiter("zen-nano", "mock response", limiter))
43- reg.RegisterFactory(provider.NewMockFactoryWithLimiter("zen-pickle", "mock response", limiter))
40+ reg.RegisterFactory("ollama", provider.NewMockFactoryWithLimiter("ollama", "mock response", limiter))
41+ reg.RegisterFactory("opencode_zen", provider.NewMockFactoryWithLimiter("opencode_zen", "mock response", limiter))
42+ reg.RegisterFactory("zen-nano", provider.NewMockFactoryWithLimiter("zen-nano", "mock response", limiter))
43+ reg.RegisterFactory("zen-pickle", provider.NewMockFactoryWithLimiter("zen-pickle", "mock response", limiter))
4444
4545 cfg := &config.Config{
4646 Swarm: config.SwarmConfig{