60255
Zn
Zoea-Nova / files
Zoea-Nova / internal / core / commander.go
10.5 KB
1package core 2 3import ( 4 "context" 5 "errors" 6 "fmt" 7 "sync" 8 "time" 9 10 "github.com/rs/zerolog/log" 11 "github.com/xonecas/zoea-nova/internal/config" 12 "github.com/xonecas/zoea-nova/internal/provider" 13 "github.com/xonecas/zoea-nova/internal/store" 14) 15 16// Commander orchestrates the swarm of myses. 17type Commander struct { 18 mu sync.RWMutex 19 wg sync.WaitGroup // Tracks running mysis goroutines 20 21 myses map[string]*Mysis 22 store *store.Store 23 registry *provider.Registry 24 bus *EventBus 25 config *config.Config 26 mcpEndpoint string // MCP upstream endpoint for myses to create their own clients 27 maxMyses int 28} 29 30// NewCommander creates a new commander. 31func NewCommander(s *store.Store, reg *provider.Registry, bus *EventBus, cfg *config.Config, mcpEndpoint string) *Commander { 32 return &Commander{ 33 myses: make(map[string]*Mysis), 34 store: s, 35 registry: reg, 36 bus: bus, 37 config: cfg, 38 mcpEndpoint: mcpEndpoint, 39 maxMyses: cfg.Swarm.MaxMyses, 40 } 41} 42 43// LoadMyses loads existing myses from the store. 44// Myses are loaded in stopped state; they must be explicitly started. 45func (c *Commander) LoadMyses() error { 46 stored, err := c.store.ListMyses() 47 if err != nil { 48 return fmt.Errorf("list myses: %w", err) 49 } 50 51 c.mu.Lock() 52 defer c.mu.Unlock() 53 54 for _, sm := range stored { 55 p, err := c.registry.Create(sm.Provider, sm.Model, sm.Temperature) 56 if err != nil { 57 // Provider not available, skip mysis 58 continue 59 } 60 61 mysis := NewMysis(sm.ID, sm.Name, sm.CreatedAt, p, c.store, c.bus, c.mcpEndpoint, c) 62 c.myses[sm.ID] = mysis 63 } 64 65 return nil 66} 67 68// CreateMysis creates a new mysis with the given name and provider. 69func (c *Commander) CreateMysis(name, providerName string) (*Mysis, error) { 70 c.mu.Lock() 71 defer c.mu.Unlock() 72 73 if len(c.myses) >= c.maxMyses { 74 return nil, fmt.Errorf("max myses (%d) reached", c.maxMyses) 75 } 76 77 // Get provider config for model 78 provCfg, ok := c.config.Providers[providerName] 79 if !ok { 80 return nil, fmt.Errorf("provider config not found: %s", providerName) 81 } 82 83 // Create provider instance for this mysis 84 p, err := c.registry.Create(providerName, provCfg.Model, provCfg.Temperature) 85 if err != nil { 86 return nil, fmt.Errorf("create provider: %w", err) 87 } 88 89 // Create in store 90 stored, err := c.store.CreateMysis(name, providerName, provCfg.Model, provCfg.Temperature) 91 if err != nil { 92 return nil, fmt.Errorf("create mysis in store: %w", err) 93 } 94 95 // Create runtime mysis 96 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, p, c.store, c.bus, c.mcpEndpoint, c) 97 c.myses[stored.ID] = mysis 98 99 // Emit event 100 c.bus.Publish(Event{ 101 Type: EventMysisCreated, 102 MysisID: stored.ID, 103 MysisName: stored.Name, 104 Timestamp: time.Now(), 105 }) 106 107 return mysis, nil 108} 109 110// DeleteMysis removes a mysis from the swarm. 111func (c *Commander) DeleteMysis(id string, purgeMemories bool) error { 112 c.mu.Lock() 113 mysis, ok := c.myses[id] 114 if !ok { 115 c.mu.Unlock() 116 return fmt.Errorf("mysis not found: %s", id) 117 } 118 119 delete(c.myses, id) 120 c.mu.Unlock() 121 122 // Stop if running (outside of commander lock to avoid deadlock) 123 if mysis.State() == MysisStateRunning { 124 mysis.Stop() 125 } 126 mysis.releaseCurrentAccount() 127 128 // Delete from store (memories cascade) 129 if err := c.store.DeleteMysis(id); err != nil { 130 return fmt.Errorf("delete mysis from store: %w", err) 131 } 132 133 // Emit event 134 c.bus.Publish(Event{ 135 Type: EventMysisDeleted, 136 MysisID: id, 137 MysisName: mysis.Name(), 138 Timestamp: time.Now(), 139 }) 140 141 return nil 142} 143 144// GetMysis returns a mysis by ID. 145func (c *Commander) GetMysis(id string) (*Mysis, error) { 146 c.mu.RLock() 147 defer c.mu.RUnlock() 148 149 mysis, ok := c.myses[id] 150 if !ok { 151 return nil, fmt.Errorf("mysis not found: %s", id) 152 } 153 return mysis, nil 154} 155 156// ListMyses returns all myses. 157func (c *Commander) ListMyses() []*Mysis { 158 c.mu.RLock() 159 defer c.mu.RUnlock() 160 161 myses := make([]*Mysis, 0, len(c.myses)) 162 for _, m := range c.myses { 163 myses = append(myses, m) 164 } 165 return myses 166} 167 168// StartMysis starts a mysis by ID. 169func (c *Commander) StartMysis(id string) error { 170 mysis, err := c.GetMysis(id) 171 if err != nil { 172 return err 173 } 174 175 // Don't increment WaitGroup here - mysis.Start() will do it 176 // This avoids double-counting when restarting errored myses 177 return mysis.Start() 178} 179 180// StopMysis stops a mysis by ID. 181func (c *Commander) StopMysis(id string) error { 182 mysis, err := c.GetMysis(id) 183 if err != nil { 184 return err 185 } 186 187 return mysis.Stop() 188} 189 190// ConfigureMysis updates a mysis provider and model. 191func (c *Commander) ConfigureMysis(id, providerName, model string) error { 192 c.mu.Lock() 193 mysis, ok := c.myses[id] 194 if !ok { 195 c.mu.Unlock() 196 return fmt.Errorf("mysis not found: %s", id) 197 } 198 c.mu.Unlock() 199 200 // Get provider config 201 provCfg, ok := c.config.Providers[providerName] 202 if !ok { 203 return fmt.Errorf("provider config not found: %s", providerName) 204 } 205 temperature := provCfg.Temperature 206 207 // Get new provider 208 p, err := c.registry.Create(providerName, model, temperature) 209 if err != nil { 210 return fmt.Errorf("create provider: %w", err) 211 } 212 213 // Update store 214 if err := c.store.UpdateMysisConfig(id, providerName, model, temperature); err != nil { 215 return fmt.Errorf("update store: %w", err) 216 } 217 218 // Update runtime 219 mysis.SetProvider(p) 220 221 // Emit event 222 c.bus.Publish(Event{ 223 Type: EventMysisConfigChanged, 224 MysisID: id, 225 MysisName: mysis.Name(), 226 Config: &ConfigChangeData{ 227 Provider: providerName, 228 Model: model, 229 }, 230 Timestamp: time.Now(), 231 }) 232 233 return nil 234} 235 236// SendMessage sends a message to a specific mysis (synchronous). 237func (c *Commander) SendMessage(id, content string) error { 238 mysis, err := c.GetMysis(id) 239 if err != nil { 240 return err 241 } 242 return mysis.SendMessage(content, store.MemorySourceDirect) 243} 244 245// SendMessageAsync sends a message to a specific mysis without waiting for processing. 246// Returns immediately after validating the mysis exists. 247// State validation is done inside mysis.SendMessage. 248func (c *Commander) SendMessageAsync(id, content string) error { 249 mysis, err := c.GetMysis(id) 250 if err != nil { 251 return err 252 } 253 // State validation is done inside mysis.SendMessage 254 go func() { 255 if err := mysis.SendMessage(content, store.MemorySourceDirect); err != nil { 256 // Error is published to bus by mysis.SendMessage 257 } 258 }() 259 return nil 260} 261 262// Broadcast sends a message to all running myses. 263// Stores the message immediately and triggers async processing. 264// Returns quickly without waiting for LLM processing. 265func (c *Commander) Broadcast(content string) error { 266 c.mu.RLock() 267 myses := make([]*Mysis, 0) 268 for _, m := range c.myses { 269 // Include myses in idle or running state (can accept messages) 270 if validateCanAcceptMessage(m.State()) == nil { 271 myses = append(myses, m) 272 } 273 } 274 c.mu.RUnlock() 275 276 // Check if any myses can receive broadcast 277 if len(myses) == 0 { 278 return fmt.Errorf("no myses available to receive broadcast (all stopped or errored)") 279 } 280 281 // Emit broadcast event 282 c.bus.Publish(Event{ 283 Type: EventBroadcast, 284 Message: &MessageData{Role: "user", Content: content}, 285 Timestamp: time.Now(), 286 }) 287 288 // Queue broadcast to each mysis (non-blocking) 289 var errs []error 290 for _, m := range myses { 291 if err := m.QueueBroadcast(content, ""); err != nil { 292 errs = append(errs, fmt.Errorf("mysis %s: %w", m.ID(), err)) 293 } 294 } 295 296 if len(errs) > 0 { 297 return fmt.Errorf("broadcast failed for %d mysis: %w", len(errs), errors.Join(errs...)) 298 } 299 return nil 300} 301 302// BroadcastFrom sends a message to all running myses except the sender. 303func (c *Commander) BroadcastFrom(senderID, content string) error { 304 c.mu.RLock() 305 myses := make([]*Mysis, 0) 306 for _, m := range c.myses { 307 // Include myses in idle or running state (can accept messages), excluding sender 308 if validateCanAcceptMessage(m.State()) == nil && m.ID() != senderID { 309 myses = append(myses, m) 310 } 311 } 312 c.mu.RUnlock() 313 314 if len(myses) == 0 { 315 return fmt.Errorf("no recipients for broadcast (sender excluded or all stopped/errored)") 316 } 317 318 // Emit broadcast event 319 c.bus.Publish(Event{ 320 Type: EventBroadcast, 321 Message: &MessageData{Role: "user", Content: content}, 322 Timestamp: time.Now(), 323 }) 324 325 var errs []error 326 for _, m := range myses { 327 if err := m.SendMessageFrom(content, store.MemorySourceBroadcast, senderID); err != nil { 328 errs = append(errs, fmt.Errorf("mysis %s: %w", m.ID(), err)) 329 } 330 } 331 332 if len(errs) > 0 { 333 return fmt.Errorf("broadcast failed for %d mysis: %w", len(errs), errors.Join(errs...)) 334 } 335 return nil 336} 337 338// BroadcastAsync sends a message to all running myses without waiting for processing. 339// Returns immediately after validating at least one mysis is running. 340func (c *Commander) BroadcastAsync(content string) error { 341 return c.BroadcastFrom("", content) 342} 343 344// StopAll stops all running myses with a 10-second timeout. 345func (c *Commander) StopAll() { 346 c.mu.RLock() 347 myses := make([]*Mysis, 0) 348 for _, m := range c.myses { 349 myses = append(myses, m) 350 } 351 c.mu.RUnlock() 352 353 // Stop with timeout 354 ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) 355 defer cancel() 356 357 done := make(chan struct{}) 358 go func() { 359 // Stop all running myses 360 for _, m := range myses { 361 if m.State() == MysisStateRunning { 362 if err := m.Stop(); err != nil { 363 log.Warn().Err(err).Str("mysis", m.Name()).Msg("Failed to stop mysis") 364 } 365 } 366 } 367 // Wait for all mysis goroutines to complete 368 c.wg.Wait() 369 close(done) 370 }() 371 372 select { 373 case <-done: 374 log.Info().Int("count", len(myses)).Msg("All myses stopped") 375 case <-ctx.Done(): 376 log.Warn().Msg("StopAll timeout - some myses may still be running") 377 } 378} 379 380// MysisCount returns the current number of myses. 381func (c *Commander) MysisCount() int { 382 c.mu.RLock() 383 defer c.mu.RUnlock() 384 return len(c.myses) 385} 386 387// MaxMyses returns the maximum allowed myses. 388func (c *Commander) MaxMyses() int { 389 return c.maxMyses 390} 391 392// GetStateCounts returns the count of myses in each state. 393func (c *Commander) GetStateCounts() map[string]int { 394 c.mu.RLock() 395 defer c.mu.RUnlock() 396 397 counts := map[string]int{ 398 "running": 0, 399 "idle": 0, 400 "stopped": 0, 401 "errored": 0, 402 } 403 404 for _, m := range c.myses { 405 state := string(m.State()) 406 counts[state]++ 407 } 408 409 return counts 410} 411 412// Store returns the store for direct access (e.g., for testing). 413func (c *Commander) Store() *store.Store { 414 return c.store 415} 416 417// AggregateTick returns the maximum lastServerTick across all myses. 418// Returns 0 if no myses exist or if no mysis has received tick data. 419func (c *Commander) AggregateTick() int64 { 420 c.mu.RLock() 421 defer c.mu.RUnlock() 422 423 var maxTick int64 424 for _, m := range c.myses { 425 m.mu.RLock() 426 tick := m.lastServerTick 427 m.mu.RUnlock() 428 429 if tick > maxTick { 430 maxTick = tick 431 } 432 } 433 434 return maxTick 435}