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