Files
archie/internal/gateway/session_store_postgres.go

909 lines
29 KiB
Go

package gateway
import (
"context"
"encoding/json"
"errors"
"fmt"
"math"
"slices"
"strings"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/samcharles93/archie-core/internal/domain/access"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/domain/presence"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/postgresdb"
)
// postgresSessionStore is the PostgreSQL SessionStore. Appends to one session
// are serialised by an advisory lock, so message timestamps stay strictly
// increasing; ClaimTurn is decided by INSERT ... ON CONFLICT DO NOTHING.
type postgresSessionStore struct {
pool *pgxpool.Pool
}
// NewPostgresSessionStore returns a SessionStore backed by pool. The pool must
// already have the gateway schema applied (postgres.Migrations). The returned
// store owns the pool: Close closes it.
func NewPostgresSessionStore(pool *pgxpool.Pool) SessionStore {
return &postgresSessionStore{pool: pool}
}
func (s *postgresSessionStore) Close() error {
s.pool.Close()
return nil
}
// ── Sessions ────────────────────────────────────────────────────────────────
// sessionSaver is the one query Save needs.
type sessionSaver interface {
SaveSession(context.Context, postgresdb.SaveSessionParams) (int64, error)
}
func (s *postgresSessionStore) Save(ctx context.Context, sc SessionContext) error {
return saveSession(ctx, postgresdb.New(s.pool), sc)
}
// saveSession writes sc for the caller's org. Visibility (sessionVisible) is a
// read rule: the SaveSession upsert already refuses a row owned by another org
// or an existing conversation with a different source, so a write needs no
// visibility check and no platform may be excluded from creating its session.
func saveSession(ctx context.Context, q sessionSaver, sc SessionContext) error {
saved, err := q.SaveSession(ctx, postgresdb.SaveSessionParams{
SessionID: sc.SessionID,
Platform: sc.Source.Platform,
BotUser: sc.Source.BotUser,
ChannelID: sc.Source.ChannelID,
ThreadID: sc.Source.ThreadID,
Title: sc.Title,
ParentSessionID: sc.ParentSessionID,
BranchName: sc.BranchName,
CreatedAt: sc.CreatedAt.UnixMilli(),
LastActiveAt: sc.LastActiveAt.UnixMilli(),
OrgID: callerOrg(ctx),
})
if err != nil {
return fmt.Errorf("sessionstore: save: %w", err)
}
if saved == 0 {
return ErrSessionNotFound
}
return nil
}
func (s *postgresSessionStore) Get(ctx context.Context, sessionID string) (*SessionContext, error) {
q := postgresdb.New(s.pool)
row, err := q.SessionByID(ctx, postgresdb.SessionByIDParams{SessionID: sessionID, OrgID: callerOrg(ctx)})
if errors.Is(err, pgx.ErrNoRows) {
return nil, nil
}
if err != nil {
return nil, fmt.Errorf("sessionstore: get: %w", err)
}
sc := sessionFromRow(row)
if !sessionVisible(ctx, sc) {
return nil, nil
}
return &sc, nil
}
func (s *postgresSessionStore) GetByChannel(ctx context.Context, platform, channelID string) ([]SessionContext, error) {
q := postgresdb.New(s.pool)
rows, err := q.SessionsByChannel(ctx, postgresdb.SessionsByChannelParams{
Platform: platform, ChannelID: channelID, OrgID: callerOrg(ctx),
})
if err != nil {
return nil, fmt.Errorf("sessionstore: get by channel: %w", err)
}
return visibleSessions(ctx, sessionsFromRows(rows)), nil
}
func (s *postgresSessionStore) Delete(ctx context.Context, sessionID string) error {
if err := s.mayWrite(ctx, sessionID); err != nil {
return err
}
tx, err := s.pool.Begin(ctx)
if err != nil {
return fmt.Errorf("sessionstore: delete: begin: %w", err)
}
defer func() { _ = tx.Rollback(ctx) }()
q := postgresdb.New(tx)
if err := q.DeleteSessionMessages(ctx, sessionID); err != nil {
return fmt.Errorf("sessionstore: delete messages: %w", err)
}
if err := q.DeleteSessionTurns(ctx, sessionID); err != nil {
return fmt.Errorf("sessionstore: delete turns: %w", err)
}
if err := q.DeleteSession(ctx, sessionID); err != nil {
return fmt.Errorf("sessionstore: delete session: %w", err)
}
if err := tx.Commit(ctx); err != nil {
return fmt.Errorf("sessionstore: delete: commit: %w", err)
}
return nil
}
func (s *postgresSessionStore) Touch(ctx context.Context, sessionID string) error {
if err := s.mayWrite(ctx, sessionID); err != nil {
return err
}
q := postgresdb.New(s.pool)
err := q.TouchSession(ctx, postgresdb.TouchSessionParams{
SessionID: sessionID, LastActiveAt: time.Now().UTC().UnixMilli(),
})
if err != nil {
return fmt.Errorf("sessionstore: touch: %w", err)
}
return nil
}
func (s *postgresSessionStore) List(ctx context.Context) ([]SessionContext, error) {
q := postgresdb.New(s.pool)
rows, err := q.ListSessions(ctx, callerOrg(ctx))
if err != nil {
return nil, fmt.Errorf("sessionstore: list: %w", err)
}
return visibleSessions(ctx, sessionsFromRows(rows)), nil
}
func sessionFromRow(row postgresdb.Session) SessionContext {
return SessionContext{
SessionID: row.SessionID,
Source: SessionSource{Platform: row.Platform, BotUser: row.BotUser, ChannelID: row.ChannelID, ThreadID: row.ThreadID},
Title: row.Title,
ParentSessionID: row.ParentSessionID,
BranchName: row.BranchName,
CreatedAt: time.UnixMilli(row.CreatedAt).UTC(),
LastActiveAt: time.UnixMilli(row.LastActiveAt).UTC(),
}
}
func sessionsFromRows(rows []postgresdb.Session) []SessionContext {
out := make([]SessionContext, 0, len(rows))
for _, row := range rows {
out = append(out, sessionFromRow(row))
}
return out
}
// ── Messages ────────────────────────────────────────────────────────────────
func (s *postgresSessionStore) SaveMessage(ctx context.Context, sessionID string, msg messaging.Message) error {
if err := s.mayWrite(ctx, sessionID); err != nil {
return err
}
tx, err := s.pool.Begin(ctx)
if err != nil {
return fmt.Errorf("sessionstore: save message: begin: %w", err)
}
defer func() { _ = tx.Rollback(ctx) }()
q := postgresdb.New(tx)
if err := q.LockSessionMessages(ctx, sessionID); err != nil {
return fmt.Errorf("sessionstore: lock session messages: %w", err)
}
if _, err := saveMessagePG(ctx, q, sessionID, msg, true); err != nil {
return err
}
if err := tx.Commit(ctx); err != nil {
return fmt.Errorf("sessionstore: save message: commit: %w", err)
}
return nil
}
func (s *postgresSessionStore) SaveMessages(ctx context.Context, sessionID string, msgs []messaging.Message) error {
if err := s.mayWrite(ctx, sessionID); err != nil {
return err
}
tx, err := s.pool.Begin(ctx)
if err != nil {
return fmt.Errorf("sessionstore: save messages: begin: %w", err)
}
defer func() { _ = tx.Rollback(ctx) }()
q := postgresdb.New(tx)
if err := q.LockSessionMessages(ctx, sessionID); err != nil {
return fmt.Errorf("sessionstore: lock session messages: %w", err)
}
for _, msg := range msgs {
if _, err := saveMessagePG(ctx, q, sessionID, msg, true); err != nil {
return fmt.Errorf("sessionstore: save messages: %w", err)
}
}
if err := tx.Commit(ctx); err != nil {
return fmt.Errorf("sessionstore: save messages: commit: %w", err)
}
return nil
}
// saveMessage persists one message through q and reports the canonical ID it
// was stored under (or was already stored under, for a redelivered message).
// The clamp parameter selects the append path's monotonic clamp, mirroring the
// SQLite store's saveMessageAt.
func saveMessagePG(ctx context.Context, q *postgresdb.Queries, sessionID string, msg messaging.Message, clamp bool) (string, error) {
id := string(msg.ID)
legacyID := ""
if msg.SourceID == "" {
if id == "" {
id = newMessageID(sessionID, "")
}
} else {
currentID, compatibleLegacyID := canonicalMessageIDs(sessionID, msg.SourceID)
if id == "" {
id = currentID
}
if id == currentID {
legacyID = compatibleLegacyID
}
}
role := string(msg.Role)
if role == "" {
role = string(messaging.RoleUser)
}
if legacyID != "" {
existingID, err := q.MessageID(ctx, postgresdb.MessageIDParams{
SessionID: sessionID, MessageID: legacyID,
})
switch {
case err == nil:
return existingID, nil
case !errors.Is(err, pgx.ErrNoRows):
return "", fmt.Errorf("sessionstore: read legacy message identity: %w", err)
}
}
at := stamp(msg)
mediaJSON, err := marshalMediaMeta(msg.Media)
if err != nil {
return "", err
}
if clamp {
err := q.InsertMessageClamped(ctx, postgresdb.InsertMessageClampedParams{
MessageID: id, SessionID: sessionID, SourceID: msg.SourceID,
Sender: msg.Sender, SenderID: msg.SenderID, Role: role, Text: msg.Text,
Media: mediaJSON,
Ts: at.UnixMilli(),
})
if err != nil {
return "", fmt.Errorf("sessionstore: save message: %w", err)
}
return id, nil
}
existingID, err := q.MessageID(ctx, postgresdb.MessageIDParams{
SessionID: sessionID, MessageID: id,
})
switch {
case err == nil:
return existingID, nil
case !errors.Is(err, pgx.ErrNoRows):
return "", fmt.Errorf("sessionstore: read existing message: %w", err)
}
err = q.InsertMessageAt(ctx, postgresdb.InsertMessageAtParams{
MessageID: id, SessionID: sessionID, SourceID: msg.SourceID,
Sender: msg.Sender, SenderID: msg.SenderID, Role: role, Text: msg.Text,
Media: mediaJSON,
Ts: at.UnixMilli(),
})
if err != nil {
return "", fmt.Errorf("sessionstore: save message: %w", err)
}
return id, nil
}
func (s *postgresSessionStore) ReplaceMessages(
ctx context.Context,
sessionID string,
msgs []messaging.Message,
superseded []string,
) error {
if err := s.mayWrite(ctx, sessionID); err != nil {
return err
}
tx, err := s.pool.Begin(ctx)
if err != nil {
return fmt.Errorf("sessionstore: replace messages: begin: %w", err)
}
defer func() { _ = tx.Rollback(ctx) }()
q := postgresdb.New(tx)
survivors := make(map[string]struct{}, len(msgs))
for _, msg := range msgs {
// No clamp: the caller has already decided where each record belongs.
id, err := saveMessagePG(ctx, q, sessionID, msg, false)
if err != nil {
return fmt.Errorf("sessionstore: replace messages: %w", err)
}
survivors[id] = struct{}{}
}
doomed := make([]string, 0, len(superseded))
for _, id := range superseded {
if _, kept := survivors[id]; kept {
continue
}
doomed = append(doomed, id)
}
if len(doomed) > 0 {
if err := q.DeleteMessagesByID(ctx, postgresdb.DeleteMessagesByIDParams{
SessionID: sessionID, Ids: doomed,
}); err != nil {
return fmt.Errorf("sessionstore: replace messages: delete old: %w", err)
}
}
if err := tx.Commit(ctx); err != nil {
return fmt.Errorf("sessionstore: replace messages: commit: %w", err)
}
return nil
}
func (s *postgresSessionStore) FindPriorReply(ctx context.Context, sessionID, sourceID, identity string) (string, error) {
if err := s.mayRead(ctx, sessionID); err != nil {
return "", err
}
if sourceID == "" {
return "", nil
}
q := postgresdb.New(s.pool)
currentID, legacyID := canonicalMessageIDs(sessionID, sourceID)
ts, err := q.SourceMessageTs(ctx, postgresdb.SourceMessageTsParams{
SessionID: sessionID, MessageID: currentID, MessageID_2: legacyID,
})
if errors.Is(err, pgx.ErrNoRows) {
return "", nil
}
if err != nil {
return "", fmt.Errorf("sessionstore: find source message: %w", err)
}
next, err := q.NextReplyAfterTs(ctx, postgresdb.NextReplyAfterTsParams{
SessionID: sessionID, Ts: ts,
})
if errors.Is(err, pgx.ErrNoRows) {
return "", nil
}
if err != nil {
return "", fmt.Errorf("sessionstore: find prior reply: %w", err)
}
if next.Sender != identity || isCompressionSummary(next.Text) {
return "", nil
}
return next.Text, nil
}
func (s *postgresSessionStore) RecentMessages(ctx context.Context, sessionID string, n int) ([]messaging.Message, error) {
if err := s.mayRead(ctx, sessionID); err != nil {
return nil, err
}
if n <= 0 {
return nil, nil
}
if n > math.MaxInt32 {
return nil, fmt.Errorf("sessionstore: recent messages: limit exceeds max int32")
}
q := postgresdb.New(s.pool)
rows, err := q.RecentMessages(ctx, postgresdb.RecentMessagesParams{
SessionID: sessionID, Limit: int32(n),
})
if err != nil {
return nil, fmt.Errorf("sessionstore: recent messages: %w", err)
}
return recentMessagesFromRows(rows), nil
}
func (s *postgresSessionStore) DeleteRecentMessages(ctx context.Context, sessionID string, n int) (int, error) {
if err := s.mayWrite(ctx, sessionID); err != nil {
return 0, err
}
if n <= 0 {
return 0, nil
}
if n > math.MaxInt32 {
return 0, fmt.Errorf("sessionstore: delete recent messages: limit exceeds max int32")
}
q := postgresdb.New(s.pool)
deleted, err := q.DeleteRecentMessages(ctx, postgresdb.DeleteRecentMessagesParams{
SessionID: sessionID, Limit: int32(n),
})
if err != nil {
return 0, fmt.Errorf("sessionstore: delete recent messages: %w", err)
}
return int(deleted), nil
}
func (s *postgresSessionStore) MessageCount(ctx context.Context, sessionID string) (int, error) {
if err := s.mayRead(ctx, sessionID); err != nil {
return 0, err
}
q := postgresdb.New(s.pool)
n, err := q.CountMessages(ctx, sessionID)
if err != nil {
return 0, fmt.Errorf("sessionstore: message count: %w", err)
}
return int(n), nil
}
func recentMessagesFromRows(rows []postgresdb.RecentMessagesRow) []messaging.Message {
out := make([]messaging.Message, 0, len(rows))
for _, row := range rows {
out = append(out, rowMessage(messaging.Message{
ID: messaging.MessageID(row.MessageID),
SourceID: row.SourceID,
Sender: row.Sender,
SenderID: row.SenderID,
Role: messaging.Role(row.Role),
Text: row.Text,
At: time.UnixMilli(row.Ts).UTC(),
ConversationID: messaging.ConversationID{
ChannelID: row.ChannelID, ThreadID: row.ThreadID,
},
}, row.Media))
}
return out
}
// stripMediaBytes returns attachments without their in-memory bytes.
func stripMediaBytes(media []messaging.MediaAttachment) []messaging.MediaAttachment {
if len(media) == 0 {
return nil
}
stripped := make([]messaging.MediaAttachment, len(media))
for i, att := range media {
stripped[i] = att
stripped[i].Data = nil
}
return stripped
}
// marshalMediaMeta serialises a message's attachment metadata for the
// database JSON column.
func marshalMediaMeta(media []messaging.MediaAttachment) ([]byte, error) {
if len(media) == 0 {
return []byte("[]"), nil
}
encoded, err := json.Marshal(stripMediaBytes(media))
if err != nil {
return nil, fmt.Errorf("sessionstore: marshal message media: %w", err)
}
return encoded, nil
}
// unmarshalMediaMeta decodes the media JSON column a message row carries.
func unmarshalMediaMeta(raw string) ([]messaging.MediaAttachment, error) {
if raw == "" || raw == "[]" {
return nil, nil
}
var media []messaging.MediaAttachment
if err := json.Unmarshal([]byte(raw), &media); err != nil {
return nil, fmt.Errorf("sessionstore: unmarshal message media: %w", err)
}
return media, nil
}
// rowMessage attaches a message row's decoded media to its base record;
// a row's media column can only fail to decode through corruption, which
// is surfaced rather than silently dropping the attachments.
func rowMessage(base messaging.Message, mediaRaw string) messaging.Message {
media, err := unmarshalMediaMeta(mediaRaw)
if err != nil {
base.Text += " [unreadable media metadata]"
return base
}
base.Media = media
return base
}
// SearchMessages full-text searches a session's message text and sender with
// plainto_tsquery. Truncated is always false.
func (s *postgresSessionStore) SearchMessages(ctx context.Context, sessionID string, q MessageQuery) (MessagePage, error) {
if err := s.mayRead(ctx, sessionID); err != nil {
return MessagePage{}, err
}
query := strings.TrimSpace(q.Query)
if query == "" {
return MessagePage{}, nil
}
if len(query) > MaxMessageSearchQueryBytes {
return MessagePage{}, fmt.Errorf("sessionstore: search query exceeds %d bytes", MaxMessageSearchQueryBytes)
}
if terms := len(strings.Fields(query)); terms > MaxMessageSearchQueryTerms {
return MessagePage{}, fmt.Errorf("sessionstore: search query exceeds %d terms", MaxMessageSearchQueryTerms)
}
limit := q.Limit
if limit <= 0 {
limit = DefaultMessagePageSize
}
limit = min(limit, MaxMessagePageSize)
offset := max(q.Offset, 0)
dbq := postgresdb.New(s.pool)
total, err := dbq.SearchMessagesCount(ctx, postgresdb.SearchMessagesCountParams{
SessionID: sessionID, PlaintoTsquery: query,
})
if err != nil {
return MessagePage{}, fmt.Errorf("sessionstore: search messages: count: %w", err)
}
if offset >= int(total) {
return MessagePage{}, nil
}
rows, err := dbq.SearchMessagesPage(ctx, postgresdb.SearchMessagesPageParams{
SessionID: sessionID, PlaintoTsquery: query, Limit: int32(limit), Offset: int32(offset),
})
if err != nil {
return MessagePage{}, fmt.Errorf("sessionstore: search messages: %w", err)
}
msgs := make([]messaging.Message, 0, len(rows))
for _, row := range rows {
msgs = append(msgs, rowMessage(messaging.Message{
ID: messaging.MessageID(row.MessageID),
SourceID: row.SourceID,
Sender: row.Sender,
SenderID: row.SenderID,
Role: messaging.Role(row.Role),
Text: row.Text,
At: time.UnixMilli(row.Ts).UTC(),
ConversationID: messaging.ConversationID{
ChannelID: row.ChannelID, ThreadID: row.ThreadID,
},
}, row.Media))
}
next := offset + len(msgs)
return MessagePage{
Messages: msgs,
NextOffset: next,
HasMore: next < int(total),
Truncated: false,
}, nil
}
// ── Turns ───────────────────────────────────────────────────────────────────
func (s *postgresSessionStore) ClaimTurn(ctx context.Context, initial TurnRecord) (TurnRecord, TurnClaim, error) {
initial, initialToolCalls, err := prepareInitialTurn(initial, time.Now().UTC())
if err != nil {
return TurnRecord{}, "", err
}
if err := s.mayWrite(ctx, initial.SessionID); err != nil {
return TurnRecord{}, "", err
}
tx, err := s.pool.Begin(ctx)
if err != nil {
return TurnRecord{}, "", fmt.Errorf("sessionstore: claim turn: begin: %w", err)
}
defer func() { _ = tx.Rollback(ctx) }()
q := postgresdb.New(tx)
inserted, err := insertInitialTurnPG(ctx, q, initial, initialToolCalls)
if err != nil {
return TurnRecord{}, "", err
}
if inserted {
if err := tx.Commit(ctx); err != nil {
return TurnRecord{}, "", fmt.Errorf("sessionstore: claim turn: commit: %w", err)
}
return initial, TurnClaimOwned, nil
}
turn, err := q.TurnByID(ctx, initial.TurnID)
if err != nil {
return TurnRecord{}, "", fmt.Errorf("sessionstore: read turn: %w", err)
}
record, err := turnFromRow(turn)
if err != nil {
return TurnRecord{}, "", err
}
return claimExistingTurnPG(ctx, q, tx, record, initial)
}
func insertInitialTurnPG(ctx context.Context, q *postgresdb.Queries, initial TurnRecord, toolCallsJSON string) (bool, error) {
affected, err := q.InsertTurn(ctx, postgresdb.InsertTurnParams{
TurnID: initial.TurnID,
SessionID: initial.SessionID,
SourceID: initial.SourceID,
Status: string(initial.Status),
Attempt: int64(initial.Attempt),
OwnerID: initial.OwnerID,
InputMessageID: initial.InputMessageID,
AssistantMessageID: initial.AssistantMessageID,
PartialText: initial.PartialText,
ResponseText: initial.ResponseText,
ToolCalls: toolCallsJSON,
Error: initial.Error,
CreatedAt: initial.CreatedAt.UnixMilli(),
UpdatedAt: initial.UpdatedAt.UnixMilli(),
})
if err != nil {
return false, fmt.Errorf("sessionstore: claim turn: insert: %w", err)
}
return affected == 1, nil
}
func claimExistingTurnPG(ctx context.Context, q *postgresdb.Queries, tx pgx.Tx, turn, initial TurnRecord) (TurnRecord, TurnClaim, error) {
switch turn.Status {
case TurnStatusCompleted:
return turn, TurnClaimCompleted, nil
case TurnStatusAccepted, TurnStatusRunning, TurnStatusPartial:
return turn, TurnClaimInProgress, nil
case TurnStatusFailed, TurnStatusCancelled:
if turn.AssistantMessageID != "" {
affected, err := q.FinalizeTurn(ctx, postgresdb.FinalizeTurnParams{
TurnID: turn.TurnID,
Status: string(TurnStatusCompleted),
Error: "",
UpdatedAt: time.Now().UTC().UnixMilli(),
Attempt: int64(turn.Attempt),
OwnerID: turn.OwnerID,
})
if err != nil {
return TurnRecord{}, "", fmt.Errorf("sessionstore: finalize turn: %w", err)
}
if affected != 1 {
return TurnRecord{}, "", fmt.Errorf("%w: %s", ErrTurnOwnershipLost, turn.TurnID)
}
if err := tx.Commit(ctx); err != nil {
return TurnRecord{}, "", fmt.Errorf("sessionstore: finalize turn: commit: %w", err)
}
turn.Status = TurnStatusCompleted
turn.Error = ""
return turn, TurnClaimCompleted, nil
}
oldOwner, oldAttempt := turn.OwnerID, turn.Attempt
turn.Status = TurnStatusRunning
turn.Attempt++
turn.OwnerID = initial.OwnerID
turn.Error = ""
turn.UpdatedAt = time.Now().UTC()
affected, err := q.RetryTurn(ctx, postgresdb.RetryTurnParams{
TurnID: turn.TurnID,
Status: string(turn.Status),
Attempt: int64(turn.Attempt),
OwnerID: turn.OwnerID,
Error: turn.Error,
UpdatedAt: turn.UpdatedAt.UnixMilli(),
Attempt_2: int64(oldAttempt),
OwnerID_2: oldOwner,
})
if err != nil {
return TurnRecord{}, "", fmt.Errorf("sessionstore: retry turn: %w", err)
}
if affected != 1 {
return TurnRecord{}, "", fmt.Errorf("%w: %s", ErrTurnOwnershipLost, turn.TurnID)
}
if err := tx.Commit(ctx); err != nil {
return TurnRecord{}, "", fmt.Errorf("sessionstore: retry turn: commit: %w", err)
}
return turn, TurnClaimOwned, nil
default:
return turn, TurnClaimInProgress, nil
}
}
func (s *postgresSessionStore) RecoverTurns(ctx context.Context, ownerID string) error {
if ownerID == "" {
return fmt.Errorf("sessionstore: recovery owner ID is required")
}
q := postgresdb.New(s.pool)
err := q.RecoverTurns(ctx, postgresdb.RecoverTurnsParams{
UpdatedAt: time.Now().UTC().UnixMilli(), OwnerID: ownerID,
})
if err != nil {
return fmt.Errorf("sessionstore: recover turns: %w", err)
}
return nil
}
func (s *postgresSessionStore) GetTurn(ctx context.Context, turnID string) (TurnRecord, bool, error) {
if turnID == "" {
return TurnRecord{}, false, nil
}
q := postgresdb.New(s.pool)
turn, err := q.TurnByID(ctx, turnID)
if errors.Is(err, pgx.ErrNoRows) {
return TurnRecord{}, false, nil
}
if err != nil {
return TurnRecord{}, false, fmt.Errorf("sessionstore: get turn: %w", err)
}
record, err := turnFromRow(turn)
if err != nil {
return TurnRecord{}, false, err
}
if err := s.mayRead(ctx, record.SessionID); errors.Is(err, ErrSessionNotFound) {
return TurnRecord{}, false, nil
} else if err != nil {
return TurnRecord{}, false, err
}
return record, true, nil
}
func (s *postgresSessionStore) RecentTurns(ctx context.Context, sessionID string, n int) ([]TurnRecord, error) {
if err := s.mayRead(ctx, sessionID); err != nil {
return nil, err
}
if n <= 0 {
return []TurnRecord{}, nil
}
if n > 500 {
n = 500
}
q := postgresdb.New(s.pool)
rows, err := q.RecentTurns(ctx, postgresdb.RecentTurnsParams{
SessionID: sessionID, Limit: int32(n),
})
if err != nil {
return nil, fmt.Errorf("sessionstore: recent turns: %w", err)
}
// RecentTurns orders newest-first; the contract returns oldest-first.
out := make([]TurnRecord, 0, len(rows))
for _, row := range slices.Backward(rows) {
record, err := turnFromRow(row)
if err != nil {
return nil, err
}
out = append(out, record)
}
return out, nil
}
func (s *postgresSessionStore) SaveTurn(ctx context.Context, turn TurnRecord) error {
if turn.TurnID == "" {
return fmt.Errorf("sessionstore: turn ID is required")
}
if err := s.mayWrite(ctx, turn.SessionID); err != nil {
return err
}
q := postgresdb.New(s.pool)
current, err := q.TurnAttemptOwner(ctx, turn.TurnID)
if errors.Is(err, pgx.ErrNoRows) {
return fmt.Errorf("sessionstore: save turn: turn not found")
}
if err != nil {
return fmt.Errorf("sessionstore: save turn: read: %w", err)
}
if int(current.Attempt) != turn.Attempt || current.OwnerID != turn.OwnerID {
return fmt.Errorf("%w: %s", ErrTurnOwnershipLost, turn.TurnID)
}
if turn.UpdatedAt.IsZero() {
turn.UpdatedAt = time.Now().UTC()
}
toolCallsJSON, err := marshalToolCalls(turn.ToolCalls)
if err != nil {
return err
}
affected, err := q.SaveTurn(ctx, postgresdb.SaveTurnParams{
TurnID: turn.TurnID,
SessionID: turn.SessionID,
SourceID: turn.SourceID,
Status: string(turn.Status),
Attempt: int64(turn.Attempt),
OwnerID: turn.OwnerID,
InputMessageID: turn.InputMessageID,
AssistantMessageID: turn.AssistantMessageID,
PartialText: turn.PartialText,
ResponseText: turn.ResponseText,
ToolCalls: toolCallsJSON,
Error: turn.Error,
CreatedAt: turn.CreatedAt.UnixMilli(),
UpdatedAt: turn.UpdatedAt.UnixMilli(),
})
if err != nil {
return fmt.Errorf("sessionstore: save turn: %w", err)
}
if affected != 1 {
return fmt.Errorf("%w: %s", ErrTurnOwnershipLost, turn.TurnID)
}
return nil
}
func (s *postgresSessionStore) ListRecoverableTurns(ctx context.Context) ([]TurnRecord, error) {
q := postgresdb.New(s.pool)
rows, err := q.ListRecoverableTurns(ctx)
if err != nil {
return nil, fmt.Errorf("sessionstore: list recoverable turns: %w", err)
}
out := make([]TurnRecord, 0, len(rows))
for _, row := range rows {
record, err := turnFromRow(row)
if err != nil {
return nil, err
}
out = append(out, record)
}
return out, nil
}
func turnFromRow(row postgresdb.Turn) (TurnRecord, error) {
toolCalls, err := unmarshalToolCalls(row.ToolCalls)
if err != nil {
return TurnRecord{}, err
}
return TurnRecord{
TurnID: row.TurnID,
SessionID: row.SessionID,
SourceID: row.SourceID,
Status: TurnStatus(row.Status),
Attempt: int(row.Attempt),
OwnerID: row.OwnerID,
InputMessageID: row.InputMessageID,
AssistantMessageID: row.AssistantMessageID,
PartialText: row.PartialText,
ResponseText: row.ResponseText,
ToolCalls: toolCalls,
Error: row.Error,
CreatedAt: time.UnixMilli(row.CreatedAt).UTC(),
UpdatedAt: time.UnixMilli(row.UpdatedAt).UTC(),
}, nil
}
// ErrSessionNotFound is a session the caller's org does not own. Another
// org's session is indistinguishable from one that does not exist.
var ErrSessionNotFound = errors.New("sessionstore: session not found")
func callerOrg(ctx context.Context) string { return string(org.OrgFromContext(ctx)) }
// mayRead allows a read of sessionID when the caller's org owns it. Messages
// with no session row predate orgs and belong to the system org.
func (s *postgresSessionStore) mayRead(ctx context.Context, sessionID string) error {
owner, err := postgresdb.New(s.pool).SessionOrg(ctx, sessionID)
if errors.Is(err, pgx.ErrNoRows) {
owner = string(org.DefaultOrgID)
} else if err != nil {
return fmt.Errorf("sessionstore: session org: %w", err)
}
if _, ok := access.PrincipalFromContext(ctx); ok {
session, err := s.Get(ctx, sessionID)
if err != nil {
return err
}
if session == nil {
return ErrSessionNotFound
}
}
if owner != callerOrg(ctx) {
return ErrSessionNotFound
}
return nil
}
// mayWrite allows a write to sessionID when the caller's org owns it, making
// the caller's org the owner of a session nobody has written yet.
func (s *postgresSessionStore) mayWrite(ctx context.Context, sessionID string) error {
q := postgresdb.New(s.pool)
if err := q.ClaimSession(ctx, postgresdb.ClaimSessionParams{SessionID: sessionID, OrgID: callerOrg(ctx)}); err != nil {
return fmt.Errorf("sessionstore: claim session: %w", err)
}
return s.mayRead(ctx, sessionID)
}
// Service-owned curation has no person principal. Signed-in callers only
// see their own web conversations, including through tools and slash commands.
// The Messaging Service speaks for an org's agent and sees that org's channel
// conversations, never a person's web ones.
func sessionVisible(ctx context.Context, session SessionContext) bool {
p, ok := access.PrincipalFromContext(ctx)
if !ok {
return true
}
if access.SourceFromContext(ctx) == presence.Messaging {
return session.Source.Platform != "web"
}
return session.Source.Platform == "web" && session.Source.ThreadID == string(p.IdentityID)
}
func visibleSessions(ctx context.Context, sessions []SessionContext) []SessionContext {
return slices.DeleteFunc(sessions, func(session SessionContext) bool { return !sessionVisible(ctx, session) })
}