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:
1 parent
37225e032c
commit
571323138d
29 files changed
+896
-350
No files matched your search
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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,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)
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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"})
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
@@ -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})
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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)}
|
||||
}
|
||||
|
||||
@@ -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])
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user