@mastra/libsql 1.16.0 → 1.17.0-alpha.3

package/CHANGELOG.md

@@ -1,5 +1,79 @@
 # @mastra/libsql
 
+## 1.17.0-alpha.3
+
+### Minor Changes
+
+- Added configurable local journal modes while preserving WAL as the default. ([#19901](https://github.com/mastra-ai/mastra/pull/19901))
+
+  ```ts
+  const storage = new LibSQLStore({
+    id: 'local-storage',
+    url: 'file:./mastra.db',
+    journalMode: 'delete',
+  });
+  ```
+
+### Patch Changes
+
+- Updated dependencies [[`c7d30cd`](https://github.com/mastra-ai/mastra/commit/c7d30cd86009c407df91105591f03cd6e3d2854d), [`ef03fbc`](https://github.com/mastra-ai/mastra/commit/ef03fbcc556bcbc04c9b3d06fab88771ecaa043c), [`a7bbe77`](https://github.com/mastra-ai/mastra/commit/a7bbe773577f60bc4761b534ef7ec6b476332dad), [`a7bbe77`](https://github.com/mastra-ai/mastra/commit/a7bbe773577f60bc4761b534ef7ec6b476332dad), [`4e68363`](https://github.com/mastra-ai/mastra/commit/4e683634f94ebd062d26a3bb6093a8dfc7263d37), [`9251370`](https://github.com/mastra-ai/mastra/commit/9251370ad413af464aa22d7566338bec5613e8de)]:
+  - @mastra/core@1.52.0-alpha.11
+
+## 1.17.0-alpha.2
+
+### Patch Changes
+
+- Replaced GitHub-specific Mastra Code session state with Factory project and linked-repository identities. This lets SDK consumers represent sessions independently of a source-control provider and select a repository explicitly when sandbox execution is required. ([#19849](https://github.com/mastra-ai/mastra/pull/19849))
+
+  Updated Mastra Code onboarding to be Factory-first: create a Factory by name, then link repositories from your connected source-control installations in a separate step. A Factory is valid with zero linked repositories, and the Board, Metrics, and Audit pages stay available for any server-backed Factory. Factory pages keep project-scoped data separate from repository-scoped intake and provide a repository selector when a Factory has multiple linked repositories. Creating a Factory from a local folder remains available as a secondary option.
+
+  **Before**
+
+  ```ts
+  const state = { githubProjectId: 'project-1', sandboxId, sandboxWorkdir };
+  ```
+
+  **After**
+
+  ```ts
+  const state = {
+    factoryProjectId: 'factory-project-1',
+    projectRepositoryId: 'project-repository-1',
+    sandboxId,
+    sandboxWorkdir,
+  };
+  ```
+
+- Updated dependencies [[`41a5392`](https://github.com/mastra-ai/mastra/commit/41a5392d9f6c5e18d6b227f0fc0ddf49c50774e9), [`675fbff`](https://github.com/mastra-ai/mastra/commit/675fbff84d3274391b33e852f76083c38a5514e5), [`da009e1`](https://github.com/mastra-ai/mastra/commit/da009e1aacd89ed94b8d1b2af09c9d4fe7c4db49), [`35c2181`](https://github.com/mastra-ai/mastra/commit/35c2181e6a50e47c90ba36260db7c9723d54696f), [`b4b7ea8`](https://github.com/mastra-ai/mastra/commit/b4b7ea8733f033fc441ea47ed03f6afb17ec2248), [`675fbff`](https://github.com/mastra-ai/mastra/commit/675fbff84d3274391b33e852f76083c38a5514e5), [`c328769`](https://github.com/mastra-ai/mastra/commit/c3287698ff8ef98dba86d415faa566fa3e5f4d56), [`232fcbc`](https://github.com/mastra-ai/mastra/commit/232fcbc14fce625dd672ba043329c0b732c62be2), [`3491666`](https://github.com/mastra-ai/mastra/commit/34916663c4fdd43b48c21f4ab2d5fb6dcccc94f9)]:
+  - @mastra/core@1.52.0-alpha.10
+
+## 1.17.0-alpha.1
+
+### Minor Changes
+
+- Added LibSQLFactoryStorage for persisting Mastra agent state and lifecycle-managed application domains through one LibSQL connection. ([#19681](https://github.com/mastra-ai/mastra/pull/19681))
+
+  ```ts
+  import { LibSQLFactoryStorage } from '@mastra/libsql';
+
+  const storage = new LibSQLFactoryStorage({ url: 'file:mastra.db' });
+  await storage.init();
+  ```
+
+### Patch Changes
+
+- Updated dependencies [[`3b77e77`](https://github.com/mastra-ai/mastra/commit/3b77e7704936522e4769d29de1b5ea6901f302bd), [`6b1bf3b`](https://github.com/mastra-ai/mastra/commit/6b1bf3b9494bd51aa8f654c68c9355d6046fa2a1), [`72e437c`](https://github.com/mastra-ai/mastra/commit/72e437c515942c80b9def5b026e0bdee61b469d9)]:
+  - @mastra/core@1.52.0-alpha.8
+
+## 1.16.1-alpha.0
+
+### Patch Changes
+
+- Fixed an uncaught `RangeError: Maximum call stack size exceeded` when writing deeply-nested values (such as a long chained `Error.cause`) to LibSQL storage. `safeStringify` now caps its recursion depth and substitutes a `"[Max depth exceeded]"` sentinel instead of overflowing the stack. ([#19610](https://github.com/mastra-ai/mastra/pull/19610))
+
+- Updated dependencies [[`ec857fc`](https://github.com/mastra-ai/mastra/commit/ec857fc79c264b53b38e16478c789b7177f2ad59), [`e1f2fae`](https://github.com/mastra-ai/mastra/commit/e1f2faebaf048c3d4c2e2c01d293767c195d5794), [`63aa799`](https://github.com/mastra-ai/mastra/commit/63aa799c6b44eacc7806cda6846b7c5bbee06b37), [`73db8db`](https://github.com/mastra-ai/mastra/commit/73db8db90d69ab6153c7942749f624db0d96952d), [`73db8db`](https://github.com/mastra-ai/mastra/commit/73db8db90d69ab6153c7942749f624db0d96952d), [`76b7181`](https://github.com/mastra-ai/mastra/commit/76b71810366e6d90b9d3973149d1c7ba3659ffb9), [`0c0e8d7`](https://github.com/mastra-ai/mastra/commit/0c0e8d7becd4d1445c656b78d5d845f606c1ff9d), [`9f7c67a`](https://github.com/mastra-ai/mastra/commit/9f7c67abeeb52c41c51a9b5edee60b62afe7cd8d), [`3b65e68`](https://github.com/mastra-ai/mastra/commit/3b65e68d7f1c771c7a70eea42d83fefdd28cad88), [`e3868e2`](https://github.com/mastra-ai/mastra/commit/e3868e22babfffd0133771669ca724501c2dd58e)]:
+  - @mastra/core@1.52.0-alpha.5
+
 ## 1.16.0
 
 ### Minor Changes
@@ -917,9 +991,7 @@
   **Example**
 
   ```ts
-  const storage = new LibSQLStore({
-    /* config */
-  });
+  const storage = new LibSQLStore({/* config */});
   const favorites = await storage.getStore('favorites');
 
   await favorites?.favorite({
@@ -947,9 +1019,7 @@
   **Example**
 
   ```ts
-  const storage = new LibSQLStore({
-    /* config */
-  });
+  const storage = new LibSQLStore({/* config */});
   const favorites = await storage.getStore('favorites');
 
   await favorites?.favorite({

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-libsql
 description: Documentation for @mastra/libsql. Use when working with @mastra/libsql APIs, configuration, or implementation.
 metadata:
   package: "@mastra/libsql"
-  version: "1.16.0"
+  version: "1.17.0-alpha.3"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.16.0",
+  "version": "1.17.0-alpha.3",
   "package": "@mastra/libsql",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-agent-builder-deploying.md

@@ -29,6 +29,7 @@ import { LibSQLStore } from '@mastra/libsql'
 
 new Mastra({
   storage: new LibSQLStore({
+    id: 'mastra-storage',
     url: process.env.DATABASE_URL!,
     authToken: process.env.DATABASE_AUTH_TOKEN,
   }),

package/dist/docs/references/docs-agent-builder-overview.md

@@ -67,7 +67,7 @@ import { createBuilderAgent } from '@mastra/editor/ee'
 import { LibSQLStore } from '@mastra/libsql'
 
 export const mastra = new Mastra({
-  storage: new LibSQLStore({ url: 'file:./mastra.db' }),
+  storage: new LibSQLStore({ id: 'mastra-storage', url: 'file:./mastra.db' }),
   agents: { builderAgent: createBuilderAgent() },
   editor: new MastraEditor({
     builder: {

package/dist/docs/references/docs-memory-multi-user-threads.md

@@ -58,7 +58,7 @@ import { Memory } from '@mastra/memory'
 import { LibSQLStore } from '@mastra/libsql'
 
 const memory = new Memory({
-  storage: new LibSQLStore({ url: 'file:./collab.db' }),
+  storage: new LibSQLStore({ id: 'collab-storage', url: 'file:./collab.db' }),
   options: {
     lastMessages: 20,
   },
@@ -128,7 +128,7 @@ import { Memory } from '@mastra/memory'
 import { LibSQLStore } from '@mastra/libsql'
 
 const memory = new Memory({
-  storage: new LibSQLStore({ url: 'file:./collab.db' }),
+  storage: new LibSQLStore({ id: 'collab-storage', url: 'file:./collab.db' }),
   options: {
     lastMessages: 20,
   },
@@ -148,7 +148,7 @@ import { Memory } from '@mastra/memory'
 import { LibSQLStore } from '@mastra/libsql'
 
 const memory = new Memory({
-  storage: new LibSQLStore({ url: 'file:./collab.db' }),
+  storage: new LibSQLStore({ id: 'collab-storage', url: 'file:./collab.db' }),
   options: {
     lastMessages: 20,
     observationalMemory: true,
@@ -171,7 +171,7 @@ import { Memory } from '@mastra/memory'
 import { LibSQLStore } from '@mastra/libsql'
 
 const memory = new Memory({
-  storage: new LibSQLStore({ url: 'file:./collab.db' }),
+  storage: new LibSQLStore({ id: 'collab-storage', url: 'file:./collab.db' }),
   options: {
     lastMessages: 20,
     workingMemory: {

package/dist/docs/references/docs-memory-overview.md

@@ -81,6 +81,8 @@ Use memory when your agent needs to maintain multi-turn conversations that refer
 
 3. Add the storage provider to your main Mastra instance to enable memory across all configured agents.
 
+   **For AI agents:** Important: Add `id` to `LibSQLStore`.
+
    ```typescript
    import { Mastra } from '@mastra/core'
    import { LibSQLStore } from '@mastra/libsql'
@@ -151,6 +153,8 @@ To list all threads for a resource, or retrieve a specific thread, [use the memo
 
 For long-running conversations, raw message history grows until it fills the context window, degrading agent performance. [Observational Memory](https://mastra.ai/docs/memory/observational-memory) solves this by running background agents that compress old messages into dense observations, keeping the context window small while preserving long-term memory.
 
+**For AI agents:** Using Observational Memory requires a storage provider! You either need to set it on the Mastra instance at `src/mastra/index.ts` or pass it to the Agent constructor.
+
 ```typescript
 import { Agent } from '@mastra/core/agent'
 import { Memory } from '@mastra/memory'

package/dist/docs/references/docs-memory-working-memory.md

@@ -403,7 +403,7 @@ By default, working memory reaches the model as part of the system message. You
 
 ```typescript
 const memory = new Memory({
-  storage: new LibSQLStore({ url: 'file:./mastra.db' }),
+  storage: new LibSQLStore({ id: 'mastra-storage', url: 'file:./mastra.db' }),
   options: {
     workingMemory: {
       enabled: true,

package/dist/docs/references/reference-core-mastra-class.md

@@ -53,7 +53,7 @@ Visit the [Configuration reference](https://mastra.ai/reference/configuration) f
 
 **agents** (`Record<string, Agent>`): Agent instances to register, keyed by name (Default: `{}`)
 
-**tools** (`Record<string, ToolApi>`): Custom tools to register. Structured as a key-value pair, with keys being the tool name and values being the tool function. (Default: `{}`)
+**tools** (`Record<string, ToolApi>`): Tool instances to register. Keys are registration keys used by \`getTool()\`, and values are tool instances. Use \`getToolById()\` for intrinsic ID lookup and \`listTools()\` to read the registry. (Default: `{}`)
 
 **storage** (`MastraCompositeStore`): Storage engine instance for persisting data
 

package/dist/docs/references/reference-storage-retention.md

@@ -228,7 +228,7 @@ const storage = new MongoDBStore({
 })
 ```
 
-> **Tip:** TTL indexes delete documents shortly after they expire (background thread runs every \~60 seconds), but the exact timing is not guaranteed. For precise, immediate cleanup, use `prune()` instead.
+> **Tip:** TTL indexes delete documents shortly after they expire (background thread runs every \~60 seconds), but the exact timing isn't guaranteed. For precise, immediate cleanup, use `prune()` instead.
 
 ## Reclaiming disk
 

package/dist/index.cjs

@@ -1198,26 +1198,28 @@ var LibSQLVector = class extends vector.MastraVector {
     });
   }
 };
+var MAX_DEPTH = 100;
 var safeStringify = (value) => {
   const ancestors = /* @__PURE__ */ new Set();
-  const sanitize = (val) => {
+  const sanitize = (val, depth = 0) => {
     if (val === null || val === void 0) return val;
     if (typeof val === "function") return void 0;
     if (typeof val === "symbol") return void 0;
     if (typeof val === "bigint") return val.toString();
     if (typeof val !== "object") return val;
+    if (depth > MAX_DEPTH) return "[Max depth exceeded]";
     if (ancestors.has(val)) return void 0;
     if (typeof val.toJSON === "function") {
-      return sanitize(val.toJSON());
+      return sanitize(val.toJSON(), depth + 1);
     }
     ancestors.add(val);
     try {
       if (Array.isArray(val)) {
-        return val.map((item) => sanitize(item));
+        return val.map((item) => sanitize(item, depth + 1));
       }
       const result = {};
       for (const key of Object.keys(val)) {
-        const sanitized = sanitize(val[key]);
+        const sanitized = sanitize(val[key], depth + 1);
         if (sanitized !== void 0) {
           result[key] = sanitized;
         }
@@ -13347,6 +13349,402 @@ var WorkspacesLibSQL = class extends storage.WorkspacesStorage {
     };
   }
 };
+var IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var COLUMN_DDL = {
+  text: "TEXT",
+  bigint: "INTEGER",
+  integer: "INTEGER",
+  boolean: "INTEGER",
+  json: "TEXT",
+  timestamp: "TEXT",
+  "uuid-pk": "TEXT"
+};
+function assertIdentifier(kind, name) {
+  if (!IDENTIFIER_RE.test(name)) {
+    throw new Error(`LibSQLFactoryStorage: invalid ${kind} identifier '${name}'`);
+  }
+}
+function isUniqueViolation(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("UNIQUE constraint failed") || message.includes("SQLITE_CONSTRAINT");
+}
+function primaryKeyOf(schema) {
+  const pks = Object.entries(schema.columns).filter(([, spec]) => spec.type === "uuid-pk" || spec.primaryKey);
+  if (pks.length !== 1) {
+    throw new Error(
+      `LibSQLFactoryStorage: collection '${schema.name}' must declare exactly one primary key (found ${pks.length})`
+    );
+  }
+  return pks[0][0];
+}
+function assertUpsertConflict(schema, conflictKeys, row) {
+  const keys = new Set(conflictKeys);
+  if (keys.size !== conflictKeys.length || conflictKeys.some((key) => row[key] === void 0)) {
+    throw new Error(
+      `LibSQLFactoryStorage: upsert conflict keys for '${schema.name}' must be unique and present in the row`
+    );
+  }
+  const primaryKey = primaryKeyOf(schema);
+  const candidates = [{ columns: [primaryKey] }, ...schema.uniqueIndexes ?? []];
+  const matches = candidates.some((candidate) => {
+    if (candidate.columns.length !== keys.size || candidate.columns.some((column) => !keys.has(column))) return false;
+    if ("whereNotNull" in candidate && candidate.whereNotNull && row[candidate.whereNotNull] == null) return false;
+    if ("whereNull" in candidate && candidate.whereNull && row[candidate.whereNull] != null) return false;
+    return true;
+  });
+  if (!matches) {
+    throw new Error(
+      `LibSQLFactoryStorage: upsert conflict keys [${conflictKeys.join(", ")}] do not match an applicable primary key or unique index on '${schema.name}'`
+    );
+  }
+}
+function serializeDefault(value) {
+  if (typeof value === "string") return `'${value.replace(/'/g, "''")}'`;
+  if (typeof value === "boolean") return value ? "1" : "0";
+  return String(value);
+}
+var Mutex = class {
+  #tail = Promise.resolve();
+  run(fn) {
+    const result = this.#tail.then(fn, fn);
+    this.#tail = result.catch(() => {
+    });
+    return result;
+  }
+};
+var LibSQLFactoryStorageOps = class {
+  #client;
+  #schemas;
+  #writeMutex = new Mutex();
+  constructor(client, schemas) {
+    this.#client = client;
+    this.#schemas = schemas;
+  }
+  #schema(collection) {
+    const schema = this.#schemas.get(collection);
+    if (!schema) {
+      throw new Error(
+        `LibSQLFactoryStorage: unknown collection '${collection}' \u2014 register it via ensureCollections() first`
+      );
+    }
+    return schema;
+  }
+  #column(schema, column) {
+    const spec = schema.columns[column];
+    if (!spec) {
+      throw new Error(`LibSQLFactoryStorage: unknown column '${column}' on collection '${schema.name}'`);
+    }
+    return spec;
+  }
+  #serialize(spec, value) {
+    if (value === null || value === void 0) return null;
+    switch (spec.type) {
+      case "timestamp":
+        return value instanceof Date ? value.toISOString() : String(value);
+      case "boolean":
+        return value ? 1 : 0;
+      case "json":
+        return JSON.stringify(value);
+      case "bigint":
+      case "integer":
+        return Number(value);
+      default:
+        return String(value);
+    }
+  }
+  #deserializeRow(schema, raw) {
+    const row = {};
+    for (const [name, spec] of Object.entries(schema.columns)) {
+      const value = raw[name];
+      if (value === null || value === void 0) {
+        row[name] = null;
+        continue;
+      }
+      switch (spec.type) {
+        case "timestamp":
+          row[name] = new Date(String(value));
+          break;
+        case "boolean":
+          row[name] = Number(value) === 1;
+          break;
+        case "json":
+          row[name] = JSON.parse(String(value));
+          break;
+        case "bigint":
+        case "integer":
+          row[name] = Number(value);
+          break;
+        default:
+          row[name] = String(value);
+      }
+    }
+    return row;
+  }
+  /** Builds `WHERE` SQL (without the keyword). `{}` yields a match-all clause. */
+  #buildWhere(schema, where) {
+    const clauses = [];
+    const args = [];
+    for (const [column, condition] of Object.entries(where)) {
+      const spec = this.#column(schema, column);
+      if (condition !== null && typeof condition === "object" && !(condition instanceof Date) && "in" in condition) {
+        if (condition.in.length === 0) {
+          clauses.push("1 = 0");
+          continue;
+        }
+        const nonNull = condition.in.filter((value) => value !== null);
+        const includesNull = nonNull.length !== condition.in.length;
+        const inClause = nonNull.length > 0 ? `"${column}" IN (${nonNull.map(() => "?").join(", ")})` : void 0;
+        clauses.push(
+          inClause && includesNull ? `(${inClause} OR "${column}" IS NULL)` : inClause ?? `"${column}" IS NULL`
+        );
+        args.push(...nonNull.map((value) => this.#serialize(spec, value)));
+      } else if (condition === null) {
+        clauses.push(`"${column}" IS NULL`);
+      } else {
+        clauses.push(`"${column}" = ?`);
+        args.push(this.#serialize(spec, condition));
+      }
+    }
+    return { sql: clauses.length > 0 ? clauses.join(" AND ") : "1 = 1", args };
+  }
+  /** Keyset condition: rows strictly after `cursor.values` in the `orderBy` order. */
+  #buildCursor(schema, orderBy, values) {
+    if (values.length !== orderBy.length) {
+      throw new Error(
+        `LibSQLFactoryStorage: cursor has ${values.length} values but orderBy has ${orderBy.length} columns`
+      );
+    }
+    const branches = [];
+    const args = [];
+    for (let i = 0; i < orderBy.length; i++) {
+      const parts = [];
+      for (let j = 0; j < i; j++) {
+        const [column2] = orderBy[j];
+        parts.push(`"${column2}" = ?`);
+        args.push(this.#serialize(this.#column(schema, column2), values[j]));
+      }
+      const [column, dir] = orderBy[i];
+      parts.push(`"${column}" ${dir === "desc" ? "<" : ">"} ?`);
+      args.push(this.#serialize(this.#column(schema, column), values[i]));
+      branches.push(`(${parts.join(" AND ")})`);
+    }
+    return { sql: `(${branches.join(" OR ")})`, args };
+  }
+  async #select(collection, where, opts) {
+    const schema = this.#schema(collection);
+    const filter = this.#buildWhere(schema, where);
+    let sql = `SELECT * FROM "${schema.name}" WHERE ${filter.sql}`;
+    const args = [...filter.args];
+    if (opts?.cursor) {
+      if (!opts.orderBy || opts.orderBy.length === 0) {
+        throw new Error("LibSQLFactoryStorage: cursor pagination requires orderBy");
+      }
+      const cursor = this.#buildCursor(schema, opts.orderBy, opts.cursor.values);
+      sql += ` AND ${cursor.sql}`;
+      args.push(...cursor.args);
+    }
+    if (opts?.orderBy && opts.orderBy.length > 0) {
+      const order = opts.orderBy.map(([column, dir]) => {
+        this.#column(schema, column);
+        return `"${column}" ${dir === "desc" ? "DESC" : "ASC"}`;
+      }).join(", ");
+      sql += ` ORDER BY ${order}`;
+    }
+    if (opts?.limit !== void 0) {
+      sql += ` LIMIT ?`;
+      args.push(opts.limit);
+    }
+    const result = await this.#client.execute({ sql, args });
+    return result.rows.map((raw) => this.#deserializeRow(schema, raw));
+  }
+  async findOne(collection, where) {
+    const rows = await this.#select(collection, where, { limit: 1 });
+    return rows[0] ?? null;
+  }
+  async findMany(collection, where, opts) {
+    return this.#select(collection, where, opts);
+  }
+  async insertOne(collection, row) {
+    const schema = this.#schema(collection);
+    const pk = primaryKeyOf(schema);
+    const values = { ...row };
+    if (schema.columns[pk].type === "uuid-pk" && values[pk] === void 0) {
+      values[pk] = crypto$1.randomUUID();
+    }
+    const columns = Object.keys(values).filter((column) => values[column] !== void 0);
+    for (const column of columns) this.#column(schema, column);
+    const sql = `INSERT INTO "${schema.name}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`;
+    const args = columns.map((column) => this.#serialize(this.#column(schema, column), values[column]));
+    try {
+      await this.#client.execute({ sql, args });
+    } catch (error) {
+      if (isUniqueViolation(error)) throw new storage.UniqueViolationError(collection, { cause: error });
+      throw error;
+    }
+    const inserted = await this.findOne(collection, { [pk]: values[pk] });
+    if (!inserted) throw new Error(`LibSQLFactoryStorage: failed to read back inserted row from '${collection}'`);
+    return inserted;
+  }
+  async upsertOne(collection, conflictKeys, row) {
+    const schema = this.#schema(collection);
+    const pk = primaryKeyOf(schema);
+    assertUpsertConflict(schema, conflictKeys, row);
+    const keyWhere = Object.fromEntries(conflictKeys.map((key) => [key, row[key]]));
+    let lastError;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const existing = await this.findOne(collection, keyWhere);
+      if (existing) {
+        const set = Object.fromEntries(
+          Object.entries(row).filter(
+            ([column, value]) => value !== void 0 && column !== pk && !conflictKeys.includes(column)
+          )
+        );
+        if (Object.keys(set).length > 0) {
+          await this.updateMany(collection, { [pk]: existing[pk] }, set);
+        }
+        const updated = await this.findOne(collection, { [pk]: existing[pk] });
+        if (!updated) continue;
+        return updated;
+      }
+      try {
+        return await this.insertOne(collection, row);
+      } catch (error) {
+        if (!(error instanceof storage.UniqueViolationError)) throw error;
+        lastError = error;
+      }
+    }
+    throw lastError ?? new Error(`LibSQLFactoryStorage: upsert into '${collection}' did not converge`);
+  }
+  async updateMany(collection, where, set) {
+    const schema = this.#schema(collection);
+    const columns = Object.keys(set).filter((column) => set[column] !== void 0);
+    if (columns.length === 0) return 0;
+    const filter = this.#buildWhere(schema, where);
+    const sql = `UPDATE "${schema.name}" SET ${columns.map((c) => `"${c}" = ?`).join(", ")} WHERE ${filter.sql}`;
+    const args = [...columns.map((column) => this.#serialize(this.#column(schema, column), set[column])), ...filter.args];
+    const result = await this.#client.execute({ sql, args });
+    return result.rowsAffected;
+  }
+  async deleteMany(collection, where) {
+    const schema = this.#schema(collection);
+    const filter = this.#buildWhere(schema, where);
+    const result = await this.#client.execute({
+      sql: `DELETE FROM "${schema.name}" WHERE ${filter.sql}`,
+      args: filter.args
+    });
+    return result.rowsAffected;
+  }
+  async updateAtomic(collection, where, fn) {
+    const schema = this.#schema(collection);
+    const pk = primaryKeyOf(schema);
+    return this.#writeMutex.run(async () => {
+      const row = await this.findOne(collection, where);
+      if (!row) return null;
+      const patch = await fn(row);
+      if (patch === null) return row;
+      const pkWhere = { [pk]: row[pk] };
+      await this.updateMany(collection, pkWhere, patch);
+      return this.findOne(collection, pkWhere);
+    });
+  }
+};
+var LibSQLFactoryStorage = class extends storage.FactoryStorage {
+  ops;
+  #client;
+  #config;
+  #schemas = /* @__PURE__ */ new Map();
+  #mastraStorage;
+  constructor(config) {
+    super();
+    this.#config = config;
+    const isLocalDb = config.url.startsWith("file:") || config.url.includes(":memory:");
+    this.#client = client.createClient({
+      url: config.url,
+      ...config.authToken ? { authToken: config.authToken } : {},
+      ...isLocalDb ? { timeout: DEFAULT_CONNECTION_TIMEOUT_MS } : {}
+    });
+    this.ops = new LibSQLFactoryStorageOps(this.#client, this.#schemas);
+  }
+  getMastraStorage() {
+    this.#mastraStorage ??= new LibSQLStore({
+      id: this.#config.id ?? "libsql-factory",
+      client: this.#client,
+      ...this.#config.retention ? { retention: this.#config.retention } : {}
+    });
+    return this.#mastraStorage;
+  }
+  async initStorage() {
+    await this.#client.execute("SELECT 1");
+  }
+  async withTransaction(fn) {
+    if (this.#config.url.includes(":memory:")) return fn(this.ops);
+    const transaction = await this.#client.transaction("write");
+    try {
+      const result = await fn(new LibSQLFactoryStorageOps(transaction, this.#schemas));
+      await transaction.commit();
+      return result;
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    } finally {
+      transaction.close();
+    }
+  }
+  async ensureCollections(schemas) {
+    for (const schema of schemas) {
+      await this.#ensureCollection(schema);
+      this.#schemas.set(schema.name, schema);
+    }
+  }
+  async close() {
+    this.#client.close();
+  }
+  authDatabase() {
+    return { dialect: "libsql", client: this.#client };
+  }
+  #columnDdl(name, spec) {
+    assertIdentifier("column", name);
+    let ddl = `"${name}" ${COLUMN_DDL[spec.type]}`;
+    if (spec.type === "uuid-pk" || spec.primaryKey) ddl += " PRIMARY KEY";
+    if (!spec.nullable && spec.type !== "uuid-pk" && !spec.primaryKey) ddl += " NOT NULL";
+    if (spec.default !== void 0) ddl += ` DEFAULT ${serializeDefault(spec.default)}`;
+    return ddl;
+  }
+  async #ensureCollection(schema) {
+    assertIdentifier("collection", schema.name);
+    primaryKeyOf(schema);
+    const columns = Object.entries(schema.columns).map(([name, spec]) => this.#columnDdl(name, spec));
+    await this.#client.execute(`CREATE TABLE IF NOT EXISTS "${schema.name}" (${columns.join(", ")})`);
+    const info = await this.#client.execute(`PRAGMA table_info("${schema.name}")`);
+    const existing = new Set(info.rows.map((row) => String(row.name)));
+    for (const [name, spec] of Object.entries(schema.columns)) {
+      if (existing.has(name)) continue;
+      await this.#client.execute(`ALTER TABLE "${schema.name}" ADD COLUMN ${this.#columnDdl(name, spec)}`);
+    }
+    for (const index of schema.uniqueIndexes ?? []) {
+      assertIdentifier("index", index.name);
+      index.columns.forEach((column) => assertIdentifier("column", column));
+      let where = "";
+      if (index.whereNotNull) {
+        assertIdentifier("column", index.whereNotNull);
+        where = ` WHERE "${index.whereNotNull}" IS NOT NULL`;
+      } else if (index.whereNull) {
+        assertIdentifier("column", index.whereNull);
+        where = ` WHERE "${index.whereNull}" IS NULL`;
+      }
+      await this.#client.execute(
+        `CREATE UNIQUE INDEX IF NOT EXISTS "${index.name}" ON "${schema.name}" (${index.columns.map((c) => `"${c}"`).join(", ")})${where}`
+      );
+    }
+    for (const index of schema.indexes ?? []) {
+      assertIdentifier("index", index.name);
+      index.columns.forEach((column) => assertIdentifier("column", column));
+      await this.#client.execute(
+        `CREATE INDEX IF NOT EXISTS "${index.name}" ON "${schema.name}" (${index.columns.map((c) => `"${c}"`).join(", ")})`
+      );
+    }
+  }
+};
 
 // src/storage/index.ts
 var DEFAULT_LOCAL_CACHE_SIZE = -16e3;
@@ -13640,6 +14038,7 @@ exports.ExperimentsLibSQL = ExperimentsLibSQL;
 exports.FavoritesLibSQL = FavoritesLibSQL;
 exports.HarnessLibSQL = HarnessLibSQL;
 exports.LIBSQL_PROMPT = LIBSQL_PROMPT;
+exports.LibSQLFactoryStorage = LibSQLFactoryStorage;
 exports.LibSQLStore = LibSQLStore;
 exports.LibSQLVector = LibSQLVector;
 exports.MCPClientsLibSQL = MCPClientsLibSQL;