@mastra/libsql 0.13.4 → 0.13.5-alpha.0

package/dist/index.js

@@ -3,8 +3,7 @@ import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { parseSqlIdentifier, parseFieldKey } from '@mastra/core/utils';
 import { MastraVector } from '@mastra/core/vector';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
-import { MastraStorage, StoreOperations, TABLE_WORKFLOW_SNAPSHOT, ScoresStorage, TABLE_SCORERS, safelyParseJSON, TracesStorage, TABLE_TRACES, WorkflowsStorage, MemoryStorage, resolveMessageLimit, TABLE_MESSAGES, TABLE_THREADS, TABLE_RESOURCES, LegacyEvalsStorage, TABLE_EVALS } from '@mastra/core/storage';
-import { parseSqlIdentifier as parseSqlIdentifier$1 } from '@mastra/core';
+import { MastraStorage, StoreOperations, TABLE_WORKFLOW_SNAPSHOT, TABLE_AI_SPANS, ScoresStorage, TABLE_SCORERS, safelyParseJSON, TracesStorage, TABLE_TRACES, WorkflowsStorage, MemoryStorage, resolveMessageLimit, TABLE_MESSAGES, TABLE_THREADS, TABLE_RESOURCES, LegacyEvalsStorage, TABLE_EVALS, ObservabilityStorage, TABLE_SCHEMAS, AI_SPAN_SCHEMA } from '@mastra/core/storage';
 import { MessageList } from '@mastra/core/agent';
 
 // src/vector/index.ts
@@ -1390,14 +1389,14 @@ var MemoryLibSQL = class extends MemoryStorage {
             }
           } : {}
         };
