Files
archie/internal/gateway/session_commands.go
T

848 lines
30 KiB
Go

package gateway
import (
"context"
"fmt"
"maps"
"strconv"
"strings"
"sync"
"time"
"github.com/google/uuid"
"github.com/samcharles93/archie-core/internal/domain/messaging"
)
// sessionTracker maps (channelID, threadID) pairs to the currently active
// session ID. When a new session is created via /new, /branch, or /topic,
// subsequent messages go to that session.
type sessionTracker struct {
sessions SessionStore
// mu guards active. Channel gateways dispatch each inbound update in
// its own goroutine, so resolve, setActive and getActive all run
// concurrently.
mu sync.RWMutex
// active maps "channelID:threadID" → sessionID
active map[string]string
}
// newSessionID uses time-ordered UUIDv7 identifiers so session listings and
// storage indexes retain creation order in the identifier itself.
func newSessionID() string {
id, err := uuid.NewV7()
if err != nil {
// Preserve session creation if the host entropy source is unavailable.
return uuid.NewString()
}
return id.String()
}
func newSessionTracker(sessions SessionStore) *sessionTracker {
return &sessionTracker{
sessions: sessions,
active: make(map[string]string),
}
}
// resolve returns the session ID for a message, creating one if needed.
// ThreadID may be empty for flat chats.
func (t *sessionTracker) resolve(ctx context.Context, platform, botUser, channelID, threadID string) (string, error) {
key := sessionTrackerKey(channelID, threadID)
t.mu.RLock()
id, ok := t.active[key]
t.mu.RUnlock()
// An empty cached value is treated as a miss rather than an answer, so a
// poisoned entry repairs itself instead of persisting every subsequent
// message under session "".
if ok && id != "" {
t.touch(ctx, id)
return id, nil
}
// Look up existing sessions for this channel+thread. The lock is not
// held across this I/O: concurrent callers may duplicate the lookup,
// but the session ID is derived deterministically from channel+thread
// so they converge on the same value and Save is an idempotent upsert.
sessions, err := t.sessions.GetByChannel(ctx, platform, channelID)
if err != nil {
return "", fmt.Errorf("resolve session: %w", err)
}
// Find the most recent session matching this thread and bot.
//
// Pick by LastActiveAt rather than trusting storage order so a restart,
// which always re-resolves because the cache is in-memory, cannot drop the
// operator back into a session they had left with /new.
var best *SessionContext
for i, s := range sessions {
if s.Source.BotUser != botUser || s.Source.ThreadID != threadID {
continue
}
if best == nil || sessionRecency(s).After(sessionRecency(*best)) {
best = &sessions[i]
}
}
if best != nil {
resolved := t.cacheActive(key, best.SessionID)
t.touch(ctx, resolved)
return resolved, nil
}
// Create a new session with a deterministic key so it matches the
// sessionKey format used by the LLM responder.
//
// Claim the cache slot before writing to the store, not after. Saving
// first and asking the cache who won afterwards meant the loser of a race
// had already persisted a session that nothing pointed at -- unreachable,
// but still listed by /topic and /sessions as "(untitled)", and
// resurrectable by a later restart now that resolution goes by recency.
// Whoever holds the slot is the only one that writes.
id = sessionKeyFromFields(channelID, threadID)
if winner, won := t.claimActive(key, id); !won {
return winner, nil
}
now := time.Now()
sc := SessionContext{
SessionID: id,
Source: SessionSource{
Platform: platform,
BotUser: botUser,
ChannelID: channelID,
ThreadID: threadID,
},
CreatedAt: now,
LastActiveAt: now,
}
if err := t.sessions.Save(ctx, sc); err != nil {
// Drop the claim: leaving it would point every later message in this
// chat at a session that was never stored.
t.releaseActive(key, id)
return "", fmt.Errorf("create session: %w", err)
}
return id, nil
}
// touch records that a session is in use now.
//
// Nothing called Touch before, so LastActiveAt only ever held the creation
// time and "resolve the most recently active session" really meant the most
// recently created one -- an operator who switched to an older session with
// /topic and worked there was dropped back into the newer, abandoned one on
// the next restart.
//
// Best-effort: a failed timestamp update must not fail the turn, and the
// worst case is the ordering this restores being stale again.
func (t *sessionTracker) touch(ctx context.Context, sessionID string) {
if sessionID == "" {
return
}
_ = t.sessions.Touch(ctx, sessionID)
}
// claimActive reserves key for sessionID unless another caller already holds
// it. It returns the winning session ID and whether this caller won.
//
// This is the same double-check cacheActive performs, moved ahead of the
// store write so only the winner writes.
func (t *sessionTracker) claimActive(key, sessionID string) (string, bool) {
t.mu.Lock()
defer t.mu.Unlock()
if existing, ok := t.active[key]; ok && existing != "" {
return existing, false
}
t.active[key] = sessionID
return sessionID, true
}
// releaseActive drops a claim that could not be completed. It only removes
// the entry when it is still this caller's, so a racing setActive that has
// since replaced it is left alone.
func (t *sessionTracker) releaseActive(key, sessionID string) {
t.mu.Lock()
defer t.mu.Unlock()
if t.active[key] == sessionID {
delete(t.active, key)
}
}
// cacheActive records the resolved session for a channel+thread. A racing
// caller may have cached one first; its value wins so every caller returns
// the same session ID.
func (t *sessionTracker) cacheActive(key, sessionID string) string {
t.mu.Lock()
defer t.mu.Unlock()
if existing, ok := t.active[key]; ok && existing != "" {
return existing
}
t.active[key] = sessionID
return sessionID
}
func sessionKeyFromFields(channelID, threadID string) string {
if threadID == "" {
return channelID
}
return channelID + ":" + threadID
}
// setActive sets the current session for a channel+thread, overriding any
// previously resolved session (used by /new, /branch and /topic).
func (t *sessionTracker) setActive(channelID, threadID, sessionID string) {
// An empty session ID is never meaningful, and caching one is actively
// destructive: resolve treats map presence as authoritative, so a "" here
// makes every later message in this chat persist under session "" with no
// way to recover. Rejecting it at the setter means no caller can poison
// the map, whatever it computes.
if sessionID == "" {
return
}
t.mu.Lock()
defer t.mu.Unlock()
t.active[sessionTrackerKey(channelID, threadID)] = sessionID
}
// flattenTopic points a channel's flat key at whatever session its thread is
// currently using, in one critical section.
//
// Doing this as setActive(get(...)) was two separate critical sections, so a
// /resume or /branch landing between them was silently clobbered by the value
// read before the switch.
func (t *sessionTracker) flattenTopic(channelID, threadID string) {
t.mu.Lock()
defer t.mu.Unlock()
current, ok := t.active[sessionTrackerKey(channelID, threadID)]
if !ok || current == "" {
// Nothing to carry over. The next message resolves from the store,
// which is the correct answer anyway.
return
}
t.active[sessionTrackerKey(channelID, "")] = current
}
// forget drops every channel+thread whose active session is sessionID.
//
// It is the counterpart to deleting a session from the store. resolve
// treats a cached entry as authoritative and never checks that the session
// still exists, so a pointer left behind here would make every later
// message in that chat persist under an ID the store no longer knows --
// history written to a session nothing can list, resume or delete.
//
// One session can be active under more than one key (a flat chat and a
// thread that /resume'd the same session), so every entry is swept, not
// just the one the command was typed in.
func (t *sessionTracker) forget(sessionID string) {
// An empty ID is a prefix of nothing and a value of everything a
// poisoned map would hold; sweeping on it would clear unrelated chats.
if sessionID == "" {
return
}
t.mu.Lock()
defer t.mu.Unlock()
maps.DeleteFunc(t.active, func(_, id string) bool { return id == sessionID })
}
// getActive returns the current session ID for a channel+thread.
func (t *sessionTracker) getActive(channelID, threadID string) string {
t.mu.RLock()
defer t.mu.RUnlock()
return t.active[sessionTrackerKey(channelID, threadID)]
}
// parsePositiveInt is a nilerr-safe wrapper: it returns (n, true) on
// success or (0, false) when the string is not a positive integer.
func parsePositiveInt(s string) (int, bool) {
n, err := strconv.Atoi(s)
return n, err == nil && n > 0
}
func sessionTrackerKey(channelID, threadID string) string {
if threadID == "" {
return channelID
}
return channelID + ":" + threadID
}
// ResolveSessionKey resolves or creates a session for a message and
// returns the session ID. This is the entry point the LLM responder
// in main.go should call instead of its inline sessionKey helper.
func (r *Router) ResolveSessionKey(ctx context.Context, in Inbound) (string, error) {
conv := in.Message.ConversationID
if r.sessionTracker == nil {
return sessionKeyFromFields(conv.ChannelID, conv.ThreadID), nil
}
return r.sessionTracker.resolve(ctx, r.gatewayName, r.Identity, conv.ChannelID, conv.ThreadID)
}
// ── Router session command handlers ────────────────────────────────────────
// handleStart acknowledges the bot is running without consuming a reply.
func (r *Router) handleStart() (string, error) {
return "Archie is running. Send a message to chat, or type /help for available commands.", nil
}
// handleNew creates a fresh session for the current channel+thread,
// optionally setting a title.
func (r *Router) handleNew(ctx context.Context, msg messaging.Message, rest string) (string, error) {
if r.sessionTracker == nil {
return "Session management is not configured.", nil
}
id := newSessionID()
now := time.Now()
title := strings.TrimSpace(rest)
sc := SessionContext{
SessionID: id,
Source: SessionSource{
Platform: r.gatewayName,
BotUser: r.Identity,
ChannelID: msg.ConversationID.ChannelID,
ThreadID: msg.ConversationID.ThreadID,
},
Title: title,
CreatedAt: now,
LastActiveAt: now,
}
if err := r.sessionTracker.sessions.Save(ctx, sc); err != nil {
return "", fmt.Errorf("create session: %w", err)
}
r.sessionTracker.setActive(msg.ConversationID.ChannelID, msg.ConversationID.ThreadID, id)
if title != "" {
return fmt.Sprintf("New session created: %s (%s)", title, shortSessionID(id)), nil
}
return fmt.Sprintf("New session created (%s). Conversation history has been cleared.", shortSessionID(id)), nil
}
// handleTopic manages topic/session switching for threaded conversations.
// "off" disables topic routing (reverts to flat), "help" shows info,
// and a session-id switches to that session.
func (r *Router) handleTopic(ctx context.Context, msg messaging.Message, rest string) (string, error) {
if r.sessionTracker == nil {
return "Session management is not configured.", nil
}
switch rest {
case "off":
r.sessionTracker.flattenTopic(msg.ConversationID.ChannelID, msg.ConversationID.ThreadID)
return "Topic routing disabled. Messages will use the General topic.", nil
case "help":
return topicHelpText(), nil
case "":
return r.topicListSessions(ctx, msg)
default:
return r.topicSwitchSession(ctx, msg, rest)
}
}
func topicHelpText() string {
return "Usage: /topic [off|help|<session-id>]\n" +
" off — disable topic routing\n" +
" help — show this help\n" +
" <session-id> — switch to a session by the ID shown in /topic"
}
func (r *Router) topicListSessions(ctx context.Context, msg messaging.Message) (string, error) {
active := r.sessionTracker.getActive(msg.ConversationID.ChannelID, msg.ConversationID.ThreadID)
sessions, err := r.sessionTracker.sessions.GetByChannel(ctx, r.gatewayName, msg.ConversationID.ChannelID)
if err != nil {
return "", fmt.Errorf("list sessions: %w", err)
}
var b strings.Builder
b.WriteString("Sessions for this channel:\n")
for _, s := range sessions {
marker := " "
if s.SessionID == active {
marker = "*"
}
fmt.Fprintf(&b, " %s %s — %s", marker, shortSessionID(s.SessionID), sessionDisplayTitle(s))
if s.BranchName != "" {
fmt.Fprintf(&b, " [branch: %s]", s.BranchName)
}
fmt.Fprintln(&b)
}
return b.String(), nil
}
func (r *Router) topicSwitchSession(ctx context.Context, msg messaging.Message, rest string) (string, error) {
sessions, err := r.sessionTracker.sessions.GetByChannel(ctx, r.gatewayName, msg.ConversationID.ChannelID)
if err != nil {
return "", fmt.Errorf("list sessions: %w", err)
}
match, ambiguous := resolveSessionRef(sessions, rest)
if ambiguous {
return fmt.Sprintf("Multiple sessions match %q. Use more of the session ID.", rest), nil
}
if match != nil {
r.sessionTracker.setActive(msg.ConversationID.ChannelID, msg.ConversationID.ThreadID, match.SessionID)
return fmt.Sprintf("Switched to session %s: %s",
shortSessionID(match.SessionID), sessionDisplayTitle(*match)), nil
}
return fmt.Sprintf("No session found matching %q. Use /topic to list available sessions.", rest), nil
}
// handleRetry removes the last assistant message from history and replays
// the last user message through the LLM.
func (r *Router) handleRetry(ctx context.Context, msg messaging.Message) (string, error) {
if r.sessionTracker == nil {
return "Session management is not configured.", nil
}
sessionID := r.sessionTracker.getActive(msg.ConversationID.ChannelID, msg.ConversationID.ThreadID)
if sessionID == "" {
return "No active session. Send a message first.", nil
}
// Delete the last message (assistant response).
deleted, err := r.sessionTracker.sessions.DeleteRecentMessages(ctx, sessionID, 1)
if err != nil {
return "", fmt.Errorf("retry: %w", err)
}
if deleted == 0 {
return "Nothing to retry — no messages in this session.", nil
}
// Retrieve the last user message and replay it.
msgs, err := r.sessionTracker.sessions.RecentMessages(ctx, sessionID, 1)
if err != nil {
return "", fmt.Errorf("retry load messages: %w", err)
}
if len(msgs) == 0 {
return "Nothing to retry — no messages remain.", nil
}
if r.LLM == nil {
return "LLM is not configured. The last response has been removed; send another message to continue.", nil
}
// Replay the stored record, but route it with the live message's
// addressing. Stored history is read back with the conversation
// address of the session that holds it, which for a replay must be
// the chat the /retry was typed in. A replay carries no page: the
// operator's route is transport context of the message they sent,
// and this message is not one they just sent.
replay := msgs[0]
replay.ConversationID = msg.ConversationID
reply, err := r.LLM(ctx, Inbound{Message: replay})
if err == nil {
r.maybeAutoTitle(ctx, replay)
}
return reply, err
}
// handleUndo removes the last N messages (default 1) from the session
// history.
func (r *Router) handleUndo(ctx context.Context, msg messaging.Message, rest string) (string, error) {
if r.sessionTracker == nil {
return "Session management is not configured.", nil
}
sessionID := r.sessionTracker.getActive(msg.ConversationID.ChannelID, msg.ConversationID.ThreadID)
if sessionID == "" {
return "No active session. Send a message first.", nil
}
n := 1
if rest != "" {
parsed, ok := parsePositiveInt(strings.TrimSpace(rest))
if !ok {
return "Usage: /undo [N] — N must be a positive number (default: 1)", nil
}
n = parsed
}
deleted, err := r.sessionTracker.sessions.DeleteRecentMessages(ctx, sessionID, n)
if err != nil {
return "", fmt.Errorf("undo: %w", err)
}
if deleted == 0 {
return "Nothing to undo — no messages in this session.", nil
}
if deleted == 1 {
return "Removed 1 message.", nil
}
return fmt.Sprintf("Removed %d messages.", deleted), nil
}
// handleTitle sets a display title on the current session.
func (r *Router) handleTitle(ctx context.Context, msg messaging.Message, rest string) (string, error) {
if r.sessionTracker == nil {
return "Session management is not configured.", nil
}
sessionID := r.sessionTracker.getActive(msg.ConversationID.ChannelID, msg.ConversationID.ThreadID)
if sessionID == "" {
return "No active session. Send a message first.", nil
}
title := strings.TrimSpace(rest)
if title == "" {
// Show current title.
sc, err := r.sessionTracker.sessions.Get(ctx, sessionID)
if err != nil {
return "", fmt.Errorf("get session: %w", err)
}
if sc == nil || sc.Title == "" {
return "No title set. Use /title <name> to set one.", nil
}
return fmt.Sprintf("Session title: %s", sc.Title), nil
}
sc, err := r.sessionTracker.sessions.Get(ctx, sessionID)
if err != nil {
return "", fmt.Errorf("get session: %w", err)
}
if sc == nil {
return "Session not found.", nil
}
sc.Title = title
if err := r.sessionTracker.sessions.Save(ctx, *sc); err != nil {
return "", fmt.Errorf("save session: %w", err)
}
return fmt.Sprintf("Session title set to: %s", title), nil
}
// handleBranch creates a new child session that inherits the current
// session's history. The new session becomes the active session.
func (r *Router) handleBranch(ctx context.Context, msg messaging.Message, rest string) (string, error) {
if r.sessionTracker == nil {
return "Session management is not configured.", nil
}
channelID := msg.ConversationID.ChannelID
threadID := msg.ConversationID.ThreadID
parentID := r.sessionTracker.getActive(channelID, threadID)
if parentID == "" {
// Nothing to branch from. Telegram never reaches this -- submitTurn
// resolves first -- but the email and webhook channels call Route
// directly, and slicing an empty parent ID for the default title
// panicked. The email path runs in a goroutine with no recover, so
// that took the daemon down over a single message.
return "No active session to branch from. Send a message first.", nil
}
branchName := strings.TrimSpace(rest)
// Get parent session for title inheritance.
parentSC, err := r.sessionTracker.sessions.Get(ctx, parentID)
if err != nil {
return "", fmt.Errorf("get parent session: %w", err)
}
id := newSessionID()
now := time.Now()
title := branchName
if parentSC != nil && parentSC.Title != "" && branchName == "" {
title = parentSC.Title + " (branch)"
}
if title == "" {
title = "Branch of " + shortSessionID(parentID)
}
sc := SessionContext{
SessionID: id,
Source: SessionSource{
Platform: r.gatewayName,
BotUser: r.Identity,
ChannelID: channelID,
ThreadID: threadID,
},
Title: title,
ParentSessionID: parentID,
BranchName: branchName,
CreatedAt: now,
LastActiveAt: now,
}
if err := r.sessionTracker.sessions.Save(ctx, sc); err != nil {
return "", fmt.Errorf("create branch session: %w", err)
}
// Inherit history from parent.
msgs, err := r.sessionTracker.sessions.RecentMessages(ctx, parentID, 200)
if err != nil {
return "", fmt.Errorf("inherit history: %w", err)
}
if len(msgs) > 0 {
// Clear the canonical ID so the child derives its own. The store
// honours an incoming MessageID -- which is what lets a
// read-modify-write keep identities -- so copying the parent's
// messages verbatim made two sessions claim one identity, leaving
// 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([]messaging.Message, 0, len(msgs))
for _, m := range msgs {
m.ID = ""
inherited = append(inherited, m)
}
if err := r.sessionTracker.sessions.SaveMessages(ctx, id, inherited); err != nil {
return "", fmt.Errorf("copy history: %w", err)
}
}
r.sessionTracker.setActive(channelID, threadID, id)
if branchName != "" {
return fmt.Sprintf("Branched to \"%s\" (%s) with %d inherited messages.", branchName, shortSessionID(id), len(msgs)), nil
}
return fmt.Sprintf("Branched session (%s) with %d inherited messages.", shortSessionID(id), len(msgs)), nil
}
// handleCompress applies context compression to the current session's
// history. Sub-commands: here [N], focus <topic>, --preview, --dry-run.
func (r *Router) handleCompress(ctx context.Context, msg messaging.Message, rest string) (string, error) {
if r.sessionTracker == nil {
return "Session management is not configured.", nil
}
sessionID := r.sessionTracker.getActive(msg.ConversationID.ChannelID, msg.ConversationID.ThreadID)
if sessionID == "" {
return "No active session. Send a message first.", nil
}
cfg := DefaultCompressionConfig()
fields := strings.Fields(rest)
// Bare /compress applies. The preview's own closing line tells the
// operator to "Run /compress to apply", so routing it to the preview
// made that instruction circular -- the documented way to compress
// could never compress.
if len(fields) == 0 {
return r.applyCompress(ctx, sessionID, cfg)
}
switch fields[0] {
case "--preview", "--dry-run":
return r.compressPreview(ctx, sessionID)
case "here":
if len(fields) < 2 {
return "Usage: /compress here <N> — keep the last N messages", nil
}
n, ok := parsePositiveInt(fields[1])
if !ok {
return "Usage: /compress here <N> — N must be a positive number", nil
}
cfg.ProtectLast = n
return r.applyCompress(ctx, sessionID, cfg)
case "focus":
if len(fields) < 2 {
return "Usage: /compress focus <topic>", nil
}
// Nothing implements topic-focused summarisation: the config has no
// field for it, so this used to discard the topic and silently run a
// full default compression instead. Rewriting history is not
// something to do as a side effect of an unimplemented option.
return "Focused compression is not supported yet — /compress summarises " +
"the whole history. Use /compress here <N> to keep the last N messages.", nil
default:
// Anything unrecognised used to fall through and compress. An
// irreversible rewrite is the wrong response to a typo.
return "Usage: /compress [here <N> | focus <topic> | --preview]", nil
}
}
func (r *Router) compressPreview(ctx context.Context, sessionID string) (string, error) {
cfg := DefaultCompressionConfig()
count, err := r.sessionTracker.sessions.MessageCount(ctx, sessionID)
if err != nil {
return "", fmt.Errorf("message count: %w", err)
}
// Read the same history applyCompress will. Reading a fixed window here
// while reporting count from the store made the two numbers in one
// sentence describe different conversations, and made the preview advise
// against a compression that was in fact needed.
msgs, err := r.sessionTracker.sessions.RecentMessages(ctx, sessionID, count)
if err != nil {
return "", fmt.Errorf("load messages: %w", err)
}
compressed := r.messagesToCompressed(msgs)
view := CompressHistory(compressed, cfg)
if !view.WasCompressed {
return fmt.Sprintf("Compression not needed (%d messages, ~%d tokens).", count, view.TokensBefore), nil
}
removed := count - cfg.ProtectFirst - cfg.ProtectLast
return fmt.Sprintf(
"Compression preview:\n"+
" Messages: %d\n"+
" Tokens before: ~%d\n"+
" Tokens after: ~%d\n"+
" %d messages would be summarised.\n"+
"Run /compress to apply, or /compress here <N> to keep the last N messages protected.",
count, view.TokensBefore, view.TokensAfter, removed,
), nil
}
// compressedHistory builds the message list that replaces a session's
// history after compression.
//
// Protected messages are carried over as the ORIGINAL records, not rebuilt
// from the compressed view. A rebuilt message is a different message: it gets
// a fresh canonical MessageID, loses the upstream SourceID and has its
// timestamp reset, so every message surviving a compression stops being
// recognisable on redelivery and the session doubles the next time a channel
// 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 -- 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
}
// Defend the slice arithmetic: a view whose protected counts do not fit
// the input would silently drop or duplicate history.
head := min(view.ProtectedFirst, len(original))
tail := min(view.ProtectedLast, len(original)-head)
// The summary stands in for the span it replaced, so it takes a
// timestamp inside that span. Ordering is by timestamp, not by the order
// the caller writes: the retained messages keep their original times --
// that is what preserves their identity -- so a summary stamped with now
// would sort after the tail it is supposed to precede, and the model
// would read the recent conversation before being told earlier context
// was summarised.
if summaryAt >= len(view.Messages) {
// A view whose summary index is outside its own messages cannot be
// reconstructed; leaving history untouched is the safe answer.
return original
}
out := make([]messaging.Message, 0, head+1+tail)
out = append(out, original[:head]...)
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
}
// 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 []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 {
return original[head].At
}
// Nothing was actually replaced. Sit just after the head instead of
// colliding with the tail.
if head > 0 {
return original[head-1].At.Add(time.Millisecond)
}
return time.Time{}
}
func (r *Router) messagesToCompressed(msgs []messaging.Message) []CompressedMessage {
compressed := make([]CompressedMessage, 0, len(msgs))
for _, h := range msgs {
role := "user"
if h.Role == messaging.RoleAssistant {
role = "assistant"
}
compressed = append(compressed, CompressedMessage{
Role: role,
Content: h.Text,
})
}
return compressed
}
// applyCompress rewrites a session's stored history with the compressed view
// of cfg and reports what changed. It is the operator-facing wrapper around
// compressSessionHistory, which the automatic turn-path trigger also calls.
func (r *Router) applyCompress(ctx context.Context, sessionID string, cfg CompressionConfig) (string, error) {
view, loaded, err := r.compressSessionHistory(ctx, sessionID, cfg)
if err != nil {
return "", err
}
if !view.WasCompressed {
return fmt.Sprintf("Compression not needed (%d messages, ~%d tokens).", loaded, view.TokensBefore), nil
}
return fmt.Sprintf(
"Compressed: %d messages → %d (~%d → ~%d tokens).",
loaded, len(view.Messages), view.TokensBefore, view.TokensAfter,
), nil
}
// compressSessionHistory loads a session's whole stored history, compresses it
// with cfg and, when that removes anything, persists the replacement. It is
// the one compression implementation: the /compress command and the automatic
// trigger on the inbound turn path both call it, so what an operator asks for
// and what a session does unattended cannot diverge.
//
// loaded is the number of stored messages read, which is what the caller's
// reply describes when nothing was compressed.
func (r *Router) compressSessionHistory(ctx context.Context, sessionID string, cfg CompressionConfig) (view CompressedView, loaded int, err error) {
// Read the whole history: the replacement below becomes the session's
// entire history, so summarising only a recent window would silently
// discard everything older than it.
count, err := r.sessionTracker.sessions.MessageCount(ctx, sessionID)
if err != nil {
return CompressedView{}, 0, fmt.Errorf("count messages: %w", err)
}
msgs, err := r.sessionTracker.sessions.RecentMessages(ctx, sessionID, count)
if err != nil {
return CompressedView{}, 0, fmt.Errorf("load messages: %w", err)
}
view = CompressHistory(r.messagesToCompressed(msgs), cfg)
if !view.WasCompressed {
return view, count, nil
}
compressedMsgs := compressedHistory(msgs, view, r.Identity)
// Name exactly the messages this compression consumed. A turn that
// arrives between the read above and the write below was never read and
// never summarised, so it must not be swept away with the ones that
// were -- that was unrecoverable loss of a message nobody had seen.
superseded := make([]string, 0, len(msgs))
for _, m := range msgs {
if m.ID != "" {
superseded = append(superseded, string(m.ID))
}
}
// ReplaceMessages writes the replacement before removing the originals,
// so a failure leaves recoverable duplicates instead of wiping the
// session -- the previous delete-then-save order lost the entire history
// if anything went wrong in between.
if err := r.sessionTracker.sessions.ReplaceMessages(ctx, sessionID, compressedMsgs, superseded); err != nil {
return CompressedView{}, count, fmt.Errorf("replace with compressed messages: %w", err)
}
return view, count, nil
}
// compressSessionIfOverBudget compresses a session's stored history when it
// sits past the budget in cfg, and reports whether it wrote a replacement.
// It is the automatic trigger's entry point into the one compression path; a
// session inside its budget is left untouched.
func (r *Router) compressSessionIfOverBudget(ctx context.Context, sessionID string, cfg CompressionConfig) (bool, error) {
if r.sessionTracker == nil {
return false, nil
}
view, _, err := r.compressSessionHistory(ctx, sessionID, cfg)
if err != nil {
return false, err
}
return view.WasCompressed, nil
}