xonecas.io
60255
Zn

Zoea-Nova / commit ff99e9e

feat(core): add SendMessageFrom and BroadcastFrom for sender tracking

Add sender-aware message delivery to prevent self-response loops:
- Add SendMessageFrom() method to Mysis for sender tracking
- Refactor SendMessage() to delegate to SendMessageFrom with empty sender
- Add BroadcastFrom() to Commander to exclude sender from recipients
- Refactor BroadcastAsync() to delegate to BroadcastFrom with empty sender
- Add TestMysisReceivesBroadcastWithSender unit test
- Add TestBroadcastExcludesSender integration test
- Update all AddMemory calls in tests for new signature

xonecas2026-02-05 ff99e9e93ee1160273dd165af9031e4ff4fc5d80 parent cc436f2

4 files changed

internal/core/commander.go+17−13
@@ -307,21 +307,19 @@ func (c *Commander) Broadcast(content string) error {
307307 return nil
308308 }
309309
310-// BroadcastAsync sends a message to all running myses without waiting for processing.
311-// Returns immediately after validating at least one mysis is running.
312-func (c *Commander) BroadcastAsync(content string) error {
310+// BroadcastFrom sends a message to all running myses except the sender.
311+func (c *Commander) BroadcastFrom(senderID, content string) error {
313312 c.mu.RLock()
314313 myses := make([]*Mysis, 0)
315314 for _, m := range c.myses {
316- if m.State() == MysisStateRunning {
315+ if m.State() == MysisStateRunning && m.ID() != senderID {
317316 myses = append(myses, m)
318317 }
319318 }
320319 c.mu.RUnlock()
321320
322- // Check if any myses are running
323321 if len(myses) == 0 {
324- return fmt.Errorf("no running myses to receive broadcast")
322+ return fmt.Errorf("no recipients for broadcast (sender excluded)")
325323 }
326324
327325 // Emit broadcast event
@@ -331,19 +329,25 @@ func (c *Commander) BroadcastAsync(content string) error {
331329 Timestamp: time.Now(),
332330 })
333331
334- // Send to each mysis asynchronously
332+ var errs []error
335333 for _, m := range myses {
336- mysis := m
337- go func() {
338- if err := mysis.SendMessage(content, store.MemorySourceBroadcast); err != nil {
339- // Error is published to bus by mysis.SendMessage
340- }
341- }()
334+ if err := m.SendMessageFrom(content, store.MemorySourceBroadcast, senderID); err != nil {
335+ errs = append(errs, fmt.Errorf("mysis %s: %w", m.ID(), err))
336+ }
342337 }
343338
339+ if len(errs) > 0 {
340+ return fmt.Errorf("broadcast failed for %d mysis: %w", len(errs), errors.Join(errs...))
341+ }
344342 return nil
345343 }
346344
345+// BroadcastAsync sends a message to all running myses without waiting for processing.
346+// Returns immediately after validating at least one mysis is running.
347+func (c *Commander) BroadcastAsync(content string) error {
348+ return c.BroadcastFrom("", content)
349+}
350+
347351 // StopAll stops all running myses.
348352 func (c *Commander) StopAll() {
349353 c.mu.RLock()
internal/core/commander_test.go+52−0
@@ -405,6 +405,58 @@ func TestCommanderBroadcastSource(t *testing.T) {
405405 }
406406 }
407407
408+func TestBroadcastExcludesSender(t *testing.T) {
409+ cmd, _, cleanup := setupCommanderTest(t)
410+ defer cleanup()
411+
412+ sender, _ := cmd.CreateMysis("sender", "mock")
413+ receiver, _ := cmd.CreateMysis("receiver", "mock")
414+
415+ cmd.StartMysis(sender.ID())
416+ cmd.StartMysis(receiver.ID())
417+
418+ deadline := time.Now().Add(time.Second)
419+ for time.Now().Before(deadline) {
420+ if sender.State() == MysisStateRunning && receiver.State() == MysisStateRunning {
421+ break
422+ }
423+ time.Sleep(10 * time.Millisecond)
424+ }
425+ if sender.State() != MysisStateRunning || receiver.State() != MysisStateRunning {
426+ t.Fatal("myses failed to start within timeout")
427+ }
428+
429+ if err := cmd.BroadcastFrom(sender.ID(), "test broadcast"); err != nil {
430+ t.Fatalf("BroadcastFrom() error: %v", err)
431+ }
432+
433+ senderMemories, err := cmd.Store().GetRecentMemories(sender.ID(), 50)
434+ if err != nil {
435+ t.Fatalf("GetRecentMemories() error: %v", err)
436+ }
437+ for _, m := range senderMemories {
438+ if m.Source == store.MemorySourceBroadcast && m.Content == "test broadcast" {
439+ t.Error("sender received its own broadcast - should be excluded")
440+ }
441+ }
442+
443+ receiverMemories, err := cmd.Store().GetRecentMemories(receiver.ID(), 50)
444+ if err != nil {
445+ t.Fatalf("GetRecentMemories() error: %v", err)
446+ }
447+
448+ found := false
449+ for _, m := range receiverMemories {
450+ if m.Source == store.MemorySourceBroadcast && m.Content == "test broadcast" && m.SenderID == sender.ID() {
451+ found = true
452+ break
453+ }
454+ }
455+ if !found {
456+ t.Error("receiver did not receive broadcast with correct sender_id")
457+ }
458+}
459+
408460 func TestCommanderStopAll(t *testing.T) {
409461 cmd, _, cleanup := setupCommanderTest(t)
410462 defer cleanup()
internal/core/mysis.go+18−9
@@ -285,7 +285,7 @@ func (a *Mysis) Start() error {
285285 // Add system prompt if this is the first time starting (no memories yet)
286286 count, err := a.store.CountMemories(a.id)
287287 if err == nil && count == 0 {
288- a.store.AddMemory(a.id, store.MemoryRoleSystem, store.MemorySourceSystem, SystemPrompt, "")
288+ a.store.AddMemory(a.id, store.MemoryRoleSystem, store.MemorySourceSystem, SystemPrompt, "", "")
289289 }
290290
291291 // Emit state change event
@@ -337,10 +337,9 @@ func (a *Mysis) Stop() error {
337337 return nil
338338 }
339339
340-// SendMessage sends a message to the mysis for processing.
341-// This implements the loop with tool calling support.
340+// SendMessageFrom sends a message to the mysis for processing with sender tracking.
342341 // The source parameter indicates whether this is a direct or broadcast message.
343-func (a *Mysis) SendMessage(content string, source store.MemorySource) error {
342+func (a *Mysis) SendMessageFrom(content string, source store.MemorySource, senderID string) error {
344343 a.turnMu.Lock()
345344 defer a.turnMu.Unlock()
346345
@@ -361,7 +360,7 @@ func (a *Mysis) SendMessage(content string, source store.MemorySource) error {
361360 }
362361
363362 // Store the message
364- if _, err := a.store.AddMemory(a.id, role, source, content, ""); err != nil {
363+ if err := a.store.AddMemory(a.id, role, source, content, "", senderID); err != nil {
365364 return fmt.Errorf("store message: %w", err)
366365 }
367366
@@ -518,7 +517,7 @@ func (a *Mysis) SendMessage(content string, source store.MemorySource) error {
518517 if len(response.ToolCalls) > 0 {
519518 // Store the assistant's tool call request
520519 toolCallJSON := a.formatToolCallsForStorage(response.ToolCalls)
521- if _, err := a.store.AddMemory(a.id, store.MemoryRoleAssistant, store.MemorySourceLLM, toolCallJSON, response.Reasoning); err != nil {
520+ if err := a.store.AddMemory(a.id, store.MemoryRoleAssistant, store.MemorySourceLLM, toolCallJSON, response.Reasoning, ""); err != nil {
522521 a.setError(err)
523522 return fmt.Errorf("store tool call: %w", err)
524523 }
@@ -550,7 +549,7 @@ func (a *Mysis) SendMessage(content string, source store.MemorySource) error {
550549
551550 // Store the tool result
552551 resultContent := a.formatToolResult(tc.ID, tc.Name, result, execErr)
553- if _, err := a.store.AddMemory(a.id, store.MemoryRoleTool, store.MemorySourceTool, resultContent, ""); err != nil {
552+ if err := a.store.AddMemory(a.id, store.MemoryRoleTool, store.MemorySourceTool, resultContent, "", ""); err != nil {
554553 a.setError(err)
555554 return fmt.Errorf("store tool result: %w", err)
556555 }
@@ -576,7 +575,7 @@ func (a *Mysis) SendMessage(content string, source store.MemorySource) error {
576575 }
577576
578577 // Store the assistant response
579- if _, err := a.store.AddMemory(a.id, store.MemoryRoleAssistant, store.MemorySourceLLM, finalResponse, response.Reasoning); err != nil {
578+ if err := a.store.AddMemory(a.id, store.MemoryRoleAssistant, store.MemorySourceLLM, finalResponse, response.Reasoning, ""); err != nil {
580579 a.setError(err)
581580 return fmt.Errorf("store response: %w", err)
582581 }
@@ -602,6 +601,11 @@ func (a *Mysis) SendMessage(content string, source store.MemorySource) error {
602601 return fmt.Errorf("max tool iterations (%d) exceeded", MaxToolIterations)
603602 }
604603
604+// SendMessage sends a message to the mysis for processing.
605+func (a *Mysis) SendMessage(content string, source store.MemorySource) error {
606+ return a.SendMessageFrom(content, source, "")
607+}
608+
605609 // memoriesToMessages converts stored memories to provider messages.
606610 func (a *Mysis) memoriesToMessages(memories []*store.Memory) []provider.Message {
607611 messages := make([]provider.Message, 0, len(memories))
@@ -643,7 +647,12 @@ func (a *Mysis) executeToolCall(ctx context.Context, mcpProxy *mcp.Proxy, tc pro
643647 }, nil
644648 }
645649
646- result, err := mcpProxy.CallTool(ctx, tc.Name, tc.Arguments)
650+ caller := mcp.CallerContext{
651+ MysisID: a.id,
652+ MysisName: a.name,
653+ }
654+
655+ result, err := mcpProxy.CallTool(ctx, caller, tc.Name, tc.Arguments)
647656 if err == nil && result != nil && !result.IsError {
648657 switch tc.Name {
649658 case "login", "register":
internal/core/mysis_test.go+65−24
@@ -173,6 +173,47 @@ eventLoop:
173173 mysis.Stop()
174174 }
175175
176+func TestMysisReceivesBroadcastWithSender(t *testing.T) {
177+ s, bus, cleanup := setupMysisTest(t)
178+ defer cleanup()
179+
180+ receiverStored, _ := s.CreateMysis("receiver", "mock", "test-model", 0.7)
181+ mock := provider.NewMock("mock", "response")
182+ receiver := NewMysis(receiverStored.ID, receiverStored.Name, receiverStored.CreatedAt, mock, s, bus)
183+
184+ if err := receiver.Start(); err != nil {
185+ t.Fatalf("Start() error: %v", err)
186+ }
187+ defer receiver.Stop()
188+
189+ senderID := "sender-mysis"
190+
191+ if err := receiver.SendMessageFrom("test broadcast", store.MemorySourceBroadcast, senderID); err != nil {
192+ t.Fatalf("SendMessageFrom() error: %v", err)
193+ }
194+
195+ memories, err := s.GetRecentMemories(receiverStored.ID, 10)
196+ if err != nil {
197+ t.Fatalf("GetRecentMemories() error: %v", err)
198+ }
199+
200+ if len(memories) == 0 {
201+ t.Fatal("expected at least 1 memory")
202+ }
203+
204+ found := false
205+ for _, m := range memories {
206+ if m.Source == store.MemorySourceBroadcast && m.SenderID == senderID {
207+ found = true
208+ break
209+ }
210+ }
211+
212+ if !found {
213+ t.Error("broadcast memory with correct sender_id not found")
214+ }
215+}
216+
176217 func TestMysisSetErrorState(t *testing.T) {
177218 s, bus, cleanup := setupMysisTest(t)
178219 defer cleanup()
@@ -274,12 +315,12 @@ func TestMysisContextMemoryLimit(t *testing.T) {
274315 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
275316
276317 // Add system prompt
277- s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "")
318+ s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "", "")
278319
279320 // Add more memories than MaxContextMessages
280321 for i := 0; i < MaxContextMessages+10; i++ {
281- s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "user message", "")
282- s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "assistant response", "")
322+ s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "user message", "", "")
323+ s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "assistant response", "", "")
283324 }
284325
285326 // Get context memories
@@ -312,12 +353,12 @@ func TestMysisContextMemoryWithRecentSystemPrompt(t *testing.T) {
312353 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
313354
314355 // Add system prompt
315- s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "")
356+ s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "", "")
316357
317358 // Add fewer memories than MaxContextMessages
318359 for i := 0; i < 5; i++ {
319- s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "user message", "")
320- s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "assistant response", "")
360+ s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "user message", "", "")
361+ s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "assistant response", "", "")
321362 }
322363
323364 // Get context memories
@@ -407,28 +448,28 @@ func TestMysisContextCompaction(t *testing.T) {
407448 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
408449
409450 // Add system prompt
410- s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "")
451+ s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "", "")
411452
412453 // Add multiple get_ship tool results (should be compacted to keep only the latest)
413454 for i := 0; i < 5; i++ {
414- s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "check ship", "")
415- s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "[TOOL_CALLS]call_1:get_ship:{}", "")
455+ s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "check ship", "", "")
456+ s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "[TOOL_CALLS]call_1:get_ship:{}", "", "")
416457 s.AddMemory(stored.ID, store.MemoryRoleTool, store.MemorySourceTool,
417- fmt.Sprintf(`call_1:{"ship_id":"ship_%d","hull":100}`, i), "")
458+ fmt.Sprintf(`call_1:{"ship_id":"ship_%d","hull":100}`, i), "", "")
418459 }
419460
420461 // Add multiple get_system tool results (should also be compacted)
421462 for i := 0; i < 3; i++ {
422- s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "check system", "")
423- s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "[TOOL_CALLS]call_2:get_system:{}", "")
463+ s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "check system", "", "")
464+ s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "[TOOL_CALLS]call_2:get_system:{}", "", "")
424465 s.AddMemory(stored.ID, store.MemoryRoleTool, store.MemorySourceTool,
425- fmt.Sprintf(`call_2:{"system_id":"sys_%d","police_level":1}`, i), "")
466+ fmt.Sprintf(`call_2:{"system_id":"sys_%d","police_level":1}`, i), "", "")
426467 }
427468
428469 // Add a non-snapshot tool result (should be kept)
429- s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "mine ore", "")
430- s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "[TOOL_CALLS]call_3:mine:{}", "")
431- s.AddMemory(stored.ID, store.MemoryRoleTool, store.MemorySourceTool, `call_3:{"result":"mining"}`, "")
470+ s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "mine ore", "", "")
471+ s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "[TOOL_CALLS]call_3:mine:{}", "", "")
472+ s.AddMemory(stored.ID, store.MemoryRoleTool, store.MemorySourceTool, `call_3:{"result":"mining"}`, "", "")
432473
433474 // Get context memories
434475 memories, err := mysis.getContextMemories()
@@ -516,14 +557,14 @@ func TestZoeaListMysesCompaction(t *testing.T) {
516557 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
517558
518559 // Add system prompt
519- s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "")
560+ s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "", "")
520561
521562 // Add multiple zoea_list_myses tool results (should be compacted to keep only the latest)
522563 for i := 0; i < 5; i++ {
523- s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "list myses", "")
524- s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "[TOOL_CALLS]call_1:zoea_list_myses:{}", "")
564+ s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "list myses", "", "")
565+ s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "[TOOL_CALLS]call_1:zoea_list_myses:{}", "", "")
525566 s.AddMemory(stored.ID, store.MemoryRoleTool, store.MemorySourceTool,
526- fmt.Sprintf(`call_1:[{"id":"mysis-%d","name":"test-%d"}]`, i, i), "")
567+ fmt.Sprintf(`call_1:[{"id":"mysis-%d","name":"test-%d"}]`, i, i), "", "")
527568 }
528569
529570 // Get context memories
@@ -563,12 +604,12 @@ func TestMysisContextCompactionNonSnapshot(t *testing.T) {
563604 mock := provider.NewMock("mock", "response")
564605 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
565606
566- s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "")
607+ s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "", "")
567608
568609 for i := 0; i < 2; i++ {
569- s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "travel", "")
570- s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, fmt.Sprintf("[TOOL_CALLS]call_%d:travel:{}", i), "")
571- s.AddMemory(stored.ID, store.MemoryRoleTool, store.MemorySourceTool, fmt.Sprintf(`call_%d:{"ship_id":"ship_%d"}`, i, i), "")
610+ s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "travel", "", "")
611+ s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, fmt.Sprintf("[TOOL_CALLS]call_%d:travel:{}", i), "", "")
612+ s.AddMemory(stored.ID, store.MemoryRoleTool, store.MemorySourceTool, fmt.Sprintf(`call_%d:{"ship_id":"ship_%d"}`, i, i), "", "")
572613 }
573614
574615 memories, err := mysis.getContextMemories()