@@ -514,3 +514,162 @@ func TestCommanderLoadMyses(t *testing.T) {
514514 t.Errorf("expected 2 myses loaded, got %d", cmd.MysisCount())
515515 }
516516 }
517+
518+// TestBroadcastDoesNotBlockOnBusyMysis verifies that broadcasting doesn't block
519+// when one or more myses are busy processing a previous message.
520+// This test ensures the parallel broadcast implementation works correctly.
521+func TestBroadcastDoesNotBlockOnBusyMysis(t *testing.T) {
522+ tmpDir := t.TempDir()
523+ dbPath := filepath.Join(tmpDir, "test.db")
524+ s, err := store.Open(dbPath)
525+ if err != nil {
526+ t.Fatalf("Open() error: %v", err)
527+ }
528+ defer s.Close()
529+
530+ bus := NewEventBus(100)
531+ defer bus.Close()
532+
533+ reg := provider.NewRegistry()
534+ limiter := rate.NewLimiter(rate.Limit(1000), 1000)
535+
536+ // Create a slow provider that will block for 2 seconds
537+ slowProvider := provider.NewMock("slow", "slow response").
538+ WithLimiter(limiter).
539+ SetDelay(2 * time.Second)
540+
541+ // Create a fast provider for the other mysis
542+ fastProvider := provider.NewMock("fast", "fast response").
543+ WithLimiter(limiter)
544+
545+ // Register custom factories that return our specific providers
546+ reg.RegisterFactory(&customMockFactory{
547+ name: "slow",
548+ provider: slowProvider,
549+ })
550+ reg.RegisterFactory(&customMockFactory{
551+ name: "fast",
552+ provider: fastProvider,
553+ })
554+
555+ cfg := &config.Config{
556+ Swarm: config.SwarmConfig{MaxMyses: 16},
557+ Providers: map[string]config.ProviderConfig{
558+ "slow": {Endpoint: "http://slow", Model: "slow-model", Temperature: 0.7},
559+ "fast": {Endpoint: "http://fast", Model: "fast-model", Temperature: 0.7},
560+ },
561+ }
562+
563+ cmd := NewCommander(s, reg, bus, cfg)
564+ proxy := mcp.NewProxy(nil)
565+ cmd.SetMCP(proxy)
566+
567+ // Create two myses: one slow, one fast
568+ slowMysis, err := cmd.CreateMysis("slow-mysis", "slow")
569+ if err != nil {
570+ t.Fatalf("CreateMysis(slow) error: %v", err)
571+ }
572+
573+ fastMysis, err := cmd.CreateMysis("fast-mysis", "fast")
574+ if err != nil {
575+ t.Fatalf("CreateMysis(fast) error: %v", err)
576+ }
577+
578+ // Start both myses
579+ if err := cmd.StartMysis(slowMysis.ID()); err != nil {
580+ t.Fatalf("StartMysis(slow) error: %v", err)
581+ }
582+ if err := cmd.StartMysis(fastMysis.ID()); err != nil {
583+ t.Fatalf("StartMysis(fast) error: %v", err)
584+ }
585+
586+ // Wait for both to be running
587+ deadline := time.Now().Add(2 * time.Second)
588+ for time.Now().Before(deadline) {
589+ if slowMysis.State() == MysisStateRunning && fastMysis.State() == MysisStateRunning {
590+ break
591+ }
592+ time.Sleep(10 * time.Millisecond)
593+ }
594+ if slowMysis.State() != MysisStateRunning || fastMysis.State() != MysisStateRunning {
595+ t.Fatal("myses failed to start within timeout")
596+ }
597+
598+ // Send a direct message to the slow mysis to make it busy
599+ // This will block for 2 seconds due to the delay
600+ go func() {
601+ cmd.SendMessage(slowMysis.ID(), "make slow mysis busy")
602+ }()
603+
604+ // Give the slow mysis time to start processing (acquire turnMu lock)
605+ time.Sleep(100 * time.Millisecond)
606+
607+ // Now broadcast a message - this should NOT block waiting for the slow mysis
608+ // The broadcast should complete quickly (within 500ms) because it sends in parallel
609+ start := time.Now()
610+ err = cmd.Broadcast("broadcast message")
611+ elapsed := time.Since(start)
612+
613+ if err != nil {
614+ t.Fatalf("Broadcast() error: %v", err)
615+ }
616+
617+ // The broadcast should complete much faster than the 2-second delay
618+ // We allow up to 1 second for the broadcast to complete (generous margin)
619+ // If it takes longer, it means the broadcast blocked waiting for the slow mysis
620+ if elapsed > 1*time.Second {
621+ t.Errorf("Broadcast took too long (%v), likely blocked on busy mysis", elapsed)
622+ }
623+
624+ // Verify both myses received the broadcast
625+ // Wait a bit for the slow mysis to finish processing
626+ time.Sleep(2500 * time.Millisecond)
627+
628+ slowMemories, err := s.GetRecentMemories(slowMysis.ID(), 50)
629+ if err != nil {
630+ t.Fatalf("GetRecentMemories(slow) error: %v", err)
631+ }
632+
633+ fastMemories, err := s.GetRecentMemories(fastMysis.ID(), 50)
634+ if err != nil {
635+ t.Fatalf("GetRecentMemories(fast) error: %v", err)
636+ }
637+
638+ // Check that both myses have the broadcast message
639+ slowHasBroadcast := false
640+ for _, m := range slowMemories {
641+ if m.Source == store.MemorySourceBroadcast && m.Content == "broadcast message" {
642+ slowHasBroadcast = true
643+ break
644+ }
645+ }
646+
647+ fastHasBroadcast := false
648+ for _, m := range fastMemories {
649+ if m.Source == store.MemorySourceBroadcast && m.Content == "broadcast message" {
650+ fastHasBroadcast = true
651+ break
652+ }
653+ }
654+
655+ if !slowHasBroadcast {
656+ t.Error("slow mysis did not receive broadcast message")
657+ }
658+ if !fastHasBroadcast {
659+ t.Error("fast mysis did not receive broadcast message")
660+ }
661+
662+ cmd.StopAll()
663+}
664+
665+// customMockFactory is a factory that returns a specific provider instance
666+type customMockFactory struct {
667+ name string
668+ provider provider.Provider
669+}
670+
671+func (f *customMockFactory) Name() string { return f.name }
672+
673+func (f *customMockFactory) Create(model string, temperature float64) provider.Provider {
674+ return f.provider
675+}