@mastra/libsql 1.12.1 → 1.13.0-alpha.0

package/dist/index.cjs

@@ -1426,6 +1426,21 @@ function transformFromSqlRow({
   return result;
 }
 
+// src/storage/db/write-lock.ts
+var clientWriteChains = /* @__PURE__ */ new WeakMap();
+function withClientWriteLock(client, fn) {
+  const previous = clientWriteChains.get(client) ?? Promise.resolve();
+  const result = previous.then(fn, fn);
+  clientWriteChains.set(
+    client,
+    result.then(
+      () => void 0,
+      () => void 0
+    )
+  );
+  return result;
+}
+
 // src/storage/db/index.ts
 function resolveClient(config) {
   if ("client" in config) {
@@ -1525,11 +1540,14 @@ var LibSQLDB = class extends base.MastraBase {
   }) {
     const filteredRecord = await this.filterRecordToKnownColumns(tableName, record);
     if (Object.keys(filteredRecord).length === 0) return;
-    await this.client.execute(
-      prepareStatement({
-        tableName,
-        record: filteredRecord
-      })
+    await withClientWriteLock(
+      this.client,
+      () => this.client.execute(
+        prepareStatement({
+          tableName,
+          record: filteredRecord
+        })
+      )
     );
   }
   /**
@@ -1552,7 +1570,10 @@ var LibSQLDB = class extends base.MastraBase {
   }) {
     const filteredData = await this.filterRecordToKnownColumns(tableName, data);
     if (Object.keys(filteredData).length === 0) return;
-    await this.client.execute(prepareUpdateStatement({ tableName, updates: filteredData, keys }));
+    await withClientWriteLock(
+      this.client,
+      () => this.client.execute(prepareUpdateStatement({ tableName, updates: filteredData, keys }))
+    );
   }
   /**
    * Updates a record in the specified table with automatic retry on lock errors.
@@ -1577,7 +1598,7 @@ var LibSQLDB = class extends base.MastraBase {
     const nonEmptyRecords = filteredRecords.filter((r) => Object.keys(r).length > 0);
     if (nonEmptyRecords.length === 0) return;
     const batchStatements = nonEmptyRecords.map((r) => prepareStatement({ tableName, record: r }));
-    await this.client.batch(batchStatements, "write");
+    await withClientWriteLock(this.client, () => this.client.batch(batchStatements, "write"));
   }
   /**
    * Inserts multiple records in a single batch transaction with automatic retry on lock errors.
@@ -1629,7 +1650,7 @@ var LibSQLDB = class extends base.MastraBase {
         keys
       })
     );
-    await this.client.batch(batchStatements, "write");
+    await withClientWriteLock(this.client, () => this.client.batch(batchStatements, "write"));
   }
   /**
    * Updates multiple records in a single batch transaction with automatic retry on lock errors.
@@ -1673,7 +1694,7 @@ var LibSQLDB = class extends base.MastraBase {
         keys: keyObj
       })
     );
-    await this.client.batch(batchStatements, "write");
+    await withClientWriteLock(this.client, () => this.client.batch(batchStatements, "write"));
   }
   /**
    * Deletes multiple records in a single batch transaction with automatic retry on lock errors.
@@ -1709,7 +1730,7 @@ var LibSQLDB = class extends base.MastraBase {
    * Internal single-record delete implementation without retry logic.
    */
   async doDelete({ tableName, keys }) {
-    await this.client.execute(prepareDeleteStatement({ tableName, keys }));
+    await withClientWriteLock(this.client, () => this.client.execute(prepareDeleteStatement({ tableName, keys })));
   }
   /**
    * Deletes a single record from the specified table with automatic retry on lock errors.
@@ -2233,7 +2254,7 @@ Note: This migration may take some time for large tables.
   async deleteData({ tableName }) {
     const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
     try {
-      await this.client.execute(`DELETE FROM ${parsedTableName}`);
+      await withClientWriteLock(this.client, () => this.client.execute(`DELETE FROM ${parsedTableName}`));
     } catch (e) {
       const mastraError = new error.MastraError(
         {
@@ -5313,6 +5334,126 @@ var FavoritesLibSQL = class extends storage.FavoritesStorage {
     }
   }
 };
+var toDate = (value) => new Date(value);
+var toOptionalDate = (value) => {
+  if (value == null) return void 0;
+  return toDate(value);
+};
+function cloneJson(value) {
+  return value === void 0 ? void 0 : structuredClone(value);
+}
+function hydratePendingItem(item) {
+  const record = {
+    id: item.id,
+    kind: item.kind,
+    status: item.status,
+    sessionId: item.sessionId,
+    createdAt: toDate(item.createdAt),
+    updatedAt: toDate(item.updatedAt)
+  };
+  if (item.runId !== void 0) record.runId = item.runId;
+  if (item.traceId !== void 0) record.traceId = item.traceId;
+  if (item.runtimeCompatibilityGeneration !== void 0) {
+    record.runtimeCompatibilityGeneration = item.runtimeCompatibilityGeneration;
+  }
+  if (item.payload !== void 0) record.payload = cloneJson(item.payload);
+  if (item.response !== void 0) record.response = cloneJson(item.response);
+  return record;
+}
+function rowToSession(row) {
+  const record = {
+    id: row.id,
+    ownerId: row.ownerId,
+    resourceId: row.resourceId,
+    threadId: row.threadId,
+    origin: row.origin,
+    modeId: row.modeId,
+    modelId: row.modelId,
+    createdAt: toDate(row.createdAt),
+    lastActivityAt: toDate(row.lastActivityAt)
+  };
+  if (row.parentSessionId != null) record.parentSessionId = row.parentSessionId;
+  if (row.subagentDepth != null) record.subagentDepth = row.subagentDepth;
+  if (row.source != null) record.source = { ...row.source, type: row.source.type };
+  if (row.runtimeCompatibilityGeneration != null) {
+    record.runtimeCompatibilityGeneration = row.runtimeCompatibilityGeneration;
+  }
+  if (row.title != null) record.title = row.title;
+  if (row.metadata != null) record.metadata = cloneJson(row.metadata);
+  if (row.state != null) record.state = cloneJson(row.state);
+  if (row.pending != null) record.pending = row.pending.map(hydratePendingItem);
+  const closingAt = toOptionalDate(row.closingAt);
+  const closeDeadlineAt = toOptionalDate(row.closeDeadlineAt);
+  const closedAt = toOptionalDate(row.closedAt);
+  const deletedAt = toOptionalDate(row.deletedAt);
+  if (closingAt) record.closingAt = closingAt;
+  if (closeDeadlineAt) record.closeDeadlineAt = closeDeadlineAt;
+  if (closedAt) record.closedAt = closedAt;
+  if (deletedAt) record.deletedAt = deletedAt;
+  return record;
+}
+function sessionToRecord(record) {
+  return {
+    id: record.id,
+    ownerId: record.ownerId,
+    resourceId: record.resourceId,
+    threadId: record.threadId,
+    parentSessionId: record.parentSessionId ?? null,
+    subagentDepth: record.subagentDepth ?? null,
+    source: record.source ?? null,
+    origin: record.origin,
+    runtimeCompatibilityGeneration: record.runtimeCompatibilityGeneration ?? null,
+    modeId: record.modeId,
+    modelId: record.modelId,
+    title: record.title ?? null,
+    metadata: record.metadata ?? null,
+    state: record.state ?? null,
+    pending: record.pending ?? null,
+    createdAt: record.createdAt,
+    lastActivityAt: record.lastActivityAt,
+    closingAt: record.closingAt ?? null,
+    closeDeadlineAt: record.closeDeadlineAt ?? null,
+    closedAt: record.closedAt ?? null,
+    deletedAt: record.deletedAt ?? null
+  };
+}
+var HarnessLibSQL = class extends storage.HarnessStorage {
+  #db;
+  constructor(config) {
+    super();
+    const client = resolveClient(config);
+    this.#db = new LibSQLDB({ client, maxRetries: config.maxRetries, initialBackoffMs: config.initialBackoffMs });
+  }
+  async init() {
+    await this.#db.createTable({
+      tableName: storage.TABLE_HARNESS_SESSIONS,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_HARNESS_SESSIONS]
+    });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: storage.TABLE_HARNESS_SESSIONS });
+  }
+  async loadSession(sessionId) {
+    const row = await this.#db.select({
+      tableName: storage.TABLE_HARNESS_SESSIONS,
+      keys: { id: sessionId }
+    });
+    return row ? rowToSession(row) : null;
+  }
+  async saveSession(record) {
+    await this.#db.insert({
+      tableName: storage.TABLE_HARNESS_SESSIONS,
+      record: sessionToRecord(record)
+    });
+  }
+  async listSessions() {
+    const rows = await this.#db.selectMany({
+      tableName: storage.TABLE_HARNESS_SESSIONS,
+      orderBy: '"lastActivityAt" DESC'
+    });
+    return rows.map(rowToSession);
+  }
+};
 var MCPClientsLibSQL = class extends storage.MCPClientsStorage {
   #db;
   #client;
@@ -11280,6 +11421,99 @@ var SkillsLibSQL = class extends storage.SkillsStorage {
     };
   }
 };
+var ThreadStateLibSQL = class extends storage.ThreadStateStorage {
+  #db;
+  #client;
+  constructor(config) {
+    super();
+    const client = resolveClient(config);
+    this.#client = client;
+    this.#db = new LibSQLDB({ client, maxRetries: config.maxRetries, initialBackoffMs: config.initialBackoffMs });
+  }
+  async init() {
+    await this.#db.createTable({
+      tableName: storage.TABLE_THREAD_STATE,
+      schema: storage.THREAD_STATE_SCHEMA,
+      compositePrimaryKey: ["threadId", "type"]
+    });
+  }
+  async dangerouslyClearAll() {
+    try {
+      await this.#client.execute(`DELETE FROM "${storage.TABLE_THREAD_STATE}"`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "THREAD_STATE_CLEAR_ALL", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getState({ threadId, type }) {
+    try {
+      const result = await this.#client.execute({
+        sql: `SELECT "value" FROM "${storage.TABLE_THREAD_STATE}" WHERE "threadId" = ? AND "type" = ? LIMIT 1`,
+        args: [threadId, type]
+      });
+      const raw = result.rows?.[0]?.value;
+      if (raw === void 0 || raw === null) return void 0;
+      return typeof raw === "string" ? JSON.parse(raw) : raw;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "THREAD_STATE_GET", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId, type }
+        },
+        error$1
+      );
+    }
+  }
+  async setState({ threadId, type, value }) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const serialized = JSON.stringify(value ?? null);
+    try {
+      await this.#client.execute({
+        sql: `INSERT INTO "${storage.TABLE_THREAD_STATE}" ("threadId", "type", "value", "createdAt", "updatedAt")
+              VALUES (?, ?, ?, ?, ?)
+              ON CONFLICT ("threadId", "type")
+              DO UPDATE SET "value" = excluded."value", "updatedAt" = excluded."updatedAt"`,
+        args: [threadId, type, serialized, now, now]
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "THREAD_STATE_SET", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId, type }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteState({ threadId, type }) {
+    try {
+      await this.#client.execute({
+        sql: `DELETE FROM "${storage.TABLE_THREAD_STATE}" WHERE "threadId" = ? AND "type" = ?`,
+        args: [threadId, type]
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "THREAD_STATE_DELETE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId, type }
+        },
+        error$1
+      );
+    }
+  }
+};
 function normaliseScope(raw) {
   const value = raw == null ? "per-author" : String(raw);
   if (value === "shared") return "shared";
@@ -11551,89 +11785,102 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
     result,
     requestContext
   }) {
-    return this.executeWithRetry(async () => {
-      const tx = await this.#client.transaction("write");
-      try {
-        const existingSnapshotResult = await tx.execute({
-          sql: `SELECT json(snapshot) as snapshot FROM ${storage.TABLE_WORKFLOW_SNAPSHOT} WHERE workflow_name = ? AND run_id = ?`,
-          args: [workflowName, runId]
-        });
-        let snapshot;
-        if (!existingSnapshotResult.rows?.[0]) {
-          snapshot = {
-            context: {},
-            activePaths: [],
-            timestamp: Date.now(),
-            suspendedPaths: {},
-            activeStepsPath: {},
-            resumeLabels: {},
-            serializedStepGraph: [],
-            status: "pending",
-            value: {},
-            waitingPaths: {},
-            runId,
-            requestContext: {}
-          };
-        } else {
-          const existingSnapshot = existingSnapshotResult.rows[0].snapshot;
-          snapshot = typeof existingSnapshot === "string" ? JSON.parse(existingSnapshot) : existingSnapshot;
-        }
-        snapshot.context[stepId] = result;
-        snapshot.requestContext = { ...snapshot.requestContext, ...requestContext };
-        const now = (/* @__PURE__ */ new Date()).toISOString();
-        await tx.execute({
-          sql: `INSERT INTO ${storage.TABLE_WORKFLOW_SNAPSHOT} (workflow_name, run_id, snapshot, createdAt, updatedAt)
+    return this.executeWithRetry(
+      () => (
+        // Serialize the interactive transaction against all other writes on the shared
+        // connection so a concurrent autocommit write can't leak into this open BEGIN.
+        withClientWriteLock(this.#client, async () => {
+          const tx = await this.#client.transaction("write");
+          try {
+            const existingSnapshotResult = await tx.execute({
+              sql: `SELECT json(snapshot) as snapshot FROM ${storage.TABLE_WORKFLOW_SNAPSHOT} WHERE workflow_name = ? AND run_id = ?`,
+              args: [workflowName, runId]
+            });
+            let snapshot;
+            if (!existingSnapshotResult.rows?.[0]) {
+              snapshot = {
+                context: {},
+                activePaths: [],
+                timestamp: Date.now(),
+                suspendedPaths: {},
+                activeStepsPath: {},
+                resumeLabels: {},
+                serializedStepGraph: [],
+                status: "pending",
+                value: {},
+                waitingPaths: {},
+                runId,
+                requestContext: {}
+              };
+            } else {
+              const existingSnapshot = existingSnapshotResult.rows[0].snapshot;
+              snapshot = typeof existingSnapshot === "string" ? JSON.parse(existingSnapshot) : existingSnapshot;
+            }
+            storage.mergeWorkflowStepResult({ snapshot, stepId, result, requestContext });
+            const now = (/* @__PURE__ */ new Date()).toISOString();
+            await tx.execute({
+              sql: `INSERT INTO ${storage.TABLE_WORKFLOW_SNAPSHOT} (workflow_name, run_id, snapshot, createdAt, updatedAt)
                 VALUES (?, ?, jsonb(?), ?, ?)
                 ON CONFLICT(workflow_name, run_id)
                 DO UPDATE SET snapshot = excluded.snapshot, updatedAt = excluded.updatedAt`,
-          args: [workflowName, runId, safeStringify(snapshot), now, now]
-        });
-        await tx.commit();
-        return snapshot.context;
-      } catch (error) {
-        if (!tx.closed) {
-          await tx.rollback();
-        }
-        throw error;
-      }
-    }, "updateWorkflowResults");
+              args: [workflowName, runId, safeStringify(snapshot), now, now]
+            });
+            await tx.commit();
+            return snapshot.context;
+          } catch (error) {
+            if (!tx.closed) {
+              await tx.rollback();
+            }
+            throw error;
+          }
+        })
+      ),
+      "updateWorkflowResults"
+    );
   }
   async updateWorkflowState({
     workflowName,
     runId,
     opts
   }) {
-    return this.executeWithRetry(async () => {
-      const tx = await this.#client.transaction("write");
-      try {
-        const existingSnapshotResult = await tx.execute({
-          sql: `SELECT json(snapshot) as snapshot FROM ${storage.TABLE_WORKFLOW_SNAPSHOT} WHERE workflow_name = ? AND run_id = ?`,
-          args: [workflowName, runId]
-        });
-        if (!existingSnapshotResult.rows?.[0]) {
-          await tx.rollback();
-          return void 0;
-        }
-        const existingSnapshot = existingSnapshotResult.rows[0].snapshot;
-        const snapshot = typeof existingSnapshot === "string" ? JSON.parse(existingSnapshot) : existingSnapshot;
-        if (!snapshot || !snapshot?.context) {
-          await tx.rollback();
-          throw new Error(`Snapshot not found for runId ${runId}`);
-        }
-        const updatedSnapshot = { ...snapshot, ...opts };
-        await tx.execute({
-          sql: `UPDATE ${storage.TABLE_WORKFLOW_SNAPSHOT} SET snapshot = jsonb(?) WHERE workflow_name = ? AND run_id = ?`,
-          args: [safeStringify(updatedSnapshot), workflowName, runId]
-        });
-        await tx.commit();
-        return updatedSnapshot;
-      } catch (error) {
-        if (!tx.closed) {
-          await tx.rollback();
-        }
-        throw error;
-      }
-    }, "updateWorkflowState");
+    return this.executeWithRetry(
+      () => (
+        // Serialize the interactive transaction against all other writes on the shared
+        // connection so a concurrent autocommit write can't leak into this open BEGIN.
+        withClientWriteLock(this.#client, async () => {
+          const tx = await this.#client.transaction("write");
+          try {
+            const existingSnapshotResult = await tx.execute({
+              sql: `SELECT json(snapshot) as snapshot FROM ${storage.TABLE_WORKFLOW_SNAPSHOT} WHERE workflow_name = ? AND run_id = ?`,
+              args: [workflowName, runId]
+            });
+            if (!existingSnapshotResult.rows?.[0]) {
+              await tx.rollback();
+              return void 0;
+            }
+            const existingSnapshot = existingSnapshotResult.rows[0].snapshot;
+            const snapshot = typeof existingSnapshot === "string" ? JSON.parse(existingSnapshot) : existingSnapshot;
+            if (!snapshot || !snapshot?.context) {
+              await tx.rollback();
+              throw new Error(`Snapshot not found for runId ${runId}`);
+            }
+            const updatedSnapshot = { ...snapshot, ...opts };
+            await tx.execute({
+              sql: `UPDATE ${storage.TABLE_WORKFLOW_SNAPSHOT} SET snapshot = jsonb(?) WHERE workflow_name = ? AND run_id = ?`,
+              args: [safeStringify(updatedSnapshot), workflowName, runId]
+            });
+            await tx.commit();
+            return updatedSnapshot;
+          } catch (error) {
+            if (!tx.closed) {
+              await tx.rollback();
+            }
+            throw error;
+          }
+        })
+      ),
+      "updateWorkflowState"
+    );
   }
   async persistWorkflowSnapshot({
     workflowName,
@@ -11727,7 +11974,7 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
   async listWorkflowRuns({
     workflowName,
     fromDate,
-    toDate,
+    toDate: toDate2,
     page,
     perPage,
     resourceId,
@@ -11748,9 +11995,9 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
         conditions.push("createdAt >= ?");
         args.push(fromDate.toISOString());
       }
-      if (toDate) {
+      if (toDate2) {
         conditions.push("createdAt <= ?");
-        args.push(toDate.toISOString());
+        args.push(toDate2.toISOString());
       }
       if (resourceId) {
         const hasResourceId = await this.#db.hasColumn(storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId");
@@ -12407,8 +12654,10 @@ var LibSQLStore = class extends storage.MastraCompositeStore {
     const blobs = new BlobsLibSQL(domainConfig);
     const backgroundTasks = new BackgroundTasksLibSQL(domainConfig);
     const schedules = new SchedulesLibSQL(domainConfig);
+    const harness = new HarnessLibSQL(domainConfig);
     const toolProviderConnections = new ToolProviderConnectionsLibSQL(domainConfig);
     const notifications = new NotificationsLibSQL(domainConfig);
+    const threadState = new ThreadStateLibSQL(domainConfig);
     this.stores = {
       scores,
       workflows,
@@ -12428,8 +12677,10 @@ var LibSQLStore = class extends storage.MastraCompositeStore {
       blobs,
       backgroundTasks,
       schedules,
+      harness,
       toolProviderConnections,
-      notifications
+      notifications,
+      threadState
     };
   }
   async applyLocalPragmas() {
@@ -12626,6 +12877,7 @@ exports.DatasetsLibSQL = DatasetsLibSQL;
 exports.DefaultStorage = LibSQLStore;
 exports.ExperimentsLibSQL = ExperimentsLibSQL;
 exports.FavoritesLibSQL = FavoritesLibSQL;
+exports.HarnessLibSQL = HarnessLibSQL;
 exports.LIBSQL_PROMPT = LIBSQL_PROMPT;
 exports.LibSQLStore = LibSQLStore;
 exports.LibSQLVector = LibSQLVector;
@@ -12639,6 +12891,7 @@ exports.SchedulesLibSQL = SchedulesLibSQL;
 exports.ScorerDefinitionsLibSQL = ScorerDefinitionsLibSQL;
 exports.ScoresLibSQL = ScoresLibSQL;
 exports.SkillsLibSQL = SkillsLibSQL;
+exports.ThreadStateLibSQL = ThreadStateLibSQL;
 exports.ToolProviderConnectionsLibSQL = ToolProviderConnectionsLibSQL;
 exports.WorkflowsLibSQL = WorkflowsLibSQL;
 exports.WorkspacesLibSQL = WorkspacesLibSQL;