xonecas.io
60255
Zn

Zoea-Nova / commit 9c1f41c

refactor: remove obsolete selectPromptSource function

The selectPromptSource() function is no longer needed after implementing
turn-aware context composition. The complete current turn is now included,
which already contains the user prompt.

xonecas2026-02-07 9c1f41c9ab201829bcfac1461d8da3a679387f8d parent 7cf375c

2 files changed

internal/core/mysis.go+0−72
@@ -1287,78 +1287,6 @@ func (m *Mysis) setIdle(reason string) {
12871287 a.releaseCurrentAccount()
12881288 }
12891289
1290-// selectPromptSource chooses the prompt source memory by priority:
1291-// 1. Most recent commander direct message (source="direct")
1292-// 2. Last commander broadcast (source="broadcast", sender_id="")
1293-// 3. Last swarm broadcast (source="broadcast", sender_id!=commander)
1294-// 4. Return nil if none found (caller will generate synthetic nudge)
1295-//
1296-// The commander is identified by empty sender_id in broadcasts.
1297-// Memories are expected to be ordered newest-first (from getContextMemories).
1298-//
1299-// Parameters:
1300-// - memories: Slice of memories ordered newest-first, typically from GetRecentMemories
1301-//
1302-// Returns:
1303-// - *store.Memory: The selected prompt source, or nil if no valid user message exists
1304-//
1305-// Rationale:
1306-//
1307-// This priority ensures that direct commands from the commander take precedence
1308-// over broadcasts, and commander broadcasts take precedence over peer messages.
1309-// When no prompt source exists, returning nil signals the caller to generate
1310-// a synthetic nudge to keep the Mysis active.
1311-func (m *Mysis) selectPromptSource(memories []*store.Memory) *store.Memory {
1312- if len(memories) == 0 {
1313- return nil
1314- }
1315-
1316- // Track most recent broadcast from commander (sender_id="") and swarm (sender_id!="")
1317- var lastCommanderBroadcast *store.Memory
1318- var lastSwarmBroadcast *store.Memory
1319-
1320- // Scan memories in order (newest first)
1321- for _, mem := range memories {
1322- // Skip non-user messages
1323- if mem.Role != store.MemoryRoleUser {
1324- continue
1325- }
1326-
1327- // Priority 1: Commander direct message (highest priority)
1328- if mem.Source == store.MemorySourceDirect {
1329- return mem
1330- }
1331-
1332- // Track broadcasts by sender
1333- if mem.Source == store.MemorySourceBroadcast {
1334- if mem.SenderID == "" {
1335- // Commander broadcast (empty sender_id)
1336- if lastCommanderBroadcast == nil {
1337- lastCommanderBroadcast = mem
1338- }
1339- } else {
1340- // Swarm broadcast (non-empty sender_id)
1341- if lastSwarmBroadcast == nil {
1342- lastSwarmBroadcast = mem
1343- }
1344- }
1345- }
1346- }
1347-
1348- // Priority 2: Last commander broadcast
1349- if lastCommanderBroadcast != nil {
1350- return lastCommanderBroadcast
1351- }
1352-
1353- // Priority 3: Last swarm broadcast
1354- if lastSwarmBroadcast != nil {
1355- return lastSwarmBroadcast
1356- }
1357-
1358- // Priority 4: No prompt source found - return nil for synthetic nudge
1359- return nil
1360-}
1361-
13621290 // extractLatestToolLoop finds the most recent tool-call message (assistant role
13631291 // with tool_calls) and returns it plus all subsequent tool results.
13641292 //
internal/core/mysis_test.go+88−92
@@ -812,98 +812,6 @@ func TestContextPromptSourcePriority(t *testing.T) {
812812 }
813813 }
814814
815-func TestSelectPromptSourceHelper(t *testing.T) {
816- s, bus, cleanup := setupMysisTest(t)
817- defer cleanup()
818-
819- stored, err := s.CreateMysis("helper-test", "mock", "test-model", 0.7)
820- if err != nil {
821- t.Fatalf("CreateMysis() error: %v", err)
822- }
823-
824- mock := provider.NewMock("mock", "response")
825- mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
826-
827- tests := []struct {
828- name string
829- memories []*store.Memory
830- expectedSource store.MemorySource
831- expectedSender string
832- expectNil bool
833- }{
834- {
835- name: "nil_memories",
836- memories: nil,
837- expectNil: true,
838- },
839- {
840- name: "empty_memories",
841- memories: []*store.Memory{},
842- expectNil: true,
843- },
844- {
845- name: "only_system_messages",
846- memories: []*store.Memory{
847- {Role: store.MemoryRoleSystem, Source: store.MemorySourceSystem, Content: "System"},
848- {Role: store.MemoryRoleAssistant, Source: store.MemorySourceLLM, Content: "Response"},
849- },
850- expectNil: true,
851- },
852- {
853- name: "direct_message_priority",
854- memories: []*store.Memory{
855- {Role: store.MemoryRoleUser, Source: store.MemorySourceDirect, Content: "Direct", SenderID: "cmd"},
856- {Role: store.MemoryRoleUser, Source: store.MemorySourceBroadcast, Content: "Broadcast", SenderID: ""},
857- },
858- expectedSource: store.MemorySourceDirect,
859- expectedSender: "cmd",
860- },
861- {
862- name: "commander_broadcast_when_no_direct",
863- memories: []*store.Memory{
864- {Role: store.MemoryRoleUser, Source: store.MemorySourceBroadcast, Content: "Commander broadcast", SenderID: ""},
865- {Role: store.MemoryRoleUser, Source: store.MemorySourceBroadcast, Content: "Swarm broadcast", SenderID: "mysis-1"},
866- },
867- expectedSource: store.MemorySourceBroadcast,
868- expectedSender: "",
869- },
870- {
871- name: "swarm_broadcast_when_no_commander",
872- memories: []*store.Memory{
873- {Role: store.MemoryRoleUser, Source: store.MemorySourceBroadcast, Content: "Swarm broadcast 1", SenderID: "mysis-1"},
874- {Role: store.MemoryRoleUser, Source: store.MemorySourceBroadcast, Content: "Swarm broadcast 2", SenderID: "mysis-2"},
875- },
876- expectedSource: store.MemorySourceBroadcast,
877- expectedSender: "mysis-1",
878- },
879- }
880-
881- for _, tt := range tests {
882- t.Run(tt.name, func(t *testing.T) {
883- result := mysis.selectPromptSource(tt.memories)
884-
885- if tt.expectNil {
886- if result != nil {
887- t.Errorf("expected nil, got %+v", result)
888- }
889- return
890- }
891-
892- if result == nil {
893- t.Fatal("expected non-nil result, got nil")
894- }
895-
896- if result.Source != tt.expectedSource {
897- t.Errorf("expected source=%s, got %s", tt.expectedSource, result.Source)
898- }
899-
900- if result.SenderID != tt.expectedSender {
901- t.Errorf("expected sender_id=%s, got %s", tt.expectedSender, result.SenderID)
902- }
903- })
904- }
905-}
906-
907815 func TestExtractLatestToolLoopHelper(t *testing.T) {
908816 s, bus, cleanup := setupMysisTest(t)
909817 defer cleanup()
@@ -2125,3 +2033,91 @@ func TestGetContextMemories_CurrentTurnPreserved(t *testing.T) {
21252033 t.Error("Missing status result from current turn")
21262034 }
21272035 }
2036+
2037+func TestGetContextMemories_NoUserPrompt(t *testing.T) {
2038+ s, bus, cleanup := setupMysisTest(t)
2039+ defer cleanup()
2040+
2041+ stored, _ := s.CreateMysis("no-prompt-test", "mock", "test-model", 0.7)
2042+ mock := provider.NewMock("mock", "response")
2043+ mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
2044+
2045+ // Add only system and assistant messages (no user prompt)
2046+ err := s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "", "")
2047+ if err != nil {
2048+ t.Fatalf("AddMemory error: %v", err)
2049+ }
2050+ err = s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "assistant msg", "", "")
2051+ if err != nil {
2052+ t.Fatalf("AddMemory error: %v", err)
2053+ }
2054+
2055+ memories, err := mysis.getContextMemories()
2056+ if err != nil {
2057+ t.Fatalf("getContextMemories error: %v", err)
2058+ }
2059+
2060+ // Should generate synthetic nudge when no user prompt exists
2061+ hasNudge := false
2062+ for _, mem := range memories {
2063+ if mem.Role == store.MemoryRoleUser && mem.Source == store.MemorySourceSystem {
2064+ hasNudge = true
2065+ break
2066+ }
2067+ }
2068+
2069+ if !hasNudge {
2070+ t.Error("Expected synthetic nudge when no user prompt exists")
2071+ }
2072+}
2073+
2074+func TestGetContextMemories_OnlyHistoricalTurns(t *testing.T) {
2075+ s, bus, cleanup := setupMysisTest(t)
2076+ defer cleanup()
2077+
2078+ stored, _ := s.CreateMysis("historical-test", "mock", "test-model", 0.7)
2079+ mock := provider.NewMock("mock", "response")
2080+ mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
2081+
2082+ // Add system prompt
2083+ err := s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "", "")
2084+ if err != nil {
2085+ t.Fatalf("AddMemory error: %v", err)
2086+ }
2087+
2088+ // Add complete historical turn
2089+ err = s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "old msg", "", "")
2090+ if err != nil {
2091+ t.Fatalf("AddMemory error: %v", err)
2092+ }
2093+ err = s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "old response", "", "")
2094+ if err != nil {
2095+ t.Fatalf("AddMemory error: %v", err)
2096+ }
2097+
2098+ memories, err := mysis.getContextMemories()
2099+ if err != nil {
2100+ t.Fatalf("getContextMemories error: %v", err)
2101+ }
2102+
2103+ // Should include system + historical context (user+assistant from last turn)
2104+ if len(memories) < 2 {
2105+ t.Fatalf("Expected at least 2 memories (system + historical), got %d", len(memories))
2106+ }
2107+
2108+ if memories[0].Role != store.MemoryRoleSystem {
2109+ t.Error("First memory should be system")
2110+ }
2111+
2112+ // Last user message should be included as current turn
2113+ hasOldUser := false
2114+ for _, mem := range memories {
2115+ if mem.Content == "old msg" {
2116+ hasOldUser = true
2117+ }
2118+ }
2119+
2120+ if !hasOldUser {
2121+ t.Error("Expected historical user message to be included as current turn")
2122+ }
2123+}