diff --git a/internal/app/archied/bootstrap.go b/internal/app/archied/bootstrap.go index 51a309907..6ec743933 100644 --- a/internal/app/archied/bootstrap.go +++ b/internal/app/archied/bootstrap.go @@ -1057,7 +1057,7 @@ func (b *boot) setupCurators(ctx context.Context) { Skills: skillcurator.NewStore(skillsRoot), // Conversations backs the session-memory curator; b.chatSessionStore // is opened by openChatSessions before setupCurators. - Conversations: sessioncurator.NewAdapter(b.chatSessionStore, b.cfg.BotUser), + Conversations: sessioncurator.NewAdapter(b.chatSessionStore), LLM: curatorLLMRunner{rt: b.llm}, // b.chatModels.ActiveModel() is the same source sendChatTurn uses // for a real chat turn (telegram_setup.go) -- not diff --git a/internal/domain/messaging/message.go b/internal/domain/messaging/message.go index e6f2111ee..563aad010 100644 --- a/internal/domain/messaging/message.go +++ b/internal/domain/messaging/message.go @@ -73,6 +73,13 @@ type Message struct { // upstream identity. SourceID string + // Sender is the channel-native display attribution (e.g. a Telegram + // username) recorded when the message was written. Like SourceID it + // is external correlation metadata, never the canonical identity: + // role discrimination uses Role, never this field. It is preserved + // so history search and transcript rendering keep working. + Sender string + Role Role Text string diff --git a/internal/gateway/branch_identity_test.go b/internal/gateway/branch_identity_test.go index 6168c6681..4411cc0aa 100644 --- a/internal/gateway/branch_identity_test.go +++ b/internal/gateway/branch_identity_test.go @@ -4,6 +4,8 @@ import ( "context" "strings" "testing" + + "github.com/samcharles93/archie-core/internal/domain/messaging" ) // A branch copies the parent's history into a new session. Those copies used @@ -33,8 +35,8 @@ func TestBranchGivesInheritedMessagesTheirOwnIdentity(t *testing.T) { } for i, text := range []string{"one", "two", "three"} { - if err := store.SaveMessage(ctx, parentID, Message{ - From: "alice", Text: text, SourceID: "tg-" + text, At: at(dur(i)), + if err := store.SaveMessage(ctx, parentID, messaging.Message{ + Sender: "alice", Role: messaging.RoleUser, Text: text, SourceID: "tg-" + text, At: at(dur(i)), }); err != nil { t.Fatalf("SaveMessage: %v", err) } @@ -66,25 +68,25 @@ func TestBranchGivesInheritedMessagesTheirOwnIdentity(t *testing.T) { parentIDs := make(map[string]struct{}, len(parentMsgs)) for _, m := range parentMsgs { - parentIDs[m.MessageID] = struct{}{} + parentIDs[string(m.ID)] = struct{}{} } for _, m := range childMsgs { - if _, shared := parentIDs[m.MessageID]; shared { + if _, shared := parentIDs[string(m.ID)]; shared { t.Errorf("inherited %q kept the parent's MessageID %q: two sessions "+ - "now claim one canonical identity", m.Text, m.MessageID) + "now claim one canonical identity", m.Text, m.ID) } if m.SourceID == "" { t.Errorf("inherited %q lost its SourceID; upstream correlation is gone", m.Text) } - if want := CanonicalMessageID(childID, m.SourceID); m.MessageID != want { + if want := CanonicalMessageID(childID, m.SourceID); string(m.ID) != want { t.Errorf("inherited %q: MessageID = %q, want the child-scoped %q", - m.Text, m.MessageID, want) + m.Text, m.ID, want) } } // Dedup must work in the child on its own terms. - if err := store.SaveMessage(ctx, childID, Message{ - From: "alice", Text: "two", SourceID: "tg-two", At: at(dur(1)), + if err := store.SaveMessage(ctx, childID, messaging.Message{ + Sender: "alice", Role: messaging.RoleUser, Text: "two", SourceID: "tg-two", At: at(dur(1)), }); err != nil { t.Fatalf("redeliver into child: %v", err) } diff --git a/internal/gateway/chat_local.go b/internal/gateway/chat_local.go index 914b30d54..997b9c232 100644 --- a/internal/gateway/chat_local.go +++ b/internal/gateway/chat_local.go @@ -68,7 +68,18 @@ func (a *LocalChatAdapter) GetSession(ctx context.Context, id string) (SessionCo } func (a *LocalChatAdapter) RecentMessages(ctx context.Context, id string, n int) ([]Message, error) { - return a.Sessions.RecentMessages(ctx, id, n) + // The ChatContract still speaks the channel-facing Message (dashboard + // JSON, channel frontends); migrating those consumers is follow-up + // work (bd label messaging-migration). Convert at this boundary. + stored, err := a.Sessions.RecentMessages(ctx, id, n) + if err != nil { + return nil, err + } + out := make([]Message, 0, len(stored)) + for _, m := range stored { + out = append(out, FromStoredMessage(m)) + } + return out, nil } func (a *LocalChatAdapter) RecentTurns(ctx context.Context, id string, n int) ([]TurnRecord, error) { diff --git a/internal/gateway/compress_command_test.go b/internal/gateway/compress_command_test.go index f2ead6d88..390aa64cb 100644 --- a/internal/gateway/compress_command_test.go +++ b/internal/gateway/compress_command_test.go @@ -4,6 +4,8 @@ import ( "context" "strings" "testing" + + "github.com/samcharles93/archie-core/internal/domain/messaging" ) // /compress dispatch. Every case here is a command an operator can type, and @@ -140,8 +142,8 @@ func TestCompressPreviewReadsTheWholeHistory(t *testing.T) { // bulk of the tokens outside that window. seedForCompress(t, store, sessionID, 40) for i := range 250 { - if err := store.SaveMessage(ctx, sessionID, Message{ - From: "alice", Text: "tiny", SourceID: pad(i), At: at(dur(1000 + i)), + if err := store.SaveMessage(ctx, sessionID, messaging.Message{ + Sender: "alice", Role: messaging.RoleUser, Text: "tiny", SourceID: pad(i), At: at(dur(1000 + i)), }); err != nil { t.Fatalf("SaveMessage: %v", err) } diff --git a/internal/gateway/compress_concurrent_test.go b/internal/gateway/compress_concurrent_test.go index 800ec47d7..3455ed58e 100644 --- a/internal/gateway/compress_concurrent_test.go +++ b/internal/gateway/compress_concurrent_test.go @@ -3,6 +3,8 @@ package gateway import ( "context" "testing" + + "github.com/samcharles93/archie-core/internal/domain/messaging" ) // A chat turn that lands while a compression is being computed is not part of @@ -35,8 +37,9 @@ func TestCompressKeepsAMessageThatArrivesMidway(t *testing.T) { // history and before it writes the replacement. const lateText = "sent while the summary was being computed" store.afterRecent = func() { - if err := inner.SaveMessage(ctx, sessionID, Message{ - From: "alice", + if err := inner.SaveMessage(ctx, sessionID, messaging.Message{ + Sender: "alice", + Role: messaging.RoleUser, Text: lateText, SourceID: "tg-late", At: at(dur(9000)), @@ -72,7 +75,7 @@ type midCompressStore struct { afterRecent func() } -func (m *midCompressStore) RecentMessages(ctx context.Context, sessionID string, n int) ([]Message, error) { +func (m *midCompressStore) RecentMessages(ctx context.Context, sessionID string, n int) ([]messaging.Message, error) { out, err := m.SessionStore.RecentMessages(ctx, sessionID, n) if m.afterRecent != nil { fn := m.afterRecent diff --git a/internal/gateway/compress_identity_test.go b/internal/gateway/compress_identity_test.go index 8ddfab571..e3042bdd3 100644 --- a/internal/gateway/compress_identity_test.go +++ b/internal/gateway/compress_identity_test.go @@ -5,6 +5,8 @@ import ( "fmt" "strings" "testing" + + "github.com/samcharles93/archie-core/internal/domain/messaging" ) // compressBackends provides the persistent store used by compression tests. @@ -38,7 +40,7 @@ func routerOn(t *testing.T, store SessionStore, channelID string) (*Router, stri // seedForCompress fills a session with enough large messages to trip the // default threshold, each carrying an upstream SourceID as Telegram does. -func seedForCompress(t *testing.T, store SessionStore, sessionID string, n int) []Message { +func seedForCompress(t *testing.T, store SessionStore, sessionID string, n int) []messaging.Message { t.Helper() // Large enough that n messages exceed 50% of a 128k context window // (tokenEstimate is len/4, so n*bodyLen/4 must clear 64k). @@ -48,8 +50,9 @@ func seedForCompress(t *testing.T, store SessionStore, sessionID string, n int) } for i := range n { - m := Message{ - From: "alice", + m := messaging.Message{ + Sender: "alice", + Role: messaging.RoleUser, Text: fmt.Sprintf("m%d %s", i, body), SourceID: fmt.Sprintf("tg-%d", i), At: at(dur(i)), @@ -84,7 +87,7 @@ func TestCompressPreservesRetainedMessageIdentity(t *testing.T) { r, sessionID := routerOn(t, store, "chat-1") before := seedForCompress(t, store, sessionID, 40) - byText := make(map[string]Message, len(before)) + byText := make(map[string]messaging.Message, len(before)) for _, m := range before { byText[m.Text] = m } @@ -105,9 +108,9 @@ func TestCompressPreservesRetainedMessageIdentity(t *testing.T) { continue // the summary, which is legitimately new } retained++ - if m.MessageID != orig.MessageID { + if m.ID != orig.ID { t.Errorf("retained %q: MessageID = %q, want the original %q", - shortText(m.Text), m.MessageID, orig.MessageID) + shortText(m.Text), m.ID, orig.ID) } if m.SourceID != orig.SourceID { t.Errorf("retained %q: SourceID = %q, want the original %q", @@ -140,8 +143,8 @@ func TestCompressKeepsRedeliveryIdempotent(t *testing.T) { last := before[len(before)-1] // Redelivery is a no-op before compression. - if err := store.SaveMessage(ctx, sessionID, Message{ - From: last.From, Text: last.Text, SourceID: last.SourceID, At: last.At, + if err := store.SaveMessage(ctx, sessionID, messaging.Message{ + Sender: last.Sender, Role: last.Role, Text: last.Text, SourceID: last.SourceID, At: last.At, }); err != nil { t.Fatalf("redeliver before compress: %v", err) } @@ -162,8 +165,8 @@ func TestCompressKeepsRedeliveryIdempotent(t *testing.T) { } // The same redelivery must still be a no-op afterwards. - if err := store.SaveMessage(ctx, sessionID, Message{ - From: last.From, Text: last.Text, SourceID: last.SourceID, At: last.At, + if err := store.SaveMessage(ctx, sessionID, messaging.Message{ + Sender: last.Sender, Role: last.Role, Text: last.Text, SourceID: last.SourceID, At: last.At, }); err != nil { t.Fatalf("redeliver after compress: %v", err) } @@ -207,10 +210,13 @@ func TestCompressSummaryIsNotAttributedToTheUser(t *testing.T) { continue } found = true - if m.From != r.Identity { - t.Errorf("summary From = %q, want the bot identity %q: consumers "+ - "reconstruct the role by comparing From against the identity, so "+ - "any other value replays the summary as a user turn", m.From, r.Identity) + if m.Sender != r.Identity { + t.Errorf("summary Sender = %q, want the bot identity %q", m.Sender, r.Identity) + } + if m.Role != messaging.RoleAssistant { + t.Errorf("summary Role = %q, want assistant: consumers read the "+ + "record's role, so any other value replays the summary as a "+ + "user turn", m.Role) } } if !found { diff --git a/internal/gateway/compress_ordering_test.go b/internal/gateway/compress_ordering_test.go index 4e012c099..50145705e 100644 --- a/internal/gateway/compress_ordering_test.go +++ b/internal/gateway/compress_ordering_test.go @@ -4,6 +4,8 @@ import ( "context" "strings" "testing" + + "github.com/samcharles93/archie-core/internal/domain/messaging" ) // The summary stands in for the messages it replaced, so it belongs where @@ -71,21 +73,23 @@ func TestPriorReplyIgnoresACompressionSummary(t *testing.T) { ) marker := DefaultCompressionConfig().SummaryMarker - history := []Message{ + history := []messaging.Message{ { - MessageID: CanonicalMessageID(sessionID, "tg-unanswered"), - SourceID: "tg-unanswered", - From: "alice", - Text: "what is 2+2?", + ID: messaging.MessageID(CanonicalMessageID(sessionID, "tg-unanswered")), + SourceID: "tg-unanswered", + Sender: "alice", + Role: messaging.RoleUser, + Text: "what is 2+2?", }, { - MessageID: "summary-record", - From: identity, - Text: marker + "\n\n[36 messages removed (~9000 tokens)]", + ID: "summary-record", + Sender: identity, + Role: messaging.RoleAssistant, + Text: marker + "\n\n[36 messages removed (~9000 tokens)]", }, } - if got := PriorReply(history, sessionID, "tg-unanswered", identity); got != "" { + if got := PriorReply(history, sessionID, "tg-unanswered"); got != "" { t.Errorf("PriorReply = %q, want \"\": the question was never answered, "+ "so redelivering it must re-run the model rather than replay a "+ "compression banner as the answer", got) @@ -99,16 +103,17 @@ func TestPriorReplyStillMatchesARealReply(t *testing.T) { sessionID = "chat-1" identity = "archie" ) - history := []Message{ + history := []messaging.Message{ { - MessageID: CanonicalMessageID(sessionID, "tg-1"), - SourceID: "tg-1", - From: "alice", - Text: "ping", + ID: messaging.MessageID(CanonicalMessageID(sessionID, "tg-1")), + SourceID: "tg-1", + Sender: "alice", + Role: messaging.RoleUser, + Text: "ping", }, - {MessageID: "reply", From: identity, Text: "pong"}, + {ID: "reply", Sender: identity, Role: messaging.RoleAssistant, Text: "pong"}, } - if got := PriorReply(history, sessionID, "tg-1", identity); got != "pong" { + if got := PriorReply(history, sessionID, "tg-1"); got != "pong" { t.Errorf("PriorReply = %q, want %q", got, "pong") } } diff --git a/internal/gateway/messaging_convert.go b/internal/gateway/messaging_convert.go new file mode 100644 index 000000000..ed68f5fcb --- /dev/null +++ b/internal/gateway/messaging_convert.go @@ -0,0 +1,59 @@ +package gateway + +import ( + "github.com/samcharles93/archie-core/internal/domain/messaging" +) + +// This file is the single boundary between the gateway's channel-facing +// Message and the canonical messaging.Message persisted by the session +// store. +// +// CURRENT: gateway.Message is built by channel adapters (Telegram, email, +// webhook, web UI) and carries transport-only routing context (ChannelID, +// ThreadID, Page) alongside the persisted fields. SessionStore persists the +// stored subset; see scanMessages, which leaves the transport fields empty +// on read. +// +// TARGET (migration-decisions.md section 2): messaging.Message is the +// canonical persisted record. The store speaks it; channel adapters are +// migrated onto it one by one (bd label messaging-migration), after which +// gateway.Message is deleted. Until then, every conversion goes through +// these two functions -- no caller maps the fields by hand. +// +// Role derivation matches the comparisons this package already performs +// (compressTurnHistory, messagesToCompressed, PriorReply, and the +// sessioncurator adapter): a message sent by the session's bot identity is +// the assistant's, anything else is the user's. + +// ToStoredMessage converts a channel-facing message into its canonical +// stored form. botUser is the session's bot identity. The message's +// channel/thread address its conversation; Page is transport-only and does +// not enter the record. +func ToStoredMessage(msg Message, botUser string) messaging.Message { + role := messaging.RoleUser + if msg.From == botUser { + role = messaging.RoleAssistant + } + return messaging.Message{ + ID: messaging.MessageID(msg.MessageID), + ConversationID: messaging.ConversationID{ChannelID: msg.ChannelID, ThreadID: msg.ThreadID}, + SourceID: msg.SourceID, + Sender: msg.From, + Role: role, + Text: msg.Text, + At: msg.At, + } +} + +// FromStoredMessage converts a canonical stored record back to the gateway +// view. The result carries exactly the fields the store persists today: +// transport-only fields stay empty, as scanMessages leaves them. +func FromStoredMessage(stored messaging.Message) Message { + return Message{ + MessageID: string(stored.ID), + SourceID: stored.SourceID, + From: stored.Sender, + Text: stored.Text, + At: stored.At, + } +} diff --git a/internal/gateway/messaging_convert_test.go b/internal/gateway/messaging_convert_test.go new file mode 100644 index 000000000..e50aa88fc --- /dev/null +++ b/internal/gateway/messaging_convert_test.go @@ -0,0 +1,80 @@ +package gateway + +import ( + "testing" + "time" + + "github.com/samcharles93/archie-core/internal/domain/messaging" +) + +// TestStoredMessageRoundTrip pins the store boundary contract: converting a +// gateway message to its canonical stored form and back preserves every +// field the store persists today (identity, conversation address, source +// correlation, sender, role, text, timestamp). Page is transport-only and +// never enters the record. The gateway view back leaves ChannelID/ThreadID +// empty, exactly as scanMessages does today -- the conversation address +// lives on the stored record, repopulated from the session on read. +func TestStoredMessageRoundTrip(t *testing.T) { + at := time.Date(2026, 8, 3, 12, 0, 0, 0, time.UTC) + tests := []struct { + name string + msg Message + botUser string + want messaging.Message + }{ + { + name: "user message keeps sender and role", + msg: Message{MessageID: "m-1", SourceID: "tg-1", From: "alice", Text: "hello", At: at}, + botUser: "archie", + want: messaging.Message{ + ID: messaging.MessageID("m-1"), SourceID: "tg-1", + Role: messaging.RoleUser, Sender: "alice", Text: "hello", At: at, + }, + }, + { + name: "assistant message derives role from bot identity", + msg: Message{MessageID: "m-2", From: "archie", Text: "hi", At: at}, + botUser: "archie", + want: messaging.Message{ + ID: messaging.MessageID("m-2"), + Role: messaging.RoleAssistant, Sender: "archie", Text: "hi", At: at, + }, + }, + { + name: "empty sender stays user role", + msg: Message{MessageID: "m-3", Text: "anon", At: at}, + botUser: "archie", + want: messaging.Message{ + ID: messaging.MessageID("m-3"), + Role: messaging.RoleUser, Text: "anon", At: at, + }, + }, + { + name: "channel and thread address the conversation; page does not persist", + msg: Message{MessageID: "m-4", ChannelID: "chat-1", ThreadID: "t-1", Page: "/tasks", From: "alice", Text: "x", At: at}, + botUser: "archie", + want: messaging.Message{ + ID: messaging.MessageID("m-4"), + ConversationID: messaging.ConversationID{ChannelID: "chat-1", ThreadID: "t-1"}, + Role: messaging.RoleUser, Sender: "alice", Text: "x", At: at, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := ToStoredMessage(tt.msg, tt.botUser) + if got != tt.want { + t.Fatalf("ToStoredMessage() = %+v, want %+v", got, tt.want) + } + back := FromStoredMessage(got) + if back.MessageID != tt.msg.MessageID || back.SourceID != tt.msg.SourceID || + back.From != tt.msg.From || back.Text != tt.msg.Text || !back.At.Equal(tt.msg.At) { + t.Fatalf("FromStoredMessage() = %+v, want stored fields of %+v", back, tt.msg) + } + if back.ChannelID != "" || back.ThreadID != "" || back.Page != "" { + t.Fatalf("FromStoredMessage() carries transport fields: %+v", back) + } + }) + } +} diff --git a/internal/gateway/redelivery_test.go b/internal/gateway/redelivery_test.go index 662713477..9b1aba51e 100644 --- a/internal/gateway/redelivery_test.go +++ b/internal/gateway/redelivery_test.go @@ -5,6 +5,8 @@ import ( "time" "github.com/google/uuid" + + "github.com/samcharles93/archie-core/internal/domain/messaging" ) func TestPriorReplyRecognisesLegacyCanonicalMessageID(t *testing.T) { @@ -16,11 +18,11 @@ func TestPriorReplyRecognisesLegacyCanonicalMessageID(t *testing.T) { identity = "archie" ) legacyID := uuid.NewSHA1(messageIDNamespace, []byte(sessionID+"\x00"+sourceID)).String() - history := []Message{ - {MessageID: legacyID, SourceID: sourceID, From: "alice", Text: "question"}, - {From: identity, Text: "answer"}, + history := []messaging.Message{ + {ID: messaging.MessageID(legacyID), SourceID: sourceID, Sender: "alice", Role: messaging.RoleUser, Text: "question"}, + {Sender: identity, Role: messaging.RoleAssistant, Text: "answer"}, } - if got := PriorReply(history, sessionID, sourceID, identity); got != "answer" { + if got := PriorReply(history, sessionID, sourceID); got != "answer" { t.Fatalf("PriorReply = %q, want legacy reply", got) } } @@ -122,18 +124,19 @@ func TestPriorReply(t *testing.T) { for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { - history := make([]Message, 0, len(tc.history)) + history := make([]messaging.Message, 0, len(tc.history)) for i, h := range tc.history { - history = append(history, Message{ + m := ToStoredMessage(Message{ MessageID: newMessageIDFor(sessionID, h.sourceID, i), SourceID: h.sourceID, From: h.from, Text: h.text, At: time.Now().Add(time.Duration(i) * time.Second), - }) + }, identity) + history = append(history, m) } - got := PriorReply(history, sessionID, tc.sourceID, identity) + got := PriorReply(history, sessionID, tc.sourceID) if got != tc.want { t.Errorf("PriorReply = %q, want %q", got, tc.want) } diff --git a/internal/gateway/session_commands.go b/internal/gateway/session_commands.go index 2fa92ce83..d71703c90 100644 --- a/internal/gateway/session_commands.go +++ b/internal/gateway/session_commands.go @@ -10,6 +10,8 @@ import ( "time" "github.com/google/uuid" + + "github.com/samcharles93/archie-core/internal/domain/messaging" ) // sessionTracker maps (channelID, threadID) pairs to the currently active @@ -423,10 +425,11 @@ func (r *Router) handleRetry(ctx context.Context, msg Message) (string, error) { return "LLM is not configured. The last response has been removed; send another message to continue.", nil } // Replay the stored text, but route it with the live message's - // addressing. Stored history carries no channel or thread -- a session - // already is one -- so replaying the stored value verbatim would - // resolve to an empty session key and strand the reply. - lastUserMsg := msgs[0] + // addressing. The gateway view of stored history carries no channel + // or thread -- a session already is one -- so replaying the stored + // value verbatim would resolve to an empty session key and strand + // the reply. + lastUserMsg := FromStoredMessage(msgs[0]) lastUserMsg.ChannelID = msg.ChannelID lastUserMsg.ThreadID = msg.ThreadID reply, err := r.LLM(ctx, lastUserMsg) @@ -577,9 +580,9 @@ func (r *Router) handleBranch(ctx context.Context, msg Message, rest string) (st // branch-point correlation ambiguous. It also broke dedup in the // child: an inherited message carried an ID derived from the // parent's session, so redelivering it appended. - inherited := make([]Message, 0, len(msgs)) + inherited := make([]messaging.Message, 0, len(msgs)) for _, m := range msgs { - m.MessageID = "" + m.ID = "" inherited = append(inherited, m) } if err := r.sessionTracker.sessions.SaveMessages(ctx, id, inherited); err != nil { @@ -697,11 +700,11 @@ func (r *Router) compressPreview(ctx context.Context, sessionID string) (string, // replays its queue. Only the summary is a new record. // // The summary is attributed to the bot. CompressHistory emits it with role -// "system", which has no representation in the store -- consumers recover the -// role by comparing From against the bot identity -- and attributing a -// description of the conversation to the user makes the model replay it as -// something the human said. -func compressedHistory(original []Message, view CompressedView, identity string) []Message { +// "system", which has no representation in the store -- the summary is +// recorded as an assistant message instead -- and attributing a description +// of the conversation to the user makes the model replay it as something +// the human said. +func compressedHistory(original []messaging.Message, view CompressedView, identity string) []messaging.Message { summaryAt := view.SummaryIndex() if summaryAt < 0 { return original @@ -724,12 +727,13 @@ func compressedHistory(original []Message, view CompressedView, identity string) // reconstructed; leaving history untouched is the safe answer. return original } - out := make([]Message, 0, head+1+tail) + out := make([]messaging.Message, 0, head+1+tail) out = append(out, original[:head]...) - out = append(out, Message{ - From: identity, - Text: view.Messages[summaryAt].Content, - At: summaryInstant(original, head, tail), + out = append(out, messaging.Message{ + Sender: identity, + Role: messaging.RoleAssistant, + Text: view.Messages[summaryAt].Content, + At: summaryInstant(original, head, tail), }) out = append(out, original[len(original)-tail:]...) return out @@ -737,7 +741,7 @@ func compressedHistory(original []Message, view CompressedView, identity string) // summaryInstant returns a time inside the gap the summary fills: after the // last retained head message and before the first retained tail message. -func summaryInstant(original []Message, head, tail int) time.Time { +func summaryInstant(original []messaging.Message, head, tail int) time.Time { // The first message the summary replaces is the natural anchor -- the // summary begins where the summarised span began. if head < len(original)-tail { @@ -751,11 +755,11 @@ func summaryInstant(original []Message, head, tail int) time.Time { return time.Time{} } -func (r *Router) messagesToCompressed(msgs []Message) []CompressedMessage { +func (r *Router) messagesToCompressed(msgs []messaging.Message) []CompressedMessage { compressed := make([]CompressedMessage, 0, len(msgs)) for _, h := range msgs { role := "user" - if h.From == r.Identity { + if h.Role == messaging.RoleAssistant { role = "assistant" } compressed = append(compressed, CompressedMessage{ @@ -793,8 +797,8 @@ func (r *Router) applyCompress(ctx context.Context, sessionID string, cfg Compre // were -- that was unrecoverable loss of a message nobody had seen. superseded := make([]string, 0, len(msgs)) for _, m := range msgs { - if m.MessageID != "" { - superseded = append(superseded, m.MessageID) + if m.ID != "" { + superseded = append(superseded, string(m.ID)) } } diff --git a/internal/gateway/session_commands_test.go b/internal/gateway/session_commands_test.go index 1ed7a276e..fa9ca6b28 100644 --- a/internal/gateway/session_commands_test.go +++ b/internal/gateway/session_commands_test.go @@ -9,6 +9,8 @@ import ( "time" "github.com/google/uuid" + + "github.com/samcharles93/archie-core/internal/domain/messaging" ) // fakeSessionStore implements SessionStore for tests. Messages are @@ -16,13 +18,13 @@ import ( type fakeSessionStore struct { mu sync.Mutex sessions map[string]SessionContext - messages map[string][]Message // sessionID → messages + messages map[string][]messaging.Message // sessionID → messages } func newFakeSessionStore() *fakeSessionStore { return &fakeSessionStore{ sessions: make(map[string]SessionContext), - messages: make(map[string][]Message), + messages: make(map[string][]messaging.Message), } } @@ -87,14 +89,14 @@ func (f *fakeSessionStore) List(_ context.Context) ([]SessionContext, error) { func (f *fakeSessionStore) Close() error { return nil } -func (f *fakeSessionStore) SaveMessage(_ context.Context, sessionID string, msg Message) error { +func (f *fakeSessionStore) SaveMessage(_ context.Context, sessionID string, msg messaging.Message) error { f.mu.Lock() defer f.mu.Unlock() f.messages[sessionID] = append(f.messages[sessionID], msg) return nil } -func (f *fakeSessionStore) RecentMessages(_ context.Context, sessionID string, n int) ([]Message, error) { +func (f *fakeSessionStore) RecentMessages(_ context.Context, sessionID string, n int) ([]messaging.Message, error) { f.mu.Lock() defer f.mu.Unlock() msgs := f.messages[sessionID] @@ -102,7 +104,7 @@ func (f *fakeSessionStore) RecentMessages(_ context.Context, sessionID string, n return nil, nil } start := max(len(msgs)-n, 0) - out := make([]Message, len(msgs)-start) + out := make([]messaging.Message, len(msgs)-start) copy(out, msgs[start:]) return out, nil } @@ -125,11 +127,11 @@ func (f *fakeSessionStore) MessageCount(_ context.Context, sessionID string) (in return len(f.messages[sessionID]), nil } -func (f *fakeSessionStore) SaveMessages(_ context.Context, sessionID string, msgs []Message) error { +func (f *fakeSessionStore) SaveMessages(_ context.Context, sessionID string, msgs []messaging.Message) error { f.mu.Lock() defer f.mu.Unlock() existing := f.messages[sessionID] - out := make([]Message, len(existing)+len(msgs)) + out := make([]messaging.Message, len(existing)+len(msgs)) copy(out, existing) copy(out[len(existing):], msgs) f.messages[sessionID] = out @@ -142,7 +144,7 @@ func (f *fakeSessionStore) SaveMessages(_ context.Context, sessionID string, msg func (f *fakeSessionStore) ReplaceMessages( _ context.Context, sessionID string, - msgs []Message, + msgs []messaging.Message, superseded []string, ) error { f.mu.Lock() @@ -153,16 +155,16 @@ func (f *fakeSessionStore) ReplaceMessages( doomed[id] = struct{}{} } - kept := make([]Message, 0, len(f.messages[sessionID])+len(msgs)) + kept := make([]messaging.Message, 0, len(f.messages[sessionID])+len(msgs)) for _, m := range f.messages[sessionID] { - if _, gone := doomed[m.MessageID]; gone { + if _, gone := doomed[string(m.ID)]; gone { continue } kept = append(kept, m) } for _, m := range msgs { - if m.MessageID == "" { - m.MessageID = uuid.NewString() + if m.ID == "" { + m.ID = messaging.MessageID(uuid.NewString()) } kept = append(kept, m) } @@ -394,8 +396,8 @@ func TestRouteRetryRemovesLastMessage(t *testing.T) { CreatedAt: time.Now(), LastActiveAt: time.Now(), } _ = r.sessionTracker.sessions.Save(context.Background(), sc) - _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, Message{From: "alice", Text: "hello"}) - _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, Message{From: "archie", Text: "hi there"}) + _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, ToStoredMessage(Message{From: "alice", Text: "hello"}, "archie")) + _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, ToStoredMessage(Message{From: "archie", Text: "hi there"}, "archie")) r.sessionTracker.setActive("chat-9", "", sessionID) // Verify initial count. @@ -433,9 +435,9 @@ func TestRouteUndoRemovesOne(t *testing.T) { CreatedAt: time.Now(), LastActiveAt: time.Now(), } _ = r.sessionTracker.sessions.Save(context.Background(), sc) - _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, Message{From: "alice", Text: "msg1"}) - _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, Message{From: "archie", Text: "reply1"}) - _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, Message{From: "alice", Text: "msg2"}) + _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, ToStoredMessage(Message{From: "alice", Text: "msg1"}, "archie")) + _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, ToStoredMessage(Message{From: "archie", Text: "reply1"}, "archie")) + _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, ToStoredMessage(Message{From: "alice", Text: "msg2"}, "archie")) r.sessionTracker.setActive("chat-10", "", sessionID) reply, err := r.Route(context.Background(), Message{Text: "/undo", ChannelID: "chat-10"}) @@ -463,7 +465,7 @@ func TestRouteUndoRemovesMultiple(t *testing.T) { } _ = r.sessionTracker.sessions.Save(context.Background(), sc) for i := range 5 { - _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, Message{From: "alice", Text: fmt.Sprintf("msg%d", i)}) + _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, ToStoredMessage(Message{From: "alice", Text: fmt.Sprintf("msg%d", i)}, "archie")) } r.sessionTracker.setActive("chat-11", "", sessionID) @@ -494,9 +496,9 @@ func TestRouteUndoReportsActualPartialRemoval(t *testing.T) { t.Fatalf("Save session: %v", err) } for i := range 6 { - if err := r.sessionTracker.sessions.SaveMessage(ctx, sessionID, Message{ + if err := r.sessionTracker.sessions.SaveMessage(ctx, sessionID, ToStoredMessage(Message{ From: "alice", Text: fmt.Sprintf("msg%d", i), - }); err != nil { + }, "archie")); err != nil { t.Fatalf("SaveMessage(%d): %v", i, err) } } @@ -613,8 +615,8 @@ func TestRouteBranchCreatesChildSession(t *testing.T) { parentID := r.sessionTracker.getActive("chat-17", "") // Add messages to parent. - _ = r.sessionTracker.sessions.SaveMessage(context.Background(), parentID, Message{From: "alice", Text: "hello"}) - _ = r.sessionTracker.sessions.SaveMessage(context.Background(), parentID, Message{From: "archie", Text: "hi"}) + _ = r.sessionTracker.sessions.SaveMessage(context.Background(), parentID, ToStoredMessage(Message{From: "alice", Text: "hello"}, "archie")) + _ = r.sessionTracker.sessions.SaveMessage(context.Background(), parentID, ToStoredMessage(Message{From: "archie", Text: "hi"}, "archie")) // Branch. reply, err := r.Route(context.Background(), Message{Text: "/branch experiment", ChannelID: "chat-17"}) @@ -653,7 +655,7 @@ func TestRouteForkAlias(t *testing.T) { _, _ = r.Route(context.Background(), Message{Text: "/new parent", ChannelID: "chat-18"}) parentID := r.sessionTracker.getActive("chat-18", "") - _ = r.sessionTracker.sessions.SaveMessage(context.Background(), parentID, Message{From: "alice", Text: "msg"}) + _ = r.sessionTracker.sessions.SaveMessage(context.Background(), parentID, ToStoredMessage(Message{From: "alice", Text: "msg"}, "archie")) reply, err := r.Route(context.Background(), Message{Text: "/fork", ChannelID: "chat-18"}) if err != nil { @@ -674,7 +676,7 @@ func TestRouteCompressPreview(t *testing.T) { // Add a bunch of messages (not enough to trigger compression by default). for i := range 10 { - _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, Message{From: "alice", Text: fmt.Sprintf("message number %d", i)}) + _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, ToStoredMessage(Message{From: "alice", Text: fmt.Sprintf("message number %d", i)}, "archie")) } reply, err := r.Route(context.Background(), Message{Text: "/compress --preview", ChannelID: "chat-19"}) @@ -693,7 +695,7 @@ func TestRouteCompactAlias(t *testing.T) { sessionID := r.sessionTracker.getActive("chat-20", "") for i := range 5 { - _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, Message{From: "alice", Text: fmt.Sprintf("msg %d with some content to make it longer than a few chars", i)}) + _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, ToStoredMessage(Message{From: "alice", Text: fmt.Sprintf("msg %d with some content to make it longer than a few chars", i)}, "archie")) } reply, err := r.Route(context.Background(), Message{Text: "/compact --dry-run", ChannelID: "chat-20"}) diff --git a/internal/gateway/session_delete_test.go b/internal/gateway/session_delete_test.go index 6721be130..6bea2a7e0 100644 --- a/internal/gateway/session_delete_test.go +++ b/internal/gateway/session_delete_test.go @@ -171,7 +171,7 @@ func TestRouteDeleteRemovesSessionAndItsHistory(t *testing.T) { r, store := newDeleteRouter(t) id := seedSession(t, r, store, "abcd-123", "chan-1", "Work") for _, text := range []string{"first", "second"} { - if err := store.SaveMessage(context.Background(), id, Message{From: "sam", Text: text}); err != nil { + if err := store.SaveMessage(context.Background(), id, ToStoredMessage(Message{From: "sam", Text: text}, "archie")); err != nil { t.Fatalf("seed message: %v", err) } } diff --git a/internal/gateway/session_store.go b/internal/gateway/session_store.go index 791ab5b92..c7c356c27 100644 --- a/internal/gateway/session_store.go +++ b/internal/gateway/session_store.go @@ -7,10 +7,22 @@ import ( "time" "github.com/google/uuid" + + "github.com/samcharles93/archie-core/internal/domain/messaging" ) // SessionStore persists gateway session metadata and conversation history. // Each session tracks one platform, bot, and channel combination. +// +// Message history is stored and loaded as canonical messaging.Message +// records (archie-core-d9dv). Session lifecycle records stay SessionContext: +// a session's UUID key, platform/bot/title/branch metadata, and the fact +// that several sessions share one channel/thread have no lossless home in +// messaging.Conversation, whose composite identity is only +// {ChannelID, ThreadID} and whose canonical Agent/user/binding ownership is +// still open (see docs/architecture/migration-decisions.md section 2). +// Conversation-keying the sessions is tracked as follow-up work once that +// ownership settles. type SessionStore interface { SessionLifecycle MessageHistory @@ -32,21 +44,23 @@ type SessionLifecycle interface { List(ctx context.Context) ([]SessionContext, error) } -// MessageHistory manages conversation messages within a session. +// MessageHistory manages conversation messages within a session. Messages +// are canonical messaging.Message records; gateway callers convert at the +// boundary with ToStoredMessage/FromStoredMessage. type MessageHistory interface { // SaveMessage appends one message with a strictly increasing timestamp. - SaveMessage(ctx context.Context, sessionID string, msg Message) error + SaveMessage(ctx context.Context, sessionID string, msg messaging.Message) error // RecentMessages returns the most recent messages in chronological order. - RecentMessages(ctx context.Context, sessionID string, n int) ([]Message, error) + RecentMessages(ctx context.Context, sessionID string, n int) ([]messaging.Message, error) // DeleteRecentMessages removes up to n messages and returns the count. DeleteRecentMessages(ctx context.Context, sessionID string, n int) (deleted int, err error) // MessageCount returns the number of stored messages in a session. MessageCount(ctx context.Context, sessionID string) (int, error) // SaveMessages appends messages used to inherit branch history. - SaveMessages(ctx context.Context, sessionID string, msgs []Message) error + SaveMessages(ctx context.Context, sessionID string, msgs []messaging.Message) error // ReplaceMessages writes replacements before deleting superseded messages. // Records absent from both inputs remain untouched. - ReplaceMessages(ctx context.Context, sessionID string, msgs []Message, superseded []string) error + ReplaceMessages(ctx context.Context, sessionID string, msgs []messaging.Message, superseded []string) error // SearchMessages searches the session's full history. SearchMessages(ctx context.Context, sessionID string, q MessageQuery) (MessagePage, error) // Close releases the database. @@ -65,7 +79,7 @@ type MessageQuery struct { // MessagePage is one page of search results. type MessagePage struct { // Messages are ordered by relevance. - Messages []Message + Messages []messaging.Message // NextOffset is meaningful only when HasMore is true. NextOffset int HasMore bool @@ -131,7 +145,7 @@ func encodeCanonicalPair(first, second string) []byte { return encoded } -func stamp(msg Message) time.Time { +func stamp(msg messaging.Message) time.Time { now := time.Now().UTC() if msg.At.IsZero() || msg.At.After(now) { // At orders the canonical conversation; it is not an authoritative @@ -151,16 +165,19 @@ func CanonicalMessageID(sessionID, sourceID string) string { } // PriorReply returns the reply already produced for an upstream message. -func PriorReply(history []Message, sessionID, sourceID, identity string) string { +// The assistant check reads the record's Role: the stored Role is derived +// from the sender at the store boundary (see ToStoredMessage), so this +// needs no bot identity. +func PriorReply(history []messaging.Message, sessionID, sourceID string) string { if sourceID == "" { return "" } id, legacyID := canonicalMessageIDs(sessionID, sourceID) for i, message := range history { - if message.MessageID != id && message.MessageID != legacyID { + if string(message.ID) != id && string(message.ID) != legacyID { continue } - if i+1 < len(history) && history[i+1].From == identity && + if i+1 < len(history) && history[i+1].Role == messaging.RoleAssistant && !isCompressionSummary(history[i+1].Text) { return history[i+1].Text } diff --git a/internal/gateway/session_store_sqlite.go b/internal/gateway/session_store_sqlite.go index c7f0c8025..3a4a5dad8 100644 --- a/internal/gateway/session_store_sqlite.go +++ b/internal/gateway/session_store_sqlite.go @@ -13,6 +13,8 @@ import ( "time" _ "modernc.org/sqlite" + + "github.com/samcharles93/archie-core/internal/domain/messaging" ) // ── SQLite implementation ─────────────────────────────────────────────────── @@ -68,6 +70,7 @@ CREATE TABLE IF NOT EXISTS messages ( session_id TEXT NOT NULL, source_id TEXT NOT NULL DEFAULT '', sender TEXT NOT NULL DEFAULT '', + role TEXT NOT NULL DEFAULT '', text TEXT NOT NULL DEFAULT '', ts INTEGER NOT NULL, UNIQUE(session_id, message_id) @@ -162,6 +165,24 @@ func openSQLiteSessionStore(dsn string) (SessionStore, error) { !strings.Contains(err.Error(), "duplicate column name") { return nil, errors.Join(fmt.Errorf("sessionstore: migrate turns table: %w", err), db.Close()) } + // A database created before the messaging migration has a messages + // table without the role column; CREATE TABLE IF NOT EXISTS above + // leaves an existing table alone, so the column is added here, with + // the same duplicate-column detection as the turns migration. + if _, err := db.ExecContext(ctx, `ALTER TABLE messages ADD COLUMN role TEXT NOT NULL DEFAULT ''`); err != nil && + !strings.Contains(err.Error(), "duplicate column name") { + return nil, errors.Join(fmt.Errorf("sessionstore: migrate messages table: %w", err), db.Close()) + } + // Backfill the role for rows written before it was persisted, using + // the same sender-equality the store boundary applies to new writes: + // a message sent by its session's bot identity is the assistant's. + if _, err := db.ExecContext(ctx, ` + UPDATE messages SET role = CASE + WHEN sender = (SELECT bot_user FROM sessions WHERE sessions.session_id = messages.session_id) + THEN 'assistant' ELSE 'user' + END WHERE role = ''`); err != nil { + return nil, errors.Join(fmt.Errorf("sessionstore: backfill message roles: %w", err), db.Close()) + } if err := repairFutureMessageTimestamps(ctx, db, time.Now().UTC()); err != nil { return nil, errors.Join(err, db.Close()) } @@ -704,7 +725,7 @@ type execer interface { QueryRowContext(ctx context.Context, query string, args ...any) *sql.Row } -func (s *sqliteSessionStore) SaveMessage(ctx context.Context, sessionID string, msg Message) error { +func (s *sqliteSessionStore) SaveMessage(ctx context.Context, sessionID string, msg messaging.Message) error { s.mu.Lock() defer s.mu.Unlock() _, err := saveMessage(ctx, s.db, sessionID, msg) @@ -718,15 +739,15 @@ func (s *sqliteSessionStore) SaveMessage(ctx context.Context, sessionID string, // must not mint a new identity. An existing record with that ID is left // untouched: stored messages are immutable, so a redelivered edit is a // no-op rather than an overwrite. -func saveMessage(ctx context.Context, ex execer, sessionID string, msg Message) (string, error) { +func saveMessage(ctx context.Context, ex execer, sessionID string, msg messaging.Message) (string, error) { return saveMessageAt(ctx, ex, sessionID, msg, true) } // saveMessageAt writes a message, optionally without the monotonic clamp. // The clamp belongs to the append path, not to a caller rewriting history and // placing records deliberately. -func saveMessageAt(ctx context.Context, ex execer, sessionID string, msg Message, clamp bool) (string, error) { - id := msg.MessageID +func saveMessageAt(ctx context.Context, ex execer, sessionID string, msg messaging.Message, clamp bool) (string, error) { + id := string(msg.ID) legacyID := "" if msg.SourceID == "" { if id == "" { @@ -744,6 +765,13 @@ func saveMessageAt(ctx context.Context, ex execer, sessionID string, msg Message legacyID = compatibleLegacyID } } + // An empty Role means "user": the boundary derives assistant explicitly + // (see ToStoredMessage), and pre-migration rows are backfilled at open, + // so only a hand-built record arrives without one. + role := string(msg.Role) + if role == "" { + role = string(messaging.RoleUser) + } if legacyID != "" { var existingID string err := ex.QueryRowContext(ctx, @@ -759,8 +787,8 @@ func saveMessageAt(ctx context.Context, ex execer, sessionID string, msg Message at := stamp(msg) if clamp { _, err := ex.ExecContext(ctx, ` - INSERT INTO messages (message_id, session_id, source_id, sender, text, ts) - VALUES (?, ?, ?, ?, ?, ( + INSERT INTO messages (message_id, session_id, source_id, sender, role, text, ts) + VALUES (?, ?, ?, ?, ?, ?, ( SELECT CASE WHEN MAX(ts) IS NOT NULL AND MAX(ts) >= ? THEN MAX(ts) + 1 ELSE ? @@ -768,7 +796,7 @@ func saveMessageAt(ctx context.Context, ex execer, sessionID string, msg Message FROM messages WHERE session_id = ? )) ON CONFLICT(session_id, message_id) DO NOTHING`, - id, sessionID, msg.SourceID, msg.From, msg.Text, + id, sessionID, msg.SourceID, msg.Sender, role, msg.Text, at.UnixMilli(), at.UnixMilli(), sessionID) if err != nil { return "", fmt.Errorf("sessionstore: save message: %w", err) @@ -787,16 +815,16 @@ func saveMessageAt(ctx context.Context, ex execer, sessionID string, msg Message } _, err = ex.ExecContext(ctx, ` - INSERT INTO messages (message_id, session_id, source_id, sender, text, ts) - VALUES (?, ?, ?, ?, ?, ?)`, - id, sessionID, msg.SourceID, msg.From, msg.Text, at.UnixMilli()) + INSERT INTO messages (message_id, session_id, source_id, sender, role, text, ts) + VALUES (?, ?, ?, ?, ?, ?, ?)`, + id, sessionID, msg.SourceID, msg.Sender, role, msg.Text, at.UnixMilli()) if err != nil { return "", fmt.Errorf("sessionstore: save message: %w", err) } return id, nil } -func (s *sqliteSessionStore) SaveMessages(ctx context.Context, sessionID string, msgs []Message) error { +func (s *sqliteSessionStore) SaveMessages(ctx context.Context, sessionID string, msgs []messaging.Message) error { s.mu.Lock() defer s.mu.Unlock() @@ -833,7 +861,7 @@ func (s *sqliteSessionStore) SaveMessages(ctx context.Context, sessionID string, func (s *sqliteSessionStore) ReplaceMessages( ctx context.Context, sessionID string, - msgs []Message, + msgs []messaging.Message, superseded []string, ) error { s.mu.Lock() @@ -914,15 +942,21 @@ func (s *sqliteSessionStore) FindPriorReply(ctx context.Context, sessionID, sour return text, nil } -func (s *sqliteSessionStore) RecentMessages(ctx context.Context, sessionID string, n int) ([]Message, error) { +func (s *sqliteSessionStore) RecentMessages(ctx context.Context, sessionID string, n int) ([]messaging.Message, error) { if n <= 0 { return nil, nil } + // The conversation address is resolved from the owning session, not + // stored per message: a LEFT JOIN keeps orphaned rows readable exactly + // as before, with an empty address. rows, err := s.db.QueryContext(ctx, ` - SELECT message_id, source_id, sender, text, ts FROM ( - SELECT message_id, source_id, sender, text, ts FROM messages + SELECT m.message_id, m.source_id, m.sender, m.role, m.text, m.ts, + COALESCE(s.channel_id, ''), COALESCE(s.thread_id, '') + FROM ( + SELECT message_id, source_id, sender, role, text, ts, session_id FROM messages WHERE session_id = ? ORDER BY ts DESC LIMIT ? - ) ORDER BY ts ASC`, sessionID, n) + ) m LEFT JOIN sessions s ON s.session_id = m.session_id + ORDER BY m.ts ASC`, sessionID, n) if err != nil { return nil, fmt.Errorf("sessionstore: recent messages: %w", err) } @@ -960,17 +994,22 @@ func (s *sqliteSessionStore) MessageCount(ctx context.Context, sessionID string) return n, nil } -func scanMessages(rows *sql.Rows) ([]Message, error) { +func scanMessages(rows *sql.Rows) ([]messaging.Message, error) { defer func() { _ = rows.Close() }() - var out []Message + var out []messaging.Message for rows.Next() { var ( - msg Message - ts int64 + msg messaging.Message + id string + role string + ts int64 ) - if err := rows.Scan(&msg.MessageID, &msg.SourceID, &msg.From, &msg.Text, &ts); err != nil { + if err := rows.Scan(&id, &msg.SourceID, &msg.Sender, &role, &msg.Text, &ts, + &msg.ConversationID.ChannelID, &msg.ConversationID.ThreadID); err != nil { return nil, fmt.Errorf("sessionstore: scan message: %w", err) } + msg.ID = messaging.MessageID(id) + msg.Role = messaging.Role(role) msg.At = time.UnixMilli(ts).UTC() out = append(out, msg) } @@ -1021,9 +1060,11 @@ func (s *sqliteSessionStore) SearchMessages(ctx context.Context, sessionID strin } rows, err := s.db.QueryContext(ctx, ` - SELECT m.message_id, m.source_id, m.sender, m.text, m.ts + SELECT m.message_id, m.source_id, m.sender, m.role, m.text, m.ts, + COALESCE(s.channel_id, ''), COALESCE(s.thread_id, '') FROM messages_fts JOIN messages m ON m.id = messages_fts.rowid + LEFT JOIN sessions s ON s.session_id = m.session_id WHERE messages_fts MATCH ? AND m.session_id = ? ORDER BY bm25(messages_fts) ASC LIMIT ? OFFSET ?`, match, sessionID, limit, offset) @@ -1044,21 +1085,25 @@ func (s *sqliteSessionStore) SearchMessages(ctx context.Context, sessionID strin }, nil } -// scanSearchMessages scans rows shaped (message_id, source_id, sender, text, -// ts) -- the same column order SearchMessages selects, distinct from -// scanMessages' column order because the FTS join names "sender" rather -// than the "from" convention the rest of the file uses. -func scanSearchMessages(rows *sql.Rows) ([]Message, error) { +// scanSearchMessages scans rows shaped (message_id, source_id, sender, +// role, text, ts, channel_id, thread_id) -- the same column order +// SearchMessages selects. +func scanSearchMessages(rows *sql.Rows) ([]messaging.Message, error) { defer func() { _ = rows.Close() }() - var out []Message + var out []messaging.Message for rows.Next() { var ( - msg Message - ts int64 + msg messaging.Message + id string + role string + ts int64 ) - if err := rows.Scan(&msg.MessageID, &msg.SourceID, &msg.From, &msg.Text, &ts); err != nil { + if err := rows.Scan(&id, &msg.SourceID, &msg.Sender, &role, &msg.Text, &ts, + &msg.ConversationID.ChannelID, &msg.ConversationID.ThreadID); err != nil { return nil, fmt.Errorf("sessionstore: scan search result: %w", err) } + msg.ID = messaging.MessageID(id) + msg.Role = messaging.Role(role) msg.At = time.UnixMilli(ts).UTC() out = append(out, msg) } diff --git a/internal/gateway/session_store_sqlite_test.go b/internal/gateway/session_store_sqlite_test.go index 7c1910a85..96ae72cb9 100644 --- a/internal/gateway/session_store_sqlite_test.go +++ b/internal/gateway/session_store_sqlite_test.go @@ -11,6 +11,8 @@ import ( "time" "github.com/google/uuid" + + "github.com/samcharles93/archie-core/internal/domain/messaging" ) func newTestSQLiteStore(t *testing.T) SessionStore { @@ -247,9 +249,9 @@ func TestSQLiteSessionStoreRecognisesLegacyCanonicalIDOnRedelivery(t *testing.T) t.Fatalf("seed legacy message: %v", err) } - if err := store.SaveMessage(ctx, sessionID, Message{ - MessageID: CanonicalMessageID(sessionID, sourceID), - SourceID: sourceID, From: "alice", Text: "redelivered", + if err := store.SaveMessage(ctx, sessionID, messaging.Message{ + ID: messaging.MessageID(CanonicalMessageID(sessionID, sourceID)), + SourceID: sourceID, Sender: "alice", Role: messaging.RoleUser, Text: "redelivered", }); err != nil { t.Fatalf("SaveMessage(redelivery): %v", err) } @@ -260,7 +262,7 @@ func TestSQLiteSessionStoreRecognisesLegacyCanonicalIDOnRedelivery(t *testing.T) if len(messages) != 1 { t.Fatalf("redelivery produced %d messages, want 1", len(messages)) } - if messages[0].MessageID != legacyID || messages[0].Text != "original" { + if string(messages[0].ID) != legacyID || messages[0].Text != "original" { t.Fatalf("legacy message changed on redelivery: %#v", messages[0]) } } @@ -315,13 +317,13 @@ func TestSQLiteSessionStoreCapsFutureMessageTimestamp(t *testing.T) { store := newTestSQLiteStore(t) ctx := t.Context() now := time.Now().UTC() - if err := store.SaveMessage(ctx, "sess", Message{ - From: "alice", Text: "future", At: now.Add(24 * time.Hour), + if err := store.SaveMessage(ctx, "sess", messaging.Message{ + Sender: "alice", Role: messaging.RoleUser, Text: "future", At: now.Add(24 * time.Hour), }); err != nil { t.Fatalf("SaveMessage(future): %v", err) } - if err := store.SaveMessage(ctx, "sess", Message{ - From: "alice", Text: "current", At: now, + if err := store.SaveMessage(ctx, "sess", messaging.Message{ + Sender: "alice", Role: messaging.RoleUser, Text: "current", At: now, }); err != nil { t.Fatalf("SaveMessage(current): %v", err) } @@ -377,8 +379,8 @@ func TestSQLiteSessionStoreRepairsPersistedFutureTimestampsOnReopen(t *testing.T t.Fatalf("reopen store: %v", err) } t.Cleanup(func() { _ = reopened.Close() }) - if err := reopened.SaveMessage(ctx, "sess", Message{ - From: "alice", Text: "current", At: time.Now().UTC(), + if err := reopened.SaveMessage(ctx, "sess", messaging.Message{ + Sender: "alice", Role: messaging.RoleUser, Text: "current", At: time.Now().UTC(), }); err != nil { t.Fatalf("SaveMessage(current): %v", err) } @@ -406,7 +408,7 @@ func TestSQLiteSessionStoreRepairsPersistedFutureTimestampsOnReopen(t *testing.T func TestSQLiteMessageTimestampRoundTrips(t *testing.T) { st := newTestSQLiteStore(t) want := sqliteBase().Add(90*time.Minute + 123*time.Millisecond) - if err := st.SaveMessage(t.Context(), "sess", Message{From: "user", Text: "hello", At: want}); err != nil { + if err := st.SaveMessage(t.Context(), "sess", messaging.Message{Sender: "user", Role: messaging.RoleUser, Text: "hello", At: want}); err != nil { t.Fatal(err) } got, err := st.RecentMessages(t.Context(), "sess", 1) @@ -436,11 +438,11 @@ func TestSQLiteMessageTimestampsIncreaseAcrossStoreHandles(t *testing.T) { for storeIndex, st := range stores { for messageIndex := range perStore { wg.Go(func() { - err := st.SaveMessage(t.Context(), "sess", Message{ - MessageID: fmt.Sprintf("%d-%d", storeIndex, messageIndex), - From: "user", - Text: "concurrent", - At: wantTime, + err := st.SaveMessage(t.Context(), "sess", messaging.Message{ + ID: messaging.MessageID(fmt.Sprintf("%d-%d", storeIndex, messageIndex)), + Sender: "user", Role: messaging.RoleUser, + Text: "concurrent", + At: wantTime, }) if err != nil { t.Errorf("SaveMessage: %v", err) @@ -477,7 +479,7 @@ func TestSQLiteSessionStore_DeleteIsAtomic(t *testing.T) { if err := st.Save(ctx, sc); err != nil { t.Fatalf("Save: %v", err) } - if err := st.SaveMessage(ctx, "sess-del", Message{From: "u", Text: "hi", At: sqliteBase()}); err != nil { + if err := st.SaveMessage(ctx, "sess-del", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: "hi", At: sqliteBase()}); err != nil { t.Fatalf("SaveMessage: %v", err) } @@ -515,7 +517,7 @@ func TestSQLiteSessionStore_SearchPagingAndTruncated(t *testing.T) { const total = 30 for i := range total { - m := Message{From: "u", Text: "needle common", At: sqliteBase().Add(time.Duration(i) * time.Second)} + m := messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: "needle common", At: sqliteBase().Add(time.Duration(i) * time.Second)} if err := st.SaveMessage(ctx, "sess", m); err != nil { t.Fatalf("SaveMessage %d: %v", i, err) } @@ -533,10 +535,10 @@ func TestSQLiteSessionStore_SearchPagingAndTruncated(t *testing.T) { t.Errorf("expected Truncated=false for SQLite backend") } for _, m := range page.Messages { - if seen[m.MessageID] { - t.Errorf("duplicate message across pages: %s", m.MessageID) + if seen[string(m.ID)] { + t.Errorf("duplicate message across pages: %s", string(m.ID)) } - seen[m.MessageID] = true + seen[string(m.ID)] = true } pages++ if !page.HasMore { @@ -570,7 +572,7 @@ func TestSQLiteSessionStore_ErrorPaths(t *testing.T) { } }) t.Run("SaveMessage after close", func(t *testing.T) { - if err := st.SaveMessage(ctx, "sess", Message{From: "u", Text: "hi"}); err == nil { + if err := st.SaveMessage(ctx, "sess", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: "hi"}); err == nil { t.Error("expected error saving message to a closed store") } }) @@ -629,6 +631,65 @@ func TestOpenSQLiteSessionStore_CreatesFile(t *testing.T) { // tests. The store pins its pool to one connection and serializes writes // with its own mutex, so a test touching this handle between operations is // safe and deterministic. +// TestSQLiteSessionStore_MigratesPreRoleDatabase pins the upgrade path for +// databases written before the messaging migration added the role column: +// opening backfills roles from the sender-vs-bot identity the boundary +// applies to new writes, so old histories keep their assistant/user +// distinction and sender search keeps working. +func TestSQLiteSessionStore_MigratesPreRoleDatabase(t *testing.T) { + path := filepath.Join(t.TempDir(), "old.db") + db, err := sql.Open("sqlite", sqliteSessionDSN(path)) + if err != nil { + t.Fatalf("open raw db: %v", err) + } + oldMessages := strings.Replace(sqliteSessionSchema, + "\tsender TEXT NOT NULL DEFAULT '',\n\trole TEXT NOT NULL DEFAULT '',\n", + "\tsender TEXT NOT NULL DEFAULT '',\n", 1) + if _, err := db.Exec(oldMessages); err != nil { + t.Fatalf("create old schema: %v", err) + } + millis := sqliteBase().UnixMilli() + if _, err := db.Exec(`INSERT INTO sessions (session_id, platform, bot_user, channel_id, created_at, last_active_at) + VALUES ('sess-old', 'telegram', 'archie', 'chat-1', ?, ?)`, millis, millis); err != nil { + t.Fatalf("seed old session: %v", err) + } + if _, err := db.Exec(`INSERT INTO messages (message_id, session_id, source_id, sender, text, ts) VALUES + ('m-user', 'sess-old', 'tg-1', 'alice', 'hello', ?), + ('m-assistant', 'sess-old', '', 'archie', 'hi', ?)`, millis, millis+1); err != nil { + t.Fatalf("seed old messages: %v", err) + } + if err := db.Close(); err != nil { + t.Fatalf("close raw db: %v", err) + } + + st, err := OpenSQLiteSessionStore(path) + if err != nil { + t.Fatalf("reopen old database: %v", err) + } + t.Cleanup(func() { _ = st.Close() }) + + hist, err := st.RecentMessages(context.Background(), "sess-old", 10) + if err != nil { + t.Fatalf("RecentMessages: %v", err) + } + if len(hist) != 2 { + t.Fatalf("history = %d messages, want 2", len(hist)) + } + if hist[0].Role != messaging.RoleUser || hist[0].Sender != "alice" { + t.Errorf("user message = %+v, want role user from alice", hist[0]) + } + if hist[1].Role != messaging.RoleAssistant || hist[1].Sender != "archie" { + t.Errorf("assistant message = %+v, want role assistant from archie", hist[1]) + } + page, err := st.SearchMessages(context.Background(), "sess-old", MessageQuery{Query: "alice", Limit: 10}) + if err != nil { + t.Fatalf("SearchMessages: %v", err) + } + if len(page.Messages) != 1 { + t.Errorf("sender search = %d matches, want 1", len(page.Messages)) + } +} + func sqliteStoreDB(t *testing.T, st SessionStore) *sql.DB { t.Helper() s, ok := st.(*sqliteSessionStore) @@ -683,13 +744,13 @@ func TestSQLiteSessionStore_CloseReopenDurability(t *testing.T) { t.Fatalf("Save: %v", err) } - wantMsgs := []Message{ - {MessageID: "canonical-1", SourceID: "tg-1001", From: "alice", Text: "first durable message", At: sqliteBase().Add(time.Second)}, - {MessageID: "canonical-2", SourceID: "tg-1002", From: "bob", Text: "second durable message", At: sqliteBase().Add(2 * time.Second)}, + wantMsgs := []messaging.Message{ + {ID: "canonical-1", SourceID: "tg-1001", Sender: "alice", Role: messaging.RoleUser, Text: "first durable message", At: sqliteBase().Add(time.Second)}, + {ID: "canonical-2", SourceID: "tg-1002", Sender: "bob", Role: messaging.RoleUser, Text: "second durable message", At: sqliteBase().Add(2 * time.Second)}, } for _, m := range wantMsgs { if err := st.SaveMessage(ctx, "sess-durable", m); err != nil { - t.Fatalf("SaveMessage %q: %v", m.MessageID, err) + t.Fatalf("SaveMessage %q: %v", string(m.ID), err) } } if err := st.Close(); err != nil { @@ -722,8 +783,8 @@ func TestSQLiteSessionStore_CloseReopenDurability(t *testing.T) { } for i, m := range hist { want := wantMsgs[i] - if m.MessageID != want.MessageID || m.SourceID != want.SourceID || - m.From != want.From || m.Text != want.Text || !m.At.Equal(want.At) { + if m.ID != want.ID || m.SourceID != want.SourceID || + m.Sender != want.Sender || m.Role != want.Role || m.Text != want.Text || !m.At.Equal(want.At) { t.Errorf("message %d after reopen:\n got %+v\nwant %+v", i, m, want) } } @@ -764,10 +825,10 @@ func TestSQLiteSessionStore_DeleteAbortRollsBack(t *testing.T) { if err := st.Save(ctx, sc); err != nil { t.Fatalf("Save: %v", err) } - seed := []Message{ - {From: "alice", Text: "alpha", At: sqliteBase()}, - {From: "bob", Text: "beta", At: sqliteBase().Add(time.Second)}, - {From: "carol", Text: "gamma", At: sqliteBase().Add(2 * time.Second)}, + seed := []messaging.Message{ + {Sender: "alice", Role: messaging.RoleUser, Text: "alpha", At: sqliteBase()}, + {Sender: "bob", Role: messaging.RoleUser, Text: "beta", At: sqliteBase().Add(time.Second)}, + {Sender: "carol", Role: messaging.RoleUser, Text: "gamma", At: sqliteBase().Add(2 * time.Second)}, } for _, m := range seed { if err := st.SaveMessage(ctx, "sess-del-abort", m); err != nil { @@ -797,8 +858,8 @@ func TestSQLiteSessionStore_DeleteAbortRollsBack(t *testing.T) { t.Fatalf("history after failed Delete: got %d messages, want %d", len(hist), len(seed)) } for i, m := range hist { - if m.Text != seed[i].Text || m.From != seed[i].From { - t.Errorf("message %d after failed Delete: got %+v, want text %q from %q", i, m, seed[i].Text, seed[i].From) + if m.Text != seed[i].Text || m.Sender != seed[i].Sender { + t.Errorf("message %d after failed Delete: got %+v, want text %q from %q", i, m, seed[i].Text, seed[i].Sender) } } @@ -829,10 +890,10 @@ func TestSQLiteSessionStore_ReplaceMessagesAbortRollsBack(t *testing.T) { ctx := context.Background() st := newTestSQLiteStore(t) - seed := []Message{ - {MessageID: "m-0", SourceID: "s-0", From: "alice", Text: "alpha", At: sqliteBase()}, - {MessageID: "m-1", SourceID: "s-1", From: "bob", Text: "beta", At: sqliteBase().Add(time.Second)}, - {MessageID: "m-2", SourceID: "s-2", From: "carol", Text: "gamma", At: sqliteBase().Add(2 * time.Second)}, + seed := []messaging.Message{ + {ID: "m-0", SourceID: "s-0", Sender: "alice", Role: messaging.RoleUser, Text: "alpha", At: sqliteBase()}, + {ID: "m-1", SourceID: "s-1", Sender: "bob", Role: messaging.RoleUser, Text: "beta", At: sqliteBase().Add(time.Second)}, + {ID: "m-2", SourceID: "s-2", Sender: "carol", Role: messaging.RoleUser, Text: "gamma", At: sqliteBase().Add(2 * time.Second)}, } if err := st.SaveMessages(ctx, "sess-replace-abort", seed); err != nil { t.Fatalf("SaveMessages: %v", err) @@ -842,7 +903,7 @@ func TestSQLiteSessionStore_ReplaceMessagesAbortRollsBack(t *testing.T) { // inserts have landed inside the transaction. installAbortTrigger(t, st, `BEFORE DELETE ON messages WHEN old.message_id = 'm-1'`) - replacement := []Message{{From: "summarizer", Text: "merged summary", At: sqliteBase().Add(time.Hour)}} + replacement := []messaging.Message{{Sender: "summarizer", Role: messaging.RoleUser, Text: "merged summary", At: sqliteBase().Add(time.Hour)}} if err := st.ReplaceMessages(ctx, "sess-replace-abort", replacement, supersededIDs(ctx, t, st, "sess-replace-abort")); err == nil { t.Fatal("expected ReplaceMessages to fail from the forced abort trigger") } @@ -855,7 +916,7 @@ func TestSQLiteSessionStore_ReplaceMessagesAbortRollsBack(t *testing.T) { t.Fatalf("history after failed ReplaceMessages: got %d messages, want %d", len(hist), len(seed)) } for i, m := range hist { - if m.MessageID != seed[i].MessageID || m.Text != seed[i].Text || m.From != seed[i].From { + if string(m.ID) != string(seed[i].ID) || m.Text != seed[i].Text || m.Sender != seed[i].Sender { t.Errorf("message %d after failed ReplaceMessages: got %+v, want %+v", i, m, seed[i]) } } @@ -968,8 +1029,8 @@ func TestSQLiteSessionStore_FTSStaysCorrectThroughMutations(t *testing.T) { { name: "ReplaceMessages swaps the document set", mutate: func(ctx context.Context, t *testing.T, st SessionStore) error { - return st.ReplaceMessages(ctx, "a", []Message{{ - From: "summarizer", Text: "merged needle summary", At: sqliteBase().Add(time.Hour), + return st.ReplaceMessages(ctx, "a", []messaging.Message{{ + Sender: "summarizer", Role: messaging.RoleUser, Text: "merged needle summary", At: sqliteBase().Add(time.Hour), }}, supersededIDs(ctx, t, st, "a")) }, wantA: []string{"merged needle summary"}, @@ -1001,12 +1062,12 @@ func TestSQLiteSessionStore_FTSStaysCorrectThroughMutations(t *testing.T) { st := newTestSQLiteStore(t) for i, text := range seedA { - if err := st.SaveMessage(ctx, "a", Message{From: "u", Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil { + if err := st.SaveMessage(ctx, "a", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil { t.Fatalf("SaveMessage a %q: %v", text, err) } } for i, text := range seedB { - if err := st.SaveMessage(ctx, "b", Message{From: "u", Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil { + if err := st.SaveMessage(ctx, "b", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil { t.Fatalf("SaveMessage b %q: %v", text, err) } } @@ -1086,7 +1147,7 @@ func TestSQLiteSessionStore_FTSIntegrityCheckDetectsOrphanedIndex(t *testing.T) st := newTestSQLiteStore(t) for i, text := range []string{"needle one", "needle two"} { - if err := st.SaveMessage(ctx, "sess", Message{From: "u", Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil { + if err := st.SaveMessage(ctx, "sess", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil { t.Fatalf("SaveMessage: %v", err) } } @@ -1110,7 +1171,7 @@ func TestSQLiteSessionStore_FTSIntegrityCheckDetectsOrphanedIndex(t *testing.T) st := newTestSQLiteStore(t) for i, text := range []string{"needle one", "needle two"} { - if err := st.SaveMessage(ctx, "sess", Message{From: "u", Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil { + if err := st.SaveMessage(ctx, "sess", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil { t.Fatalf("SaveMessage: %v", err) } } @@ -1149,7 +1210,7 @@ func TestSQLiteSessionStore_HostileQueriesAreLiteral(t *testing.T) { "beta alone", } for i, text := range seed { - if err := st.SaveMessage(ctx, "sess", Message{From: "u", Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil { + if err := st.SaveMessage(ctx, "sess", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil { t.Fatalf("SaveMessage %q: %v", text, err) } } diff --git a/internal/gateway/session_titles_test.go b/internal/gateway/session_titles_test.go index 809fdb317..fe5da410a 100644 --- a/internal/gateway/session_titles_test.go +++ b/internal/gateway/session_titles_test.go @@ -400,10 +400,10 @@ func TestRetryAutoTitlesUntitledSession(t *testing.T) { t.Fatalf("resolve: %v", err) } gen.titles[sessionID] = "Deploy worker" - if err := store.SaveMessage(ctx, sessionID, Message{From: "u", Text: "deploy the worker"}); err != nil { + if err := store.SaveMessage(ctx, sessionID, ToStoredMessage(Message{From: "u", Text: "deploy the worker"}, "archie")); err != nil { t.Fatalf("save user message: %v", err) } - if err := store.SaveMessage(ctx, sessionID, Message{From: "bot", Text: "sure"}); err != nil { + if err := store.SaveMessage(ctx, sessionID, ToStoredMessage(Message{From: "bot", Text: "sure"}, "archie")); err != nil { t.Fatalf("save reply: %v", err) } if _, err := r.Route(ctx, Message{ChannelID: "ch", From: "u", Text: "/retry"}); err != nil { diff --git a/internal/gateway/sessionstore_conformance_test.go b/internal/gateway/sessionstore_conformance_test.go index f9857c820..bc3227eec 100644 --- a/internal/gateway/sessionstore_conformance_test.go +++ b/internal/gateway/sessionstore_conformance_test.go @@ -5,6 +5,8 @@ import ( "fmt" "testing" "time" + + "github.com/samcharles93/archie-core/internal/domain/messaging" ) // base is a fixed instant so message timestamps are deterministic; tests @@ -16,11 +18,11 @@ func at(offset time.Duration) time.Time { return base.Add(offset) } // dur spaces the nth message one second apart from the first. func dur(n int) time.Duration { return time.Duration(n) * time.Second } -func msg(text string, offset time.Duration) Message { - return Message{From: "user", Text: text, At: at(offset)} +func msg(text string, offset time.Duration) messaging.Message { + return messaging.Message{Sender: "user", Role: messaging.RoleUser, Text: text, At: at(offset)} } -func texts(msgs []Message) []string { +func texts(msgs []messaging.Message) []string { out := make([]string, 0, len(msgs)) for _, m := range msgs { out = append(out, m.Text) @@ -57,7 +59,7 @@ func supersededIDs(ctx context.Context, t *testing.T, s SessionStore, sessionID } ids := make([]string, 0, len(msgs)) for _, m := range msgs { - ids = append(ids, m.MessageID) + ids = append(ids, string(m.ID)) } return ids } @@ -352,7 +354,7 @@ func testSaveMessagesAppends(t *testing.T, newStore func(t *testing.T) SessionSt offset += time.Second } - bulk := make([]Message, 0, len(tc.bulk)) + bulk := make([]messaging.Message, 0, len(tc.bulk)) for _, text := range tc.bulk { bulk = append(bulk, msg(text, offset)) offset += time.Second @@ -479,11 +481,11 @@ func testReplyCannotPrecedeItsPrompt(t *testing.T, newStore func(t *testing.T) S s := newStore(t) t.Cleanup(func() { _ = s.Close() }) - reply := Message{From: "bot", Text: "reply", At: base.Add(10*time.Second + 400*time.Millisecond)} + reply := messaging.Message{Sender: "bot", Role: messaging.RoleAssistant, Text: "reply", At: base.Add(10*time.Second + 400*time.Millisecond)} if err := s.SaveMessage(ctx, "sess", reply); err != nil { t.Fatalf("SaveMessage reply: %v", err) } - next := Message{SourceID: "tg-1", From: "user", Text: "next", At: base.Add(10 * time.Second)} + next := messaging.Message{SourceID: "tg-1", Sender: "user", Role: messaging.RoleUser, Text: "next", At: base.Add(10 * time.Second)} if err := s.SaveMessage(ctx, "sess", next); err != nil { t.Fatalf("SaveMessage next: %v", err) } @@ -504,7 +506,7 @@ func testUpstreamRedeliveryKeepsOriginalTime(t *testing.T, newStore func(t *test s := newStore(t) t.Cleanup(func() { _ = s.Close() }) - first := Message{SourceID: "tg-1", From: "u", Text: "first", At: base} + first := messaging.Message{SourceID: "tg-1", Sender: "u", Role: messaging.RoleUser, Text: "first", At: base} if err := s.SaveMessage(ctx, "sess", first); err != nil { t.Fatalf("SaveMessage: %v", err) } @@ -543,7 +545,7 @@ func testSaveMessageStampsMissingTimestamp(t *testing.T, newStore func(t *testin t.Cleanup(func() { _ = s.Close() }) before := time.Now().UTC().Add(-time.Second) - if err := s.SaveMessage(ctx, "sess", Message{From: "u", Text: "no timestamp"}); err != nil { + if err := s.SaveMessage(ctx, "sess", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: "no timestamp"}); err != nil { t.Fatalf("SaveMessage: %v", err) } after := time.Now().UTC().Add(time.Second) @@ -569,7 +571,7 @@ func testCanonicalMessageIDIsStable(t *testing.T, newStore func(t *testing.T) Se t.Cleanup(func() { _ = s.Close() }) const sourceID = "tg-42" - if err := s.SaveMessage(ctx, "sess", Message{SourceID: sourceID, From: "u", Text: "hi", At: base}); err != nil { + if err := s.SaveMessage(ctx, "sess", messaging.Message{SourceID: sourceID, Sender: "u", Role: messaging.RoleUser, Text: "hi", At: base}); err != nil { t.Fatalf("SaveMessage: %v", err) } first, err := s.RecentMessages(ctx, "sess", 1) @@ -579,14 +581,14 @@ func testCanonicalMessageIDIsStable(t *testing.T, newStore func(t *testing.T) Se if len(first) != 1 { t.Fatalf("got %d messages, want 1", len(first)) } - if first[0].MessageID == "" { + if string(first[0].ID) == "" { t.Fatal("MessageID is empty; reads must carry a canonical ID") } - if first[0].MessageID == sourceID { + if string(first[0].ID) == sourceID { t.Errorf("MessageID = %q, which is the platform identifier; it must be application-generated", sourceID) } - if err := s.SaveMessage(ctx, "sess", Message{SourceID: sourceID, From: "u", Text: "hi", At: base}); err != nil { + if err := s.SaveMessage(ctx, "sess", messaging.Message{SourceID: sourceID, Sender: "u", Role: messaging.RoleUser, Text: "hi", At: base}); err != nil { t.Fatalf("redeliver: %v", err) } again, err := s.RecentMessages(ctx, "sess", 10) @@ -596,8 +598,8 @@ func testCanonicalMessageIDIsStable(t *testing.T, newStore func(t *testing.T) Se if len(again) != 1 { t.Fatalf("redelivery produced %d messages, want 1", len(again)) } - if again[0].MessageID != first[0].MessageID { - t.Errorf("MessageID changed from %q to %q across redelivery", first[0].MessageID, again[0].MessageID) + if string(again[0].ID) != string(first[0].ID) { + t.Errorf("MessageID changed from %q to %q across redelivery", string(first[0].ID), string(again[0].ID)) } } @@ -613,7 +615,7 @@ func testSourceIDRoundTrips(t *testing.T, newStore func(t *testing.T) SessionSto t.Cleanup(func() { _ = s.Close() }) const sourceID = "tg-777" - if err := s.SaveMessage(ctx, "sess", Message{SourceID: sourceID, From: "u", Text: "hi", At: base}); err != nil { + if err := s.SaveMessage(ctx, "sess", messaging.Message{SourceID: sourceID, Sender: "u", Role: messaging.RoleUser, Text: "hi", At: base}); err != nil { t.Fatalf("SaveMessage: %v", err) } @@ -627,16 +629,16 @@ func testSourceIDRoundTrips(t *testing.T, newStore func(t *testing.T) SessionSto if first[0].SourceID != sourceID { t.Errorf("SourceID = %q after save, want %q", first[0].SourceID, sourceID) } - if first[0].MessageID == "" { + if string(first[0].ID) == "" { t.Fatal("MessageID is empty; reads must carry a canonical ID") } - if first[0].MessageID == sourceID { - t.Errorf("MessageID = %q equals SourceID; the canonical ID must be application-generated", first[0].MessageID) + if string(first[0].ID) == sourceID { + t.Errorf("MessageID = %q equals SourceID; the canonical ID must be application-generated", string(first[0].ID)) } // Redelivery of the same upstream message must keep its SourceID and // canonical identity and must not append a second turn. - if err := s.SaveMessage(ctx, "sess", Message{SourceID: sourceID, From: "u", Text: "hi", At: base}); err != nil { + if err := s.SaveMessage(ctx, "sess", messaging.Message{SourceID: sourceID, Sender: "u", Role: messaging.RoleUser, Text: "hi", At: base}); err != nil { t.Fatalf("redeliver: %v", err) } again, err := s.RecentMessages(ctx, "sess", 10) @@ -649,14 +651,14 @@ func testSourceIDRoundTrips(t *testing.T, newStore func(t *testing.T) SessionSto if again[0].SourceID != sourceID { t.Errorf("SourceID = %q after redelivery, want %q", again[0].SourceID, sourceID) } - if again[0].MessageID != first[0].MessageID { - t.Errorf("MessageID changed from %q to %q across redelivery", first[0].MessageID, again[0].MessageID) + if string(again[0].ID) != string(first[0].ID) { + t.Errorf("MessageID changed from %q to %q across redelivery", string(first[0].ID), string(again[0].ID)) } // A message with no upstream identity -- the shape of a document written // before source_id was persisted -- must read back with an empty // SourceID, not a zero-value artifact or an error. - if err := s.SaveMessage(ctx, "sess", Message{From: "u", Text: "local", At: at(time.Second)}); err != nil { + if err := s.SaveMessage(ctx, "sess", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: "local", At: at(time.Second)}); err != nil { t.Fatalf("SaveMessage without SourceID: %v", err) } got, err := s.RecentMessages(ctx, "sess", 10) @@ -690,7 +692,7 @@ func testSourceIDIsNotSearchable(t *testing.T, newStore func(t *testing.T) Sessi s := newStore(t) t.Cleanup(func() { _ = s.Close() }) - m := Message{SourceID: tc.sourceID, From: "u", Text: "hello world", At: base} + m := messaging.Message{SourceID: tc.sourceID, Sender: "u", Role: messaging.RoleUser, Text: "hello world", At: base} if err := s.SaveMessage(ctx, "sess", m); err != nil { t.Fatalf("SaveMessage: %v", err) } @@ -727,38 +729,38 @@ func testSourceIDIsNotSearchable(t *testing.T, newStore func(t *testing.T) Sessi func testMessageDeduplication(t *testing.T, newStore func(t *testing.T) SessionStore) { tests := []struct { name string - saves []Message + saves []messaging.Message want []string }{ { name: "same upstream ID saved twice", - saves: []Message{ - {SourceID: "tg-100", From: "u", Text: "hello", At: at(0)}, - {SourceID: "tg-100", From: "u", Text: "hello", At: at(0)}, + saves: []messaging.Message{ + {SourceID: "tg-100", Sender: "u", Role: messaging.RoleUser, Text: "hello", At: at(0)}, + {SourceID: "tg-100", Sender: "u", Role: messaging.RoleUser, Text: "hello", At: at(0)}, }, want: []string{"hello"}, }, { name: "distinct upstream IDs both persist", - saves: []Message{ - {SourceID: "tg-100", From: "u", Text: "first", At: at(0)}, - {SourceID: "tg-101", From: "u", Text: "second", At: at(dur(1))}, + saves: []messaging.Message{ + {SourceID: "tg-100", Sender: "u", Role: messaging.RoleUser, Text: "first", At: at(0)}, + {SourceID: "tg-101", Sender: "u", Role: messaging.RoleUser, Text: "second", At: at(dur(1))}, }, want: []string{"first", "second"}, }, { name: "redelivery with edited text leaves the record intact", - saves: []Message{ - {SourceID: "tg-100", From: "u", Text: "original", At: at(0)}, - {SourceID: "tg-100", From: "u", Text: "edited", At: at(0)}, + saves: []messaging.Message{ + {SourceID: "tg-100", Sender: "u", Role: messaging.RoleUser, Text: "original", At: at(0)}, + {SourceID: "tg-100", Sender: "u", Role: messaging.RoleUser, Text: "edited", At: at(0)}, }, want: []string{"original"}, }, { name: "messages without an upstream ID are never deduplicated", - saves: []Message{ - {From: "u", Text: "same", At: at(0)}, - {From: "u", Text: "same", At: at(0)}, + saves: []messaging.Message{ + {Sender: "u", Role: messaging.RoleUser, Text: "same", At: at(0)}, + {Sender: "u", Role: messaging.RoleUser, Text: "same", At: at(0)}, }, want: []string{"same", "same"}, }, @@ -813,7 +815,7 @@ func testReplaceMessagesIsFailureSafe(t *testing.T, newStore func(t *testing.T) } } - replacement := make([]Message, 0, len(tc.replacement)) + replacement := make([]messaging.Message, 0, len(tc.replacement)) for i, text := range tc.replacement { replacement = append(replacement, msg(text, dur(len(tc.existing)+i))) } @@ -852,7 +854,7 @@ func testReplaceMessagesBeyondScanPageLimit(t *testing.T, newStore func(t *testi t.Fatalf("SaveMessage: %v", err) } } - if err := s.ReplaceMessages(ctx, "sess", []Message{msg("summary", dur(total))}, supersededIDs(ctx, t, s, "sess")); err != nil { + if err := s.ReplaceMessages(ctx, "sess", []messaging.Message{msg("summary", dur(total))}, supersededIDs(ctx, t, s, "sess")); err != nil { t.Fatalf("ReplaceMessages: %v", err) } got, err := s.RecentMessages(ctx, "sess", 100) @@ -873,7 +875,7 @@ func testReplaceMessagesKeepsSurvivors(t *testing.T, newStore func(t *testing.T) t.Cleanup(func() { _ = s.Close() }) for i, text := range []string{"keep-a", "keep-b", "drop"} { - m := Message{SourceID: "tg-" + text, From: "u", Text: text, At: at(dur(i))} + m := messaging.Message{SourceID: "tg-" + text, Sender: "u", Role: messaging.RoleUser, Text: text, At: at(dur(i))} if err := s.SaveMessage(ctx, "sess", m); err != nil { t.Fatalf("SaveMessage: %v", err) } @@ -1148,13 +1150,20 @@ func testSearchMatchesTextNotMetadata(t *testing.T, newStore func(t *testing.T) s := newStore(t) t.Cleanup(func() { _ = s.Close() }) - if err := s.SaveMessage(ctx, "sess", Message{ - From: "alice", Text: "hello world", ChannelID: "chan-xyz", ThreadID: "thread-xyz", At: base, + // The conversation address rides the record but is resolved + // from the owning session on read, never indexed: queries for + // channel fragments must not match. + if err := s.SaveMessage(ctx, "sess", messaging.Message{ + Sender: "alice", Role: messaging.RoleUser, Text: "hello world", + ConversationID: messaging.ConversationID{ChannelID: "chan-xyz", ThreadID: "thread-xyz"}, + At: base, }); err != nil { t.Fatalf("SaveMessage: %v", err) } - if err := s.SaveMessage(ctx, "sess", Message{ - From: "bob", Text: "goodbye", ChannelID: "chan-xyz", ThreadID: "thread-xyz", At: at(time.Second), + if err := s.SaveMessage(ctx, "sess", messaging.Message{ + Sender: "bob", Role: messaging.RoleUser, Text: "goodbye", + ConversationID: messaging.ConversationID{ChannelID: "chan-xyz", ThreadID: "thread-xyz"}, + At: at(time.Second), }); err != nil { t.Fatalf("SaveMessage: %v", err) } diff --git a/internal/gateway/turn.go b/internal/gateway/turn.go index 22f5176d6..6b017d438 100644 --- a/internal/gateway/turn.go +++ b/internal/gateway/turn.go @@ -8,6 +8,7 @@ import ( "sync" "time" + "github.com/samcharles93/archie-core/internal/domain/messaging" "github.com/samcharles93/archie-core/internal/events" "github.com/samcharles93/archie-core/internal/tools" ) @@ -180,9 +181,9 @@ func (r *TurnRunner) checkConfigured() error { // (text, err); done is false when there is no prior reply to replay and // Run should continue generating one. func (r *TurnRunner) replayPriorReply( - ctx context.Context, turn TurnRecord, sessionID string, msg Message, history []Message, stream TurnStream, + ctx context.Context, turn TurnRecord, sessionID string, msg Message, history []messaging.Message, stream TurnStream, ) (string, bool, error) { - prior := PriorReply(history, sessionID, msg.SourceID, r.BotUser) + prior := PriorReply(history, sessionID, msg.SourceID) if prior == "" && msg.SourceID != "" { if replayStore, ok := r.Sessions.(TurnReplayStore); ok { var err error @@ -249,11 +250,12 @@ func (r *TurnRunner) claimTurn( // the turn's input on first sight, and folds it into history if it is not // already present there. func (r *TurnRunner) recordInboundMessage( - ctx context.Context, turn *TurnRecord, sessionID string, msg Message, history []Message, -) (Message, []Message, error) { + ctx context.Context, turn *TurnRecord, sessionID string, msg Message, history []messaging.Message, +) (Message, []messaging.Message, error) { msg.MessageID = messageIDForTurn(sessionID, msg) + stored := ToStoredMessage(msg, r.BotUser) if turn.InputMessageID == "" { - if err := r.Sessions.SaveMessage(ctx, sessionID, msg); err != nil { + if err := r.Sessions.SaveMessage(ctx, sessionID, stored); err != nil { return msg, history, fmt.Errorf("save inbound chat message: %w", err) } turn.InputMessageID = msg.MessageID @@ -263,9 +265,10 @@ func (r *TurnRunner) recordInboundMessage( } } else { msg.MessageID = turn.InputMessageID + stored.ID = messaging.MessageID(turn.InputMessageID) } if !messageInHistory(history, msg.SourceID) { - history = append(history, msg) + history = append(history, stored) } return msg, history, nil } @@ -282,8 +285,8 @@ type preparedTurn struct { // prepareTurn builds the tools, system prompt, and compressed history view // for one turn's generation call. -func (r *TurnRunner) prepareTurn(ctx context.Context, sessionID string, msg Message, history []Message) (preparedTurn, error) { - compressed := compressTurnHistory(history, r.BotUser) +func (r *TurnRunner) prepareTurn(ctx context.Context, sessionID string, msg Message, history []messaging.Message) (preparedTurn, error) { + compressed := compressTurnHistory(history) extraTools := append( TaskTools(r.TaskLister, r.Tasks, r.TaskLogs, r.TaskActor, r.TaskIdentity), SessionTools(r.Sessions, r.Router.SessionTracker(), r.Channel, msg)..., @@ -412,7 +415,7 @@ func (r *TurnRunner) generateAndComplete( return "", r.failTurn(ctx, turn, err) } assistant := Message{MessageID: assistantMessageIDForTurn(turn.TurnID), From: r.BotUser, Text: text} - if err := r.Sessions.SaveMessage(ctx, sessionID, assistant); err != nil { + if err := r.Sessions.SaveMessage(ctx, sessionID, ToStoredMessage(assistant, r.BotUser)); err != nil { return "", r.failTurn(ctx, turn, fmt.Errorf("save outbound chat message: %w", err)) } turn.Status = TurnStatusCompleted @@ -499,7 +502,7 @@ func messageIDForTurn(sessionID string, msg Message) string { return NewTurnID() } -func messageInHistory(history []Message, sourceID string) bool { +func messageInHistory(history []messaging.Message, sourceID string) bool { if sourceID == "" { return false } @@ -511,11 +514,14 @@ func messageInHistory(history []Message, sourceID string) bool { return false } -func compressTurnHistory(history []Message, botUser string) []CompressedMessage { +// compressTurnHistory renders stored history as role/content pairs. The +// role comes from the record, which the store boundary derives from the +// sender when the message is written (see ToStoredMessage). +func compressTurnHistory(history []messaging.Message) []CompressedMessage { compressed := make([]CompressedMessage, 0, len(history)) for _, message := range history { role := "user" - if message.From == botUser { + if message.Role == messaging.RoleAssistant { role = "assistant" } compressed = append(compressed, CompressedMessage{Role: role, Content: message.Text}) diff --git a/internal/gateway/turn_test.go b/internal/gateway/turn_test.go index 12039ec94..f52f17819 100644 --- a/internal/gateway/turn_test.go +++ b/internal/gateway/turn_test.go @@ -312,9 +312,9 @@ func TestTurnRunnerReplaysCompletedDuplicateOutsideRecentWindow(t *testing.T) { t.Fatalf("first Run() error = %v", err) } for i := range 110 { - if err := store.SaveMessage(context.Background(), "chat-1", Message{ + if err := store.SaveMessage(context.Background(), "chat-1", ToStoredMessage(Message{ From: "user", SourceID: fmt.Sprintf("later-%d", i), Text: "later", - }); err != nil { + }, "archie")); err != nil { t.Fatalf("SaveMessage(%d) error = %v", i, err) } } diff --git a/internal/infrastructure/gatewayrpc/client.go b/internal/infrastructure/gatewayrpc/client.go index 01b3b34fa..7743befab 100644 --- a/internal/infrastructure/gatewayrpc/client.go +++ b/internal/infrastructure/gatewayrpc/client.go @@ -13,86 +13,14 @@ import ( "github.com/samcharles93/archie-core/internal/taskstate" ) -var ( - _ gateway.ChatContract = (*Client)(nil) - _ gateway.SessionStore = (*Client)(nil) -) +var _ gateway.ChatContract = (*Client)(nil) +// Client implements gateway.ChatContract over the chat service. Session +// history crosses in its channel-facing shape (the proto is unchanged by +// the messaging migration); StoreClient serves the SessionStore view over +// the same RPCs. type Client struct{ client pb.ChatServiceClient } -func (c *Client) Get(ctx context.Context, id string) (*gateway.SessionContext, error) { - s, found, err := c.GetSession(ctx, id) - if err != nil || !found { - return nil, err - } - return &s, nil -} - -func (c *Client) Save(ctx context.Context, s gateway.SessionContext) error { - _, e := c.client.SaveSession(ctx, &pb.SaveSessionRequest{Session: sessionProto(s)}) - return e -} - -func (c *Client) GetByChannel(ctx context.Context, p, ch string) ([]gateway.SessionContext, error) { - v, e := c.client.GetSessionsByChannel(ctx, &pb.GetSessionsByChannelRequest{Platform: p, ChannelId: ch}) - if e != nil { - return nil, e - } - return mapValues(v.Sessions, sessionValue), nil -} - -func (c *Client) Delete(ctx context.Context, id string) error { - _, e := c.client.DeleteSession(ctx, &pb.DeleteSessionRequest{SessionId: id}) - return e -} - -func (c *Client) Touch(ctx context.Context, id string) error { - _, e := c.client.TouchSession(ctx, &pb.TouchSessionRequest{SessionId: id}) - return e -} - -func (c *Client) List(ctx context.Context) ([]gateway.SessionContext, error) { - v, e := c.client.ListSessions(ctx, &pb.ListSessionsRequest{}) - if e != nil { - return nil, e - } - return mapValues(v.Sessions, sessionValue), nil -} - -func (c *Client) SaveMessage(ctx context.Context, id string, m gateway.Message) error { - _, e := c.client.SaveMessage(ctx, &pb.SaveMessageRequest{SessionId: id, Message: messageProto(m)}) - return e -} - -func (c *Client) DeleteRecentMessages(ctx context.Context, id string, n int) (int, error) { - v, e := c.client.DeleteRecentMessages(ctx, &pb.DeleteRecentMessagesRequest{SessionId: id, Limit: int64(n)}) - return int(v.Deleted), e -} - -func (c *Client) MessageCount(ctx context.Context, id string) (int, error) { - v, e := c.client.MessageCount(ctx, &pb.MessageCountRequest{SessionId: id}) - return int(v.Count), e -} - -func (c *Client) SaveMessages(ctx context.Context, id string, m []gateway.Message) error { - _, e := c.client.SaveMessages(ctx, &pb.SaveMessagesRequest{SessionId: id, Messages: mapValues(m, messageProto)}) - return e -} - -func (c *Client) ReplaceMessages(ctx context.Context, id string, m []gateway.Message, s []string) error { - _, e := c.client.ReplaceMessages(ctx, &pb.ReplaceMessagesRequest{SessionId: id, Messages: mapValues(m, messageProto), Superseded: s}) - return e -} - -func (c *Client) SearchMessages(ctx context.Context, id string, q gateway.MessageQuery) (gateway.MessagePage, error) { - v, e := c.client.SearchMessages(ctx, &pb.SearchMessagesRequest{SessionId: id, Query: q.Query, Limit: int64(q.Limit), Offset: int64(q.Offset)}) - if e != nil { - return gateway.MessagePage{}, e - } - return gateway.MessagePage{Messages: mapValues(v.Messages, messageValue), NextOffset: int(v.NextOffset), HasMore: v.HasMore, Truncated: v.Truncated}, nil -} -func (c *Client) Close() error { return nil } - func NewClient(conn grpc.ClientConnInterface) *Client { return &Client{client: pb.NewChatServiceClient(conn)} } diff --git a/internal/infrastructure/gatewayrpc/server.go b/internal/infrastructure/gatewayrpc/server.go index d47506702..a94b9ab5e 100644 --- a/internal/infrastructure/gatewayrpc/server.go +++ b/internal/infrastructure/gatewayrpc/server.go @@ -8,6 +8,7 @@ import ( "google.golang.org/grpc/status" pb "github.com/samcharles93/archie-core/internal/contracts/gateway/v1" + "github.com/samcharles93/archie-core/internal/domain/messaging" "github.com/samcharles93/archie-core/internal/gateway" "github.com/samcharles93/archie-core/internal/taskstate" ) @@ -139,12 +140,34 @@ func (s *server) ListSessions(ctx context.Context, _ *pb.ListSessionsRequest) (* return &pb.ListSessionsResponse{Sessions: mapValues(v, sessionProto)}, e } +// storedMessages converts wire messages to canonical records, deriving +// roles from the owning session's bot identity -- the same derivation the +// in-process boundary applies (see gateway.ToStoredMessage). The wire +// carries no role; both sides derive from the same session, so they agree. +func (s *server) storedMessages(ctx context.Context, ss gateway.SessionStore, sessionID string, msgs []gateway.Message) ([]messaging.Message, error) { + var botUser string + if sc, err := ss.Get(ctx, sessionID); err != nil { + return nil, err + } else if sc != nil { + botUser = sc.Source.BotUser + } + out := make([]messaging.Message, 0, len(msgs)) + for _, m := range msgs { + out = append(out, gateway.ToStoredMessage(m, botUser)) + } + return out, nil +} + func (s *server) SaveMessage(ctx context.Context, r *pb.SaveMessageRequest) (*pb.SaveMessageResponse, error) { ss, e := s.sessionStore() if e != nil { return nil, e } - return &pb.SaveMessageResponse{}, ss.SaveMessage(ctx, r.SessionId, messageValue(r.Message)) + msgs, e := s.storedMessages(ctx, ss, r.SessionId, []gateway.Message{messageValue(r.Message)}) + if e != nil { + return nil, e + } + return &pb.SaveMessageResponse{}, ss.SaveMessage(ctx, r.SessionId, msgs[0]) } func (s *server) DeleteRecentMessages(ctx context.Context, r *pb.DeleteRecentMessagesRequest) (*pb.DeleteRecentMessagesResponse, error) { @@ -170,7 +193,11 @@ func (s *server) SaveMessages(ctx context.Context, r *pb.SaveMessagesRequest) (* if e != nil { return nil, e } - return &pb.SaveMessagesResponse{}, ss.SaveMessages(ctx, r.SessionId, mapValues(r.Messages, messageValue)) + msgs, e := s.storedMessages(ctx, ss, r.SessionId, mapValues(r.Messages, messageValue)) + if e != nil { + return nil, e + } + return &pb.SaveMessagesResponse{}, ss.SaveMessages(ctx, r.SessionId, msgs) } func (s *server) ReplaceMessages(ctx context.Context, r *pb.ReplaceMessagesRequest) (*pb.ReplaceMessagesResponse, error) { @@ -178,7 +205,11 @@ func (s *server) ReplaceMessages(ctx context.Context, r *pb.ReplaceMessagesReque if e != nil { return nil, e } - return &pb.ReplaceMessagesResponse{}, ss.ReplaceMessages(ctx, r.SessionId, mapValues(r.Messages, messageValue), r.Superseded) + msgs, e := s.storedMessages(ctx, ss, r.SessionId, mapValues(r.Messages, messageValue)) + if e != nil { + return nil, e + } + return &pb.ReplaceMessagesResponse{}, ss.ReplaceMessages(ctx, r.SessionId, msgs, r.Superseded) } func (s *server) SearchMessages(ctx context.Context, r *pb.SearchMessagesRequest) (*pb.SearchMessagesResponse, error) { @@ -187,7 +218,7 @@ func (s *server) SearchMessages(ctx context.Context, r *pb.SearchMessagesRequest return nil, e } v, e := ss.SearchMessages(ctx, r.SessionId, gateway.MessageQuery{Query: r.Query, Limit: int(r.Limit), Offset: int(r.Offset)}) - return &pb.SearchMessagesResponse{Messages: mapValues(v.Messages, messageProto), NextOffset: int64(v.NextOffset), HasMore: v.HasMore, Truncated: v.Truncated}, e + return &pb.SearchMessagesResponse{Messages: mapValues(v.Messages, storedProto), NextOffset: int64(v.NextOffset), HasMore: v.HasMore, Truncated: v.Truncated}, e } func (s *server) Stream(r *pb.StreamRequest, out grpc.ServerStreamingServer[pb.StreamResponse]) error { diff --git a/internal/infrastructure/gatewayrpc/store_client.go b/internal/infrastructure/gatewayrpc/store_client.go new file mode 100644 index 000000000..38401989f --- /dev/null +++ b/internal/infrastructure/gatewayrpc/store_client.go @@ -0,0 +1,142 @@ +package gatewayrpc + +import ( + "context" + + "google.golang.org/grpc" + + pb "github.com/samcharles93/archie-core/internal/contracts/gateway/v1" + "github.com/samcharles93/archie-core/internal/domain/messaging" + "github.com/samcharles93/archie-core/internal/gateway" +) + +var _ gateway.SessionStore = (*StoreClient)(nil) + +// StoreClient implements gateway.SessionStore over the chat service's +// session-store RPCs. It is separate from Client (the ChatContract view) +// because the two contracts shape history differently: the wire keeps the +// channel-facing message (the proto is unchanged by the messaging +// migration) while the store speaks canonical records. +// +// Role and conversation address do not cross the wire. Both sides derive +// them from the owning session instead -- the server on write, this client +// on read -- so they agree without a proto change. A missing session +// yields zero values, matching the store's LEFT JOIN for orphaned rows. +type StoreClient struct{ client pb.ChatServiceClient } + +func NewStoreClient(conn grpc.ClientConnInterface) *StoreClient { + return &StoreClient{client: pb.NewChatServiceClient(conn)} +} + +func (c *StoreClient) Get(ctx context.Context, id string) (*gateway.SessionContext, error) { + v, err := c.client.GetSession(ctx, &pb.GetSessionRequest{SessionId: id}) + if err != nil { + return nil, err + } + if !v.Found { + return nil, nil + } + s := sessionValue(v.Session) + return &s, nil +} + +func (c *StoreClient) Save(ctx context.Context, s gateway.SessionContext) error { + _, e := c.client.SaveSession(ctx, &pb.SaveSessionRequest{Session: sessionProto(s)}) + return e +} + +func (c *StoreClient) GetByChannel(ctx context.Context, p, ch string) ([]gateway.SessionContext, error) { + v, e := c.client.GetSessionsByChannel(ctx, &pb.GetSessionsByChannelRequest{Platform: p, ChannelId: ch}) + if e != nil { + return nil, e + } + return mapValues(v.Sessions, sessionValue), nil +} + +func (c *StoreClient) Delete(ctx context.Context, id string) error { + _, e := c.client.DeleteSession(ctx, &pb.DeleteSessionRequest{SessionId: id}) + return e +} + +func (c *StoreClient) Touch(ctx context.Context, id string) error { + _, e := c.client.TouchSession(ctx, &pb.TouchSessionRequest{SessionId: id}) + return e +} + +func (c *StoreClient) List(ctx context.Context) ([]gateway.SessionContext, error) { + v, e := c.client.ListSessions(ctx, &pb.ListSessionsRequest{}) + if e != nil { + return nil, e + } + return mapValues(v.Sessions, sessionValue), nil +} + +func (c *StoreClient) SaveMessage(ctx context.Context, id string, m messaging.Message) error { + _, e := c.client.SaveMessage(ctx, &pb.SaveMessageRequest{SessionId: id, Message: messageProto(gateway.FromStoredMessage(m))}) + return e +} + +func (c *StoreClient) DeleteRecentMessages(ctx context.Context, id string, n int) (int, error) { + v, e := c.client.DeleteRecentMessages(ctx, &pb.DeleteRecentMessagesRequest{SessionId: id, Limit: int64(n)}) + return int(v.Deleted), e +} + +func (c *StoreClient) MessageCount(ctx context.Context, id string) (int, error) { + v, e := c.client.MessageCount(ctx, &pb.MessageCountRequest{SessionId: id}) + return int(v.Count), e +} + +func (c *StoreClient) SaveMessages(ctx context.Context, id string, m []messaging.Message) error { + _, e := c.client.SaveMessages(ctx, &pb.SaveMessagesRequest{SessionId: id, Messages: mapValues(m, storedProto)}) + return e +} + +func (c *StoreClient) ReplaceMessages(ctx context.Context, id string, m []messaging.Message, s []string) error { + _, e := c.client.ReplaceMessages(ctx, &pb.ReplaceMessagesRequest{SessionId: id, Messages: mapValues(m, storedProto), Superseded: s}) + return e +} + +func (c *StoreClient) RecentMessages(ctx context.Context, id string, n int) ([]messaging.Message, error) { + // No store-RecentMessages RPC exists; the chat contract serves the same + // gateway view LocalChatAdapter serves in-process. Re-address it into + // canonical records (see addressRecords). + v, err := c.client.RecentMessages(ctx, &pb.RecentMessagesRequest{SessionId: id, Limit: int64(n)}) + if err != nil { + return nil, err + } + return c.addressRecords(ctx, id, mapValues(v.Messages, messageValue)) +} + +func (c *StoreClient) SearchMessages(ctx context.Context, id string, q gateway.MessageQuery) (gateway.MessagePage, error) { + v, e := c.client.SearchMessages(ctx, &pb.SearchMessagesRequest{SessionId: id, Query: q.Query, Limit: int64(q.Limit), Offset: int64(q.Offset)}) + if e != nil { + return gateway.MessagePage{}, e + } + msgs, err := c.addressRecords(ctx, id, mapValues(v.Messages, messageValue)) + if err != nil { + return gateway.MessagePage{}, err + } + return gateway.MessagePage{Messages: msgs, NextOffset: int(v.NextOffset), HasMore: v.HasMore, Truncated: v.Truncated}, nil +} + +func (c *StoreClient) Close() error { return nil } + +// addressRecords restores the canonical fields the wire drops (role, +// conversation address) from the owning session. +func (c *StoreClient) addressRecords(ctx context.Context, id string, msgs []gateway.Message) ([]messaging.Message, error) { + var botUser string + var conv messaging.ConversationID + if sc, err := c.Get(ctx, id); err != nil { + return nil, err + } else if sc != nil { + botUser = sc.Source.BotUser + conv = messaging.ConversationID{ChannelID: sc.Source.ChannelID, ThreadID: sc.Source.ThreadID} + } + out := make([]messaging.Message, 0, len(msgs)) + for _, m := range msgs { + stored := gateway.ToStoredMessage(m, botUser) + stored.ConversationID = conv + out = append(out, stored) + } + return out, nil +} diff --git a/internal/infrastructure/gatewayrpc/store_client_test.go b/internal/infrastructure/gatewayrpc/store_client_test.go new file mode 100644 index 000000000..85fdbca5d --- /dev/null +++ b/internal/infrastructure/gatewayrpc/store_client_test.go @@ -0,0 +1,106 @@ +package gatewayrpc + +import ( + "context" + "net" + "testing" + "time" + + "google.golang.org/grpc" + "google.golang.org/grpc/credentials/insecure" + "google.golang.org/grpc/test/bufconn" + + "github.com/samcharles93/archie-core/internal/domain/messaging" + "github.com/samcharles93/archie-core/internal/gateway" +) + +// remoteStore wires a StoreClient to a real SQLite session store through the +// gRPC server, mirroring production (standalone gateway owns the store, +// archied dials in). +func remoteStore(t *testing.T, sessions gateway.SessionStore, chat gateway.ChatContract) gateway.SessionStore { + t.Helper() + listener := bufconn.Listen(1 << 20) + server := grpc.NewServer() + RegisterServer(server, chat, sessions) + go func() { _ = server.Serve(listener) }() + t.Cleanup(func() { server.Stop(); _ = listener.Close() }) + conn, err := grpc.NewClient("passthrough:///gateway", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithContextDialer(func(ctx context.Context, _ string) (net.Conn, error) { return listener.DialContext(ctx) })) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = conn.Close() }) + return NewStoreClient(conn) +} + +// TestStoreClientPreservesCanonicalRecords pins the remote store contract: +// messages cross the wire in their gateway shape (the proto is unchanged) +// and come back as the same canonical records -- sender, derived role, and +// conversation address intact. Roles are passed empty to prove the server +// derives them from the owning session, exactly like the in-process +// boundary. +func TestStoreClientPreservesCanonicalRecords(t *testing.T) { + ctx := t.Context() + sessions := gateway.NewSessionStoreMemory() + t.Cleanup(func() { _ = sessions.Close() }) + router := gateway.NewRouter(nil, nil, "web") + router.InitSessions(sessions) + local := &gateway.LocalChatAdapter{Router: router, Sessions: sessions} + store := remoteStore(t, sessions, local) + + sc := gateway.SessionContext{ + SessionID: "sess-1", + Source: gateway.SessionSource{Platform: "web", BotUser: "archie", ChannelID: "chat-1"}, + CreatedAt: time.Now().UTC(), + LastActiveAt: time.Now().UTC(), + } + if err := store.Save(ctx, sc); err != nil { + t.Fatalf("Save: %v", err) + } + + msgs := []messaging.Message{ + {SourceID: "w-1", Sender: "web", Text: "hello", At: time.Now().UTC()}, + {SourceID: "w-2", Sender: "archie", Text: "hi", At: time.Now().UTC()}, + } + for _, m := range msgs { + if err := store.SaveMessage(ctx, "sess-1", m); err != nil { + t.Fatalf("SaveMessage: %v", err) + } + } + + got, err := store.RecentMessages(ctx, "sess-1", 10) + if err != nil { + t.Fatalf("RecentMessages: %v", err) + } + if len(got) != 2 { + t.Fatalf("RecentMessages returned %d messages, want 2", len(got)) + } + want := []messaging.Message{ + { + SourceID: "w-1", Sender: "web", Role: messaging.RoleUser, Text: "hello", + ConversationID: messaging.ConversationID{ChannelID: "chat-1"}, + }, + { + SourceID: "w-2", Sender: "archie", Role: messaging.RoleAssistant, Text: "hi", + ConversationID: messaging.ConversationID{ChannelID: "chat-1"}, + }, + } + for i, w := range want { + if got[i].SourceID != w.SourceID || got[i].Sender != w.Sender || + got[i].Role != w.Role || got[i].Text != w.Text || + got[i].ConversationID != w.ConversationID { + t.Fatalf("message %d = %+v, want %+v", i, got[i], w) + } + if got[i].ID == "" { + t.Fatalf("message %d has no canonical ID", i) + } + } + + page, err := store.SearchMessages(ctx, "sess-1", gateway.MessageQuery{Query: "hello", Limit: 10}) + if err != nil { + t.Fatalf("SearchMessages: %v", err) + } + if len(page.Messages) != 1 || page.Messages[0].Role != messaging.RoleUser || + page.Messages[0].ConversationID.ChannelID != "chat-1" { + t.Fatalf("SearchMessages = %+v, want the user message with its conversation", page.Messages) + } +} diff --git a/internal/infrastructure/gatewayrpc/values.go b/internal/infrastructure/gatewayrpc/values.go index 7038dad43..b50649a11 100644 --- a/internal/infrastructure/gatewayrpc/values.go +++ b/internal/infrastructure/gatewayrpc/values.go @@ -6,6 +6,7 @@ import ( "google.golang.org/protobuf/types/known/timestamppb" pb "github.com/samcharles93/archie-core/internal/contracts/gateway/v1" + "github.com/samcharles93/archie-core/internal/domain/messaging" "github.com/samcharles93/archie-core/internal/gateway" ) @@ -35,6 +36,13 @@ func messageProto(v gateway.Message) *pb.Message { } } +// storedProto renders a canonical record in its wire shape. The role stays +// store-side: each side derives it from the owning session (see +// gateway.ToStoredMessage), so the wire carries no role. +func storedProto(m messaging.Message) *pb.Message { + return messageProto(gateway.FromStoredMessage(m)) +} + func messageValue(v *pb.Message) gateway.Message { if v == nil { return gateway.Message{} diff --git a/internal/infrastructure/sessioncurator/adapter.go b/internal/infrastructure/sessioncurator/adapter.go index dc7869544..7792b80a9 100644 --- a/internal/infrastructure/sessioncurator/adapter.go +++ b/internal/infrastructure/sessioncurator/adapter.go @@ -10,6 +10,7 @@ import ( "time" "github.com/samcharles93/archie-core/internal/domain/curator" + "github.com/samcharles93/archie-core/internal/domain/messaging" "github.com/samcharles93/archie-core/internal/gateway" ) @@ -18,17 +19,13 @@ import ( // curator needs -- never the full session CRUD/branch/search surface a // chat gateway exposes. See docs/prds/session-memory-curator.md. type Adapter struct { - store gateway.SessionStore - botUser string + store gateway.SessionStore } -// NewAdapter builds an Adapter. botUser is compared against -// gateway.Message.From to derive role ("assistant" when it matches, else -// "user"), the same derivation gateway.compressTurnHistory already uses -// -- copied logic, not shared code, since curator must not import -// gateway.Message. -func NewAdapter(store gateway.SessionStore, botUser string) *Adapter { - return &Adapter{store: store, botUser: botUser} +// NewAdapter builds an Adapter. Roles come from the canonical records the +// store returns, so no bot identity is needed to derive them. +func NewAdapter(store gateway.SessionStore) *Adapter { + return &Adapter{store: store} } func (a *Adapter) RecentSessions(ctx context.Context, since time.Time) ([]curator.SessionSummary, error) { @@ -54,7 +51,7 @@ func (a *Adapter) Messages(ctx context.Context, sessionID string, n int) ([]cura out := make([]curator.ConversationMessage, 0, len(msgs)) for _, m := range msgs { role := "user" - if m.From == a.botUser { + if m.Role == messaging.RoleAssistant { role = "assistant" } out = append(out, curator.ConversationMessage{Role: role, Content: m.Text, At: m.At}) diff --git a/internal/infrastructure/sessioncurator/adapter_test.go b/internal/infrastructure/sessioncurator/adapter_test.go index 5e9db4366..c775139ec 100644 --- a/internal/infrastructure/sessioncurator/adapter_test.go +++ b/internal/infrastructure/sessioncurator/adapter_test.go @@ -5,6 +5,7 @@ import ( "testing" "time" + "github.com/samcharles93/archie-core/internal/domain/messaging" "github.com/samcharles93/archie-core/internal/gateway" ) @@ -29,7 +30,7 @@ func TestAdapterRecentSessionsFiltersByActivity(t *testing.T) { t.Fatalf("Save(recent) = %v", err) } - a := NewAdapter(store, "archie") + a := NewAdapter(store) got, err := a.RecentSessions(ctx, time.Unix(1000, 0)) if err != nil { t.Fatalf("RecentSessions() = %v, want nil", err) @@ -39,7 +40,7 @@ func TestAdapterRecentSessionsFiltersByActivity(t *testing.T) { } } -func TestAdapterMessagesDerivesRoleFromBotUser(t *testing.T) { +func TestAdapterMessagesReadsRoleFromRecords(t *testing.T) { t.Parallel() store := newTestStore(t) ctx := context.Background() @@ -48,20 +49,28 @@ func TestAdapterMessagesDerivesRoleFromBotUser(t *testing.T) { if err := store.Save(ctx, sess); err != nil { t.Fatalf("Save() = %v", err) } - if err := store.SaveMessage(ctx, "s1", gateway.Message{From: "user123", Text: "hello", At: time.Unix(1, 0)}); err != nil { - t.Fatalf("SaveMessage(user) = %v", err) + // Roles are derived from the sender at the store boundary; the adapter + // reads them from the records, needing no bot identity of its own. + for _, m := range []gateway.Message{ + {From: "user123", Text: "hello", At: time.Unix(1, 0)}, + {From: "archie", Text: "hi there", At: time.Unix(2, 0)}, + } { + if err := store.SaveMessage(ctx, "s1", gateway.ToStoredMessage(m, "archie")); err != nil { + t.Fatalf("SaveMessage(%v) = %v", m, err) + } } - if err := store.SaveMessage(ctx, "s1", gateway.Message{From: "archie", Text: "hi there", At: time.Unix(2, 0)}); err != nil { - t.Fatalf("SaveMessage(bot) = %v", err) + // A hand-built record without a role reads as a user message. + if err := store.SaveMessage(ctx, "s1", messaging.Message{Text: "bare", At: time.Unix(3, 0)}); err != nil { + t.Fatalf("SaveMessage(bare) = %v", err) } - a := NewAdapter(store, "archie") + a := NewAdapter(store) got, err := a.Messages(ctx, "s1", 10) if err != nil { t.Fatalf("Messages() = %v, want nil", err) } - if len(got) != 2 { - t.Fatalf("Messages() = %v, want 2", got) + if len(got) != 3 { + t.Fatalf("Messages() = %v, want 3", got) } if got[0].Role != "user" || got[0].Content != "hello" { t.Errorf("Messages()[0] = %+v, want user/hello", got[0]) @@ -69,4 +78,7 @@ func TestAdapterMessagesDerivesRoleFromBotUser(t *testing.T) { if got[1].Role != "assistant" || got[1].Content != "hi there" { t.Errorf("Messages()[1] = %+v, want assistant/hi there", got[1]) } + if got[2].Role != "user" || got[2].Content != "bare" { + t.Errorf("Messages()[2] = %+v, want user/bare", got[2]) + } } diff --git a/internal/webui/api_chat_test.go b/internal/webui/api_chat_test.go index 91812bc89..825516e6f 100644 --- a/internal/webui/api_chat_test.go +++ b/internal/webui/api_chat_test.go @@ -114,7 +114,7 @@ func TestChatSessionAndMessageEndpoints(t *testing.T) { if err := sessions.Save(context.Background(), session); err != nil { t.Fatal(err) } - if err := sessions.SaveMessage(context.Background(), session.SessionID, gateway.Message{From: "web", Text: "hello"}); err != nil { + if err := sessions.SaveMessage(context.Background(), session.SessionID, gateway.ToStoredMessage(gateway.Message{From: "web", Text: "hello"}, "")); err != nil { t.Fatal(err) }