From 710fbab0949f83db4394052bfd870370f53e4689 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Thu, 24 Sep 2026 02:16:48 +1000 Subject: [PATCH] feat(gateway): port session store to Postgres Move sessions, messages, turns and full-text search off the per-process SQLite file onto Postgres behind the existing messaging.SessionStore contract. New adapter internal/gateway/session_store_postgres.go, sqlc queries/gateway.sql, migration 0003_gateway.sql, regenerated postgresdb. FTS5 becomes a STORED generated tsvector column over (sender, text) plus GIN. plainto_tsquery is the tsvector analog of ftsMatchQuery's quote-escaping: query text is parsed as plain text, never query syntax, and the surviving terms are ANDed. MessagePage.Truncated stays always-false on Postgres too: the result set is counted exactly. On internal/domain/messaging/session_store.go: this is a comment-only edit to the MessagePage.Truncated doc comment (the brief's own "change the comment" instruction). It changes no type, method or value, so L2 and the import lane still build against an unchanged contract and the wire is unaffected. No interface widened or altered. Semantics preserved verbatim: - The timestamp clamp is SQL-atomic (INSERT ... SELECT MAX(ts)+1). Appends to one session are serialised by a transaction-scoped advisory lock keyed on the session so two concurrent appends cannot read the same MAX(ts); a Go clamp would race (proven by the new cross-handle monotonicity test). - Session ordering is GREATEST(last_active_at, created_at) with a matching expression index. - ClaimTurn is insert-first (ON CONFLICT DO NOTHING), with a race test across two handles. State outside the store is NOT made shared by this change, and none of it is silently improved or worsened: - sessionTracker.active, Router.titling and per-session persona selection are in-memory, per-process caches; a second Gateway still diverges from the first. - messaging.Turns lanes and the per-process recovery latch stay per-process. - RecoverTurns still fails every turn owned by another process, so a second Gateway starting would still fail the first's in-flight turns. This lane does NOT make that safe and does not try to: the safeguard is D4.1's single-Gateway advisory serve-ownership lock (not implemented here), which prevents a second Gateway from serving at all. The turn-recovery semantics are left exactly as they were. Production openers still return SQLite; this lane adds the adapter and tests only. The cutover and the state-sharing questions remain follow-up work. --- internal/domain/messaging/session_store.go | 5 +- internal/gateway/session_store_postgres.go | 743 +++++++++++++++ .../gateway/session_store_postgres_test.go | 191 ++++ .../postgres/migrations/0003_gateway.sql | 82 ++ .../postgres/postgresdb/gateway.sql.go | 844 ++++++++++++++++++ .../postgres/postgresdb/models.go | 43 + .../postgres/queries/gateway.sql | 174 ++++ 7 files changed, 2080 insertions(+), 2 deletions(-) create mode 100644 internal/gateway/session_store_postgres.go create mode 100644 internal/gateway/session_store_postgres_test.go create mode 100644 internal/infrastructure/postgres/migrations/0003_gateway.sql create mode 100644 internal/infrastructure/postgres/postgresdb/gateway.sql.go create mode 100644 internal/infrastructure/postgres/queries/gateway.sql diff --git a/internal/domain/messaging/session_store.go b/internal/domain/messaging/session_store.go index d38b99ad5..3298d422d 100644 --- a/internal/domain/messaging/session_store.go +++ b/internal/domain/messaging/session_store.go @@ -131,8 +131,9 @@ type MessagePage struct { // NextOffset is meaningful only when HasMore is true. NextOffset int HasMore bool - // Truncated is retained in the transport contract and is always false for - // SQLite because it can count the complete result set. + // Truncated is retained in the transport contract and is always false: + // both store implementations (SQLite FTS5 and Postgres tsvector) count the + // complete result set, so no page is ever reported as truncated. Truncated bool } diff --git a/internal/gateway/session_store_postgres.go b/internal/gateway/session_store_postgres.go new file mode 100644 index 000000000..c131a6d4c --- /dev/null +++ b/internal/gateway/session_store_postgres.go @@ -0,0 +1,743 @@ +package gateway + +import ( + "context" + "errors" + "fmt" + "strings" + "time" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/samcharles93/archie-core/internal/domain/messaging" + "github.com/samcharles93/archie-core/internal/infrastructure/postgres/postgresdb" +) + +// ── PostgreSQL implementation ─────────────────────────────────────────────── +// +// postgresSessionStore is the PostgreSQL-backed SessionStore. It shares the +// SQLite store's wire contract (messaging.SessionStore plus the optional +// TurnLedger, TurnHistory and TurnReplayStore capability interfaces) and its +// on-disk representation: timestamps remain bigint milliseconds so the +// monotonic clamp (MAX(ts) + 1) keeps the same unit, and full-text search +// moves from FTS5 to a tsvector + GIN generated column over (sender, text). +// +// Unlike the SQLite store it carries no in-process mutex. Two semantics make +// that safe: +// - The strictly-increasing message timestamp is assigned inside +// InsertMessageClamped, and appends to one session are serialised by a +// transaction-scoped advisory lock (LockSessionMessages), so two +// concurrent appends cannot both read the same MAX(ts). +// - ClaimTurn is insert-first: InsertTurn's ON CONFLICT DO NOTHING makes the +// claim winner/loser decision atomically in the database. +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 ──────────────────────────────────────────────────────────────── + +func (s *postgresSessionStore) Save(ctx context.Context, sc SessionContext) error { + q := postgresdb.New(s.pool) + 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(), + }) + if err != nil { + return fmt.Errorf("sessionstore: save: %w", err) + } + return nil +} + +func (s *postgresSessionStore) Get(ctx context.Context, sessionID string) (*SessionContext, error) { + q := postgresdb.New(s.pool) + row, err := q.SessionByID(ctx, sessionID) + if errors.Is(err, pgx.ErrNoRows) { + return nil, nil + } + if err != nil { + return nil, fmt.Errorf("sessionstore: get: %w", err) + } + sc := sessionFromRow(row) + 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, + }) + if err != nil { + return nil, fmt.Errorf("sessionstore: get by channel: %w", err) + } + return sessionsFromRows(rows), nil +} + +func (s *postgresSessionStore) Delete(ctx context.Context, sessionID string) error { + 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 { + 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) + if err != nil { + return nil, fmt.Errorf("sessionstore: list: %w", err) + } + return 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 { + 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 { + 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) + 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, + 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, + 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 { + 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 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 n <= 0 { + return nil, nil + } + 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 n <= 0 { + return 0, nil + } + 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) { + 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, 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, + }, + }) + } + return out +} + +// SearchMessages runs a tsvector search over the session's entire message +// history, matching message text and sender only. The generated search column +// indexes exactly (sender, text), so ts, source_id and the other metadata are +// not part of the indexed content -- a query like "2026" cannot match every +// message via its timestamp. +// +// plainto_tsquery is the tsvector analog of the SQLite store's ftsMatchQuery: +// it parses the query as plain text, never as query syntax, and ANDs the +// surviving terms. Punctuation in the input is therefore treated as text to +// tokenize, not as a Boolean operator or column filter, which is the +// quote-escaping behaviour ftsMatchQuery provided for FTS5. +// +// Like SQLite, the full result set is counted exactly, so MessagePage.Truncated +// is always false. +func (s *postgresSessionStore) SearchMessages(ctx context.Context, sessionID string, q MessageQuery) (MessagePage, error) { + 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, 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, + }, + }) + } + + 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 + } + + 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 + } + return record, true, nil +} + +func (s *postgresSessionStore) RecentTurns(ctx context.Context, sessionID string, n int) ([]TurnRecord, error) { + 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 i := len(rows) - 1; i >= 0; i-- { + record, err := turnFromRow(rows[i]) + 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") + } + 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 +} diff --git a/internal/gateway/session_store_postgres_test.go b/internal/gateway/session_store_postgres_test.go new file mode 100644 index 000000000..bf8903e00 --- /dev/null +++ b/internal/gateway/session_store_postgres_test.go @@ -0,0 +1,191 @@ +package gateway + +import ( + "context" + "fmt" + "os" + "sync" + "testing" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/samcharles93/archie-core/internal/domain/messaging" + "github.com/samcharles93/archie-core/internal/infrastructure/postgres" + "github.com/samcharles93/archie-core/internal/infrastructure/postgres/pgtest" +) + +func TestMain(m *testing.M) { + os.Exit(pgtest.Main(m)) +} + +// newPostgresPool opens a pool to a fresh database with the full schema +// applied and registers pool cleanup. +func newPostgresPool(t *testing.T) *pgxpool.Pool { + t.Helper() + pool, err := postgres.Open(t.Context(), pgtest.URL(t)) + if err != nil { + t.Fatalf("postgres.Open: %v", err) + } + if err := postgres.Migrate(t.Context(), pool, postgres.Migrations()); err != nil { + pool.Close() + t.Fatalf("postgres.Migrate: %v", err) + } + t.Cleanup(pool.Close) + return pool +} + +// newPostgresStore returns a fresh PostgreSQL SessionStore with the gateway +// schema applied. +func newPostgresStore(t *testing.T) SessionStore { + t.Helper() + return NewPostgresSessionStore(newPostgresPool(t)) +} + +// TestSessionStoreConformancePostgres runs the shared SessionStore contract +// against the PostgreSQL implementation. +func TestSessionStoreConformancePostgres(t *testing.T) { + runSessionStoreSuite(t, newPostgresStore) +} + +// TestPostgresMessageTimestampsIncreaseAcrossStoreHandles pins the clamp is +// SQL-atomic, not mutex-derived: two independent stores (two connections) +// appending concurrently to one session must produce strictly increasing +// timestamps. The per-session advisory lock serialises the appends so the +// INSERT ... SELECT MAX(ts) clamp sees the prior committed append. +func TestPostgresMessageTimestampsIncreaseAcrossStoreHandles(t *testing.T) { + pool := newPostgresPool(t) + stores := make([]SessionStore, 2) + for i := range stores { + stores[i] = NewPostgresSessionStore(pool) + } + + const perStore = 100 + wantTime := time.Date(2026, 8, 3, 12, 0, 0, 0, time.UTC) + var wg sync.WaitGroup + for storeIndex, st := range stores { + for messageIndex := range perStore { + wg.Go(func() { + err := st.SaveMessage(t.Context(), "sess", messaging.Message{ + ID: messaging.MessageID(fmt.Sprintf("%d-%d", storeIndex, messageIndex)), + Sender: "user", Role: messaging.RoleUser, + Text: "concurrent", + At: wantTime, + }) + if err != nil { + t.Errorf("SaveMessage: %v", err) + } + }) + } + } + wg.Wait() + + messages, err := stores[0].RecentMessages(t.Context(), "sess", perStore*len(stores)) + if err != nil { + t.Fatal(err) + } + if len(messages) != perStore*len(stores) { + t.Fatalf("messages = %d, want %d", len(messages), perStore*len(stores)) + } + for i := 1; i < len(messages); i++ { + if !messages[i].At.After(messages[i-1].At) { + t.Fatalf("timestamp %d (%s) is not after timestamp %d (%s)", i, messages[i].At, i-1, messages[i-1].At) + } + } +} + +// TestPostgresClaimTurnConcurrentInsertRaceResolvesToOneOwner pins the +// insert-first claim: racing two independent stores over one turn ID must +// yield exactly one TurnClaimOwned, never two. +func TestPostgresClaimTurnConcurrentInsertRaceResolvesToOneOwner(t *testing.T) { + pool := newPostgresPool(t) + + const stores = 2 + const trials = 100 + + ledgers := make([]TurnLedger, stores) + for i := range ledgers { + store, ok := NewPostgresSessionStore(pool).(TurnLedger) + if !ok { + t.Fatalf("store[%d] is %T, want TurnLedger", i, store) + } + ledgers[i] = store + } + + ctx := context.Background() + now := time.UnixMilli(1000).UTC() + + for trial := range trials { + turnID := fmt.Sprintf("race-turn-%d", trial) + initial := TurnRecord{ + TurnID: turnID, + SessionID: "race-session", + SourceID: turnID, + Status: TurnStatusAccepted, + CreatedAt: now, + UpdatedAt: now, + } + errs := make([]error, stores) + claims := make([]TurnClaim, stores) + var wg sync.WaitGroup + var start sync.WaitGroup + start.Add(1) + for i := range stores { + wg.Add(1) + go func(i int) { + defer wg.Done() + start.Wait() + _, claims[i], errs[i] = ledgers[i].ClaimTurn(ctx, initial) + }(i) + } + start.Done() + wg.Wait() + + for i, err := range errs { + if err != nil { + t.Fatalf("trial %d, store %d: ClaimTurn() unexpected error = %v", trial, i, err) + } + } + owners := 0 + for _, c := range claims { + if c == TurnClaimOwned { + owners++ + } + } + if owners != 1 { + t.Fatalf("trial %d: expected exactly one TurnClaimOwned across %d racers, got %d (claims=%v)", trial, stores, owners, claims) + } + } +} + +// TestPostgresSessionStoreRecentTurnsReturnsReplayableToolHistory pins the +// TurnLedger/TurnHistory round-trip: a completed turn reads back with its +// tool calls and response text intact. +func TestPostgresSessionStoreRecentTurnsReturnsReplayableToolHistory(t *testing.T) { + st := newPostgresStore(t) + ledger, ok := st.(TurnLedger) + if !ok { + t.Fatalf("store is %T, want TurnLedger", st) + } + turn, claim, err := ledger.ClaimTurn(t.Context(), TurnRecord{ + TurnID: "turn-history", SessionID: "session-history", SourceID: "source-history", OwnerID: "owner", + ToolCalls: []ToolCallEvent{{Name: "shell", Output: "exit 0"}}, + }) + if err != nil || claim != TurnClaimOwned { + t.Fatalf("ClaimTurn() = %#v, %v, %v", turn, claim, err) + } + turn.Status = TurnStatusCompleted + turn.ResponseText = "answer" + turn.UpdatedAt = time.Now().UTC() + if err := ledger.SaveTurn(t.Context(), turn); err != nil { + t.Fatalf("SaveTurn() error = %v", err) + } + history, ok := st.(TurnHistory) + if !ok { + t.Fatalf("store is %T, want TurnHistory", st) + } + got, err := history.RecentTurns(t.Context(), "session-history", 10) + if err != nil || len(got) != 1 || len(got[0].ToolCalls) != 1 || got[0].ResponseText != "answer" { + t.Fatalf("RecentTurns() = %#v, %v; want one replayable turn", got, err) + } +} diff --git a/internal/infrastructure/postgres/migrations/0003_gateway.sql b/internal/infrastructure/postgres/migrations/0003_gateway.sql new file mode 100644 index 000000000..ea2b7fbb9 --- /dev/null +++ b/internal/infrastructure/postgres/migrations/0003_gateway.sql @@ -0,0 +1,82 @@ +-- Gateway conversation schema: sessions, messages, turns and full-text search. +-- +-- Translations from the SQLite schema this replaces (session_store_sqlite.go), +-- and why: +-- * Times stay bigint milliseconds. SQLite stored them as INTEGER ms and the +-- monotonic clamp adds one to that integer (MAX(ts) + 1); a timestamptz +-- translation would change the unit of the "+1" and therefore the strict +-- message-ordering contract, so the millisecond representation is kept +-- verbatim and the Go adapter converts with time.UnixMilli exactly as the +-- SQLite store did. +-- * FTS5 becomes a STORED generated tsvector column over (sender, text) plus +-- a GIN index. The external-content FTS5 table was kept in sync by three +-- triggers on messages; a generated column cannot drift from its row, so +-- the triggers are unnecessary here. The 'simple' configuration matches +-- FTS5's default tokenizer: case-folding only, no stemming, no stop words. +-- * Every column behind a Go int is bigint: SQLite's INTEGER is 64-bit. + +-- +goose Up + +CREATE TABLE sessions ( + session_id text PRIMARY KEY, + platform text NOT NULL DEFAULT '', + bot_user text NOT NULL DEFAULT '', + channel_id text NOT NULL DEFAULT '', + thread_id text NOT NULL DEFAULT '', + title text NOT NULL DEFAULT '', + parent_session_id text NOT NULL DEFAULT '', + branch_name text NOT NULL DEFAULT '', + created_at bigint NOT NULL DEFAULT 0, + last_active_at bigint NOT NULL DEFAULT 0 +); +CREATE INDEX idx_sessions_channel ON sessions (platform, channel_id); +-- Ordering is by recency: last_active_at when set, created_at otherwise +-- (GREATEST is the two-argument max SQLite's MAX(a, b) expressed). The index +-- matches that expression so newest-first listings do not sort at query time. +CREATE INDEX idx_sessions_recency + ON sessions (platform, channel_id, GREATEST(last_active_at, created_at) DESC); + +CREATE TABLE messages ( + id bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, + message_id text NOT NULL, + session_id text NOT NULL, + source_id text NOT NULL DEFAULT '', + sender text NOT NULL DEFAULT '', + sender_id text NOT NULL DEFAULT '', + role text NOT NULL DEFAULT '', + text text NOT NULL DEFAULT '', + ts bigint NOT NULL, + -- Full-text search over sender and text only: ts, source_id and other + -- metadata are not indexed, so a query like "2026" cannot match every + -- message via its timestamp (the SQLite FTS5 external-content index kept + -- exactly these two columns). + search tsvector GENERATED ALWAYS AS (to_tsvector('simple', sender || ' ' || text)) STORED, + UNIQUE (session_id, message_id) +); +CREATE INDEX idx_messages_session_ts ON messages (session_id, ts); +CREATE INDEX idx_messages_search ON messages USING GIN (search); + +CREATE TABLE turns ( + turn_id text PRIMARY KEY, + session_id text NOT NULL, + source_id text NOT NULL DEFAULT '', + status text NOT NULL, + attempt bigint NOT NULL DEFAULT 0, + owner_id text NOT NULL DEFAULT '', + input_message_id text NOT NULL DEFAULT '', + assistant_message_id text NOT NULL DEFAULT '', + partial_text text NOT NULL DEFAULT '', + response_text text NOT NULL DEFAULT '', + tool_calls text NOT NULL DEFAULT '[]', + error text NOT NULL DEFAULT '', + created_at bigint NOT NULL, + updated_at bigint NOT NULL +); +CREATE INDEX idx_turns_session_source ON turns (session_id, source_id); +CREATE INDEX idx_turns_status_updated ON turns (status, updated_at); + +-- +goose Down + +DROP TABLE turns; +DROP TABLE messages; +DROP TABLE sessions; diff --git a/internal/infrastructure/postgres/postgresdb/gateway.sql.go b/internal/infrastructure/postgres/postgresdb/gateway.sql.go new file mode 100644 index 000000000..40f350942 --- /dev/null +++ b/internal/infrastructure/postgres/postgresdb/gateway.sql.go @@ -0,0 +1,844 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: gateway.sql + +package postgresdb + +import ( + "context" +) + +const countMessages = `-- name: CountMessages :one +SELECT COUNT(*) FROM messages WHERE session_id = $1 +` + +func (q *Queries) CountMessages(ctx context.Context, sessionID string) (int64, error) { + row := q.db.QueryRow(ctx, countMessages, sessionID) + var count int64 + err := row.Scan(&count) + return count, err +} + +const deleteMessagesByID = `-- name: DeleteMessagesByID :exec +DELETE FROM messages WHERE session_id = $1 AND message_id = ANY($2::text[]) +` + +type DeleteMessagesByIDParams struct { + SessionID string + Ids []string +} + +func (q *Queries) DeleteMessagesByID(ctx context.Context, arg DeleteMessagesByIDParams) error { + _, err := q.db.Exec(ctx, deleteMessagesByID, arg.SessionID, arg.Ids) + return err +} + +const deleteRecentMessages = `-- name: DeleteRecentMessages :execrows +DELETE FROM messages WHERE id IN ( + SELECT m.id FROM messages m WHERE m.session_id = $1 ORDER BY m.ts DESC LIMIT $2 +) +` + +type DeleteRecentMessagesParams struct { + SessionID string + Limit int32 +} + +func (q *Queries) DeleteRecentMessages(ctx context.Context, arg DeleteRecentMessagesParams) (int64, error) { + result, err := q.db.Exec(ctx, deleteRecentMessages, arg.SessionID, arg.Limit) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const deleteSession = `-- name: DeleteSession :exec +DELETE FROM sessions WHERE session_id = $1 +` + +func (q *Queries) DeleteSession(ctx context.Context, sessionID string) error { + _, err := q.db.Exec(ctx, deleteSession, sessionID) + return err +} + +const deleteSessionMessages = `-- name: DeleteSessionMessages :exec +DELETE FROM messages WHERE session_id = $1 +` + +func (q *Queries) DeleteSessionMessages(ctx context.Context, sessionID string) error { + _, err := q.db.Exec(ctx, deleteSessionMessages, sessionID) + return err +} + +const deleteSessionTurns = `-- name: DeleteSessionTurns :exec +DELETE FROM turns WHERE session_id = $1 +` + +func (q *Queries) DeleteSessionTurns(ctx context.Context, sessionID string) error { + _, err := q.db.Exec(ctx, deleteSessionTurns, sessionID) + return err +} + +const finalizeTurn = `-- name: FinalizeTurn :execrows +UPDATE turns SET status = $2, error = $3, updated_at = $4 +WHERE turn_id = $1 AND attempt = $5 AND owner_id = $6 +` + +type FinalizeTurnParams struct { + TurnID string + Status string + Error string + UpdatedAt int64 + Attempt int64 + OwnerID string +} + +func (q *Queries) FinalizeTurn(ctx context.Context, arg FinalizeTurnParams) (int64, error) { + result, err := q.db.Exec(ctx, finalizeTurn, + arg.TurnID, + arg.Status, + arg.Error, + arg.UpdatedAt, + arg.Attempt, + arg.OwnerID, + ) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const insertMessageAt = `-- name: InsertMessageAt :exec +INSERT INTO messages (message_id, session_id, source_id, sender, sender_id, role, text, ts) +VALUES ($1, $2, $3, $4, $5, $6, $7, $8) +ON CONFLICT (session_id, message_id) DO NOTHING +` + +type InsertMessageAtParams struct { + MessageID string + SessionID string + SourceID string + Sender string + SenderID string + Role string + Text string + Ts int64 +} + +// Rewriting history places records deliberately, so no clamp applies. +func (q *Queries) InsertMessageAt(ctx context.Context, arg InsertMessageAtParams) error { + _, err := q.db.Exec(ctx, insertMessageAt, + arg.MessageID, + arg.SessionID, + arg.SourceID, + arg.Sender, + arg.SenderID, + arg.Role, + arg.Text, + arg.Ts, + ) + return err +} + +const insertMessageClamped = `-- name: InsertMessageClamped :exec +INSERT INTO messages (message_id, session_id, source_id, sender, sender_id, role, text, ts) +VALUES ($1, $2, $3, $4, $5, $6, $7, ( + SELECT CASE + WHEN MAX(m.ts) IS NOT NULL AND MAX(m.ts) >= $8 THEN MAX(m.ts) + 1 + ELSE $8 + END + FROM messages m WHERE m.session_id = $2 +)) +ON CONFLICT (session_id, message_id) DO NOTHING +` + +type InsertMessageClampedParams struct { + MessageID string + SessionID string + SourceID string + Sender string + SenderID string + Role string + Text string + Ts int64 +} + +// The append path's strictly-increasing timestamp. The clamp is computed in +// SQL, not in Go: the CASE assigns MAX(ts)+1 when the caller's timestamp is +// not ahead of the session's newest, else the caller's timestamp. A Go-side +// read-then-write would race two concurrent appends to the same session. +func (q *Queries) InsertMessageClamped(ctx context.Context, arg InsertMessageClampedParams) error { + _, err := q.db.Exec(ctx, insertMessageClamped, + arg.MessageID, + arg.SessionID, + arg.SourceID, + arg.Sender, + arg.SenderID, + arg.Role, + arg.Text, + arg.Ts, + ) + return err +} + +const insertTurn = `-- name: InsertTurn :execrows + +INSERT INTO turns (turn_id, session_id, source_id, status, attempt, owner_id, + input_message_id, assistant_message_id, partial_text, + response_text, tool_calls, error, created_at, updated_at) +VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14) +ON CONFLICT (turn_id) DO NOTHING +` + +type InsertTurnParams struct { + TurnID string + SessionID string + SourceID string + Status string + Attempt int64 + OwnerID string + InputMessageID string + AssistantMessageID string + PartialText string + ResponseText string + ToolCalls string + Error string + CreatedAt int64 + UpdatedAt int64 +} + +// ── Turns ─────────────────────────────────────────────────────────────────── +func (q *Queries) InsertTurn(ctx context.Context, arg InsertTurnParams) (int64, error) { + result, err := q.db.Exec(ctx, insertTurn, + arg.TurnID, + arg.SessionID, + arg.SourceID, + arg.Status, + arg.Attempt, + arg.OwnerID, + arg.InputMessageID, + arg.AssistantMessageID, + arg.PartialText, + arg.ResponseText, + arg.ToolCalls, + arg.Error, + arg.CreatedAt, + arg.UpdatedAt, + ) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const listRecoverableTurns = `-- name: ListRecoverableTurns :many +SELECT turn_id, session_id, source_id, status, attempt, owner_id, + input_message_id, assistant_message_id, partial_text, + response_text, tool_calls, error, created_at, updated_at +FROM turns WHERE status IN ('accepted', 'running', 'partial') ORDER BY updated_at ASC +` + +func (q *Queries) ListRecoverableTurns(ctx context.Context) ([]Turn, error) { + rows, err := q.db.Query(ctx, listRecoverableTurns) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Turn + for rows.Next() { + var i Turn + if err := rows.Scan( + &i.TurnID, + &i.SessionID, + &i.SourceID, + &i.Status, + &i.Attempt, + &i.OwnerID, + &i.InputMessageID, + &i.AssistantMessageID, + &i.PartialText, + &i.ResponseText, + &i.ToolCalls, + &i.Error, + &i.CreatedAt, + &i.UpdatedAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listSessions = `-- name: ListSessions :many +SELECT session_id, platform, bot_user, channel_id, thread_id, + title, parent_session_id, branch_name, created_at, last_active_at +FROM sessions +ORDER BY GREATEST(last_active_at, created_at) DESC +` + +func (q *Queries) ListSessions(ctx context.Context) ([]Session, error) { + rows, err := q.db.Query(ctx, listSessions) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Session + for rows.Next() { + var i Session + if err := rows.Scan( + &i.SessionID, + &i.Platform, + &i.BotUser, + &i.ChannelID, + &i.ThreadID, + &i.Title, + &i.ParentSessionID, + &i.BranchName, + &i.CreatedAt, + &i.LastActiveAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const lockSessionMessages = `-- name: LockSessionMessages :exec + +SELECT pg_advisory_xact_lock(hashtextextended('messages:' || $1::text, 0)) +` + +// ── Messages ──────────────────────────────────────────────────────────────── +// Serialises message appends per session so the monotonic clamp's MAX(ts) +// read cannot race a concurrent append of the same session. Transaction-scoped: +// released at commit/rollback, which is exactly the lifetime of the append. +func (q *Queries) LockSessionMessages(ctx context.Context, dollar_1 string) error { + _, err := q.db.Exec(ctx, lockSessionMessages, dollar_1) + return err +} + +const messageID = `-- name: MessageID :one +SELECT message_id FROM messages WHERE session_id = $1 AND message_id = $2 +` + +type MessageIDParams struct { + SessionID string + MessageID string +} + +func (q *Queries) MessageID(ctx context.Context, arg MessageIDParams) (string, error) { + row := q.db.QueryRow(ctx, messageID, arg.SessionID, arg.MessageID) + var message_id string + err := row.Scan(&message_id) + return message_id, err +} + +const nextReplyAfterTs = `-- name: NextReplyAfterTs :one +SELECT sender, text FROM messages +WHERE session_id = $1 AND ts > $2 ORDER BY ts ASC LIMIT 1 +` + +type NextReplyAfterTsParams struct { + SessionID string + Ts int64 +} + +type NextReplyAfterTsRow struct { + Sender string + Text string +} + +func (q *Queries) NextReplyAfterTs(ctx context.Context, arg NextReplyAfterTsParams) (NextReplyAfterTsRow, error) { + row := q.db.QueryRow(ctx, nextReplyAfterTs, arg.SessionID, arg.Ts) + var i NextReplyAfterTsRow + err := row.Scan(&i.Sender, &i.Text) + return i, err +} + +const recentMessages = `-- name: RecentMessages :many +SELECT m.message_id, m.source_id, m.sender, m.sender_id, m.role, m.text, m.ts, + COALESCE(s.channel_id, '') AS channel_id, COALESCE(s.thread_id, '') AS thread_id +FROM ( + SELECT msg.message_id, msg.source_id, msg.sender, msg.sender_id, msg.role, msg.text, msg.ts, msg.session_id + FROM messages msg WHERE msg.session_id = $1 ORDER BY msg.ts DESC LIMIT $2 +) m +LEFT JOIN sessions s ON s.session_id = m.session_id +ORDER BY m.ts ASC +` + +type RecentMessagesParams struct { + SessionID string + Limit int32 +} + +type RecentMessagesRow struct { + MessageID string + SourceID string + Sender string + SenderID string + Role string + Text string + Ts int64 + ChannelID string + ThreadID string +} + +func (q *Queries) RecentMessages(ctx context.Context, arg RecentMessagesParams) ([]RecentMessagesRow, error) { + rows, err := q.db.Query(ctx, recentMessages, arg.SessionID, arg.Limit) + if err != nil { + return nil, err + } + defer rows.Close() + var items []RecentMessagesRow + for rows.Next() { + var i RecentMessagesRow + if err := rows.Scan( + &i.MessageID, + &i.SourceID, + &i.Sender, + &i.SenderID, + &i.Role, + &i.Text, + &i.Ts, + &i.ChannelID, + &i.ThreadID, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const recentTurns = `-- name: RecentTurns :many +SELECT turn_id, session_id, source_id, status, attempt, owner_id, + input_message_id, assistant_message_id, partial_text, + response_text, tool_calls, error, created_at, updated_at +FROM turns WHERE session_id = $1 ORDER BY created_at DESC LIMIT $2 +` + +type RecentTurnsParams struct { + SessionID string + Limit int32 +} + +func (q *Queries) RecentTurns(ctx context.Context, arg RecentTurnsParams) ([]Turn, error) { + rows, err := q.db.Query(ctx, recentTurns, arg.SessionID, arg.Limit) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Turn + for rows.Next() { + var i Turn + if err := rows.Scan( + &i.TurnID, + &i.SessionID, + &i.SourceID, + &i.Status, + &i.Attempt, + &i.OwnerID, + &i.InputMessageID, + &i.AssistantMessageID, + &i.PartialText, + &i.ResponseText, + &i.ToolCalls, + &i.Error, + &i.CreatedAt, + &i.UpdatedAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const recoverTurns = `-- name: RecoverTurns :exec +UPDATE turns SET status = 'failed', error = 'recovered after process restart', updated_at = $1 +WHERE status IN ('accepted', 'running', 'partial') AND owner_id <> $2 +` + +type RecoverTurnsParams struct { + UpdatedAt int64 + OwnerID string +} + +func (q *Queries) RecoverTurns(ctx context.Context, arg RecoverTurnsParams) error { + _, err := q.db.Exec(ctx, recoverTurns, arg.UpdatedAt, arg.OwnerID) + return err +} + +const retryTurn = `-- name: RetryTurn :execrows +UPDATE turns SET status = $2, attempt = $3, owner_id = $4, error = $5, updated_at = $6 +WHERE turn_id = $1 AND attempt = $7 AND owner_id = $8 +` + +type RetryTurnParams struct { + TurnID string + Status string + Attempt int64 + OwnerID string + Error string + UpdatedAt int64 + Attempt_2 int64 + OwnerID_2 string +} + +func (q *Queries) RetryTurn(ctx context.Context, arg RetryTurnParams) (int64, error) { + result, err := q.db.Exec(ctx, retryTurn, + arg.TurnID, + arg.Status, + arg.Attempt, + arg.OwnerID, + arg.Error, + arg.UpdatedAt, + arg.Attempt_2, + arg.OwnerID_2, + ) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const saveSession = `-- name: SaveSession :exec + + +INSERT INTO sessions (session_id, platform, bot_user, channel_id, thread_id, + title, parent_session_id, branch_name, created_at, last_active_at) +VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) +ON CONFLICT (session_id) DO UPDATE SET + platform = EXCLUDED.platform, + bot_user = EXCLUDED.bot_user, + channel_id = EXCLUDED.channel_id, + thread_id = EXCLUDED.thread_id, + title = EXCLUDED.title, + parent_session_id = EXCLUDED.parent_session_id, + branch_name = EXCLUDED.branch_name, + created_at = EXCLUDED.created_at, + last_active_at = EXCLUDED.last_active_at +` + +type SaveSessionParams struct { + SessionID string + Platform string + BotUser string + ChannelID string + ThreadID string + Title string + ParentSessionID string + BranchName string + CreatedAt int64 + LastActiveAt int64 +} + +// Gateway conversation queries: sessions, messages, turns, full-text search. +// These back internal/gateway's PostgreSQL SessionStore. +// ── Sessions ──────────────────────────────────────────────────────────────── +func (q *Queries) SaveSession(ctx context.Context, arg SaveSessionParams) error { + _, err := q.db.Exec(ctx, saveSession, + arg.SessionID, + arg.Platform, + arg.BotUser, + arg.ChannelID, + arg.ThreadID, + arg.Title, + arg.ParentSessionID, + arg.BranchName, + arg.CreatedAt, + arg.LastActiveAt, + ) + return err +} + +const saveTurn = `-- name: SaveTurn :execrows +UPDATE turns SET + session_id = $2, source_id = $3, status = $4, attempt = $5, owner_id = $6, + input_message_id = $7, assistant_message_id = $8, partial_text = $9, + response_text = $10, tool_calls = $11, error = $12, created_at = $13, updated_at = $14 +WHERE turn_id = $1 AND attempt = $5 AND owner_id = $6 +` + +type SaveTurnParams struct { + TurnID string + SessionID string + SourceID string + Status string + Attempt int64 + OwnerID string + InputMessageID string + AssistantMessageID string + PartialText string + ResponseText string + ToolCalls string + Error string + CreatedAt int64 + UpdatedAt int64 +} + +func (q *Queries) SaveTurn(ctx context.Context, arg SaveTurnParams) (int64, error) { + result, err := q.db.Exec(ctx, saveTurn, + arg.TurnID, + arg.SessionID, + arg.SourceID, + arg.Status, + arg.Attempt, + arg.OwnerID, + arg.InputMessageID, + arg.AssistantMessageID, + arg.PartialText, + arg.ResponseText, + arg.ToolCalls, + arg.Error, + arg.CreatedAt, + arg.UpdatedAt, + ) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const searchMessagesCount = `-- name: SearchMessagesCount :one +SELECT COUNT(*) FROM messages +WHERE session_id = $1 AND search @@ plainto_tsquery('simple', $2) +` + +type SearchMessagesCountParams struct { + SessionID string + PlaintoTsquery string +} + +func (q *Queries) SearchMessagesCount(ctx context.Context, arg SearchMessagesCountParams) (int64, error) { + row := q.db.QueryRow(ctx, searchMessagesCount, arg.SessionID, arg.PlaintoTsquery) + var count int64 + err := row.Scan(&count) + return count, err +} + +const searchMessagesPage = `-- name: SearchMessagesPage :many +SELECT m.message_id, m.source_id, m.sender, m.sender_id, m.role, m.text, m.ts, + COALESCE(s.channel_id, '') AS channel_id, COALESCE(s.thread_id, '') AS thread_id +FROM messages m +LEFT JOIN sessions s ON s.session_id = m.session_id +WHERE m.session_id = $1 AND m.search @@ plainto_tsquery('simple', $2) +ORDER BY ts_rank(m.search, plainto_tsquery('simple', $2)) DESC, m.ts DESC, m.id DESC +LIMIT $3 OFFSET $4 +` + +type SearchMessagesPageParams struct { + SessionID string + PlaintoTsquery string + Limit int32 + Offset int32 +} + +type SearchMessagesPageRow struct { + MessageID string + SourceID string + Sender string + SenderID string + Role string + Text string + Ts int64 + ChannelID string + ThreadID string +} + +func (q *Queries) SearchMessagesPage(ctx context.Context, arg SearchMessagesPageParams) ([]SearchMessagesPageRow, error) { + rows, err := q.db.Query(ctx, searchMessagesPage, + arg.SessionID, + arg.PlaintoTsquery, + arg.Limit, + arg.Offset, + ) + if err != nil { + return nil, err + } + defer rows.Close() + var items []SearchMessagesPageRow + for rows.Next() { + var i SearchMessagesPageRow + if err := rows.Scan( + &i.MessageID, + &i.SourceID, + &i.Sender, + &i.SenderID, + &i.Role, + &i.Text, + &i.Ts, + &i.ChannelID, + &i.ThreadID, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const sessionByID = `-- name: SessionByID :one +SELECT session_id, platform, bot_user, channel_id, thread_id, + title, parent_session_id, branch_name, created_at, last_active_at +FROM sessions WHERE session_id = $1 +` + +func (q *Queries) SessionByID(ctx context.Context, sessionID string) (Session, error) { + row := q.db.QueryRow(ctx, sessionByID, sessionID) + var i Session + err := row.Scan( + &i.SessionID, + &i.Platform, + &i.BotUser, + &i.ChannelID, + &i.ThreadID, + &i.Title, + &i.ParentSessionID, + &i.BranchName, + &i.CreatedAt, + &i.LastActiveAt, + ) + return i, err +} + +const sessionsByChannel = `-- name: SessionsByChannel :many +SELECT session_id, platform, bot_user, channel_id, thread_id, + title, parent_session_id, branch_name, created_at, last_active_at +FROM sessions +WHERE platform = $1 AND channel_id = $2 +ORDER BY GREATEST(last_active_at, created_at) DESC +` + +type SessionsByChannelParams struct { + Platform string + ChannelID string +} + +func (q *Queries) SessionsByChannel(ctx context.Context, arg SessionsByChannelParams) ([]Session, error) { + rows, err := q.db.Query(ctx, sessionsByChannel, arg.Platform, arg.ChannelID) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Session + for rows.Next() { + var i Session + if err := rows.Scan( + &i.SessionID, + &i.Platform, + &i.BotUser, + &i.ChannelID, + &i.ThreadID, + &i.Title, + &i.ParentSessionID, + &i.BranchName, + &i.CreatedAt, + &i.LastActiveAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const sourceMessageTs = `-- name: SourceMessageTs :one +SELECT ts FROM messages +WHERE session_id = $1 AND message_id IN ($2, $3) +ORDER BY CASE WHEN message_id = $3 THEN 0 ELSE 1 END +LIMIT 1 +` + +type SourceMessageTsParams struct { + SessionID string + MessageID string + MessageID_2 string +} + +func (q *Queries) SourceMessageTs(ctx context.Context, arg SourceMessageTsParams) (int64, error) { + row := q.db.QueryRow(ctx, sourceMessageTs, arg.SessionID, arg.MessageID, arg.MessageID_2) + var ts int64 + err := row.Scan(&ts) + return ts, err +} + +const touchSession = `-- name: TouchSession :exec +UPDATE sessions SET last_active_at = $2 WHERE session_id = $1 +` + +type TouchSessionParams struct { + SessionID string + LastActiveAt int64 +} + +func (q *Queries) TouchSession(ctx context.Context, arg TouchSessionParams) error { + _, err := q.db.Exec(ctx, touchSession, arg.SessionID, arg.LastActiveAt) + return err +} + +const turnAttemptOwner = `-- name: TurnAttemptOwner :one +SELECT attempt, owner_id FROM turns WHERE turn_id = $1 +` + +type TurnAttemptOwnerRow struct { + Attempt int64 + OwnerID string +} + +func (q *Queries) TurnAttemptOwner(ctx context.Context, turnID string) (TurnAttemptOwnerRow, error) { + row := q.db.QueryRow(ctx, turnAttemptOwner, turnID) + var i TurnAttemptOwnerRow + err := row.Scan(&i.Attempt, &i.OwnerID) + return i, err +} + +const turnByID = `-- name: TurnByID :one +SELECT turn_id, session_id, source_id, status, attempt, owner_id, + input_message_id, assistant_message_id, partial_text, + response_text, tool_calls, error, created_at, updated_at +FROM turns WHERE turn_id = $1 +` + +func (q *Queries) TurnByID(ctx context.Context, turnID string) (Turn, error) { + row := q.db.QueryRow(ctx, turnByID, turnID) + var i Turn + err := row.Scan( + &i.TurnID, + &i.SessionID, + &i.SourceID, + &i.Status, + &i.Attempt, + &i.OwnerID, + &i.InputMessageID, + &i.AssistantMessageID, + &i.PartialText, + &i.ResponseText, + &i.ToolCalls, + &i.Error, + &i.CreatedAt, + &i.UpdatedAt, + ) + return i, err +} diff --git a/internal/infrastructure/postgres/postgresdb/models.go b/internal/infrastructure/postgres/postgresdb/models.go index a4ec58e17..03580480e 100644 --- a/internal/infrastructure/postgres/postgresdb/models.go +++ b/internal/infrastructure/postgres/postgresdb/models.go @@ -85,6 +85,19 @@ type IdentitySubject struct { BoundAt time.Time } +type Message struct { + ID int64 + MessageID string + SessionID string + SourceID string + Sender string + SenderID string + Role string + Text string + Ts int64 + Search interface{} +} + type Resource struct { Kind string Value []byte @@ -105,6 +118,19 @@ type ResourceHistory struct { At time.Time } +type Session struct { + SessionID string + Platform string + BotUser string + ChannelID string + ThreadID string + Title string + ParentSessionID string + BranchName string + CreatedAt int64 + LastActiveAt int64 +} + type Task struct { ID int64 Owner string @@ -148,3 +174,20 @@ type Transition struct { ToStatus string Detail string } + +type Turn struct { + TurnID string + SessionID string + SourceID string + Status string + Attempt int64 + OwnerID string + InputMessageID string + AssistantMessageID string + PartialText string + ResponseText string + ToolCalls string + Error string + CreatedAt int64 + UpdatedAt int64 +} diff --git a/internal/infrastructure/postgres/queries/gateway.sql b/internal/infrastructure/postgres/queries/gateway.sql new file mode 100644 index 000000000..c1dc9a334 --- /dev/null +++ b/internal/infrastructure/postgres/queries/gateway.sql @@ -0,0 +1,174 @@ +-- Gateway conversation queries: sessions, messages, turns, full-text search. +-- These back internal/gateway's PostgreSQL SessionStore. + +-- ── Sessions ──────────────────────────────────────────────────────────────── + +-- name: SaveSession :exec +INSERT INTO sessions (session_id, platform, bot_user, channel_id, thread_id, + title, parent_session_id, branch_name, created_at, last_active_at) +VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) +ON CONFLICT (session_id) DO UPDATE SET + platform = EXCLUDED.platform, + bot_user = EXCLUDED.bot_user, + channel_id = EXCLUDED.channel_id, + thread_id = EXCLUDED.thread_id, + title = EXCLUDED.title, + parent_session_id = EXCLUDED.parent_session_id, + branch_name = EXCLUDED.branch_name, + created_at = EXCLUDED.created_at, + last_active_at = EXCLUDED.last_active_at; + +-- name: SessionByID :one +SELECT session_id, platform, bot_user, channel_id, thread_id, + title, parent_session_id, branch_name, created_at, last_active_at +FROM sessions WHERE session_id = $1; + +-- name: SessionsByChannel :many +SELECT session_id, platform, bot_user, channel_id, thread_id, + title, parent_session_id, branch_name, created_at, last_active_at +FROM sessions +WHERE platform = $1 AND channel_id = $2 +ORDER BY GREATEST(last_active_at, created_at) DESC; + +-- name: ListSessions :many +SELECT session_id, platform, bot_user, channel_id, thread_id, + title, parent_session_id, branch_name, created_at, last_active_at +FROM sessions +ORDER BY GREATEST(last_active_at, created_at) DESC; + +-- name: DeleteSessionMessages :exec +DELETE FROM messages WHERE session_id = $1; + +-- name: DeleteSessionTurns :exec +DELETE FROM turns WHERE session_id = $1; + +-- name: DeleteSession :exec +DELETE FROM sessions WHERE session_id = $1; + +-- name: TouchSession :exec +UPDATE sessions SET last_active_at = $2 WHERE session_id = $1; + +-- ── Messages ──────────────────────────────────────────────────────────────── + +-- name: LockSessionMessages :exec +-- Serialises message appends per session so the monotonic clamp's MAX(ts) +-- read cannot race a concurrent append of the same session. Transaction-scoped: +-- released at commit/rollback, which is exactly the lifetime of the append. +SELECT pg_advisory_xact_lock(hashtextextended('messages:' || $1::text, 0)); + +-- name: InsertMessageClamped :exec +-- The append path's strictly-increasing timestamp. The clamp is computed in +-- SQL, not in Go: the CASE assigns MAX(ts)+1 when the caller's timestamp is +-- not ahead of the session's newest, else the caller's timestamp. A Go-side +-- read-then-write would race two concurrent appends to the same session. +INSERT INTO messages (message_id, session_id, source_id, sender, sender_id, role, text, ts) +VALUES ($1, $2, $3, $4, $5, $6, $7, ( + SELECT CASE + WHEN MAX(m.ts) IS NOT NULL AND MAX(m.ts) >= $8 THEN MAX(m.ts) + 1 + ELSE $8 + END + FROM messages m WHERE m.session_id = $2 +)) +ON CONFLICT (session_id, message_id) DO NOTHING; + +-- name: InsertMessageAt :exec +-- Rewriting history places records deliberately, so no clamp applies. +INSERT INTO messages (message_id, session_id, source_id, sender, sender_id, role, text, ts) +VALUES ($1, $2, $3, $4, $5, $6, $7, $8) +ON CONFLICT (session_id, message_id) DO NOTHING; + +-- name: MessageID :one +SELECT message_id FROM messages WHERE session_id = $1 AND message_id = $2; + +-- name: RecentMessages :many +SELECT m.message_id, m.source_id, m.sender, m.sender_id, m.role, m.text, m.ts, + COALESCE(s.channel_id, '') AS channel_id, COALESCE(s.thread_id, '') AS thread_id +FROM ( + SELECT msg.message_id, msg.source_id, msg.sender, msg.sender_id, msg.role, msg.text, msg.ts, msg.session_id + FROM messages msg WHERE msg.session_id = $1 ORDER BY msg.ts DESC LIMIT $2 +) m +LEFT JOIN sessions s ON s.session_id = m.session_id +ORDER BY m.ts ASC; + +-- name: DeleteRecentMessages :execrows +DELETE FROM messages WHERE id IN ( + SELECT m.id FROM messages m WHERE m.session_id = $1 ORDER BY m.ts DESC LIMIT $2 +); + +-- name: DeleteMessagesByID :exec +DELETE FROM messages WHERE session_id = $1 AND message_id = ANY(sqlc.arg(ids)::text[]); + +-- name: CountMessages :one +SELECT COUNT(*) FROM messages WHERE session_id = $1; + +-- name: SearchMessagesCount :one +SELECT COUNT(*) FROM messages +WHERE session_id = $1 AND search @@ plainto_tsquery('simple', $2); + +-- name: SearchMessagesPage :many +SELECT m.message_id, m.source_id, m.sender, m.sender_id, m.role, m.text, m.ts, + COALESCE(s.channel_id, '') AS channel_id, COALESCE(s.thread_id, '') AS thread_id +FROM messages m +LEFT JOIN sessions s ON s.session_id = m.session_id +WHERE m.session_id = $1 AND m.search @@ plainto_tsquery('simple', $2) +ORDER BY ts_rank(m.search, plainto_tsquery('simple', $2)) DESC, m.ts DESC, m.id DESC +LIMIT $3 OFFSET $4; + +-- name: SourceMessageTs :one +SELECT ts FROM messages +WHERE session_id = $1 AND message_id IN ($2, $3) +ORDER BY CASE WHEN message_id = $3 THEN 0 ELSE 1 END +LIMIT 1; + +-- name: NextReplyAfterTs :one +SELECT sender, text FROM messages +WHERE session_id = $1 AND ts > $2 ORDER BY ts ASC LIMIT 1; + +-- ── Turns ─────────────────────────────────────────────────────────────────── + +-- name: InsertTurn :execrows +INSERT INTO turns (turn_id, session_id, source_id, status, attempt, owner_id, + input_message_id, assistant_message_id, partial_text, + response_text, tool_calls, error, created_at, updated_at) +VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14) +ON CONFLICT (turn_id) DO NOTHING; + +-- name: TurnByID :one +SELECT turn_id, session_id, source_id, status, attempt, owner_id, + input_message_id, assistant_message_id, partial_text, + response_text, tool_calls, error, created_at, updated_at +FROM turns WHERE turn_id = $1; + +-- name: TurnAttemptOwner :one +SELECT attempt, owner_id FROM turns WHERE turn_id = $1; + +-- name: FinalizeTurn :execrows +UPDATE turns SET status = $2, error = $3, updated_at = $4 +WHERE turn_id = $1 AND attempt = $5 AND owner_id = $6; + +-- name: RetryTurn :execrows +UPDATE turns SET status = $2, attempt = $3, owner_id = $4, error = $5, updated_at = $6 +WHERE turn_id = $1 AND attempt = $7 AND owner_id = $8; + +-- name: RecoverTurns :exec +UPDATE turns SET status = 'failed', error = 'recovered after process restart', updated_at = $1 +WHERE status IN ('accepted', 'running', 'partial') AND owner_id <> $2; + +-- name: SaveTurn :execrows +UPDATE turns SET + session_id = $2, source_id = $3, status = $4, attempt = $5, owner_id = $6, + input_message_id = $7, assistant_message_id = $8, partial_text = $9, + response_text = $10, tool_calls = $11, error = $12, created_at = $13, updated_at = $14 +WHERE turn_id = $1 AND attempt = $5 AND owner_id = $6; + +-- name: RecentTurns :many +SELECT turn_id, session_id, source_id, status, attempt, owner_id, + input_message_id, assistant_message_id, partial_text, + response_text, tool_calls, error, created_at, updated_at +FROM turns WHERE session_id = $1 ORDER BY created_at DESC LIMIT $2; + +-- name: ListRecoverableTurns :many +SELECT turn_id, session_id, source_id, status, attempt, owner_id, + input_message_id, assistant_message_id, partial_text, + response_text, tool_calls, error, created_at, updated_at +FROM turns WHERE status IN ('accepted', 'running', 'partial') ORDER BY updated_at ASC;