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) } // Pick the most recently active session for this thread and bot. 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 } // Claim the cache slot before saving, so only the winner of a race 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. Best-effort. 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 holds it, and // returns the winning session ID and whether this caller won. 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) { // Never cache an empty session ID. if sessionID == "" { return } t.mu.Lock() defer t.mu.Unlock() t.active[sessionTrackerKey(channelID, threadID)] = sessionID } // flattenTopic points a channel's flat key at its thread's current session, // in one critical section. 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 cached key whose active session is sessionID. 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. It parses // at 32 bits because the value reaches int32 SQL LIMIT parameters; anything // larger is rejected here rather than wrapping at the conversion. func parsePositiveInt(s string) (int, bool) { n, err := strconv.ParseInt(s, 10, 32) return int(n), err == nil && n > 0 } func sessionTrackerKey(channelID, threadID string) string { if threadID == "" { return channelID } return channelID + ":" + threadID } // sessionPlatform returns the channel that carried the message, else the // gateway's own name. func (r *Router) sessionPlatform(in Inbound) string { if in.Platform != "" { return in.Platform } return r.gatewayName } // 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.sessionPlatform(in), 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, platform, 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: platform, 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, platform, 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, platform) default: return r.topicSwitchSession(ctx, msg, platform, rest) } } func topicHelpText() string { return "Usage: /topic [off|help|]\n" + " off — disable topic routing\n" + " help — show this help\n" + " — switch to a session by the ID shown in /topic" } func (r *Router) topicListSessions(ctx context.Context, msg messaging.Message, platform string) (string, error) { active := r.sessionTracker.getActive(msg.ConversationID.ChannelID, msg.ConversationID.ThreadID) sessions, err := r.sessionTracker.sessions.GetByChannel(ctx, platform, 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, platform, rest string) (string, error) { sessions, err := r.sessionTracker.sessions.GetByChannel(ctx, platform, 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 with the live message's addressing and no page. 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 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, platform, 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 == "" { // Channels that call Route directly can reach this with no session. 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: platform, 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 MessageID so the child's copies get their own IDs. 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 , --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 — keep the last N messages", nil } n, ok := parsePositiveInt(fields[1]) if !ok { return "Usage: /compress here — 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 ", 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 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 | focus | --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 to keep the last N messages protected.", count, view.TokensBefore, view.TokensAfter, removed, ), nil } // compressedHistory builds a session's history after compression: protected // messages are the original records, and the summary is a new assistant // message. 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) // Timestamp the summary inside the span it replaced so it sorts before the // retained tail. 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 compresses a session's stored history with cfg and // persists the result when anything was removed. loaded is the number of // messages read. Both /compress and the automatic trigger use it. 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 }