Files
archie/internal/gateway/compress_trigger_test.go
T

333 lines
11 KiB
Go

package gateway
import (
"context"
"fmt"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/domain/messaging"
)
// compressTriggerModelManager publishes catalog details the way production's
// chatModelManager does, so the turn path can derive a real context budget.
type compressTriggerModelManager struct {
fakeModelManager
details map[string]ModelDetails
}
func (m *compressTriggerModelManager) ModelDetails(ref string) (ModelDetails, bool) {
details, ok := m.details[ref]
return details, ok
}
// countingReplaceStore counts history replacements, so a test can tell an
// automatic compression apart from a later turn that did not need one.
type countingReplaceStore struct {
SessionStore
TurnLedger
replaces int
}
func (s *countingReplaceStore) ReplaceMessages(ctx context.Context, sessionID string, msgs []messaging.Message, superseded []string) error {
s.replaces++
return s.SessionStore.ReplaceMessages(ctx, sessionID, msgs, superseded)
}
// newTriggerStore returns an in-memory store that reports every replacement
// written to it.
func newTriggerStore(t *testing.T) *countingReplaceStore {
t.Helper()
inner := NewSessionStoreMemory()
t.Cleanup(func() { _ = inner.Close() })
ledger, ok := inner.(TurnLedger)
if !ok {
t.Fatal("the session store does not implement TurnLedger")
}
return &countingReplaceStore{SessionStore: inner, TurnLedger: ledger}
}
// newTriggerRunner builds the production turn path for one channel: a
// TurnRunner over store, exactly as the composition root wires it.
func newTriggerRunner(t *testing.T, store SessionStore, models ModelManager, router *Router) (*TurnRunner, *turnTestPreparedModel) {
t.Helper()
prepared := &turnTestPreparedModel{reply: "ok"}
runner := NewTurnRunner(TurnRunnerConfig{
Router: router,
Sessions: store,
Models: models,
Model: &turnTestModel{prepared: prepared},
BotUser: "archie",
Channel: "telegram",
})
return runner, prepared
}
// seedLargeHistory fills a session with n bulk messages followed by a short
// tail. The bulk clears a small model's history budget while the tail is what
// survives compression, so the compressed result lands well under the budget
// instead of on top of it.
func seedLargeHistory(t *testing.T, store SessionStore, sessionID string, n int) {
t.Helper()
ctx := context.Background()
body := strings.Repeat("x", 1000) // ~250 tokens
for i := range n {
if err := store.SaveMessage(ctx, sessionID, messaging.Message{
Sender: "alice",
Role: messaging.RoleUser,
Text: fmt.Sprintf("bulk m%d %s", i, body),
SourceID: fmt.Sprintf("bulk-%d", i),
At: at(dur(i)),
}); err != nil {
t.Fatalf("SaveMessage bulk %d: %v", i, err)
}
}
for i := range 20 {
if err := store.SaveMessage(ctx, sessionID, messaging.Message{
Sender: "alice",
Role: messaging.RoleUser,
Text: "recent",
SourceID: fmt.Sprintf("tail-%d", i),
At: at(dur(1000 + i)),
}); err != nil {
t.Fatalf("SaveMessage tail %d: %v", i, err)
}
}
}
// turnIn builds the inbound message a channel hands the turn path.
func turnIn(channelID, sourceID string, offset int) Inbound {
in := inboundFrom(channelID, "alice", "and another")
in.Message.SourceID = sourceID
in.Message.At = at(dur(offset))
return in
}
// A plain channel message -- not a command -- reaches the trigger through the
// router: the router exists so the messaging path has one place to answer a
// turn, and the compression must happen there rather than in a caller only
// one surface would use.
func TestRoutedChannelMessageCompressesTheSession(t *testing.T) {
ctx := context.Background()
store := newTriggerStore(t)
router, sessionID := routerOn(t, store, "chat-1")
models := &compressTriggerModelManager{
models: []string{"local/small"}, activeModel: "local/small",
details: map[string]ModelDetails{
"local/small": {Ref: "local/small", ContextWindow: 8192, MaxOutputTokens: 1024},
},
}
runner, _ := newTriggerRunner(t, store, models, router)
router.LLM = runner.Respond
router.LLMStream = runner.RespondStream
seedLargeHistory(t, store, sessionID, 60)
in := turnIn("chat-1", "tg-routed", 2000)
in.Message.Text = "what did we decide?"
if _, err := router.Route(ctx, in); err != nil {
t.Fatalf("Route() error = %v", err)
}
if store.replaces != 1 {
t.Fatalf("replacements = %d after one routed channel message, want 1", store.replaces)
}
stored, err := store.RecentMessages(ctx, sessionID, 1000)
if err != nil {
t.Fatalf("RecentMessages: %v", err)
}
if found := summarised(t, stored); len(found) != 1 {
t.Fatalf("summaries = %d, want exactly 1", len(found))
}
}
// summarised returns the session's summary record, which is the one message a
// compression adds.
func summarised(t *testing.T, msgs []messaging.Message) []messaging.Message {
t.Helper()
marker := DefaultCompressionConfig().SummaryMarker
var found []messaging.Message
for _, m := range msgs {
if strings.Contains(m.Text, marker) {
found = append(found, m)
}
}
return found
}
// A channel turn that pushes a session past the model-derived budget must
// compress the session on the same path the whole conversation is served
// from, without the operator typing /compress. This is the trigger the
// compressor shipped without.
func TestTurnCompressesSessionAtTheModelBudget(t *testing.T) {
ctx := context.Background()
store := newTriggerStore(t)
router, sessionID := routerOn(t, store, "chat-1")
// A small local window: the 60 bulk messages (15k tokens) are far past
// the history budget an 8k window leaves after prompt and output reserve.
models := &compressTriggerModelManager{
models: []string{"local/small"}, activeModel: "local/small",
details: map[string]ModelDetails{
"local/small": {Ref: "local/small", ContextWindow: 8192, MaxOutputTokens: 1024},
},
}
runner, prepared := newTriggerRunner(t, store, models, router)
seedLargeHistory(t, store, sessionID, 60)
seeded := 80
if _, err := runner.Run(ctx, turnIn("chat-1", "tg-1", 2000), nil); err != nil {
t.Fatalf("Run() error = %v", err)
}
stored, err := store.RecentMessages(ctx, sessionID, 1000)
if err != nil {
t.Fatalf("RecentMessages: %v", err)
}
if store.replaces != 1 {
t.Fatalf("replacements = %d after a turn that pushed the session past the budget, want exactly 1 "+
"(history is still %d messages)", store.replaces, len(stored))
}
if len(stored) >= seeded {
t.Fatalf("history = %d messages, want the %d-message session compressed", len(stored), seeded)
}
found := summarised(t, stored)
if len(found) != 1 {
t.Fatalf("summaries = %d, want exactly 1", len(found))
}
if found[0].Sender != router.Identity {
t.Errorf("summary sender = %q, want %q: the summary describes the conversation, it is not something the user said",
found[0].Sender, router.Identity)
}
if !strings.Contains(found[0].Text, "messages removed") {
t.Errorf("summary = %q, want it to account for the messages it replaced", found[0].Text)
}
// The turn generated from the compressed session, not from the history it
// was handed: the request carries the very summary the store now holds,
// where a request built from the uncompressed history would carry the
// model's own summary of a different span.
var requestSummary string
for _, m := range prepared.lastRequest.Messages {
if strings.Contains(m.Content, DefaultCompressionConfig().SummaryMarker) {
requestSummary = m.Content
}
}
if requestSummary != found[0].Text {
t.Errorf("the request's summary is not the session's summary: the turn was assembled from a different history")
}
// Once per crossing: compression put the session back under the budget, so
// the turns that follow must not compress it again.
for i := range 3 {
if _, err := runner.Run(ctx, turnIn("chat-1", fmt.Sprintf("tg-next-%d", i), 2100+i), nil); err != nil {
t.Fatalf("Run() after compression: %v", err)
}
}
if store.replaces != 1 {
t.Fatalf("replacements = %d after further turns, want 1: the session was already below the budget",
store.replaces)
}
after, err := store.RecentMessages(ctx, sessionID, 1000)
if err != nil {
t.Fatalf("RecentMessages: %v", err)
}
if got := len(summarised(t, after)); got != 1 {
t.Fatalf("summaries = %d after further turns, want exactly 1", got)
}
}
// A long conversation that still fits its model's budget is left alone: the
// trigger answers to the budget, not to the passage of turns.
func TestTurnLeavesAnUnderBudgetSessionAlone(t *testing.T) {
ctx := context.Background()
store := newTriggerStore(t)
router, sessionID := routerOn(t, store, "chat-1")
models := &compressTriggerModelManager{
models: []string{"local/large"}, activeModel: "local/large",
details: map[string]ModelDetails{
"local/large": {Ref: "local/large", ContextWindow: 200000, MaxOutputTokens: 4096},
},
}
runner, _ := newTriggerRunner(t, store, models, router)
seedLargeHistory(t, store, sessionID, 60)
if _, err := runner.Run(ctx, turnIn("chat-1", "tg-1", 2000), nil); err != nil {
t.Fatalf("Run() error = %v", err)
}
if store.replaces != 0 {
t.Fatalf("replacements = %d, want 0: the session is inside the model's budget", store.replaces)
}
stored, err := store.RecentMessages(ctx, sessionID, 1000)
if err != nil {
t.Fatalf("RecentMessages: %v", err)
}
// 60 bulk + 20 tail + this turn's inbound and reply, all untouched.
if len(stored) != 82 {
t.Fatalf("history = %d messages, want all 82", len(stored))
}
if found := summarised(t, stored); len(found) != 0 {
t.Fatalf("summaries = %d, want none", len(found))
}
}
// Without a resolved model context window there is no budget to compare the
// session against, so the trigger leaves it alone. Guessing -- the compressor's
// 128k compatibility window -- would rewrite a session nobody measured.
func TestTurnSkipsCompressionWhenTheModelBudgetIsUnknown(t *testing.T) {
tests := []struct {
name string
models ModelManager
}{
{
name: "the model manager publishes no details",
models: &fakeModelManager{models: []string{"test/model"}, activeModel: "test/model"},
},
{
name: "the details carry no context window",
models: &compressTriggerModelManager{
models: []string{"test/model"}, activeModel: "test/model",
details: map[string]ModelDetails{"test/model": {Ref: "test/model"}},
},
},
{
name: "there are no details for the active model",
models: &compressTriggerModelManager{
models: []string{"test/model"}, activeModel: "test/model",
details: map[string]ModelDetails{},
},
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
ctx := context.Background()
store := newTriggerStore(t)
router, sessionID := routerOn(t, store, "chat-1")
runner, _ := newTriggerRunner(t, store, tc.models, router)
// 70 messages of ~2000 tokens: over the 128k compatibility
// window's 127750-token history budget, so a trigger that guessed
// a window would compress this session.
seedForCompress(t, store, sessionID, 70)
if _, err := runner.Run(ctx, turnIn("chat-1", "tg-1", 2000), nil); err != nil {
t.Fatalf("Run() error = %v", err)
}
if store.replaces != 0 {
t.Fatalf("replacements = %d, want 0: the model's context window is unknown, so the budget is unknown",
store.replaces)
}
stored, err := store.RecentMessages(ctx, sessionID, 1000)
if err != nil {
t.Fatalf("RecentMessages: %v", err)
}
if found := summarised(t, stored); len(found) != 0 {
t.Fatalf("summaries = %d, want none", len(found))
}
})
}
}