@ai-setting/roy-agent-core 1.5.89 → 1.5.90

package/dist/shared/@ai-setting/{roy-agent-core-q7sqeax6.js → roy-agent-core-zky9jse4.js}

@@ -1,10 +1,27 @@
 import {
   SessionMessageConverter
-} from "./roy-agent-core-c1j7ev4e.js";
+} from "./roy-agent-core-txwf64pd.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-shme7set.js";
 import {
   __require
 } from "./roy-agent-core-fs0mn2jk.js";
 
+// src/env/session/session-store.ts
+class BaseSessionStore {
+  async addMessages(sessionId, messages) {
+    if (messages.length === 0)
+      return [];
+    const ids = [];
+    for (const msg of messages) {
+      ids.push(await this.addMessage(sessionId, msg));
+    }
+    return ids;
+  }
+}
+
 // src/env/session/storage/memory.ts
 import { randomUUID } from "crypto";
 function generateSessionId() {
@@ -14,7 +31,7 @@ function generateMessageId() {
   return `msg_${randomUUID()}`;
 }
 
-class MemorySessionStore {
+class MemorySessionStore extends BaseSessionStore {
   sessions = new Map;
   messages = new Map;
   checkpoints = new Map;
@@ -138,6 +155,40 @@ class MemorySessionStore {
     session.updatedAt = Date.now();
     return msg.id;
   }
+  async addMessages(sessionId, messages) {
+    if (messages.length === 0) {
+      return [];
+    }
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const sessionMessages = this.messages.get(sessionId) ?? [];
+    const ids = [];
+    const now = Date.now();
+    for (const message of messages) {
+      const rawMessage = {
+        sessionID: sessionId,
+        role: message.role,
+        content: message.content,
+        parts: message.parts,
+        metadata: message.metadata
+      };
+      const msg = this.messageConverter.migrateMessage(rawMessage);
+      msg.id = generateMessageId();
+      msg.timestamp = now;
+      sessionMessages.push(msg);
+      ids.push(msg.id);
+    }
+    this.messages.set(sessionId, sessionMessages);
+    session.messageCount = sessionMessages.filter((m) => !m.isArchived).length;
+    session.metadata = {
+      ...session.metadata,
+      messageCount: session.messageCount
+    };
+    session.updatedAt = now;
+    return ids;
+  }
   async updateMessage(sessionId, messageId, updates) {
     const sessionMessages = this.messages.get(sessionId);
     if (!sessionMessages) {
@@ -371,6 +422,8 @@ class MemorySessionStore {
 // src/env/session/storage/sqlite.ts
 import { join } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
+init_logger();
+var logger = createLogger("session:storage:sqlite");
 function getDatabaseClass() {
   if (typeof Bun !== "undefined") {
     const { Database } = __require("bun:sqlite");
@@ -379,6 +432,17 @@ function getDatabaseClass() {
     return __require("better-sqlite3");
   }
 }
+function isSqliteBusyError(err) {
+  if (err == null)
+    return false;
+  const e = err;
+  if (typeof e.code === "string" && /^SQLITE_(BUSY|LOCKED)$/i.test(e.code))
+    return true;
+  if (typeof e.errno === "number" && (e.errno === 5 || e.errno === 6))
+    return true;
+  const msg = e.message ?? "";
+  return /SQLiteError:\s+(database is locked|database table is locked)/i.test(msg);
+}
 function createCompatibleDatabase(path) {
   const Database = getDatabaseClass();
   const db = new Database(path);
@@ -407,7 +471,7 @@ function getDefaultSessionDbPath() {
   return join(getDefaultDataDir(), "roy-agent", "sessions.db");
 }
 
-class SQLiteSessionStore {
+class SQLiteSessionStore extends BaseSessionStore {
   db = null;
   dbPath;
   initialized = false;
@@ -416,6 +480,7 @@ class SQLiteSessionStore {
   checkpointsCache = new Map;
   messageConverter = new SessionMessageConverter;
   constructor(dbPath) {
+    super();
     this.dbPath = dbPath || getDefaultSessionDbPath();
   }
   async initialize() {
@@ -430,6 +495,10 @@ class SQLiteSessionStore {
       }
     }
     this.db = createCompatibleDatabase(this.dbPath);
+    this.applyPragma("PRAGMA journal_mode = WAL");
+    this.applyPragma("PRAGMA busy_timeout = 5000");
+    this.applyPragma("PRAGMA synchronous = NORMAL");
+    this.applyPragma("PRAGMA wal_autocheckpoint = 1000");
     this.db.run(`
       CREATE TABLE IF NOT EXISTS session (
         id TEXT PRIMARY KEY,
@@ -611,6 +680,90 @@ class SQLiteSessionStore {
     this.sessionsCache.set(sessionId, session);
     return msg.id;
   }
+  async addMessages(sessionId, messages) {
+    if (messages.length === 0) {
+      return [];
+    }
+    const BATCH_BACKOFFS_MS = [50, 100, 200];
+    let lastError = undefined;
+    for (let attempt = 0;attempt <= BATCH_BACKOFFS_MS.length; attempt++) {
+      try {
+        return await this.addMessagesOnce(sessionId, messages);
+      } catch (err) {
+        if (!isSqliteBusyError(err) || attempt === BATCH_BACKOFFS_MS.length) {
+          this.messagesCache.delete(sessionId);
+          this.sessionsCache.delete(sessionId);
+          lastError = err;
+          if (!isSqliteBusyError(err))
+            throw err;
+          break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, BATCH_BACKOFFS_MS[attempt]));
+      }
+    }
+    throw lastError;
+  }
+  async addMessagesOnce(sessionId, messages) {
+    await this.initialize();
+    const session = await this.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const now = Date.now();
+    const ids = [];
+    const insertStmt = this.db.prepare(`
+      INSERT INTO message (id, session_id, role, content, timestamp, parts, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    const sessionUpdateStmt = this.db.prepare(`
+      UPDATE session SET message_count = ?, metadata = ?, updated_at = ? WHERE id = ?
+    `);
+    this.db.run("BEGIN");
+    try {
+      for (const message of messages) {
+        const id = generateMessageId2();
+        ids.push(id);
+        insertStmt.run(id, sessionId, message.role, message.content, now, message.parts ? JSON.stringify(message.parts) : null, message.metadata ? JSON.stringify(message.metadata) : null);
+      }
+      const countResult = this.db.prepare("SELECT COUNT(*) as count FROM message WHERE session_id = ? AND is_archived = 0").get(sessionId);
+      const newCount = countResult?.count ?? 0;
+      session.messageCount = newCount;
+      session.updatedAt = now;
+      session.metadata = {
+        ...session.metadata ?? {},
+        messageCount: newCount
+      };
+      sessionUpdateStmt.run(newCount, JSON.stringify(session.metadata), now, sessionId);
+      this.db.run("COMMIT");
+    } catch (err) {
+      try {
+        this.db.run("ROLLBACK");
+      } catch {}
+      throw err;
+    }
+    try {
+      const cached = this.messagesCache.get(sessionId) ?? [];
+      for (let i = 0;i < messages.length; i++) {
+        const message = messages[i];
+        cached.push({
+          id: ids[i],
+          sessionID: sessionId,
+          role: message.role,
+          content: message.content,
+          timestamp: now,
+          parts: message.parts,
+          metadata: message.metadata
+        });
+      }
+      this.messagesCache.set(sessionId, cached);
+      this.sessionsCache.set(sessionId, session);
+    } catch (cacheErr) {
+      logger.warn(`[SQLiteSessionStore] cache update failed after commit; invalidating: ${cacheErr}`);
+      this.messagesCache.delete(sessionId);
+      this.sessionsCache.delete(sessionId);
+    }
+    return ids;
+  }
   async updateMessage(sessionId, messageId, updates) {
     await this.initialize();
     const row = this.db.prepare("SELECT id FROM message WHERE id = ? AND session_id = ?").get(messageId, sessionId);
@@ -679,6 +832,13 @@ class SQLiteSessionStore {
     const rows = this.db.prepare(sql).all(...params);
     return rows.map((row) => this.rowToMessage(row));
   }
+  applyPragma(pragmaSql) {
+    this.db.run(pragmaSql);
+    const readback = this.db.prepare(pragmaSql.split("=")[0].trim()).get();
+    const key = Object.keys(readback ?? {})[0];
+    const actual = key ? readback[key] : undefined;
+    logger.info(`[SQLiteSessionStore] Applied ${pragmaSql} → ${actual}`);
+  }
   async getMessageCount(sessionId, includeArchived = false) {
     await this.initialize();
     let sql = "SELECT COUNT(*) as count FROM message WHERE session_id = ?";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.5.89",
+  "version": "1.5.90",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",