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/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. func sessionVisible(ctx context.Context, session SessionContext) bool { p, ok := access.PrincipalFromContext(ctx) return !ok || (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) }) }