62159
Sy
symb / files
symb / internal / store / session.go
9.4 KB
1package store 2 3import ( 4 "encoding/json" 5 "fmt" 6 "strings" 7 "time" 8 9 "github.com/rs/zerolog/log" 10 "github.com/xonecas/symb/internal/provider" 11) 12 13const ( 14 SQLiteBusyMaxRetries = 10 15 SQLiteBusyBackoffStepMs = 50 16 SQLiteBusyMaxBackoff = time.Second 17) 18 19// Session represents a conversation session. 20type Session struct { 21 ID string 22 Title string 23 Created time.Time 24 Updated time.Time 25} 26 27// SessionMessage is a persisted chat message. 28type SessionMessage struct { 29 Role string 30 Content string 31 Reasoning string 32 ToolCalls json.RawMessage // JSON array 33 ToolCallID string 34 CreatedAt time.Time 35 InputTokens int 36 OutputTokens int 37} 38 39// CreateSession inserts a new session and returns its ID. 40func (c *Cache) CreateSession(id string) error { 41 if c == nil { 42 return nil 43 } 44 c.mu.Lock() 45 defer c.mu.Unlock() 46 47 now := time.Now().Unix() 48 _, err := c.db.Exec( 49 "INSERT INTO sessions (id, title, created, updated) VALUES (?, '', ?, ?)", 50 id, now, now, 51 ) 52 if err != nil { 53 log.Warn().Err(err).Str("id", id).Msg("failed to create session") 54 } 55 return err 56} 57 58// SaveMessage persists a message synchronously. 59func (c *Cache) SaveMessage(sessionID string, msg SessionMessage) { 60 if err := c.SaveMessages(sessionID, []SessionMessage{msg}); err != nil { 61 log.Warn().Err(err).Str("session", sessionID).Msg("failed to save message") 62 } 63} 64 65// SaveMessages persists a batch of messages atomically. 66func (c *Cache) SaveMessages(sessionID string, msgs []SessionMessage) error { 67 if c == nil || len(msgs) == 0 { 68 return nil 69 } 70 71 var err error 72 for attempt := 0; attempt <= SQLiteBusyMaxRetries; attempt++ { 73 err = c.saveMessagesOnce(sessionID, msgs) 74 if err == nil { 75 return nil 76 } 77 if !IsSQLiteBusy(err) || attempt == SQLiteBusyMaxRetries { 78 return err 79 } 80 backoff := time.Duration((attempt+1)*SQLiteBusyBackoffStepMs) * time.Millisecond 81 if backoff > SQLiteBusyMaxBackoff { 82 backoff = SQLiteBusyMaxBackoff 83 } 84 time.Sleep(backoff) 85 } 86 return err 87} 88 89// SaveMessageSync persists a message synchronously and returns its DB row ID. 90// Used for turn-start messages where we need the ID immediately. 91func (c *Cache) SaveMessageSync(sessionID string, msg SessionMessage) (int64, error) { 92 if c == nil { 93 return 0, nil 94 } 95 96 var err error 97 for attempt := 0; attempt <= SQLiteBusyMaxRetries; attempt++ { 98 id, attemptErr := c.saveMessageSyncOnce(sessionID, msg) 99 if attemptErr == nil { 100 return id, nil 101 } 102 err = attemptErr 103 if !IsSQLiteBusy(err) || attempt == SQLiteBusyMaxRetries { 104 return 0, err 105 } 106 backoff := time.Duration((attempt+1)*SQLiteBusyBackoffStepMs) * time.Millisecond 107 if backoff > SQLiteBusyMaxBackoff { 108 backoff = SQLiteBusyMaxBackoff 109 } 110 time.Sleep(backoff) 111 } 112 return 0, err 113} 114 115func (c *Cache) saveMessagesOnce(sessionID string, msgs []SessionMessage) error { 116 c.mu.Lock() 117 defer c.mu.Unlock() 118 119 tx, err := c.db.Begin() 120 if err != nil { 121 return err 122 } 123 124 for _, msg := range msgs { 125 tc := msg.ToolCalls 126 if tc == nil { 127 tc = json.RawMessage("[]") 128 } 129 if _, err := tx.Exec( 130 `INSERT INTO messages (session_id, role, content, reasoning, tool_calls, tool_call_id, created, input_tokens, output_tokens) 131 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, 132 sessionID, msg.Role, msg.Content, msg.Reasoning, string(tc), msg.ToolCallID, msg.CreatedAt.Unix(), 133 msg.InputTokens, msg.OutputTokens, 134 ); err != nil { 135 if rbErr := tx.Rollback(); rbErr != nil { 136 log.Warn().Err(rbErr).Msg("failed to rollback message save") 137 } 138 return err 139 } 140 } 141 142 if _, err := tx.Exec("UPDATE sessions SET updated = ? WHERE id = ?", time.Now().Unix(), sessionID); err != nil { 143 if rbErr := tx.Rollback(); rbErr != nil { 144 log.Warn().Err(rbErr).Msg("failed to rollback message save") 145 } 146 return err 147 } 148 149 if err := tx.Commit(); err != nil { 150 if rbErr := tx.Rollback(); rbErr != nil { 151 log.Warn().Err(rbErr).Msg("failed to rollback message save") 152 } 153 return err 154 } 155 return nil 156} 157 158func (c *Cache) saveMessageSyncOnce(sessionID string, msg SessionMessage) (int64, error) { 159 c.mu.Lock() 160 defer c.mu.Unlock() 161 162 tx, err := c.db.Begin() 163 if err != nil { 164 return 0, err 165 } 166 167 tc := msg.ToolCalls 168 if tc == nil { 169 tc = json.RawMessage("[]") 170 } 171 172 res, err := tx.Exec( 173 `INSERT INTO messages (session_id, role, content, reasoning, tool_calls, tool_call_id, created, input_tokens, output_tokens) 174 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, 175 sessionID, msg.Role, msg.Content, msg.Reasoning, string(tc), msg.ToolCallID, msg.CreatedAt.Unix(), 176 msg.InputTokens, msg.OutputTokens, 177 ) 178 if err != nil { 179 if rbErr := tx.Rollback(); rbErr != nil { 180 log.Warn().Err(rbErr).Msg("failed to rollback message save") 181 } 182 return 0, err 183 } 184 185 if _, err := tx.Exec("UPDATE sessions SET updated = ? WHERE id = ?", time.Now().Unix(), sessionID); err != nil { 186 if rbErr := tx.Rollback(); rbErr != nil { 187 log.Warn().Err(rbErr).Msg("failed to rollback message save") 188 } 189 return 0, err 190 } 191 192 if err := tx.Commit(); err != nil { 193 if rbErr := tx.Rollback(); rbErr != nil { 194 log.Warn().Err(rbErr).Msg("failed to rollback message save") 195 } 196 return 0, err 197 } 198 199 return res.LastInsertId() 200} 201 202func IsSQLiteBusy(err error) bool { 203 if err == nil { 204 return false 205 } 206 msg := err.Error() 207 return strings.Contains(msg, "SQLITE_BUSY") || strings.Contains(msg, "database is locked") 208} 209 210// DeleteMessagesFrom removes all messages with id >= minID for a session. 211func (c *Cache) DeleteMessagesFrom(sessionID string, minID int64) error { 212 if c == nil { 213 return nil 214 } 215 c.mu.Lock() 216 defer c.mu.Unlock() 217 218 _, err := c.db.Exec( 219 "DELETE FROM messages WHERE session_id = ? AND id >= ?", 220 sessionID, minID, 221 ) 222 return err 223} 224 225// LoadLastMessage returns the most recent message for a session, or nil if none. 226func (c *Cache) LoadLastMessage(sessionID string) (*SessionMessage, error) { 227 if c == nil { 228 return nil, nil 229 } 230 c.mu.Lock() 231 defer c.mu.Unlock() 232 233 var m SessionMessage 234 var tc string 235 var created int64 236 err := c.db.QueryRow( 237 `SELECT role, content, reasoning, tool_calls, tool_call_id, created, input_tokens, output_tokens 238 FROM messages WHERE session_id = ? ORDER BY id DESC LIMIT 1`, sessionID, 239 ).Scan(&m.Role, &m.Content, &m.Reasoning, &tc, &m.ToolCallID, &created, &m.InputTokens, &m.OutputTokens) 240 if err != nil { 241 return nil, err 242 } 243 m.ToolCalls = json.RawMessage(tc) 244 m.CreatedAt = time.Unix(created, 0) 245 return &m, nil 246} 247 248// LoadMessages returns all messages for a session, ordered by ID. 249func (c *Cache) LoadMessages(sessionID string) ([]SessionMessage, error) { 250 if c == nil { 251 return nil, nil 252 } 253 c.mu.Lock() 254 defer c.mu.Unlock() 255 256 rows, err := c.db.Query( 257 `SELECT role, content, reasoning, tool_calls, tool_call_id, created, input_tokens, output_tokens 258 FROM messages WHERE session_id = ? ORDER BY id`, sessionID, 259 ) 260 if err != nil { 261 return nil, err 262 } 263 defer rows.Close() 264 265 var msgs []SessionMessage 266 for rows.Next() { 267 var m SessionMessage 268 var tc string 269 var created int64 270 if err := rows.Scan(&m.Role, &m.Content, &m.Reasoning, &tc, &m.ToolCallID, &created, &m.InputTokens, &m.OutputTokens); err != nil { 271 continue 272 } 273 m.ToolCalls = json.RawMessage(tc) 274 m.CreatedAt = time.Unix(created, 0) 275 msgs = append(msgs, m) 276 } 277 return msgs, rows.Err() 278} 279 280// SessionSummary holds info for listing sessions. 281type SessionSummary struct { 282 ID string 283 Timestamp time.Time 284 Preview string // first 50 chars of last user message 285} 286 287// ListSessions returns sessions ordered by most recent user message. 288func (c *Cache) ListSessions() ([]SessionSummary, error) { 289 if c == nil { 290 return nil, nil 291 } 292 c.mu.Lock() 293 defer c.mu.Unlock() 294 295 rows, err := c.db.Query(` 296 SELECT s.id, m.created, m.content 297 FROM sessions s 298 JOIN messages m ON m.session_id = s.id 299 WHERE m.role = 'user' 300 AND m.id = ( 301 SELECT MAX(m2.id) FROM messages m2 302 WHERE m2.session_id = s.id AND m2.role = 'user' 303 ) 304 ORDER BY m.created DESC`) 305 if err != nil { 306 return nil, err 307 } 308 defer rows.Close() 309 310 var out []SessionSummary 311 for rows.Next() { 312 var s SessionSummary 313 var ts int64 314 if err := rows.Scan(&s.ID, &ts, &s.Preview); err != nil { 315 continue 316 } 317 s.Timestamp = time.Unix(ts, 0) 318 if len(s.Preview) > 50 { 319 s.Preview = s.Preview[:50] 320 } 321 out = append(out, s) 322 } 323 return out, rows.Err() 324} 325 326// LatestSessionID returns the session with the most recent user message. 327func (c *Cache) LatestSessionID() (string, error) { 328 if c == nil { 329 return "", fmt.Errorf("no cache") 330 } 331 c.mu.Lock() 332 defer c.mu.Unlock() 333 334 var id string 335 err := c.db.QueryRow(` 336 SELECT s.id FROM sessions s 337 JOIN messages m ON m.session_id = s.id 338 WHERE m.role = 'user' 339 ORDER BY m.created DESC 340 LIMIT 1`).Scan(&id) 341 if err != nil { 342 return "", fmt.Errorf("no sessions found") 343 } 344 return id, nil 345} 346 347// ToProviderMessages converts stored messages to provider messages. 348func ToProviderMessages(msgs []SessionMessage) []provider.Message { 349 out := make([]provider.Message, 0, len(msgs)) 350 for _, m := range msgs { 351 pm := provider.Message{ 352 Role: m.Role, 353 Content: m.Content, 354 Reasoning: m.Reasoning, 355 ToolCallID: m.ToolCallID, 356 CreatedAt: m.CreatedAt, 357 } 358 if len(m.ToolCalls) > 0 { 359 var tcs []provider.ToolCall 360 if err := json.Unmarshal(m.ToolCalls, &tcs); err == nil { 361 pm.ToolCalls = tcs 362 } 363 } 364 out = append(out, pm) 365 } 366 return out 367} 368 369// SessionExists returns true if a session with the given ID exists. 370func (c *Cache) SessionExists(id string) (bool, error) { 371 if c == nil { 372 return false, nil 373 } 374 c.mu.Lock() 375 defer c.mu.Unlock() 376 377 var count int 378 err := c.db.QueryRow("SELECT COUNT(*) FROM sessions WHERE id = ?", id).Scan(&count) 379 if err != nil { 380 return false, err 381 } 382 return count > 0, nil 383}