xonecas.io
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}