@ai-setting/roy-agent-core 1.0.0

package/src/env/session/storage/sqlite.ts

@@ -0,0 +1,794 @@
+/**
+ * @fileoverview SQLite Session Store
+ * 
+ * SQLite-based implementation of SessionStore with checkpoint support.
+ * Uses Bun's built-in bun:sqlite module for persistence.
+ */
+
+import { join } from "path";
+import { randomUUID } from "crypto";
+import type {
+  Session,
+  CreateSessionOptions,
+  UpdateSessionOptions,
+  ListSessionsOptions,
+  SessionMessage,
+  SessionCheckpoint,
+  GetMessagesOptions,
+  SessionCheckpointsMeta,
+  SessionMetadata,
+  SearchMessagesOptions,
+  MessageMatch,
+} from "../types";
+import type { SessionStore } from "../session-store";
+import { SessionMessageConverter } from "../session-message-converter";
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+/**
+ * Generate a unique session ID using crypto UUID
+ */
+function generateSessionId(): string {
+  return `session_${randomUUID()}`;
+}
+
+/**
+ * Generate a unique message ID using crypto UUID
+ */
+function generateMessageId(): string {
+  return `msg_${randomUUID()}`;
+}
+
+/**
+ * Get default data directory for session storage
+ */
+function getDefaultDataDir(): string {
+  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+  return join(home, ".local", "share");
+}
+
+/**
+ * Get default database path for session storage
+ */
+function getDefaultSessionDbPath(): string {
+  return join(getDefaultDataDir(), "roy-agent", "sessions.db");
+}
+
+// ============================================================================
+// SQLiteSessionStore
+// ============================================================================
+
+/**
+ * SQLite-based Session Store with checkpoint support
+ * 
+ * Provides persistent storage for sessions and messages using SQLite.
+ * Follows the same interface as MemorySessionStore but persists to disk.
+ */
+export class SQLiteSessionStore implements SessionStore {
+  private db: any = null;
+  private dbPath: string;
+  private initialized = false;
+
+  // In-memory cache for performance
+  private sessionsCache = new Map<string, Session>();
+  private messagesCache = new Map<string, SessionMessage[]>();
+  private checkpointsCache = new Map<string, SessionCheckpoint[]>();
+  private messageConverter = new SessionMessageConverter();
+
+  constructor(dbPath?: string) {
+    this.dbPath = dbPath || getDefaultSessionDbPath();
+  }
+
+  // ========================================================================
+  // Initialization
+  // ========================================================================
+
+  private async initialize(): Promise<void> {
+    if (this.initialized) return;
+
+    // 使用 Bun 内置的 bun:sqlite
+    const { Database } = require("bun:sqlite");
+
+    // 确保目录存在
+    if (this.dbPath !== ":memory:") {
+      const fs = require("fs");
+      const path = require("path");
+      const dir = path.dirname(this.dbPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    }
+
+    this.db = new Database(this.dbPath);
+
+    // 创建表
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS session (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        directory TEXT NOT NULL,
+        parent_id TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        message_count INTEGER DEFAULT 0,
+        metadata TEXT
+      )
+    `);
+
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS message (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        content TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        parts TEXT,
+        is_archived INTEGER DEFAULT 0,
+        archived_at INTEGER,
+        checkpoint_id TEXT,
+        metadata TEXT,
+        FOREIGN KEY (session_id) REFERENCES session(id) ON DELETE CASCADE
+      )
+    `);
+
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_message_session ON message(session_id)");
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_message_checkpoint ON message(checkpoint_id)");
+
+    this.initialized = true;
+  }
+
+  // ========================================================================
+  // Session CRUD
+  // ========================================================================
+
+  async create(options: CreateSessionOptions): Promise<Session> {
+    await this.initialize();
+
+    const now = Date.now();
+    const session: Session = {
+      id: options.id ?? generateSessionId(),  // Use custom ID if provided
+      title: options.title ?? "Session",
+      directory: options.directory ?? "/tmp",
+      parentID: options.parentID,
+      createdAt: now,
+      updatedAt: now,
+      messageCount: 0,
+      metadata: {
+        ...options.metadata,
+        messageCount: 0,
+        checkpoints: { checkpoints: [] },
+      } as SessionMetadata,
+    };
+
+    // Check for duplicate ID (in case)
+    const existing = this.db.prepare("SELECT id FROM session WHERE id = ?").get(session.id);
+    if (existing) {
+      throw new Error(`Session with ID '${session.id}' already exists`);
+    }
+
+    // Insert into database
+    const stmt = this.db.prepare(`
+      INSERT INTO session (id, title, directory, parent_id, created_at, updated_at, message_count, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      session.id,
+      session.title,
+      session.directory,
+      session.parentID || null,
+      session.createdAt,
+      session.updatedAt,
+      session.messageCount,
+      JSON.stringify(session.metadata)
+    );
+
+    // Update cache
+    this.sessionsCache.set(session.id, session);
+    this.messagesCache.set(session.id, []);
+    this.checkpointsCache.set(session.id, []);
+
+    return session;
+  }
+
+  async get(id: string): Promise<Session | undefined> {
+    await this.initialize();
+
+    // Check cache first
+    const cached = this.sessionsCache.get(id);
+    if (cached) return cached;
+
+    // Query from database
+    const row = this.db.prepare("SELECT * FROM session WHERE id = ?").get(id);
+    if (!row) return undefined;
+
+    const session = this.rowToSession(row);
+    this.sessionsCache.set(session.id, session);
+    return session;
+  }
+
+  async list(options?: ListSessionsOptions): Promise<Session[]> {
+    await this.initialize();
+
+    let sql = "SELECT * FROM session";
+    const params: any[] = [];
+    const conditions: string[] = [];
+
+    // Filter by metadata
+    if (options?.filter?.metadata) {
+      for (const [key, value] of Object.entries(options.filter.metadata)) {
+        conditions.push(`json_extract(metadata, '$.${key}') = ?`);
+        params.push(JSON.stringify(value));
+      }
+    }
+
+    // Filter by time range
+    if (options?.filter?.startTime) {
+      conditions.push("created_at >= ?");
+      params.push(options.filter.startTime);
+    }
+    if (options?.filter?.endTime) {
+      conditions.push("created_at <= ?");
+      params.push(options.filter.endTime);
+    }
+
+    if (conditions.length > 0) {
+      sql += " WHERE " + conditions.join(" AND ");
+    }
+
+    // Sort
+    const sortField = options?.sort?.field ?? "updatedAt";
+    const sortOrder = options?.sort?.order ?? "desc";
+    const orderColumn = sortField === "title" ? "title" 
+      : sortField === "createdAt" ? "created_at" 
+      : "updated_at";
+    sql += ` ORDER BY ${orderColumn} ${sortOrder.toUpperCase()}`;
+
+    // Paginate
+    const offset = options?.offset ?? 0;
+    const limit = options?.limit ?? 100;
+    sql += " LIMIT ? OFFSET ?";
+    params.push(limit, offset);
+
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((row: any) => this.rowToSession(row));
+  }
+
+  async getCount(): Promise<number> {
+    await this.initialize();
+    const result = this.db.prepare("SELECT COUNT(*) as count FROM session").get() as { count: number };
+    return result.count;
+  }
+
+  async update(id: string, updates: UpdateSessionOptions): Promise<boolean> {
+    await this.initialize();
+
+    const session = await this.get(id);
+    if (!session) return false;
+
+    // Update fields
+    if (updates.title !== undefined) {
+      session.title = updates.title;
+    }
+    if (updates.metadata !== undefined) {
+      session.metadata = { ...session.metadata, ...updates.metadata } as SessionMetadata;
+    }
+    session.updatedAt = Date.now();
+
+    // Update database
+    const stmt = this.db.prepare(`
+      UPDATE session 
+      SET title = ?, metadata = ?, updated_at = ?
+      WHERE id = ?
+    `);
+    stmt.run(session.title, JSON.stringify(session.metadata), session.updatedAt, id);
+
+    // Update cache
+    this.sessionsCache.set(id, session);
+    return true;
+  }
+
+  async delete(id: string): Promise<boolean> {
+    await this.initialize();
+
+    const session = await this.get(id);
+    if (!session) return false;
+
+    // Delete from database (messages will cascade)
+    this.db.prepare("DELETE FROM session WHERE id = ?").run(id);
+
+    // Clean up cache
+    this.sessionsCache.delete(id);
+    this.messagesCache.delete(id);
+    this.checkpointsCache.delete(id);
+
+    return true;
+  }
+
+  // ========================================================================
+  // Messages
+  // ========================================================================
+
+  async addMessage(
+    sessionId: string,
+    message: { role: string; content: string; parts?: unknown[]; metadata?: Record<string, unknown> }
+  ): Promise<string> {
+    await this.initialize();
+
+    const session = await this.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    const now = Date.now();
+    const msg: SessionMessage = {
+      id: generateMessageId(),
+      sessionID: sessionId,
+      role: message.role as SessionMessage["role"],
+      content: message.content,
+      timestamp: now,
+      parts: message.parts as SessionMessage["parts"],
+      metadata: message.metadata as SessionMessage["metadata"],
+    };
+
+    // Insert into database
+    const stmt = this.db.prepare(`
+      INSERT INTO message (id, session_id, role, content, timestamp, parts, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      msg.id,
+      msg.sessionID,
+      msg.role,
+      msg.content,
+      msg.timestamp,
+      msg.parts ? JSON.stringify(msg.parts) : null,
+      msg.metadata ? JSON.stringify(msg.metadata) : null
+    );
+
+    // Update message count
+    const countResult = this.db.prepare(
+      "SELECT COUNT(*) as count FROM message WHERE session_id = ? AND is_archived = 0"
+    ).get(sessionId);
+    session.messageCount = countResult?.count || 0;
+    session.updatedAt = now;
+    
+    // Update metadata with messageCount
+    session.metadata = {
+      ...session.metadata,
+      messageCount: session.messageCount
+    } as SessionMetadata;
+    
+    this.db.prepare(`
+      UPDATE session SET message_count = ?, metadata = ?, updated_at = ? WHERE id = ?
+    `).run(session.messageCount, JSON.stringify(session.metadata), session.updatedAt, sessionId);
+
+    // Update cache
+    const messages = this.messagesCache.get(sessionId) ?? [];
+    messages.push(msg);
+    this.messagesCache.set(sessionId, messages);
+    this.sessionsCache.set(sessionId, session);
+
+    return msg.id;
+  }
+
+  async getMessages(
+    sessionId: string,
+    offset = 0,
+    limit = 50,
+    options?: GetMessagesOptions
+  ): Promise<SessionMessage[]> {
+    await this.initialize();
+
+    let sql = "SELECT * FROM message WHERE session_id = ?";
+    let countSql = "SELECT COUNT(*) as count FROM message WHERE session_id = ?";
+    const params: any[] = [sessionId];
+    const countParams: any[] = [sessionId];
+
+    // Filter by archived status
+    if (!options?.includeArchived) {
+      sql += " AND is_archived = 0";
+      countSql += " AND is_archived = 0";
+    }
+
+    // Handle fromCheckpointId
+    if (options?.fromCheckpointId) {
+      sql += " AND timestamp >= (SELECT MIN(timestamp) FROM message WHERE session_id = ? AND json_extract(metadata, '$.checkpointId') = ?)";
+      params.push(sessionId, options.fromCheckpointId);
+    }
+
+    // Handle negative offset: count total messages first, then calculate actual offset
+    // offset = -1, limit = 50: latest 50 messages → offset = total - limit
+    // offset = -2, limit = 50: 2nd latest 50 messages → offset = total - 2*limit
+    let actualOffset = offset;
+    if (offset < 0) {
+      const totalResult = this.db.prepare(countSql).get(...countParams);
+      const total = totalResult?.count || 0;
+      actualOffset = Math.max(0, total + offset * limit);
+    }
+
+    // Sort
+    if (options?.reverse) {
+      sql += " ORDER BY timestamp DESC";
+    } else {
+      sql += " ORDER BY timestamp ASC";
+    }
+
+    // Paginate
+    sql += " LIMIT ? OFFSET ?";
+    params.push(limit, actualOffset);
+
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((row: any) => this.rowToMessage(row));
+  }
+
+  async getMessageCount(sessionId: string, includeArchived = false): Promise<number> {
+    await this.initialize();
+
+    let sql = "SELECT COUNT(*) as count FROM message WHERE session_id = ?";
+    if (!includeArchived) {
+      sql += " AND is_archived = 0";
+    }
+    
+    const result = this.db.prepare(sql).get(sessionId);
+    return result?.count || 0;
+  }
+
+  async getMessageIndexes(sessionId: string, role: string): Promise<number[]> {
+    await this.initialize();
+
+    // Use ROW_NUMBER() to get the offset index based on timestamp ASC order
+    // This ensures the index matches what getMessages returns with default ordering
+    const sql = `
+      SELECT idx FROM (
+        SELECT 
+          ROW_NUMBER() OVER (ORDER BY timestamp ASC) - 1 as idx,
+          role
+        FROM message 
+        WHERE session_id = ? AND is_archived = 0
+      ) ranked
+      WHERE role = ?
+    `;
+    
+    const rows = this.db.prepare(sql).all(sessionId, role) as { idx: number }[];
+    return rows.map(row => row.idx);
+  }
+
+  // ========================================================================
+  // Checkpoint Management
+  // ========================================================================
+
+  async saveCheckpoint(sessionId: string, checkpoint: SessionCheckpoint): Promise<void> {
+    await this.initialize();
+
+    const session = await this.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    // Save to checkpoints cache
+    const cps = this.checkpointsCache.get(sessionId) ?? [];
+    cps.push(checkpoint);
+    this.checkpointsCache.set(sessionId, cps);
+
+    // Update session metadata
+    const meta = session.metadata as Record<string, unknown> || {};
+    const checkpointsMeta: SessionCheckpointsMeta = (meta.checkpoints as SessionCheckpointsMeta) || { checkpoints: [] };
+    checkpointsMeta.checkpoints.push({
+      id: checkpoint.id,
+      messageIndex: checkpoint.messageIndex,
+      title: checkpoint.title,
+      createdAt: checkpoint.createdAt,
+      type: checkpoint.type,
+    });
+    checkpointsMeta.latestCheckpointId = checkpoint.id;
+    
+    meta.checkpoints = checkpointsMeta;
+    
+    // Store checkpoint details separately
+    if (!meta.checkpointDetails) {
+      meta.checkpointDetails = {};
+    }
+    (meta.checkpointDetails as Record<string, SessionCheckpoint>)[checkpoint.id] = checkpoint;
+    
+    session.metadata = meta as SessionMetadata;
+    session.updatedAt = Date.now();
+
+    // Update database
+    const stmt = this.db.prepare(`
+      UPDATE session SET metadata = ?, updated_at = ? WHERE id = ?
+    `);
+    stmt.run(JSON.stringify(session.metadata), session.updatedAt, sessionId);
+
+    // Update cache
+    this.sessionsCache.set(sessionId, session);
+  }
+
+  async getCheckpoints(sessionId: string): Promise<SessionCheckpoint[]> {
+    await this.initialize();
+
+    const session = await this.get(sessionId);
+    if (!session) return [];
+
+    const meta = session.metadata as Record<string, unknown>;
+    const checkpointDetails = meta?.checkpointDetails as Record<string, SessionCheckpoint>;
+    if (!checkpointDetails) return [];
+
+    return Object.values(checkpointDetails);
+  }
+
+  async getCheckpoint(sessionId: string, checkpointId: string): Promise<SessionCheckpoint | undefined> {
+    await this.initialize();
+
+    const checkpoints = await this.getCheckpoints(sessionId);
+    return checkpoints.find((cp) => cp.id === checkpointId);
+  }
+
+  async deleteCheckpoint(sessionId: string, checkpointId: string): Promise<boolean> {
+    await this.initialize();
+
+    const session = await this.get(sessionId);
+    if (!session) return false;
+
+    const checkpoints = this.checkpointsCache.get(sessionId) ?? [];
+    const index = checkpoints.findIndex((cp) => cp.id === checkpointId);
+    if (index === -1) return false;
+
+    // Remove checkpoint
+    checkpoints.splice(index, 1);
+    this.checkpointsCache.set(sessionId, checkpoints);
+
+    // Restore archived messages
+    this.db.prepare(`
+      UPDATE message SET is_archived = 0, archived_at = NULL, checkpoint_id = NULL
+      WHERE session_id = ? AND checkpoint_id = ?
+    `).run(sessionId, checkpointId);
+
+    // Update session metadata
+    const meta = session.metadata as Record<string, unknown> || {};
+    const checkpointsMeta: SessionCheckpointsMeta = (meta.checkpoints as SessionCheckpointsMeta) || { checkpoints: [] };
+    checkpointsMeta.checkpoints = checkpointsMeta.checkpoints.filter((cp) => cp.id !== checkpointId);
+    checkpointsMeta.latestCheckpointId = checkpoints[checkpoints.length - 1]?.id;
+    
+    if (meta.checkpointDetails) {
+      delete (meta.checkpointDetails as Record<string, SessionCheckpoint>)[checkpointId];
+    }
+    
+    session.metadata = meta as SessionMetadata;
+
+    // Update message count
+    const countResult = this.db.prepare(
+      "SELECT COUNT(*) as count FROM message WHERE session_id = ? AND is_archived = 0"
+    ).get(sessionId);
+    session.messageCount = countResult?.count || 0;
+    session.updatedAt = Date.now();
+
+    // Update database
+    this.db.prepare(`
+      UPDATE session SET metadata = ?, message_count = ?, updated_at = ? WHERE id = ?
+    `).run(JSON.stringify(session.metadata), session.messageCount, session.updatedAt, sessionId);
+
+    // Update cache
+    this.sessionsCache.set(sessionId, session);
+
+    return true;
+  }
+
+  async archiveMessages(sessionId: string, checkpointId: string, beforeIndex: number): Promise<number> {
+    await this.initialize();
+
+    const session = await this.get(sessionId);
+    if (!session) return 0;
+
+    const now = Date.now();
+
+    // Archive messages before the index
+    const result = this.db.prepare(`
+      UPDATE message 
+      SET is_archived = 1, archived_at = ?, checkpoint_id = ?
+      WHERE session_id = ? AND id IN (
+        SELECT id FROM message WHERE session_id = ? AND is_archived = 0
+        ORDER BY timestamp ASC LIMIT ?
+      )
+    `).run(now, checkpointId, sessionId, sessionId, beforeIndex);
+
+    // Update message count
+    const countResult = this.db.prepare(
+      "SELECT COUNT(*) as count FROM message WHERE session_id = ? AND is_archived = 0"
+    ).get(sessionId);
+    session.messageCount = countResult?.count || 0;
+    session.updatedAt = now;
+
+    // Update database
+    this.db.prepare(`
+      UPDATE session SET message_count = ?, updated_at = ? WHERE id = ?
+    `).run(session.messageCount, session.updatedAt, sessionId);
+
+    // Update cache
+    this.sessionsCache.set(sessionId, session);
+    this.messagesCache.delete(sessionId); // Clear message cache
+
+    return result.changes;
+  }
+
+  async getActiveMessages(sessionId: string, offset = 0, limit = 50): Promise<SessionMessage[]> {
+    return this.getMessages(sessionId, offset, limit, { includeArchived: false });
+  }
+
+  // ========================================================================
+  // Search [new]
+  // ========================================================================
+
+  async searchMessages(options: SearchMessagesOptions): Promise<MessageMatch[]> {
+    await this.initialize();
+    
+    const matches: MessageMatch[] = [];
+    const {
+      query,
+      sessionId,
+      limit = 10,
+      beforeTime,
+      afterTime,
+      includeArchived = false,
+    } = options;
+
+    // Build SQL query
+    let sql = "SELECT * FROM message WHERE 1=1";
+    const params: any[] = [];
+
+    // Filter by session
+    if (sessionId) {
+      sql += " AND session_id = ?";
+      params.push(sessionId);
+    }
+
+    // Filter by archived status
+    if (!includeArchived) {
+      sql += " AND is_archived = 0";
+    }
+
+    // Filter by time
+    if (beforeTime) {
+      sql += " AND timestamp <= ?";
+      params.push(beforeTime);
+    }
+    if (afterTime) {
+      sql += " AND timestamp >= ?";
+      params.push(afterTime);
+    }
+
+    // Order by timestamp
+    sql += " ORDER BY timestamp DESC";
+
+    // Limit
+    sql += " LIMIT ?";
+    params.push(limit * 10); // Get more than limit to filter by query
+
+    const rows = this.db.prepare(sql).all(...params);
+
+    // Parse query for simple text matching
+    const queryTerms = this.parseQuery(query);
+    const lowerQuery = query.toLowerCase();
+
+    // Filter and match messages
+    for (const row of rows) {
+      const content = (row.content as string).toLowerCase();
+      
+      // Check if content matches query
+      let matchesQuery = true;
+      
+      // Check excluded terms
+      for (const term of queryTerms.excluded) {
+        if (content.includes(term.toLowerCase())) {
+          matchesQuery = false;
+          break;
+        }
+      }
+
+      // Check required terms
+      if (matchesQuery && queryTerms.required.length > 0) {
+        for (const term of queryTerms.required) {
+          if (!content.includes(term.toLowerCase())) {
+            matchesQuery = false;
+            break;
+          }
+        }
+      }
+
+      // Simple fallback: check if query string appears in content
+      if (!matchesQuery && lowerQuery && content.includes(lowerQuery)) {
+        matchesQuery = true;
+      }
+
+      if (matchesQuery) {
+        matches.push({
+          messageId: row.id,
+          sessionId: row.session_id,
+          role: row.role as MessageMatch["role"],
+          content: row.content,
+          timestamp: row.timestamp,
+        });
+
+        if (matches.length >= limit) break;
+      }
+    }
+
+    return matches;
+  }
+
+  /**
+   * Parse simple query into terms
+   */
+  private parseQuery(query: string): { required: string[]; excluded: string[] } {
+    // Remove quoted phrases (simplified)
+    const terms = query.split(/\s+/).filter((t) => !t.startsWith('"') && !t.endsWith('"'));
+    
+    const required: string[] = [];
+    const excluded: string[] = [];
+    
+    for (const term of terms) {
+      if (term.startsWith("-") || term.toUpperCase().startsWith("NOT ")) {
+        excluded.push(term.replace(/^-|^NOT /i, ""));
+      } else {
+        required.push(term);
+      }
+    }
+    
+    return { required, excluded };
+  }
+
+  // ========================================================================
+  // Lifecycle
+  // ========================================================================
+
+  async close(): Promise<void> {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+    this.sessionsCache.clear();
+    this.messagesCache.clear();
+    this.checkpointsCache.clear();
+    this.initialized = false;
+  }
+
+  // ========================================================================
+  // Row Conversions
+  // ========================================================================
+
+  private rowToSession(row: any): Session {
+    return {
+      id: row.id,
+      title: row.title,
+      directory: row.directory,
+      parentID: row.parent_id,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      messageCount: row.message_count,
+      metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+    };
+  }
+
+  private rowToMessage(row: any): SessionMessage {
+    // Parse the raw message from database
+    const rawMessage: Partial<SessionMessage> = {
+      id: row.id,
+      sessionID: row.session_id,
+      role: row.role as SessionMessage["role"],
+      content: row.content,
+      timestamp: row.timestamp,
+      parts: row.parts ? JSON.parse(row.parts) : undefined,
+      isArchived: row.is_archived === 1,
+      archivedAt: row.archived_at || undefined,
+      checkpointId: row.checkpoint_id || undefined,
+      metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+    };
+    
+    // Apply migration for backward compatibility with old format
+    return this.messageConverter.migrateMessage(rawMessage);
+  }
+}
+
+// Export helper functions
+export { getDefaultSessionDbPath, getDefaultDataDir };