-        setClauses.push(`${parseSqlIdentifier$1("content", "column name")} = ?`);
+        setClauses.push(`${parseSqlIdentifier("content", "column name")} = ?`);
         args.push(JSON.stringify(newContent));
         delete updatableFields.content;
       }
       for (const key in updatableFields) {
         if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
           const dbKey = columnMapping[key] || key;
-          setClauses.push(`${parseSqlIdentifier$1(dbKey, "column name")} = ?`);
+          setClauses.push(`${parseSqlIdentifier(dbKey, "column name")} = ?`);
           let value = updatableFields[key];
           if (typeof value === "object" && value !== null) {
             value = JSON.stringify(value);
@@ -1799,7 +1798,7 @@ function prepareStatement({ tableName, record }) {
   const parsedTableName = parseSqlIdentifier(tableName, "table name");
   const columns = Object.keys(record).map((col) => parseSqlIdentifier(col, "column name"));
   const values = Object.values(record).map((v) => {
-    if (typeof v === `undefined`) {
+    if (typeof v === `undefined` || v === null) {
       return null;
     }
     if (v instanceof Date) {
@@ -1813,8 +1812,338 @@ function prepareStatement({ tableName, record }) {
     args: values
   };
 }
+function prepareUpdateStatement({
+  tableName,
+  updates,
+  keys
+}) {
+  const parsedTableName = parseSqlIdentifier(tableName, "table name");
+  const schema = TABLE_SCHEMAS[tableName];
+  const updateColumns = Object.keys(updates).map((col) => parseSqlIdentifier(col, "column name"));
+  const updateValues = Object.values(updates).map(transformToSqlValue);
+  const setClause = updateColumns.map((col) => `${col} = ?`).join(", ");
+  const whereClause = prepareWhereClause(keys, schema);
+  return {
+    sql: `UPDATE ${parsedTableName} SET ${setClause}${whereClause.sql}`,
+    args: [...updateValues, ...whereClause.args]
+  };
+}
+function transformToSqlValue(value) {
+  if (typeof value === "undefined" || value === null) {
+    return null;
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  return typeof value === "object" ? JSON.stringify(value) : value;
+}
+function prepareDeleteStatement({ tableName, keys }) {
+  const parsedTableName = parseSqlIdentifier(tableName, "table name");
+  const whereClause = prepareWhereClause(keys, TABLE_SCHEMAS[tableName]);
+  return {
+    sql: `DELETE FROM ${parsedTableName}${whereClause.sql}`,
+    args: whereClause.args
+  };
+}
+function prepareWhereClause(filters, schema) {
+  const conditions = [];
+  const args = [];
+  for (const [columnName, filterValue] of Object.entries(filters)) {
+    const column = schema[columnName];
+    if (!column) {
+      throw new Error(`Unknown column: ${columnName}`);
+    }
+    const parsedColumn = parseSqlIdentifier(columnName, "column name");
+    const result = buildCondition2(parsedColumn, filterValue);
+    conditions.push(result.condition);
+    args.push(...result.args);
+  }
+  return {
+    sql: conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "",
+    args
+  };
+}
+function buildCondition2(columnName, filterValue) {
+  if (filterValue === null) {
+    return { condition: `${columnName} IS NULL`, args: [] };
+  }
+  if (typeof filterValue === "object" && filterValue !== null && ("startAt" in filterValue || "endAt" in filterValue)) {
+    return buildDateRangeCondition(columnName, filterValue);
+  }
+  return {
+    condition: `${columnName} = ?`,
+    args: [transformToSqlValue(filterValue)]
+  };
+}
+function buildDateRangeCondition(columnName, range) {
+  const conditions = [];
+  const args = [];
+  if (range.startAt !== void 0) {
+    conditions.push(`${columnName} >= ?`);
+    args.push(transformToSqlValue(range.startAt));
+  }
+  if (range.endAt !== void 0) {
+    conditions.push(`${columnName} <= ?`);
+    args.push(transformToSqlValue(range.endAt));
+  }
+  if (conditions.length === 0) {
+    throw new Error("Date range must specify at least startAt or endAt");
+  }
+  return {
+    condition: conditions.join(" AND "),
+    args
+  };
+}
+function buildDateRangeFilter(dateRange, columnName = "createdAt") {
+  if (!dateRange?.start && !dateRange?.end) {
+    return {};
+  }
+  const filter = {};
+  if (dateRange.start) {
+    filter.startAt = new Date(dateRange.start).toISOString();
+  }
+  if (dateRange.end) {
+    filter.endAt = new Date(dateRange.end).toISOString();
+  }
+  return { [columnName]: filter };
+}
+function transformFromSqlRow({
+  tableName,
+  sqlRow
+}) {
+  const result = {};
+  const jsonColumns = new Set(
+    Object.keys(TABLE_SCHEMAS[tableName]).filter((key) => TABLE_SCHEMAS[tableName][key].type === "jsonb").map((key) => key)
+  );
+  const dateColumns = new Set(
+    Object.keys(TABLE_SCHEMAS[tableName]).filter((key) => TABLE_SCHEMAS[tableName][key].type === "timestamp").map((key) => key)
+  );
+  for (const [key, value] of Object.entries(sqlRow)) {
+    if (value === null || value === void 0) {
+      result[key] = value;
+      continue;
+    }
+    if (dateColumns.has(key) && typeof value === "string") {
+      result[key] = new Date(value);
+      continue;
+    }
+    if (jsonColumns.has(key) && typeof value === "string") {
+      result[key] = safelyParseJSON(value);
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
 
-// src/storage/domains/operations/index.ts
+// src/storage/domains/observability/index.ts
+var ObservabilityLibSQL = class extends ObservabilityStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
+  }
+  async createAISpan(span) {
+    try {
+      return this.operations.insert({ tableName: TABLE_AI_SPANS, record: span });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "LIBSQL_STORE_CREATE_AI_SPAN_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: {
+            spanId: span.spanId,
+            traceId: span.traceId,
+            spanType: span.spanType,
+            spanName: span.name
+          }
+        },
+        error
+      );
+    }
+  }
+  async getAITrace(traceId) {
+    try {
+      const spans = await this.operations.loadMany({
+        tableName: TABLE_AI_SPANS,
+        whereClause: { sql: " WHERE traceId = ?", args: [traceId] },
+        orderBy: "startedAt DESC"
+      });
+      if (!spans || spans.length === 0) {
+        return null;
+      }
+      return {
+        traceId,
+        spans: spans.map((span) => transformFromSqlRow({ tableName: TABLE_AI_SPANS, sqlRow: span }))
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "LIBSQL_STORE_GET_AI_TRACE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: {
+            traceId
+          }
+        },
+        error
+      );
+    }
+  }
+  async updateAISpan({
+    spanId,
+    traceId,
+    updates
+  }) {
+    try {
+      await this.operations.update({
+        tableName: TABLE_AI_SPANS,
+        keys: { spanId, traceId },
+        data: { ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "LIBSQL_STORE_UPDATE_AI_SPAN_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: {
+            spanId,
+            traceId
+          }
+        },
+        error
+      );
+    }
+  }
+  async getAITracesPaginated({
+    filters,
+    pagination
+  }) {
+    const page = pagination?.page ?? 0;
+    const perPage = pagination?.perPage ?? 10;
+    const filtersWithDateRange = {
+      ...filters,
+      ...buildDateRangeFilter(pagination?.dateRange, "startedAt")
+    };
+    const whereClause = prepareWhereClause(filtersWithDateRange, AI_SPAN_SCHEMA);
+    const orderBy = "startedAt DESC";
+    let count = 0;
+    try {
+      count = await this.operations.loadTotalCount({
+        tableName: TABLE_AI_SPANS,
+        whereClause: { sql: whereClause.sql, args: whereClause.args }
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "LIBSQL_STORE_GET_AI_TRACES_PAGINATED_COUNT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER
+        },
+        error
+      );
+    }
+    if (count === 0) {
+      return {
+        pagination: {
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        },
+        spans: []
+      };
+    }
+    try {
+      const spans = await this.operations.loadMany({
+        tableName: TABLE_AI_SPANS,
+        whereClause,
+        orderBy,
+        offset: page * perPage,
+        limit: perPage
+      });
+      return {
+        pagination: {
+          total: count,
+          page,
+          perPage,
+          hasMore: spans.length === perPage
+        },
+        spans: spans.map((span) => transformFromSqlRow({ tableName: TABLE_AI_SPANS, sqlRow: span }))
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "LIBSQL_STORE_GET_AI_TRACES_PAGINATED_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER
+        },
+        error
+      );
+    }
+  }
+  async batchCreateAISpans(args) {
+    try {
+      return this.operations.batchInsert({
+        tableName: TABLE_AI_SPANS,
+        records: args.records.map((record) => ({
+          ...record,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }))
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "LIBSQL_STORE_BATCH_CREATE_AI_SPANS_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER
+        },
+        error
+      );
+    }
+  }
+  async batchUpdateAISpans(args) {
+    try {
+      return this.operations.batchUpdate({
+        tableName: TABLE_AI_SPANS,
+        updates: args.records.map((record) => ({
+          keys: { spanId: record.spanId, traceId: record.traceId },
+          data: { ...record.updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }
+        }))
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "LIBSQL_STORE_BATCH_UPDATE_AI_SPANS_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER
+        },
+        error
+      );
+    }
+  }
+  async batchDeleteAITraces(args) {
+    try {
+      const keys = args.traceIds.map((traceId) => ({ traceId }));
+      return this.operations.batchDelete({
+        tableName: TABLE_AI_SPANS,
+        keys
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "LIBSQL_STORE_BATCH_DELETE_AI_TRACES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER
+        },
+        error
+      );
+    }
+  }
+};
 var StoreOperationsLibSQL = class extends StoreOperations {
   client;
   /**
@@ -1862,6 +2191,13 @@ var StoreOperationsLibSQL = class extends StoreOperations {
                 )`;
       return stmnt;
     }
+    if (tableName === TABLE_AI_SPANS) {
+      const stmnt = `CREATE TABLE IF NOT EXISTS ${parsedTableName} (
+                    ${columns.join(",\n")},
+                    PRIMARY KEY (traceId, spanId)
+                )`;
+      return stmnt;
+    }
     return `CREATE TABLE IF NOT EXISTS ${parsedTableName} (${columns.join(", ")})`;
   }
   async createTable({
@@ -1941,6 +2277,64 @@ var StoreOperationsLibSQL = class extends StoreOperations {
     );
     return parsed;
   }
+  async loadMany({
+    tableName,
+    whereClause,
+    orderBy,
+    offset,
+    limit,
+    args
+  }) {
+    const parsedTableName = parseSqlIdentifier(tableName, "table name");
+    let statement = `SELECT * FROM ${parsedTableName}`;
+    if (whereClause?.sql) {
+      statement += `${whereClause.sql}`;
+    }
+    if (orderBy) {
+      statement += ` ORDER BY ${orderBy}`;
+    }
+    if (limit) {
+      statement += ` LIMIT ${limit}`;
+    }
+    if (offset) {
+      statement += ` OFFSET ${offset}`;
+    }
+    const result = await this.client.execute({
+      sql: statement,
+      args: [...whereClause?.args ?? [], ...args ?? []]
+    });
+    return result.rows;
+  }
+  async loadTotalCount({
+    tableName,
+    whereClause
+  }) {
+    const parsedTableName = parseSqlIdentifier(tableName, "table name");
+    const statement = `SELECT COUNT(*) as count FROM ${parsedTableName} ${whereClause ? `${whereClause.sql}` : ""}`;
+    const result = await this.client.execute({
+      sql: statement,
+      args: whereClause?.args ?? []
+    });
+    if (!result.rows || result.rows.length === 0) {
+      return 0;
+    }
+    return result.rows[0]?.count ?? 0;
+  }
+  update(args) {
+    const executeWriteOperationWithRetry = createExecuteWriteOperationWithRetry({
+      logger: this.logger,
+      maxRetries: this.maxRetries,
+      initialBackoffMs: this.initialBackoffMs
+    });
+    return executeWriteOperationWithRetry(() => this.executeUpdate(args), `update table ${args.tableName}`);
+  }
+  async executeUpdate({
+    tableName,
+    keys,
+    data
+  }) {
+    await this.client.execute(prepareUpdateStatement({ tableName, updates: data, keys }));
+  }
   async doBatchInsert({
     tableName,
     records
@@ -1972,6 +2366,91 @@ var StoreOperationsLibSQL = class extends StoreOperations {
       );
     });
   }
+  /**
+   * Public batch update method with retry logic
+   */
+  batchUpdate(args) {
+    const executeWriteOperationWithRetry = createExecuteWriteOperationWithRetry({
+      logger: this.logger,
+      maxRetries: this.maxRetries,
+      initialBackoffMs: this.initialBackoffMs
+    });
+    return executeWriteOperationWithRetry(
+      () => this.executeBatchUpdate(args),
+      `batch update in table ${args.tableName}`
+    ).catch((error) => {
+      throw new MastraError(
+        {
+          id: "LIBSQL_STORE_BATCH_UPDATE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName: args.tableName
+          }
+        },
+        error
+      );
+    });
+  }
+  /**
+   * Updates multiple records in batch. Each record can be updated based on single or composite keys.
+   */
+  async executeBatchUpdate({
+    tableName,
+    updates
+  }) {
+    if (updates.length === 0) return;
+    const batchStatements = updates.map(
+      ({ keys, data }) => prepareUpdateStatement({
+        tableName,
+        updates: data,
+        keys
+      })
+    );
+    await this.client.batch(batchStatements, "write");
+  }
+  /**
+   * Public batch delete method with retry logic
+   */
+  batchDelete({ tableName, keys }) {
+    const executeWriteOperationWithRetry = createExecuteWriteOperationWithRetry({
+      logger: this.logger,
+      maxRetries: this.maxRetries,
+      initialBackoffMs: this.initialBackoffMs
+    });
+    return executeWriteOperationWithRetry(
+      () => this.executeBatchDelete({ tableName, keys }),
+      `batch delete from table ${tableName}`
+    ).catch((error) => {
+      throw new MastraError(
+        {
+          id: "LIBSQL_STORE_BATCH_DELETE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error
+      );
+    });
+  }
+  /**
+   * Deletes multiple records in batch. Each record can be deleted based on single or composite keys.
+   */
+  async executeBatchDelete({
+    tableName,
+    keys
+  }) {
+    if (keys.length === 0) return;
+    const batchStatements = keys.map(
+      (keyObj) => prepareDeleteStatement({
+        tableName,
+        keys: keyObj
+      })
+    );
+    await this.client.batch(batchStatements, "write");
+  }
   /**
    * Alters table schema to add columns if they don't exist
    * @param tableName Name of the table
@@ -2391,10 +2870,165 @@ function parseWorkflowRun(row) {
 var WorkflowsLibSQL = class extends WorkflowsStorage {
   operations;
   client;
-  constructor({ operations, client }) {
+  maxRetries;
+  initialBackoffMs;
+  constructor({
+    operations,
+    client,
+    maxRetries = 5,
+    initialBackoffMs = 500
+  }) {
     super();
     this.operations = operations;
     this.client = client;
+    this.maxRetries = maxRetries;
+    this.initialBackoffMs = initialBackoffMs;
+    this.setupPragmaSettings().catch(
+      (err) => this.logger.warn("LibSQL Workflows: Failed to setup PRAGMA settings.", err)
+    );
+  }
+  async setupPragmaSettings() {
+    try {
+      await this.client.execute("PRAGMA busy_timeout = 10000;");
+      this.logger.debug("LibSQL Workflows: PRAGMA busy_timeout=10000 set.");
+      try {
+        await this.client.execute("PRAGMA journal_mode = WAL;");
+        this.logger.debug("LibSQL Workflows: PRAGMA journal_mode=WAL set.");
+      } catch {
+        this.logger.debug("LibSQL Workflows: WAL mode not supported, using default journal mode.");
+      }
+      try {
+        await this.client.execute("PRAGMA synchronous = NORMAL;");
+        this.logger.debug("LibSQL Workflows: PRAGMA synchronous=NORMAL set.");
+      } catch {
+        this.logger.debug("LibSQL Workflows: Failed to set synchronous mode.");
+      }
+    } catch (err) {
+      this.logger.warn("LibSQL Workflows: Failed to set PRAGMA settings.", err);
+    }
+  }
+  async executeWithRetry(operation) {
+    let attempts = 0;
+    let backoff = this.initialBackoffMs;
+    while (attempts < this.maxRetries) {
+      try {
+        return await operation();
+      } catch (error) {
+        this.logger.debug("LibSQL Workflows: Error caught in retry loop", {
+          errorType: error.constructor.name,
+          errorCode: error.code,
+          errorMessage: error.message,
+          attempts,
+          maxRetries: this.maxRetries
+        });
+        const isLockError = error.code === "SQLITE_BUSY" || error.code === "SQLITE_LOCKED" || error.message?.toLowerCase().includes("database is locked") || error.message?.toLowerCase().includes("database table is locked") || error.message?.toLowerCase().includes("table is locked") || error.constructor.name === "SqliteError" && error.message?.toLowerCase().includes("locked");
+        if (isLockError) {
+          attempts++;
+          if (attempts >= this.maxRetries) {
+            this.logger.error(
+              `LibSQL Workflows: Operation failed after ${this.maxRetries} attempts due to database lock: ${error.message}`,
+              { error, attempts, maxRetries: this.maxRetries }
+            );
+            throw error;
+          }
+          this.logger.warn(
+            `LibSQL Workflows: Attempt ${attempts} failed due to database lock. Retrying in ${backoff}ms...`,
+            { errorMessage: error.message, attempts, backoff, maxRetries: this.maxRetries }
+          );
+          await new Promise((resolve) => setTimeout(resolve, backoff));
+          backoff *= 2;
+        } else {
+          this.logger.error("LibSQL Workflows: Non-lock error occurred, not retrying", { error });
+          throw error;
+        }
+      }
+    }
+    throw new Error("LibSQL Workflows: Max retries reached, but no error was re-thrown from the loop.");
+  }
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    runtimeContext
+  }) {
+    return this.executeWithRetry(async () => {
+      const tx = await this.client.transaction("write");
+      try {
+        const existingSnapshotResult = await tx.execute({
+          sql: `SELECT snapshot FROM ${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: {},
+            serializedStepGraph: [],
+            value: {},
+            waitingPaths: {},
+            status: "pending",
+            runId,
+            runtimeContext: {}
+          };
+        } else {
+          const existingSnapshot = existingSnapshotResult.rows[0].snapshot;
+          snapshot = typeof existingSnapshot === "string" ? JSON.parse(existingSnapshot) : existingSnapshot;
+        }
+        snapshot.context[stepId] = result;
+        snapshot.runtimeContext = { ...snapshot.runtimeContext, ...runtimeContext };
+        await tx.execute({
+          sql: `UPDATE ${TABLE_WORKFLOW_SNAPSHOT} SET snapshot = ? WHERE workflow_name = ? AND run_id = ?`,
+          args: [JSON.stringify(snapshot), workflowName, runId]
+        });
+        await tx.commit();
+        return snapshot.context;
+      } catch (error) {
+        if (!tx.closed) {
+          await tx.rollback();
+        }
+        throw error;
+      }
+    });
+  }
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
+  }) {
+    return this.executeWithRetry(async () => {
+      const tx = await this.client.transaction("write");
+      try {
+        const existingSnapshotResult = await tx.execute({
+          sql: `SELECT snapshot FROM ${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 ${TABLE_WORKFLOW_SNAPSHOT} SET snapshot = ? WHERE workflow_name = ? AND run_id = ?`,
+          args: [JSON.stringify(updatedSnapshot), workflowName, runId]
+        });
+        await tx.commit();
+        return updatedSnapshot;
+      } catch (error) {
+        if (!tx.closed) {
+          await tx.rollback();
+        }
+        throw error;
+      }
+    });
   }
   async persistWorkflowSnapshot({
     workflowName,
@@ -2555,13 +3189,15 @@ var LibSQLStore = class extends MastraStorage {
     const workflows = new WorkflowsLibSQL({ client: this.client, operations });
     const memory = new MemoryLibSQL({ client: this.client, operations });
     const legacyEvals = new LegacyEvalsLibSQL({ client: this.client });
+    const observability = new ObservabilityLibSQL({ operations });
     this.stores = {
       operations,
       scores,
       traces,
       workflows,
       memory,
-      legacyEvals
+      legacyEvals,
+      observability
     };
   }
   get supports() {
@@ -2570,7 +3206,8 @@ var LibSQLStore = class extends MastraStorage {
       resourceWorkingMemory: true,
       hasColumn: true,
       createTable: true,
-      deleteMessages: true
+      deleteMessages: true,
+      aiTracing: true
     };
   }
   async createTable({
@@ -2712,6 +3349,22 @@ var LibSQLStore = class extends MastraStorage {
   /**
    * WORKFLOWS
    */
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    runtimeContext
+  }) {
+    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, runtimeContext });
+  }
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
+  }) {
+    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
+  }
   async persistWorkflowSnapshot({
     workflowName,
     runId,
@@ -2754,6 +3407,24 @@ var LibSQLStore = class extends MastraStorage {
   }) {
     return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
   }
+  async createAISpan(span) {
+    return this.stores.observability.createAISpan(span);
+  }
+  async updateAISpan(params) {
+    return this.stores.observability.updateAISpan(params);
+  }
+  async getAITrace(traceId) {
+    return this.stores.observability.getAITrace(traceId);
+  }
+  async getAITracesPaginated(args) {
+    return this.stores.observability.getAITracesPaginated(args);
+  }
+  async batchCreateAISpans(args) {
+    return this.stores.observability.batchCreateAISpans(args);
+  }
+  async batchUpdateAISpans(args) {
+    return this.stores.observability.batchUpdateAISpans(args);
+  }
 };
 
 // src/vector/prompt.ts