feat(messaging): migrate gateway session persistence onto domain types

SessionStore message history now stores/loads domain/messaging.Message:
sender attribution, derived role, and conversation address are canonical
record fields. SQLite gains a role column with open-time backfill for
pre-migration databases. gateway.Message remains the channel-facing
transport; conversion lives in one boundary module. ChatContract,
gatewayrpc proto, and dashboard JSON are unchanged; the RPC client
splits into ChatContract (Client) and SessionStore (StoreClient) views.

Sessions stay SessionContext: UUID keys and platform/bot/title/branch
metadata have no lossless home in Conversation; keyed migration tracked
separately once Agent/user/binding ownership settles.

Refs: archie-core-d9dv
This commit is contained in:
sam committed 2026-09-08 21:28:19 +10:00
1 parent 37225e032c
commit 571323138d
29 files changed
+896 -350

No files matched your search

+1 -1
View File
@@ -1057,7 +1057,7 @@ func (b *boot) setupCurators(ctx context.Context) {
Skills: skillcurator.NewStore(skillsRoot), Skills: skillcurator.NewStore(skillsRoot),
// Conversations backs the session-memory curator; b.chatSessionStore // Conversations backs the session-memory curator; b.chatSessionStore
// is opened by openChatSessions before setupCurators. // is opened by openChatSessions before setupCurators.
Conversations: sessioncurator.NewAdapter(b.chatSessionStore, b.cfg.BotUser), Conversations: sessioncurator.NewAdapter(b.chatSessionStore),
LLM: curatorLLMRunner{rt: b.llm}, LLM: curatorLLMRunner{rt: b.llm},
// b.chatModels.ActiveModel() is the same source sendChatTurn uses // b.chatModels.ActiveModel() is the same source sendChatTurn uses
// for a real chat turn (telegram_setup.go) -- not // for a real chat turn (telegram_setup.go) -- not
+7
View File
@@ -73,6 +73,13 @@ type Message struct {
// upstream identity. // upstream identity.
SourceID string 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 Role Role
Text string Text string
+11 -9
View File
@@ -4,6 +4,8 @@ import (
"context" "context"
"strings" "strings"
"testing" "testing"
"github.com/samcharles93/archie-core/internal/domain/messaging"
) )
// A branch copies the parent's history into a new session. Those copies used // 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"} { for i, text := range []string{"one", "two", "three"} {
if err := store.SaveMessage(ctx, parentID, Message{ if err := store.SaveMessage(ctx, parentID, messaging.Message{
From: "alice", Text: text, SourceID: "tg-" + text, At: at(dur(i)), Sender: "alice", Role: messaging.RoleUser, Text: text, SourceID: "tg-" + text, At: at(dur(i)),
}); err != nil { }); err != nil {
t.Fatalf("SaveMessage: %v", err) t.Fatalf("SaveMessage: %v", err)
} }
@@ -66,25 +68,25 @@ func TestBranchGivesInheritedMessagesTheirOwnIdentity(t *testing.T) {
parentIDs := make(map[string]struct{}, len(parentMsgs)) parentIDs := make(map[string]struct{}, len(parentMsgs))
for _, m := range parentMsgs { for _, m := range parentMsgs {
parentIDs[m.MessageID] = struct{}{} parentIDs[string(m.ID)] = struct{}{}
} }
for _, m := range childMsgs { 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 "+ 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 == "" { if m.SourceID == "" {
t.Errorf("inherited %q lost its SourceID; upstream correlation is gone", m.Text) 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", 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. // Dedup must work in the child on its own terms.
if err := store.SaveMessage(ctx, childID, Message{ if err := store.SaveMessage(ctx, childID, messaging.Message{
From: "alice", Text: "two", SourceID: "tg-two", At: at(dur(1)), Sender: "alice", Role: messaging.RoleUser, Text: "two", SourceID: "tg-two", At: at(dur(1)),
}); err != nil { }); err != nil {
t.Fatalf("redeliver into child: %v", err) t.Fatalf("redeliver into child: %v", err)
} }
+12 -1
View File
@@ -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) { 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) { func (a *LocalChatAdapter) RecentTurns(ctx context.Context, id string, n int) ([]TurnRecord, error) {
+4 -2
View File
@@ -4,6 +4,8 @@ import (
"context" "context"
"strings" "strings"
"testing" "testing"
"github.com/samcharles93/archie-core/internal/domain/messaging"
) )
// /compress dispatch. Every case here is a command an operator can type, and // /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. // bulk of the tokens outside that window.
seedForCompress(t, store, sessionID, 40) seedForCompress(t, store, sessionID, 40)
for i := range 250 { for i := range 250 {
if err := store.SaveMessage(ctx, sessionID, Message{ if err := store.SaveMessage(ctx, sessionID, messaging.Message{
From: "alice", Text: "tiny", SourceID: pad(i), At: at(dur(1000 + i)), Sender: "alice", Role: messaging.RoleUser, Text: "tiny", SourceID: pad(i), At: at(dur(1000 + i)),
}); err != nil { }); err != nil {
t.Fatalf("SaveMessage: %v", err) t.Fatalf("SaveMessage: %v", err)
} }
+6 -3
View File
@@ -3,6 +3,8 @@ package gateway
import ( import (
"context" "context"
"testing" "testing"
"github.com/samcharles93/archie-core/internal/domain/messaging"
) )
// A chat turn that lands while a compression is being computed is not part of // 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. // history and before it writes the replacement.
const lateText = "sent while the summary was being computed" const lateText = "sent while the summary was being computed"
store.afterRecent = func() { store.afterRecent = func() {
if err := inner.SaveMessage(ctx, sessionID, Message{ if err := inner.SaveMessage(ctx, sessionID, messaging.Message{
From: "alice", Sender: "alice",
Role: messaging.RoleUser,
Text: lateText, Text: lateText,
SourceID: "tg-late", SourceID: "tg-late",
At: at(dur(9000)), At: at(dur(9000)),
@@ -72,7 +75,7 @@ type midCompressStore struct {
afterRecent func() 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) out, err := m.SessionStore.RecentMessages(ctx, sessionID, n)
if m.afterRecent != nil { if m.afterRecent != nil {
fn := m.afterRecent fn := m.afterRecent
+20 -14
View File
@@ -5,6 +5,8 @@ import (
"fmt" "fmt"
"strings" "strings"
"testing" "testing"
"github.com/samcharles93/archie-core/internal/domain/messaging"
) )
// compressBackends provides the persistent store used by compression tests. // 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 // seedForCompress fills a session with enough large messages to trip the
// default threshold, each carrying an upstream SourceID as Telegram does. // 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() t.Helper()
// Large enough that n messages exceed 50% of a 128k context window // Large enough that n messages exceed 50% of a 128k context window
// (tokenEstimate is len/4, so n*bodyLen/4 must clear 64k). // (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 { for i := range n {
m := Message{ m := messaging.Message{
From: "alice", Sender: "alice",
Role: messaging.RoleUser,
Text: fmt.Sprintf("m%d %s", i, body), Text: fmt.Sprintf("m%d %s", i, body),
SourceID: fmt.Sprintf("tg-%d", i), SourceID: fmt.Sprintf("tg-%d", i),
At: at(dur(i)), At: at(dur(i)),
@@ -84,7 +87,7 @@ func TestCompressPreservesRetainedMessageIdentity(t *testing.T) {
r, sessionID := routerOn(t, store, "chat-1") r, sessionID := routerOn(t, store, "chat-1")
before := seedForCompress(t, store, sessionID, 40) 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 { for _, m := range before {
byText[m.Text] = m byText[m.Text] = m
} }
@@ -105,9 +108,9 @@ func TestCompressPreservesRetainedMessageIdentity(t *testing.T) {
continue // the summary, which is legitimately new continue // the summary, which is legitimately new
} }
retained++ retained++
if m.MessageID != orig.MessageID { if m.ID != orig.ID {
t.Errorf("retained %q: MessageID = %q, want the original %q", 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 { if m.SourceID != orig.SourceID {
t.Errorf("retained %q: SourceID = %q, want the original %q", t.Errorf("retained %q: SourceID = %q, want the original %q",
@@ -140,8 +143,8 @@ func TestCompressKeepsRedeliveryIdempotent(t *testing.T) {
last := before[len(before)-1] last := before[len(before)-1]
// Redelivery is a no-op before compression. // Redelivery is a no-op before compression.
if err := store.SaveMessage(ctx, sessionID, Message{ if err := store.SaveMessage(ctx, sessionID, messaging.Message{
From: last.From, Text: last.Text, SourceID: last.SourceID, At: last.At, Sender: last.Sender, Role: last.Role, Text: last.Text, SourceID: last.SourceID, At: last.At,
}); err != nil { }); err != nil {
t.Fatalf("redeliver before compress: %v", err) 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. // The same redelivery must still be a no-op afterwards.
if err := store.SaveMessage(ctx, sessionID, Message{ if err := store.SaveMessage(ctx, sessionID, messaging.Message{
From: last.From, Text: last.Text, SourceID: last.SourceID, At: last.At, Sender: last.Sender, Role: last.Role, Text: last.Text, SourceID: last.SourceID, At: last.At,
}); err != nil { }); err != nil {
t.Fatalf("redeliver after compress: %v", err) t.Fatalf("redeliver after compress: %v", err)
} }
@@ -207,10 +210,13 @@ func TestCompressSummaryIsNotAttributedToTheUser(t *testing.T) {
continue continue
} }
found = true found = true
if m.From != r.Identity { if m.Sender != r.Identity {
t.Errorf("summary From = %q, want the bot identity %q: consumers "+ t.Errorf("summary Sender = %q, want the bot identity %q", m.Sender, r.Identity)
"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.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 { if !found {
+21 -16
View File
@@ -4,6 +4,8 @@ import (
"context" "context"
"strings" "strings"
"testing" "testing"
"github.com/samcharles93/archie-core/internal/domain/messaging"
) )
// The summary stands in for the messages it replaced, so it belongs where // 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 marker := DefaultCompressionConfig().SummaryMarker
history := []Message{ history := []messaging.Message{
{ {
MessageID: CanonicalMessageID(sessionID, "tg-unanswered"), ID: messaging.MessageID(CanonicalMessageID(sessionID, "tg-unanswered")),
SourceID: "tg-unanswered", SourceID: "tg-unanswered",
From: "alice", Sender: "alice",
Text: "what is 2+2?", Role: messaging.RoleUser,
Text: "what is 2+2?",
}, },
{ {
MessageID: "summary-record", ID: "summary-record",
From: identity, Sender: identity,
Text: marker + "\n\n[36 messages removed (~9000 tokens)]", 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, "+ t.Errorf("PriorReply = %q, want \"\": the question was never answered, "+
"so redelivering it must re-run the model rather than replay a "+ "so redelivering it must re-run the model rather than replay a "+
"compression banner as the answer", got) "compression banner as the answer", got)
@@ -99,16 +103,17 @@ func TestPriorReplyStillMatchesARealReply(t *testing.T) {
sessionID = "chat-1" sessionID = "chat-1"
identity = "archie" identity = "archie"
) )
history := []Message{ history := []messaging.Message{
{ {
MessageID: CanonicalMessageID(sessionID, "tg-1"), ID: messaging.MessageID(CanonicalMessageID(sessionID, "tg-1")),
SourceID: "tg-1", SourceID: "tg-1",
From: "alice", Sender: "alice",
Text: "ping", 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") t.Errorf("PriorReply = %q, want %q", got, "pong")
} }
} }
+59
View File
@@ -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,
}
}
@@ -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)
}
})
}
}
+11 -8
View File
@@ -5,6 +5,8 @@ import (
"time" "time"
"github.com/google/uuid" "github.com/google/uuid"
"github.com/samcharles93/archie-core/internal/domain/messaging"
) )
func TestPriorReplyRecognisesLegacyCanonicalMessageID(t *testing.T) { func TestPriorReplyRecognisesLegacyCanonicalMessageID(t *testing.T) {
@@ -16,11 +18,11 @@ func TestPriorReplyRecognisesLegacyCanonicalMessageID(t *testing.T) {
identity = "archie" identity = "archie"
) )
legacyID := uuid.NewSHA1(messageIDNamespace, []byte(sessionID+"\x00"+sourceID)).String() legacyID := uuid.NewSHA1(messageIDNamespace, []byte(sessionID+"\x00"+sourceID)).String()
history := []Message{ history := []messaging.Message{
{MessageID: legacyID, SourceID: sourceID, From: "alice", Text: "question"}, {ID: messaging.MessageID(legacyID), SourceID: sourceID, Sender: "alice", Role: messaging.RoleUser, Text: "question"},
{From: identity, Text: "answer"}, {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) t.Fatalf("PriorReply = %q, want legacy reply", got)
} }
} }
@@ -122,18 +124,19 @@ func TestPriorReply(t *testing.T) {
for _, tc := range tests { for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) { 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 { for i, h := range tc.history {
history = append(history, Message{ m := ToStoredMessage(Message{
MessageID: newMessageIDFor(sessionID, h.sourceID, i), MessageID: newMessageIDFor(sessionID, h.sourceID, i),
SourceID: h.sourceID, SourceID: h.sourceID,
From: h.from, From: h.from,
Text: h.text, Text: h.text,
At: time.Now().Add(time.Duration(i) * time.Second), 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 { if got != tc.want {
t.Errorf("PriorReply = %q, want %q", got, tc.want) t.Errorf("PriorReply = %q, want %q", got, tc.want)
} }
+25 -21
View File
@@ -10,6 +10,8 @@ import (
"time" "time"
"github.com/google/uuid" "github.com/google/uuid"
"github.com/samcharles93/archie-core/internal/domain/messaging"
) )
// sessionTracker maps (channelID, threadID) pairs to the currently active // 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 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 // Replay the stored text, but route it with the live message's
// addressing. Stored history carries no channel or thread -- a session // addressing. The gateway view of stored history carries no channel
// already is one -- so replaying the stored value verbatim would // or thread -- a session already is one -- so replaying the stored
// resolve to an empty session key and strand the reply. // value verbatim would resolve to an empty session key and strand
lastUserMsg := msgs[0] // the reply.
lastUserMsg := FromStoredMessage(msgs[0])
lastUserMsg.ChannelID = msg.ChannelID lastUserMsg.ChannelID = msg.ChannelID
lastUserMsg.ThreadID = msg.ThreadID lastUserMsg.ThreadID = msg.ThreadID
reply, err := r.LLM(ctx, lastUserMsg) 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 // branch-point correlation ambiguous. It also broke dedup in the
// child: an inherited message carried an ID derived from the // child: an inherited message carried an ID derived from the
// parent's session, so redelivering it appended. // parent's session, so redelivering it appended.
inherited := make([]Message, 0, len(msgs)) inherited := make([]messaging.Message, 0, len(msgs))
for _, m := range msgs { for _, m := range msgs {
m.MessageID = "" m.ID = ""
inherited = append(inherited, m) inherited = append(inherited, m)
} }
if err := r.sessionTracker.sessions.SaveMessages(ctx, id, inherited); err != nil { 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. // replays its queue. Only the summary is a new record.
// //
// The summary is attributed to the bot. CompressHistory emits it with role // The summary is attributed to the bot. CompressHistory emits it with role
// "system", which has no representation in the store -- consumers recover the // "system", which has no representation in the store -- the summary is
// role by comparing From against the bot identity -- and attributing a // recorded as an assistant message instead -- and attributing a description
// description of the conversation to the user makes the model replay it as // of the conversation to the user makes the model replay it as something
// something the human said. // the human said.
func compressedHistory(original []Message, view CompressedView, identity string) []Message { func compressedHistory(original []messaging.Message, view CompressedView, identity string) []messaging.Message {
summaryAt := view.SummaryIndex() summaryAt := view.SummaryIndex()
if summaryAt < 0 { if summaryAt < 0 {
return original return original
@@ -724,12 +727,13 @@ func compressedHistory(original []Message, view CompressedView, identity string)
// reconstructed; leaving history untouched is the safe answer. // reconstructed; leaving history untouched is the safe answer.
return original 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, original[:head]...)
out = append(out, Message{ out = append(out, messaging.Message{
From: identity, Sender: identity,
Text: view.Messages[summaryAt].Content, Role: messaging.RoleAssistant,
At: summaryInstant(original, head, tail), Text: view.Messages[summaryAt].Content,
At: summaryInstant(original, head, tail),
}) })
out = append(out, original[len(original)-tail:]...) out = append(out, original[len(original)-tail:]...)
return out 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 // summaryInstant returns a time inside the gap the summary fills: after the
// last retained head message and before the first retained tail message. // 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 // The first message the summary replaces is the natural anchor -- the
// summary begins where the summarised span began. // summary begins where the summarised span began.
if head < len(original)-tail { if head < len(original)-tail {
@@ -751,11 +755,11 @@ func summaryInstant(original []Message, head, tail int) time.Time {
return 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)) compressed := make([]CompressedMessage, 0, len(msgs))
for _, h := range msgs { for _, h := range msgs {
role := "user" role := "user"
if h.From == r.Identity { if h.Role == messaging.RoleAssistant {
role = "assistant" role = "assistant"
} }
compressed = append(compressed, CompressedMessage{ 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. // were -- that was unrecoverable loss of a message nobody had seen.
superseded := make([]string, 0, len(msgs)) superseded := make([]string, 0, len(msgs))
for _, m := range msgs { for _, m := range msgs {
if m.MessageID != "" { if m.ID != "" {
superseded = append(superseded, m.MessageID) superseded = append(superseded, string(m.ID))
} }
} }
+27 -25
View File
@@ -9,6 +9,8 @@ import (
"time" "time"
"github.com/google/uuid" "github.com/google/uuid"
"github.com/samcharles93/archie-core/internal/domain/messaging"
) )
// fakeSessionStore implements SessionStore for tests. Messages are // fakeSessionStore implements SessionStore for tests. Messages are
@@ -16,13 +18,13 @@ import (
type fakeSessionStore struct { type fakeSessionStore struct {
mu sync.Mutex mu sync.Mutex
sessions map[string]SessionContext sessions map[string]SessionContext
messages map[string][]Message // sessionID → messages messages map[string][]messaging.Message // sessionID → messages
} }
func newFakeSessionStore() *fakeSessionStore { func newFakeSessionStore() *fakeSessionStore {
return &fakeSessionStore{ return &fakeSessionStore{
sessions: make(map[string]SessionContext), 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) 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() f.mu.Lock()
defer f.mu.Unlock() defer f.mu.Unlock()
f.messages[sessionID] = append(f.messages[sessionID], msg) f.messages[sessionID] = append(f.messages[sessionID], msg)
return nil 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() f.mu.Lock()
defer f.mu.Unlock() defer f.mu.Unlock()
msgs := f.messages[sessionID] msgs := f.messages[sessionID]
@@ -102,7 +104,7 @@ func (f *fakeSessionStore) RecentMessages(_ context.Context, sessionID string, n
return nil, nil return nil, nil
} }
start := max(len(msgs)-n, 0) start := max(len(msgs)-n, 0)
out := make([]Message, len(msgs)-start) out := make([]messaging.Message, len(msgs)-start)
copy(out, msgs[start:]) copy(out, msgs[start:])
return out, nil return out, nil
} }
@@ -125,11 +127,11 @@ func (f *fakeSessionStore) MessageCount(_ context.Context, sessionID string) (in
return len(f.messages[sessionID]), nil 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() f.mu.Lock()
defer f.mu.Unlock() defer f.mu.Unlock()
existing := f.messages[sessionID] existing := f.messages[sessionID]
out := make([]Message, len(existing)+len(msgs)) out := make([]messaging.Message, len(existing)+len(msgs))
copy(out, existing) copy(out, existing)
copy(out[len(existing):], msgs) copy(out[len(existing):], msgs)
f.messages[sessionID] = out f.messages[sessionID] = out
@@ -142,7 +144,7 @@ func (f *fakeSessionStore) SaveMessages(_ context.Context, sessionID string, msg
func (f *fakeSessionStore) ReplaceMessages( func (f *fakeSessionStore) ReplaceMessages(
_ context.Context, _ context.Context,
sessionID string, sessionID string,
msgs []Message, msgs []messaging.Message,
superseded []string, superseded []string,
) error { ) error {
f.mu.Lock() f.mu.Lock()
@@ -153,16 +155,16 @@ func (f *fakeSessionStore) ReplaceMessages(
doomed[id] = struct{}{} 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] { for _, m := range f.messages[sessionID] {
if _, gone := doomed[m.MessageID]; gone { if _, gone := doomed[string(m.ID)]; gone {
continue continue
} }
kept = append(kept, m) kept = append(kept, m)
} }
for _, m := range msgs { for _, m := range msgs {
if m.MessageID == "" { if m.ID == "" {
m.MessageID = uuid.NewString() m.ID = messaging.MessageID(uuid.NewString())
} }
kept = append(kept, m) kept = append(kept, m)
} }
@@ -394,8 +396,8 @@ func TestRouteRetryRemovesLastMessage(t *testing.T) {
CreatedAt: time.Now(), LastActiveAt: time.Now(), CreatedAt: time.Now(), LastActiveAt: time.Now(),
} }
_ = r.sessionTracker.sessions.Save(context.Background(), sc) _ = 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, ToStoredMessage(Message{From: "alice", Text: "hello"}, "archie"))
_ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, Message{From: "archie", Text: "hi there"}) _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, ToStoredMessage(Message{From: "archie", Text: "hi there"}, "archie"))
r.sessionTracker.setActive("chat-9", "", sessionID) r.sessionTracker.setActive("chat-9", "", sessionID)
// Verify initial count. // Verify initial count.
@@ -433,9 +435,9 @@ func TestRouteUndoRemovesOne(t *testing.T) {
CreatedAt: time.Now(), LastActiveAt: time.Now(), CreatedAt: time.Now(), LastActiveAt: time.Now(),
} }
_ = r.sessionTracker.sessions.Save(context.Background(), sc) _ = 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, ToStoredMessage(Message{From: "alice", Text: "msg1"}, "archie"))
_ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, Message{From: "archie", Text: "reply1"}) _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, ToStoredMessage(Message{From: "archie", Text: "reply1"}, "archie"))
_ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, Message{From: "alice", Text: "msg2"}) _ = r.sessionTracker.sessions.SaveMessage(context.Background(), sessionID, ToStoredMessage(Message{From: "alice", Text: "msg2"}, "archie"))
r.sessionTracker.setActive("chat-10", "", sessionID) r.sessionTracker.setActive("chat-10", "", sessionID)
reply, err := r.Route(context.Background(), Message{Text: "/undo", ChannelID: "chat-10"}) 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) _ = r.sessionTracker.sessions.Save(context.Background(), sc)
for i := range 5 { 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) r.sessionTracker.setActive("chat-11", "", sessionID)
@@ -494,9 +496,9 @@ func TestRouteUndoReportsActualPartialRemoval(t *testing.T) {
t.Fatalf("Save session: %v", err) t.Fatalf("Save session: %v", err)
} }
for i := range 6 { 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), From: "alice", Text: fmt.Sprintf("msg%d", i),
}); err != nil { }, "archie")); err != nil {
t.Fatalf("SaveMessage(%d): %v", i, err) t.Fatalf("SaveMessage(%d): %v", i, err)
} }
} }
@@ -613,8 +615,8 @@ func TestRouteBranchCreatesChildSession(t *testing.T) {
parentID := r.sessionTracker.getActive("chat-17", "") parentID := r.sessionTracker.getActive("chat-17", "")
// Add messages to parent. // Add messages to parent.
_ = r.sessionTracker.sessions.SaveMessage(context.Background(), parentID, Message{From: "alice", Text: "hello"}) _ = r.sessionTracker.sessions.SaveMessage(context.Background(), parentID, ToStoredMessage(Message{From: "alice", Text: "hello"}, "archie"))
_ = r.sessionTracker.sessions.SaveMessage(context.Background(), parentID, Message{From: "archie", Text: "hi"}) _ = r.sessionTracker.sessions.SaveMessage(context.Background(), parentID, ToStoredMessage(Message{From: "archie", Text: "hi"}, "archie"))
// Branch. // Branch.
reply, err := r.Route(context.Background(), Message{Text: "/branch experiment", ChannelID: "chat-17"}) 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"}) _, _ = r.Route(context.Background(), Message{Text: "/new parent", ChannelID: "chat-18"})
parentID := r.sessionTracker.getActive("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"}) reply, err := r.Route(context.Background(), Message{Text: "/fork", ChannelID: "chat-18"})
if err != nil { if err != nil {
@@ -674,7 +676,7 @@ func TestRouteCompressPreview(t *testing.T) {
// Add a bunch of messages (not enough to trigger compression by default). // Add a bunch of messages (not enough to trigger compression by default).
for i := range 10 { 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"}) 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", "") sessionID := r.sessionTracker.getActive("chat-20", "")
for i := range 5 { 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"}) reply, err := r.Route(context.Background(), Message{Text: "/compact --dry-run", ChannelID: "chat-20"})
+1 -1
View File
@@ -171,7 +171,7 @@ func TestRouteDeleteRemovesSessionAndItsHistory(t *testing.T) {
r, store := newDeleteRouter(t) r, store := newDeleteRouter(t)
id := seedSession(t, r, store, "abcd-123", "chan-1", "Work") id := seedSession(t, r, store, "abcd-123", "chan-1", "Work")
for _, text := range []string{"first", "second"} { 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) t.Fatalf("seed message: %v", err)
} }
} }
+27 -10
View File
@@ -7,10 +7,22 @@ import (
"time" "time"
"github.com/google/uuid" "github.com/google/uuid"
"github.com/samcharles93/archie-core/internal/domain/messaging"
) )
// SessionStore persists gateway session metadata and conversation history. // SessionStore persists gateway session metadata and conversation history.
// Each session tracks one platform, bot, and channel combination. // 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 { type SessionStore interface {
SessionLifecycle SessionLifecycle
MessageHistory MessageHistory
@@ -32,21 +44,23 @@ type SessionLifecycle interface {
List(ctx context.Context) ([]SessionContext, error) 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 { type MessageHistory interface {
// SaveMessage appends one message with a strictly increasing timestamp. // 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 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 removes up to n messages and returns the count.
DeleteRecentMessages(ctx context.Context, sessionID string, n int) (deleted int, err error) DeleteRecentMessages(ctx context.Context, sessionID string, n int) (deleted int, err error)
// MessageCount returns the number of stored messages in a session. // MessageCount returns the number of stored messages in a session.
MessageCount(ctx context.Context, sessionID string) (int, error) MessageCount(ctx context.Context, sessionID string) (int, error)
// SaveMessages appends messages used to inherit branch history. // 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. // ReplaceMessages writes replacements before deleting superseded messages.
// Records absent from both inputs remain untouched. // 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 searches the session's full history.
SearchMessages(ctx context.Context, sessionID string, q MessageQuery) (MessagePage, error) SearchMessages(ctx context.Context, sessionID string, q MessageQuery) (MessagePage, error)
// Close releases the database. // Close releases the database.
@@ -65,7 +79,7 @@ type MessageQuery struct {
// MessagePage is one page of search results. // MessagePage is one page of search results.
type MessagePage struct { type MessagePage struct {
// Messages are ordered by relevance. // Messages are ordered by relevance.
Messages []Message Messages []messaging.Message
// NextOffset is meaningful only when HasMore is true. // NextOffset is meaningful only when HasMore is true.
NextOffset int NextOffset int
HasMore bool HasMore bool
@@ -131,7 +145,7 @@ func encodeCanonicalPair(first, second string) []byte {
return encoded return encoded
} }
func stamp(msg Message) time.Time { func stamp(msg messaging.Message) time.Time {
now := time.Now().UTC() now := time.Now().UTC()
if msg.At.IsZero() || msg.At.After(now) { if msg.At.IsZero() || msg.At.After(now) {
// At orders the canonical conversation; it is not an authoritative // 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. // 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 == "" { if sourceID == "" {
return "" return ""
} }
id, legacyID := canonicalMessageIDs(sessionID, sourceID) id, legacyID := canonicalMessageIDs(sessionID, sourceID)
for i, message := range history { for i, message := range history {
if message.MessageID != id && message.MessageID != legacyID { if string(message.ID) != id && string(message.ID) != legacyID {
continue 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) { !isCompressionSummary(history[i+1].Text) {
return history[i+1].Text return history[i+1].Text
} }
+76 -31
View File
@@ -13,6 +13,8 @@ import (
"time" "time"
_ "modernc.org/sqlite" _ "modernc.org/sqlite"
"github.com/samcharles93/archie-core/internal/domain/messaging"
) )
// ── SQLite implementation ─────────────────────────────────────────────────── // ── SQLite implementation ───────────────────────────────────────────────────
@@ -68,6 +70,7 @@ CREATE TABLE IF NOT EXISTS messages (
session_id TEXT NOT NULL, session_id TEXT NOT NULL,
source_id TEXT NOT NULL DEFAULT '', source_id TEXT NOT NULL DEFAULT '',
sender TEXT NOT NULL DEFAULT '', sender TEXT NOT NULL DEFAULT '',
role TEXT NOT NULL DEFAULT '',
text TEXT NOT NULL DEFAULT '', text TEXT NOT NULL DEFAULT '',
ts INTEGER NOT NULL, ts INTEGER NOT NULL,
UNIQUE(session_id, message_id) UNIQUE(session_id, message_id)
@@ -162,6 +165,24 @@ func openSQLiteSessionStore(dsn string) (SessionStore, error) {
!strings.Contains(err.Error(), "duplicate column name") { !strings.Contains(err.Error(), "duplicate column name") {
return nil, errors.Join(fmt.Errorf("sessionstore: migrate turns table: %w", err), db.Close()) 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 { if err := repairFutureMessageTimestamps(ctx, db, time.Now().UTC()); err != nil {
return nil, errors.Join(err, db.Close()) return nil, errors.Join(err, db.Close())
} }
@@ -704,7 +725,7 @@ type execer interface {
QueryRowContext(ctx context.Context, query string, args ...any) *sql.Row 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() s.mu.Lock()
defer s.mu.Unlock() defer s.mu.Unlock()
_, err := saveMessage(ctx, s.db, sessionID, msg) _, 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 // 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 // untouched: stored messages are immutable, so a redelivered edit is a
// no-op rather than an overwrite. // 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) return saveMessageAt(ctx, ex, sessionID, msg, true)
} }
// saveMessageAt writes a message, optionally without the monotonic clamp. // saveMessageAt writes a message, optionally without the monotonic clamp.
// The clamp belongs to the append path, not to a caller rewriting history and // The clamp belongs to the append path, not to a caller rewriting history and
// placing records deliberately. // placing records deliberately.
func saveMessageAt(ctx context.Context, ex execer, sessionID string, msg Message, clamp bool) (string, error) { func saveMessageAt(ctx context.Context, ex execer, sessionID string, msg messaging.Message, clamp bool) (string, error) {
id := msg.MessageID id := string(msg.ID)
legacyID := "" legacyID := ""
if msg.SourceID == "" { if msg.SourceID == "" {
if id == "" { if id == "" {
@@ -744,6 +765,13 @@ func saveMessageAt(ctx context.Context, ex execer, sessionID string, msg Message
legacyID = compatibleLegacyID 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 != "" { if legacyID != "" {
var existingID string var existingID string
err := ex.QueryRowContext(ctx, err := ex.QueryRowContext(ctx,
@@ -759,8 +787,8 @@ func saveMessageAt(ctx context.Context, ex execer, sessionID string, msg Message
at := stamp(msg) at := stamp(msg)
if clamp { if clamp {
_, err := ex.ExecContext(ctx, ` _, err := ex.ExecContext(ctx, `
INSERT INTO messages (message_id, session_id, source_id, sender, text, ts) INSERT INTO messages (message_id, session_id, source_id, sender, role, text, ts)
VALUES (?, ?, ?, ?, ?, ( VALUES (?, ?, ?, ?, ?, ?, (
SELECT CASE SELECT CASE
WHEN MAX(ts) IS NOT NULL AND MAX(ts) >= ? THEN MAX(ts) + 1 WHEN MAX(ts) IS NOT NULL AND MAX(ts) >= ? THEN MAX(ts) + 1
ELSE ? ELSE ?
@@ -768,7 +796,7 @@ func saveMessageAt(ctx context.Context, ex execer, sessionID string, msg Message
FROM messages WHERE session_id = ? FROM messages WHERE session_id = ?
)) ))
ON CONFLICT(session_id, message_id) DO NOTHING`, 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) at.UnixMilli(), at.UnixMilli(), sessionID)
if err != nil { if err != nil {
return "", fmt.Errorf("sessionstore: save message: %w", err) 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, ` _, err = ex.ExecContext(ctx, `
INSERT INTO messages (message_id, session_id, source_id, sender, text, ts) INSERT INTO messages (message_id, session_id, source_id, sender, role, text, ts)
VALUES (?, ?, ?, ?, ?, ?)`, VALUES (?, ?, ?, ?, ?, ?, ?)`,
id, sessionID, msg.SourceID, msg.From, msg.Text, at.UnixMilli()) id, sessionID, msg.SourceID, msg.Sender, role, msg.Text, at.UnixMilli())
if err != nil { if err != nil {
return "", fmt.Errorf("sessionstore: save message: %w", err) return "", fmt.Errorf("sessionstore: save message: %w", err)
} }
return id, nil 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() s.mu.Lock()
defer s.mu.Unlock() defer s.mu.Unlock()
@@ -833,7 +861,7 @@ func (s *sqliteSessionStore) SaveMessages(ctx context.Context, sessionID string,
func (s *sqliteSessionStore) ReplaceMessages( func (s *sqliteSessionStore) ReplaceMessages(
ctx context.Context, ctx context.Context,
sessionID string, sessionID string,
msgs []Message, msgs []messaging.Message,
superseded []string, superseded []string,
) error { ) error {
s.mu.Lock() s.mu.Lock()
@@ -914,15 +942,21 @@ func (s *sqliteSessionStore) FindPriorReply(ctx context.Context, sessionID, sour
return text, nil 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 { if n <= 0 {
return nil, nil 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, ` rows, err := s.db.QueryContext(ctx, `
SELECT message_id, source_id, sender, text, ts FROM ( SELECT m.message_id, m.source_id, m.sender, m.role, m.text, m.ts,
SELECT message_id, source_id, sender, text, ts FROM messages 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 ? 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 { if err != nil {
return nil, fmt.Errorf("sessionstore: recent messages: %w", err) 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 return n, nil
} }
func scanMessages(rows *sql.Rows) ([]Message, error) { func scanMessages(rows *sql.Rows) ([]messaging.Message, error) {
defer func() { _ = rows.Close() }() defer func() { _ = rows.Close() }()
var out []Message var out []messaging.Message
for rows.Next() { for rows.Next() {
var ( var (
msg Message msg messaging.Message
ts int64 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) 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() msg.At = time.UnixMilli(ts).UTC()
out = append(out, msg) out = append(out, msg)
} }
@@ -1021,9 +1060,11 @@ func (s *sqliteSessionStore) SearchMessages(ctx context.Context, sessionID strin
} }
rows, err := s.db.QueryContext(ctx, ` 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 FROM messages_fts
JOIN messages m ON m.id = messages_fts.rowid 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 = ? WHERE messages_fts MATCH ? AND m.session_id = ?
ORDER BY bm25(messages_fts) ASC ORDER BY bm25(messages_fts) ASC
LIMIT ? OFFSET ?`, match, sessionID, limit, offset) LIMIT ? OFFSET ?`, match, sessionID, limit, offset)
@@ -1044,21 +1085,25 @@ func (s *sqliteSessionStore) SearchMessages(ctx context.Context, sessionID strin
}, nil }, nil
} }
// scanSearchMessages scans rows shaped (message_id, source_id, sender, text, // scanSearchMessages scans rows shaped (message_id, source_id, sender,
// ts) -- the same column order SearchMessages selects, distinct from // role, text, ts, channel_id, thread_id) -- the same column order
// scanMessages' column order because the FTS join names "sender" rather // SearchMessages selects.
// than the "from" convention the rest of the file uses. func scanSearchMessages(rows *sql.Rows) ([]messaging.Message, error) {
func scanSearchMessages(rows *sql.Rows) ([]Message, error) {
defer func() { _ = rows.Close() }() defer func() { _ = rows.Close() }()
var out []Message var out []messaging.Message
for rows.Next() { for rows.Next() {
var ( var (
msg Message msg messaging.Message
ts int64 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) 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() msg.At = time.UnixMilli(ts).UTC()
out = append(out, msg) out = append(out, msg)
} }
+108 -47
View File
@@ -11,6 +11,8 @@ import (
"time" "time"
"github.com/google/uuid" "github.com/google/uuid"
"github.com/samcharles93/archie-core/internal/domain/messaging"
) )
func newTestSQLiteStore(t *testing.T) SessionStore { func newTestSQLiteStore(t *testing.T) SessionStore {
@@ -247,9 +249,9 @@ func TestSQLiteSessionStoreRecognisesLegacyCanonicalIDOnRedelivery(t *testing.T)
t.Fatalf("seed legacy message: %v", err) t.Fatalf("seed legacy message: %v", err)
} }
if err := store.SaveMessage(ctx, sessionID, Message{ if err := store.SaveMessage(ctx, sessionID, messaging.Message{
MessageID: CanonicalMessageID(sessionID, sourceID), ID: messaging.MessageID(CanonicalMessageID(sessionID, sourceID)),
SourceID: sourceID, From: "alice", Text: "redelivered", SourceID: sourceID, Sender: "alice", Role: messaging.RoleUser, Text: "redelivered",
}); err != nil { }); err != nil {
t.Fatalf("SaveMessage(redelivery): %v", err) t.Fatalf("SaveMessage(redelivery): %v", err)
} }
@@ -260,7 +262,7 @@ func TestSQLiteSessionStoreRecognisesLegacyCanonicalIDOnRedelivery(t *testing.T)
if len(messages) != 1 { if len(messages) != 1 {
t.Fatalf("redelivery produced %d messages, want 1", len(messages)) 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]) t.Fatalf("legacy message changed on redelivery: %#v", messages[0])
} }
} }
@@ -315,13 +317,13 @@ func TestSQLiteSessionStoreCapsFutureMessageTimestamp(t *testing.T) {
store := newTestSQLiteStore(t) store := newTestSQLiteStore(t)
ctx := t.Context() ctx := t.Context()
now := time.Now().UTC() now := time.Now().UTC()
if err := store.SaveMessage(ctx, "sess", Message{ if err := store.SaveMessage(ctx, "sess", messaging.Message{
From: "alice", Text: "future", At: now.Add(24 * time.Hour), Sender: "alice", Role: messaging.RoleUser, Text: "future", At: now.Add(24 * time.Hour),
}); err != nil { }); err != nil {
t.Fatalf("SaveMessage(future): %v", err) t.Fatalf("SaveMessage(future): %v", err)
} }
if err := store.SaveMessage(ctx, "sess", Message{ if err := store.SaveMessage(ctx, "sess", messaging.Message{
From: "alice", Text: "current", At: now, Sender: "alice", Role: messaging.RoleUser, Text: "current", At: now,
}); err != nil { }); err != nil {
t.Fatalf("SaveMessage(current): %v", err) t.Fatalf("SaveMessage(current): %v", err)
} }
@@ -377,8 +379,8 @@ func TestSQLiteSessionStoreRepairsPersistedFutureTimestampsOnReopen(t *testing.T
t.Fatalf("reopen store: %v", err) t.Fatalf("reopen store: %v", err)
} }
t.Cleanup(func() { _ = reopened.Close() }) t.Cleanup(func() { _ = reopened.Close() })
if err := reopened.SaveMessage(ctx, "sess", Message{ if err := reopened.SaveMessage(ctx, "sess", messaging.Message{
From: "alice", Text: "current", At: time.Now().UTC(), Sender: "alice", Role: messaging.RoleUser, Text: "current", At: time.Now().UTC(),
}); err != nil { }); err != nil {
t.Fatalf("SaveMessage(current): %v", err) t.Fatalf("SaveMessage(current): %v", err)
} }
@@ -406,7 +408,7 @@ func TestSQLiteSessionStoreRepairsPersistedFutureTimestampsOnReopen(t *testing.T
func TestSQLiteMessageTimestampRoundTrips(t *testing.T) { func TestSQLiteMessageTimestampRoundTrips(t *testing.T) {
st := newTestSQLiteStore(t) st := newTestSQLiteStore(t)
want := sqliteBase().Add(90*time.Minute + 123*time.Millisecond) 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) t.Fatal(err)
} }
got, err := st.RecentMessages(t.Context(), "sess", 1) got, err := st.RecentMessages(t.Context(), "sess", 1)
@@ -436,11 +438,11 @@ func TestSQLiteMessageTimestampsIncreaseAcrossStoreHandles(t *testing.T) {
for storeIndex, st := range stores { for storeIndex, st := range stores {
for messageIndex := range perStore { for messageIndex := range perStore {
wg.Go(func() { wg.Go(func() {
err := st.SaveMessage(t.Context(), "sess", Message{ err := st.SaveMessage(t.Context(), "sess", messaging.Message{
MessageID: fmt.Sprintf("%d-%d", storeIndex, messageIndex), ID: messaging.MessageID(fmt.Sprintf("%d-%d", storeIndex, messageIndex)),
From: "user", Sender: "user", Role: messaging.RoleUser,
Text: "concurrent", Text: "concurrent",
At: wantTime, At: wantTime,
}) })
if err != nil { if err != nil {
t.Errorf("SaveMessage: %v", err) t.Errorf("SaveMessage: %v", err)
@@ -477,7 +479,7 @@ func TestSQLiteSessionStore_DeleteIsAtomic(t *testing.T) {
if err := st.Save(ctx, sc); err != nil { if err := st.Save(ctx, sc); err != nil {
t.Fatalf("Save: %v", err) 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) t.Fatalf("SaveMessage: %v", err)
} }
@@ -515,7 +517,7 @@ func TestSQLiteSessionStore_SearchPagingAndTruncated(t *testing.T) {
const total = 30 const total = 30
for i := range total { 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 { if err := st.SaveMessage(ctx, "sess", m); err != nil {
t.Fatalf("SaveMessage %d: %v", i, err) 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") t.Errorf("expected Truncated=false for SQLite backend")
} }
for _, m := range page.Messages { for _, m := range page.Messages {
if seen[m.MessageID] { if seen[string(m.ID)] {
t.Errorf("duplicate message across pages: %s", m.MessageID) t.Errorf("duplicate message across pages: %s", string(m.ID))
} }
seen[m.MessageID] = true seen[string(m.ID)] = true
} }
pages++ pages++
if !page.HasMore { if !page.HasMore {
@@ -570,7 +572,7 @@ func TestSQLiteSessionStore_ErrorPaths(t *testing.T) {
} }
}) })
t.Run("SaveMessage after close", func(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") 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 // 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 // with its own mutex, so a test touching this handle between operations is
// safe and deterministic. // 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 { func sqliteStoreDB(t *testing.T, st SessionStore) *sql.DB {
t.Helper() t.Helper()
s, ok := st.(*sqliteSessionStore) s, ok := st.(*sqliteSessionStore)
@@ -683,13 +744,13 @@ func TestSQLiteSessionStore_CloseReopenDurability(t *testing.T) {
t.Fatalf("Save: %v", err) t.Fatalf("Save: %v", err)
} }
wantMsgs := []Message{ wantMsgs := []messaging.Message{
{MessageID: "canonical-1", SourceID: "tg-1001", From: "alice", Text: "first durable message", At: sqliteBase().Add(time.Second)}, {ID: "canonical-1", SourceID: "tg-1001", Sender: "alice", Role: messaging.RoleUser, 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)}, {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 { for _, m := range wantMsgs {
if err := st.SaveMessage(ctx, "sess-durable", m); err != nil { 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 { if err := st.Close(); err != nil {
@@ -722,8 +783,8 @@ func TestSQLiteSessionStore_CloseReopenDurability(t *testing.T) {
} }
for i, m := range hist { for i, m := range hist {
want := wantMsgs[i] want := wantMsgs[i]
if m.MessageID != want.MessageID || m.SourceID != want.SourceID || if m.ID != want.ID || m.SourceID != want.SourceID ||
m.From != want.From || m.Text != want.Text || !m.At.Equal(want.At) { 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) 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 { if err := st.Save(ctx, sc); err != nil {
t.Fatalf("Save: %v", err) t.Fatalf("Save: %v", err)
} }
seed := []Message{ seed := []messaging.Message{
{From: "alice", Text: "alpha", At: sqliteBase()}, {Sender: "alice", Role: messaging.RoleUser, Text: "alpha", At: sqliteBase()},
{From: "bob", Text: "beta", At: sqliteBase().Add(time.Second)}, {Sender: "bob", Role: messaging.RoleUser, Text: "beta", At: sqliteBase().Add(time.Second)},
{From: "carol", Text: "gamma", At: sqliteBase().Add(2 * time.Second)}, {Sender: "carol", Role: messaging.RoleUser, Text: "gamma", At: sqliteBase().Add(2 * time.Second)},
} }
for _, m := range seed { for _, m := range seed {
if err := st.SaveMessage(ctx, "sess-del-abort", m); err != nil { 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)) t.Fatalf("history after failed Delete: got %d messages, want %d", len(hist), len(seed))
} }
for i, m := range hist { for i, m := range hist {
if m.Text != seed[i].Text || m.From != 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].From) 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() ctx := context.Background()
st := newTestSQLiteStore(t) st := newTestSQLiteStore(t)
seed := []Message{ seed := []messaging.Message{
{MessageID: "m-0", SourceID: "s-0", From: "alice", Text: "alpha", At: sqliteBase()}, {ID: "m-0", SourceID: "s-0", Sender: "alice", Role: messaging.RoleUser, Text: "alpha", At: sqliteBase()},
{MessageID: "m-1", SourceID: "s-1", From: "bob", Text: "beta", At: sqliteBase().Add(time.Second)}, {ID: "m-1", SourceID: "s-1", Sender: "bob", Role: messaging.RoleUser, Text: "beta", At: sqliteBase().Add(time.Second)},
{MessageID: "m-2", SourceID: "s-2", From: "carol", Text: "gamma", At: sqliteBase().Add(2 * 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 { if err := st.SaveMessages(ctx, "sess-replace-abort", seed); err != nil {
t.Fatalf("SaveMessages: %v", err) t.Fatalf("SaveMessages: %v", err)
@@ -842,7 +903,7 @@ func TestSQLiteSessionStore_ReplaceMessagesAbortRollsBack(t *testing.T) {
// inserts have landed inside the transaction. // inserts have landed inside the transaction.
installAbortTrigger(t, st, `BEFORE DELETE ON messages WHEN old.message_id = 'm-1'`) 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 { 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") 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)) t.Fatalf("history after failed ReplaceMessages: got %d messages, want %d", len(hist), len(seed))
} }
for i, m := range hist { 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]) 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", name: "ReplaceMessages swaps the document set",
mutate: func(ctx context.Context, t *testing.T, st SessionStore) error { mutate: func(ctx context.Context, t *testing.T, st SessionStore) error {
return st.ReplaceMessages(ctx, "a", []Message{{ return st.ReplaceMessages(ctx, "a", []messaging.Message{{
From: "summarizer", Text: "merged needle summary", At: sqliteBase().Add(time.Hour), Sender: "summarizer", Role: messaging.RoleUser, Text: "merged needle summary", At: sqliteBase().Add(time.Hour),
}}, supersededIDs(ctx, t, st, "a")) }}, supersededIDs(ctx, t, st, "a"))
}, },
wantA: []string{"merged needle summary"}, wantA: []string{"merged needle summary"},
@@ -1001,12 +1062,12 @@ func TestSQLiteSessionStore_FTSStaysCorrectThroughMutations(t *testing.T) {
st := newTestSQLiteStore(t) st := newTestSQLiteStore(t)
for i, text := range seedA { 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) t.Fatalf("SaveMessage a %q: %v", text, err)
} }
} }
for i, text := range seedB { 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) t.Fatalf("SaveMessage b %q: %v", text, err)
} }
} }
@@ -1086,7 +1147,7 @@ func TestSQLiteSessionStore_FTSIntegrityCheckDetectsOrphanedIndex(t *testing.T)
st := newTestSQLiteStore(t) st := newTestSQLiteStore(t)
for i, text := range []string{"needle one", "needle two"} { 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) t.Fatalf("SaveMessage: %v", err)
} }
} }
@@ -1110,7 +1171,7 @@ func TestSQLiteSessionStore_FTSIntegrityCheckDetectsOrphanedIndex(t *testing.T)
st := newTestSQLiteStore(t) st := newTestSQLiteStore(t)
for i, text := range []string{"needle one", "needle two"} { 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) t.Fatalf("SaveMessage: %v", err)
} }
} }
@@ -1149,7 +1210,7 @@ func TestSQLiteSessionStore_HostileQueriesAreLiteral(t *testing.T) {
"beta alone", "beta alone",
} }
for i, text := range seed { 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) t.Fatalf("SaveMessage %q: %v", text, err)
} }
} }
+2 -2
View File
@@ -400,10 +400,10 @@ func TestRetryAutoTitlesUntitledSession(t *testing.T) {
t.Fatalf("resolve: %v", err) t.Fatalf("resolve: %v", err)
} }
gen.titles[sessionID] = "Deploy worker" 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) 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) t.Fatalf("save reply: %v", err)
} }
if _, err := r.Route(ctx, Message{ChannelID: "ch", From: "u", Text: "/retry"}); err != nil { if _, err := r.Route(ctx, Message{ChannelID: "ch", From: "u", Text: "/retry"}); err != nil {
@@ -5,6 +5,8 @@ import (
"fmt" "fmt"
"testing" "testing"
"time" "time"
"github.com/samcharles93/archie-core/internal/domain/messaging"
) )
// base is a fixed instant so message timestamps are deterministic; tests // 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. // dur spaces the nth message one second apart from the first.
func dur(n int) time.Duration { return time.Duration(n) * time.Second } func dur(n int) time.Duration { return time.Duration(n) * time.Second }
func msg(text string, offset time.Duration) Message { func msg(text string, offset time.Duration) messaging.Message {
return Message{From: "user", Text: text, At: at(offset)} 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)) out := make([]string, 0, len(msgs))
for _, m := range msgs { for _, m := range msgs {
out = append(out, m.Text) 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)) ids := make([]string, 0, len(msgs))
for _, m := range msgs { for _, m := range msgs {
ids = append(ids, m.MessageID) ids = append(ids, string(m.ID))
} }
return ids return ids
} }
@@ -352,7 +354,7 @@ func testSaveMessagesAppends(t *testing.T, newStore func(t *testing.T) SessionSt
offset += time.Second offset += time.Second
} }
bulk := make([]Message, 0, len(tc.bulk)) bulk := make([]messaging.Message, 0, len(tc.bulk))
for _, text := range tc.bulk { for _, text := range tc.bulk {
bulk = append(bulk, msg(text, offset)) bulk = append(bulk, msg(text, offset))
offset += time.Second offset += time.Second
@@ -479,11 +481,11 @@ func testReplyCannotPrecedeItsPrompt(t *testing.T, newStore func(t *testing.T) S
s := newStore(t) s := newStore(t)
t.Cleanup(func() { _ = s.Close() }) 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 { if err := s.SaveMessage(ctx, "sess", reply); err != nil {
t.Fatalf("SaveMessage reply: %v", err) 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 { if err := s.SaveMessage(ctx, "sess", next); err != nil {
t.Fatalf("SaveMessage next: %v", err) t.Fatalf("SaveMessage next: %v", err)
} }
@@ -504,7 +506,7 @@ func testUpstreamRedeliveryKeepsOriginalTime(t *testing.T, newStore func(t *test
s := newStore(t) s := newStore(t)
t.Cleanup(func() { _ = s.Close() }) 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 { if err := s.SaveMessage(ctx, "sess", first); err != nil {
t.Fatalf("SaveMessage: %v", err) t.Fatalf("SaveMessage: %v", err)
} }
@@ -543,7 +545,7 @@ func testSaveMessageStampsMissingTimestamp(t *testing.T, newStore func(t *testin
t.Cleanup(func() { _ = s.Close() }) t.Cleanup(func() { _ = s.Close() })
before := time.Now().UTC().Add(-time.Second) 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) t.Fatalf("SaveMessage: %v", err)
} }
after := time.Now().UTC().Add(time.Second) 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() }) t.Cleanup(func() { _ = s.Close() })
const sourceID = "tg-42" 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) t.Fatalf("SaveMessage: %v", err)
} }
first, err := s.RecentMessages(ctx, "sess", 1) 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 { if len(first) != 1 {
t.Fatalf("got %d messages, want 1", len(first)) 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") 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) 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) t.Fatalf("redeliver: %v", err)
} }
again, err := s.RecentMessages(ctx, "sess", 10) 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 { if len(again) != 1 {
t.Fatalf("redelivery produced %d messages, want 1", len(again)) t.Fatalf("redelivery produced %d messages, want 1", len(again))
} }
if again[0].MessageID != first[0].MessageID { if string(again[0].ID) != string(first[0].ID) {
t.Errorf("MessageID changed from %q to %q across redelivery", first[0].MessageID, again[0].MessageID) 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() }) t.Cleanup(func() { _ = s.Close() })
const sourceID = "tg-777" 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) 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 { if first[0].SourceID != sourceID {
t.Errorf("SourceID = %q after save, want %q", 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") 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 equals SourceID; the canonical ID must be application-generated", first[0].MessageID) 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 // Redelivery of the same upstream message must keep its SourceID and
// canonical identity and must not append a second turn. // 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) t.Fatalf("redeliver: %v", err)
} }
again, err := s.RecentMessages(ctx, "sess", 10) 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 { if again[0].SourceID != sourceID {
t.Errorf("SourceID = %q after redelivery, want %q", again[0].SourceID, sourceID) t.Errorf("SourceID = %q after redelivery, want %q", again[0].SourceID, sourceID)
} }
if again[0].MessageID != first[0].MessageID { if string(again[0].ID) != string(first[0].ID) {
t.Errorf("MessageID changed from %q to %q across redelivery", first[0].MessageID, again[0].MessageID) 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 // A message with no upstream identity -- the shape of a document written
// before source_id was persisted -- must read back with an empty // before source_id was persisted -- must read back with an empty
// SourceID, not a zero-value artifact or an error. // 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) t.Fatalf("SaveMessage without SourceID: %v", err)
} }
got, err := s.RecentMessages(ctx, "sess", 10) 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) s := newStore(t)
t.Cleanup(func() { _ = s.Close() }) 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 { if err := s.SaveMessage(ctx, "sess", m); err != nil {
t.Fatalf("SaveMessage: %v", err) 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) { func testMessageDeduplication(t *testing.T, newStore func(t *testing.T) SessionStore) {
tests := []struct { tests := []struct {
name string name string
saves []Message saves []messaging.Message
want []string want []string
}{ }{
{ {
name: "same upstream ID saved twice", name: "same upstream ID saved twice",
saves: []Message{ saves: []messaging.Message{
{SourceID: "tg-100", From: "u", Text: "hello", At: at(0)}, {SourceID: "tg-100", Sender: "u", Role: messaging.RoleUser, Text: "hello", At: at(0)},
{SourceID: "tg-100", From: "u", Text: "hello", At: at(0)}, {SourceID: "tg-100", Sender: "u", Role: messaging.RoleUser, Text: "hello", At: at(0)},
}, },
want: []string{"hello"}, want: []string{"hello"},
}, },
{ {
name: "distinct upstream IDs both persist", name: "distinct upstream IDs both persist",
saves: []Message{ saves: []messaging.Message{
{SourceID: "tg-100", From: "u", Text: "first", At: at(0)}, {SourceID: "tg-100", Sender: "u", Role: messaging.RoleUser, Text: "first", At: at(0)},
{SourceID: "tg-101", From: "u", Text: "second", At: at(dur(1))}, {SourceID: "tg-101", Sender: "u", Role: messaging.RoleUser, Text: "second", At: at(dur(1))},
}, },
want: []string{"first", "second"}, want: []string{"first", "second"},
}, },
{ {
name: "redelivery with edited text leaves the record intact", name: "redelivery with edited text leaves the record intact",
saves: []Message{ saves: []messaging.Message{
{SourceID: "tg-100", From: "u", Text: "original", At: at(0)}, {SourceID: "tg-100", Sender: "u", Role: messaging.RoleUser, Text: "original", At: at(0)},
{SourceID: "tg-100", From: "u", Text: "edited", At: at(0)}, {SourceID: "tg-100", Sender: "u", Role: messaging.RoleUser, Text: "edited", At: at(0)},
}, },
want: []string{"original"}, want: []string{"original"},
}, },
{ {
name: "messages without an upstream ID are never deduplicated", name: "messages without an upstream ID are never deduplicated",
saves: []Message{ saves: []messaging.Message{
{From: "u", Text: "same", At: at(0)}, {Sender: "u", Role: messaging.RoleUser, Text: "same", At: at(0)},
{From: "u", Text: "same", At: at(0)}, {Sender: "u", Role: messaging.RoleUser, Text: "same", At: at(0)},
}, },
want: []string{"same", "same"}, 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 { for i, text := range tc.replacement {
replacement = append(replacement, msg(text, dur(len(tc.existing)+i))) 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) 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) t.Fatalf("ReplaceMessages: %v", err)
} }
got, err := s.RecentMessages(ctx, "sess", 100) 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() }) t.Cleanup(func() { _ = s.Close() })
for i, text := range []string{"keep-a", "keep-b", "drop"} { 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 { if err := s.SaveMessage(ctx, "sess", m); err != nil {
t.Fatalf("SaveMessage: %v", err) t.Fatalf("SaveMessage: %v", err)
} }
@@ -1148,13 +1150,20 @@ func testSearchMatchesTextNotMetadata(t *testing.T, newStore func(t *testing.T)
s := newStore(t) s := newStore(t)
t.Cleanup(func() { _ = s.Close() }) t.Cleanup(func() { _ = s.Close() })
if err := s.SaveMessage(ctx, "sess", Message{ // The conversation address rides the record but is resolved
From: "alice", Text: "hello world", ChannelID: "chan-xyz", ThreadID: "thread-xyz", At: base, // 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 { }); err != nil {
t.Fatalf("SaveMessage: %v", err) t.Fatalf("SaveMessage: %v", err)
} }
if err := s.SaveMessage(ctx, "sess", Message{ if err := s.SaveMessage(ctx, "sess", messaging.Message{
From: "bob", Text: "goodbye", ChannelID: "chan-xyz", ThreadID: "thread-xyz", At: at(time.Second), Sender: "bob", Role: messaging.RoleUser, Text: "goodbye",
ConversationID: messaging.ConversationID{ChannelID: "chan-xyz", ThreadID: "thread-xyz"},
At: at(time.Second),
}); err != nil { }); err != nil {
t.Fatalf("SaveMessage: %v", err) t.Fatalf("SaveMessage: %v", err)
} }
+18 -12
View File
@@ -8,6 +8,7 @@ import (
"sync" "sync"
"time" "time"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/events" "github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/tools" "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 // (text, err); done is false when there is no prior reply to replay and
// Run should continue generating one. // Run should continue generating one.
func (r *TurnRunner) replayPriorReply( 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) { ) (string, bool, error) {
prior := PriorReply(history, sessionID, msg.SourceID, r.BotUser) prior := PriorReply(history, sessionID, msg.SourceID)
if prior == "" && msg.SourceID != "" { if prior == "" && msg.SourceID != "" {
if replayStore, ok := r.Sessions.(TurnReplayStore); ok { if replayStore, ok := r.Sessions.(TurnReplayStore); ok {
var err error 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 // the turn's input on first sight, and folds it into history if it is not
// already present there. // already present there.
func (r *TurnRunner) recordInboundMessage( func (r *TurnRunner) recordInboundMessage(
ctx context.Context, turn *TurnRecord, sessionID string, msg Message, history []Message, ctx context.Context, turn *TurnRecord, sessionID string, msg Message, history []messaging.Message,
) (Message, []Message, error) { ) (Message, []messaging.Message, error) {
msg.MessageID = messageIDForTurn(sessionID, msg) msg.MessageID = messageIDForTurn(sessionID, msg)
stored := ToStoredMessage(msg, r.BotUser)
if turn.InputMessageID == "" { 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) return msg, history, fmt.Errorf("save inbound chat message: %w", err)
} }
turn.InputMessageID = msg.MessageID turn.InputMessageID = msg.MessageID
@@ -263,9 +265,10 @@ func (r *TurnRunner) recordInboundMessage(
} }
} else { } else {
msg.MessageID = turn.InputMessageID msg.MessageID = turn.InputMessageID
stored.ID = messaging.MessageID(turn.InputMessageID)
} }
if !messageInHistory(history, msg.SourceID) { if !messageInHistory(history, msg.SourceID) {
history = append(history, msg) history = append(history, stored)
} }
return msg, history, nil return msg, history, nil
} }
@@ -282,8 +285,8 @@ type preparedTurn struct {
// prepareTurn builds the tools, system prompt, and compressed history view // prepareTurn builds the tools, system prompt, and compressed history view
// for one turn's generation call. // for one turn's generation call.
func (r *TurnRunner) prepareTurn(ctx context.Context, sessionID string, msg Message, history []Message) (preparedTurn, error) { func (r *TurnRunner) prepareTurn(ctx context.Context, sessionID string, msg Message, history []messaging.Message) (preparedTurn, error) {
compressed := compressTurnHistory(history, r.BotUser) compressed := compressTurnHistory(history)
extraTools := append( extraTools := append(
TaskTools(r.TaskLister, r.Tasks, r.TaskLogs, r.TaskActor, r.TaskIdentity), TaskTools(r.TaskLister, r.Tasks, r.TaskLogs, r.TaskActor, r.TaskIdentity),
SessionTools(r.Sessions, r.Router.SessionTracker(), r.Channel, msg)..., SessionTools(r.Sessions, r.Router.SessionTracker(), r.Channel, msg)...,
@@ -412,7 +415,7 @@ func (r *TurnRunner) generateAndComplete(
return "", r.failTurn(ctx, turn, err) return "", r.failTurn(ctx, turn, err)
} }
assistant := Message{MessageID: assistantMessageIDForTurn(turn.TurnID), From: r.BotUser, Text: text} 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)) return "", r.failTurn(ctx, turn, fmt.Errorf("save outbound chat message: %w", err))
} }
turn.Status = TurnStatusCompleted turn.Status = TurnStatusCompleted
@@ -499,7 +502,7 @@ func messageIDForTurn(sessionID string, msg Message) string {
return NewTurnID() return NewTurnID()
} }
func messageInHistory(history []Message, sourceID string) bool { func messageInHistory(history []messaging.Message, sourceID string) bool {
if sourceID == "" { if sourceID == "" {
return false return false
} }
@@ -511,11 +514,14 @@ func messageInHistory(history []Message, sourceID string) bool {
return false 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)) compressed := make([]CompressedMessage, 0, len(history))
for _, message := range history { for _, message := range history {
role := "user" role := "user"
if message.From == botUser { if message.Role == messaging.RoleAssistant {
role = "assistant" role = "assistant"
} }
compressed = append(compressed, CompressedMessage{Role: role, Content: message.Text}) compressed = append(compressed, CompressedMessage{Role: role, Content: message.Text})
+2 -2
View File
@@ -312,9 +312,9 @@ func TestTurnRunnerReplaysCompletedDuplicateOutsideRecentWindow(t *testing.T) {
t.Fatalf("first Run() error = %v", err) t.Fatalf("first Run() error = %v", err)
} }
for i := range 110 { 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", From: "user", SourceID: fmt.Sprintf("later-%d", i), Text: "later",
}); err != nil { }, "archie")); err != nil {
t.Fatalf("SaveMessage(%d) error = %v", i, err) t.Fatalf("SaveMessage(%d) error = %v", i, err)
} }
} }
+5 -77
View File
@@ -13,86 +13,14 @@ import (
"github.com/samcharles93/archie-core/internal/taskstate" "github.com/samcharles93/archie-core/internal/taskstate"
) )
var ( var _ gateway.ChatContract = (*Client)(nil)
_ gateway.ChatContract = (*Client)(nil)
_ gateway.SessionStore = (*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 } 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 { func NewClient(conn grpc.ClientConnInterface) *Client {
return &Client{client: pb.NewChatServiceClient(conn)} return &Client{client: pb.NewChatServiceClient(conn)}
} }
+35 -4
View File
@@ -8,6 +8,7 @@ import (
"google.golang.org/grpc/status" "google.golang.org/grpc/status"
pb "github.com/samcharles93/archie-core/internal/contracts/gateway/v1" 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/gateway"
"github.com/samcharles93/archie-core/internal/taskstate" "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 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) { func (s *server) SaveMessage(ctx context.Context, r *pb.SaveMessageRequest) (*pb.SaveMessageResponse, error) {
ss, e := s.sessionStore() ss, e := s.sessionStore()
if e != nil { if e != nil {
return nil, e 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) { 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 { if e != nil {
return nil, e 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) { 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 { if e != nil {
return nil, e 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) { 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 return nil, e
} }
v, e := ss.SearchMessages(ctx, r.SessionId, gateway.MessageQuery{Query: r.Query, Limit: int(r.Limit), Offset: int(r.Offset)}) 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 { func (s *server) Stream(r *pb.StreamRequest, out grpc.ServerStreamingServer[pb.StreamResponse]) error {
@@ -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
}
@@ -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)
}
}
@@ -6,6 +6,7 @@ import (
"google.golang.org/protobuf/types/known/timestamppb" "google.golang.org/protobuf/types/known/timestamppb"
pb "github.com/samcharles93/archie-core/internal/contracts/gateway/v1" 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/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 { func messageValue(v *pb.Message) gateway.Message {
if v == nil { if v == nil {
return gateway.Message{} return gateway.Message{}
@@ -10,6 +10,7 @@ import (
"time" "time"
"github.com/samcharles93/archie-core/internal/domain/curator" "github.com/samcharles93/archie-core/internal/domain/curator"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/gateway" "github.com/samcharles93/archie-core/internal/gateway"
) )
@@ -18,17 +19,13 @@ import (
// curator needs -- never the full session CRUD/branch/search surface a // curator needs -- never the full session CRUD/branch/search surface a
// chat gateway exposes. See docs/prds/session-memory-curator.md. // chat gateway exposes. See docs/prds/session-memory-curator.md.
type Adapter struct { type Adapter struct {
store gateway.SessionStore store gateway.SessionStore
botUser string
} }
// NewAdapter builds an Adapter. botUser is compared against // NewAdapter builds an Adapter. Roles come from the canonical records the
// gateway.Message.From to derive role ("assistant" when it matches, else // store returns, so no bot identity is needed to derive them.
// "user"), the same derivation gateway.compressTurnHistory already uses func NewAdapter(store gateway.SessionStore) *Adapter {
// -- copied logic, not shared code, since curator must not import return &Adapter{store: store}
// gateway.Message.
func NewAdapter(store gateway.SessionStore, botUser string) *Adapter {
return &Adapter{store: store, botUser: botUser}
} }
func (a *Adapter) RecentSessions(ctx context.Context, since time.Time) ([]curator.SessionSummary, error) { 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)) out := make([]curator.ConversationMessage, 0, len(msgs))
for _, m := range msgs { for _, m := range msgs {
role := "user" role := "user"
if m.From == a.botUser { if m.Role == messaging.RoleAssistant {
role = "assistant" role = "assistant"
} }
out = append(out, curator.ConversationMessage{Role: role, Content: m.Text, At: m.At}) out = append(out, curator.ConversationMessage{Role: role, Content: m.Text, At: m.At})
@@ -5,6 +5,7 @@ import (
"testing" "testing"
"time" "time"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/gateway" "github.com/samcharles93/archie-core/internal/gateway"
) )
@@ -29,7 +30,7 @@ func TestAdapterRecentSessionsFiltersByActivity(t *testing.T) {
t.Fatalf("Save(recent) = %v", err) t.Fatalf("Save(recent) = %v", err)
} }
a := NewAdapter(store, "archie") a := NewAdapter(store)
got, err := a.RecentSessions(ctx, time.Unix(1000, 0)) got, err := a.RecentSessions(ctx, time.Unix(1000, 0))
if err != nil { if err != nil {
t.Fatalf("RecentSessions() = %v, want nil", err) 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() t.Parallel()
store := newTestStore(t) store := newTestStore(t)
ctx := context.Background() ctx := context.Background()
@@ -48,20 +49,28 @@ func TestAdapterMessagesDerivesRoleFromBotUser(t *testing.T) {
if err := store.Save(ctx, sess); err != nil { if err := store.Save(ctx, sess); err != nil {
t.Fatalf("Save() = %v", err) t.Fatalf("Save() = %v", err)
} }
if err := store.SaveMessage(ctx, "s1", gateway.Message{From: "user123", Text: "hello", At: time.Unix(1, 0)}); err != nil { // Roles are derived from the sender at the store boundary; the adapter
t.Fatalf("SaveMessage(user) = %v", err) // 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 { // A hand-built record without a role reads as a user message.
t.Fatalf("SaveMessage(bot) = %v", err) 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) got, err := a.Messages(ctx, "s1", 10)
if err != nil { if err != nil {
t.Fatalf("Messages() = %v, want nil", err) t.Fatalf("Messages() = %v, want nil", err)
} }
if len(got) != 2 { if len(got) != 3 {
t.Fatalf("Messages() = %v, want 2", got) t.Fatalf("Messages() = %v, want 3", got)
} }
if got[0].Role != "user" || got[0].Content != "hello" { if got[0].Role != "user" || got[0].Content != "hello" {
t.Errorf("Messages()[0] = %+v, want user/hello", got[0]) 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" { if got[1].Role != "assistant" || got[1].Content != "hi there" {
t.Errorf("Messages()[1] = %+v, want assistant/hi there", got[1]) 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])
}
} }
+1 -1
View File
@@ -114,7 +114,7 @@ func TestChatSessionAndMessageEndpoints(t *testing.T) {
if err := sessions.Save(context.Background(), session); err != nil { if err := sessions.Save(context.Background(), session); err != nil {
t.Fatal(err) 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) t.Fatal(err)
} }