mirror of
https://github.com/sipeed/picoclaw.git
synced 2026-06-12 18:08:54 +00:00
is-Xiaoen
26f623ed32
* feat(session): add SessionStore interface and JSONL backend adapter Extract a SessionStore interface from the methods the agent loop uses (AddMessage, GetHistory, SetSummary, TruncateHistory, Save, etc.). Both SessionManager and the new JSONLBackend satisfy this interface, allowing the persistence layer to be swapped transparently. JSONLBackend wraps memory.Store and maps its error-returning API to the fire-and-forget contract that the agent loop expects — write errors are logged, reads return empty defaults on failure. Save() triggers compaction to reclaim space after logical truncation. Part of #1169 * test(session): add JSONLBackend integration tests 8 tests covering the full SessionStore contract through the JSONL backend: message roundtrip, tool calls, summary, truncation with compaction, history replacement, empty sessions, session isolation, and the complete summarization flow (SetSummary → TruncateHistory → Save). Includes compile-time interface satisfaction checks for both SessionManager and JSONLBackend. Part of #1169 * feat(agent): wire JSONL session store into agent loop Replace the concrete *SessionManager field with the SessionStore interface and initialize the JSONL backend by default. Legacy .json session files are auto-migrated on first startup. Falls back to SessionManager if the JSONL store cannot be initialized. The agent loop code (loop.go) requires zero changes — all method calls work identically through the interface. Closes #1169 * fix(session): propagate compact error from Save Save() was swallowing the error returned by Compact and always returning nil. Callers checking Save's return value would never see a compaction failure. Return the error directly so the agent loop can log or handle it as needed. * feat(session): add Close to SessionStore interface Add Close() error to SessionStore so callers can release resources through the interface. JSONLBackend already had Close; this adds a no-op implementation to SessionManager for compatibility. * fix(session): close session stores on shutdown and harden migration - Add Close() to AgentInstance, AgentRegistry, and AgentLoop so JSONL file handles are released during gateway shutdown and CLI exit. - Fall back to SessionManager when migration fails, preventing a split state where some sessions live in JSONL and others remain in JSON. - Add defer agentLoop.Close() in the CLI agent command path. - Document SessionStore interface methods (fire-and-forget contract).
82 lines
2.4 KiB
Go
82 lines
2.4 KiB
Go
package session
|
|
|
|
import (
|
|
"context"
|
|
"log"
|
|
|
|
"github.com/sipeed/picoclaw/pkg/memory"
|
|
"github.com/sipeed/picoclaw/pkg/providers"
|
|
)
|
|
|
|
// JSONLBackend adapts a memory.Store into the SessionStore interface.
|
|
// Write errors are logged rather than returned, matching the fire-and-forget
|
|
// contract of SessionManager that the agent loop relies on.
|
|
type JSONLBackend struct {
|
|
store memory.Store
|
|
}
|
|
|
|
// NewJSONLBackend wraps a memory.Store for use as a SessionStore.
|
|
func NewJSONLBackend(store memory.Store) *JSONLBackend {
|
|
return &JSONLBackend{store: store}
|
|
}
|
|
|
|
func (b *JSONLBackend) AddMessage(sessionKey, role, content string) {
|
|
if err := b.store.AddMessage(context.Background(), sessionKey, role, content); err != nil {
|
|
log.Printf("session: add message: %v", err)
|
|
}
|
|
}
|
|
|
|
func (b *JSONLBackend) AddFullMessage(sessionKey string, msg providers.Message) {
|
|
if err := b.store.AddFullMessage(context.Background(), sessionKey, msg); err != nil {
|
|
log.Printf("session: add full message: %v", err)
|
|
}
|
|
}
|
|
|
|
func (b *JSONLBackend) GetHistory(key string) []providers.Message {
|
|
msgs, err := b.store.GetHistory(context.Background(), key)
|
|
if err != nil {
|
|
log.Printf("session: get history: %v", err)
|
|
return []providers.Message{}
|
|
}
|
|
return msgs
|
|
}
|
|
|
|
func (b *JSONLBackend) GetSummary(key string) string {
|
|
summary, err := b.store.GetSummary(context.Background(), key)
|
|
if err != nil {
|
|
log.Printf("session: get summary: %v", err)
|
|
return ""
|
|
}
|
|
return summary
|
|
}
|
|
|
|
func (b *JSONLBackend) SetSummary(key, summary string) {
|
|
if err := b.store.SetSummary(context.Background(), key, summary); err != nil {
|
|
log.Printf("session: set summary: %v", err)
|
|
}
|
|
}
|
|
|
|
func (b *JSONLBackend) SetHistory(key string, history []providers.Message) {
|
|
if err := b.store.SetHistory(context.Background(), key, history); err != nil {
|
|
log.Printf("session: set history: %v", err)
|
|
}
|
|
}
|
|
|
|
func (b *JSONLBackend) TruncateHistory(key string, keepLast int) {
|
|
if err := b.store.TruncateHistory(context.Background(), key, keepLast); err != nil {
|
|
log.Printf("session: truncate history: %v", err)
|
|
}
|
|
}
|
|
|
|
// Save persists session state. Since the JSONL store fsyncs every write
|
|
// immediately, the data is already durable. Save runs compaction to reclaim
|
|
// space from logically truncated messages (no-op when there are none).
|
|
func (b *JSONLBackend) Save(key string) error {
|
|
return b.store.Compact(context.Background(), key)
|
|
}
|
|
|
|
// Close releases resources held by the underlying store.
|
|
func (b *JSONLBackend) Close() error {
|
|
return b.store.Close()
|
|
}
|