@mastra/libsql 1.22.4-alpha.1 → 1.22.5-alpha.0

package/dist/index.js

@@ -11,6 +11,84 @@ import { randomUUID } from "crypto";
 import { MessageList } from "@mastra/core/agent";
 import { saveScorePayloadSchema } from "@mastra/core/evals";
 import { skillSnapshotFieldValuesEqual } from "@mastra/core/storage/domains/skills";
+//#region src/shared/single-connection-client.ts
+/**
+* Whether `@libsql/client` backs this database with exactly one connection.
+*
+* An in-memory database exists only on the connection that opened it, and each
+* embedded-replica connection carries its own sync state, so `@libsql/client`
+* (>= 0.18.0) gives both a pool of one. Any `execute`/`batch` issued while an
+* interactive `transaction()` holds that connection is rejected immediately
+* with `TRANSACTION_ACTIVE` instead of waiting for the transaction to settle.
+*/
+function isSingleConnectionDatabase({ url, syncUrl }) {
+	return url.includes(":memory:") || Boolean(syncUrl);
+}
+/**
+* Wraps a single-connection client so client calls queue behind open
+* transactions rather than failing with `TRANSACTION_ACTIVE`.
+*
+* `transaction()` takes the gate and releases it when the transaction commits,
+* rolls back, or closes. `execute`, `batch`, `executeMultiple`, and `migrate`
+* wait for the gate to be free before running but do not hold it — the driver
+* executes them synchronously on the connection, so they cannot interleave
+* with each other. Every other member passes through untouched.
+*
+* Callers must not issue client calls from inside their own open transaction
+* (use `tx.execute`); such a call would wait for the transaction it is part of.
+*/
+function gateSingleConnectionClient(client) {
+	let gate = Promise.resolve();
+	const waitForGate = (run) => gate.then(run, run);
+	const transaction = async (mode) => {
+		let release;
+		const held = new Promise((resolve) => {
+			release = resolve;
+		});
+		const previous = gate;
+		gate = previous.then(() => held, () => held);
+		await previous.then(() => void 0, () => void 0);
+		let tx;
+		try {
+			tx = await client.transaction(mode);
+		} catch (error) {
+			release();
+			throw error;
+		}
+		return new Proxy(tx, { get(target, prop) {
+			if (prop === "commit" || prop === "rollback") return async () => {
+				try {
+					await target[prop].call(target);
+				} finally {
+					release();
+				}
+			};
+			if (prop === "close") return () => {
+				try {
+					target.close();
+				} finally {
+					release();
+				}
+			};
+			const value = Reflect.get(target, prop);
+			return typeof value === "function" ? value.bind(target) : value;
+		} });
+	};
+	return new Proxy(client, { get(target, prop) {
+		switch (prop) {
+			case "transaction": return transaction;
+			case "execute":
+			case "batch":
+			case "executeMultiple":
+			case "migrate": return (...args) => waitForGate(() => target[prop].apply(target, args));
+			default: {
+				const value = Reflect.get(target, prop);
+				return typeof value === "function" ? value.bind(target) : value;
+			}
+		}
+	} });
+}
+//#endregion
 //#region src/vector/filter.ts
 /**
 * Translates MongoDB-style filters to LibSQL compatible filters.
@@ -426,13 +504,17 @@ var LibSQLVector = class extends MastraVector {
 		this.isMemoryDb = url.includes(":memory:");
 		const isLocalDb = (url.startsWith("file:") || this.isMemoryDb) && !syncUrl;
 		const cwd = process.cwd();
-		this.turso = createClient({
+		const client = createClient({
 			url,
 			syncUrl,
 			authToken,
 			syncInterval,
 			...isLocalDb ? { timeout: 5e3 } : {}
 		});
+		this.turso = isSingleConnectionDatabase({
+			url,
+			syncUrl
+		}) ? gateSingleConnectionClient(client) : client;
 		this.maxRetries = maxRetries;
 		this.initialBackoffMs = initialBackoffMs;
 		if (!Number.isInteger(vectorTopKOverFetchMultiplier) || vectorTopKOverFetchMultiplier < 1) throw new Error("vectorTopKOverFetchMultiplier must be a positive integer");
@@ -1279,24 +1361,26 @@ function transformFromSqlRow({ tableName, sqlRow }) {
 /**
 * Per-client write serialization.
 *
-* `@libsql/client` backs a local (`file:`/`:memory:`) database with a single
-* underlying connection. An interactive `client.transaction('write')` issues a
-* `BEGIN` and then yields to the event loop on every `await tx.execute(...)`.
-* Any autocommit write (`client.execute`/`client.batch`) issued on the same
-* client during that window runs on the same connection — so it is swept into
-* the still-open transaction and is committed or rolled back with it, instead
-* of as its own statement. Two concurrent interactive transactions collide the
-* same way ("cannot start a transaction within a transaction").
+* `@libsql/client` >= 0.18.0 pools connections for local `file:` databases, but
+* SQLite still admits one writer at a time: an interactive
+* `client.transaction('write')` holds `BEGIN` open across every
+* `await tx.execute(...)`, and any other write on the same database in that
+* window contends on the file lock and can fail with `SQLITE_BUSY` once
+* `busy_timeout` expires.
 *
 * This is dormant under the default engine but the evented engine runs many
 * concurrent workflow snapshot writes per agent run, so a write issued by an
-* unrelated domain (e.g. creating a dataset experiment) can silently vanish.
+* unrelated domain (e.g. creating a dataset experiment) can fail spuriously.
 *
 * Serializing every write on a given client closes that window: writes — both
 * autocommit statements and full interactive transactions — run one at a time,
 * so none can interleave with an open transaction. Reads are intentionally not
 * gated; WAL readers never observe a partial write and must not queue behind a
 * long-running writer.
+*
+* `:memory:` databases and embedded replicas get a single pooled connection
+* instead; see `shared/single-connection-client.ts`, which gates *all* calls
+* (reads included) behind open transactions for those clients.
 */
 const clientWriteChains = /* @__PURE__ */ new WeakMap();
 /**
@@ -14221,11 +14305,12 @@ var LibSQLFactoryStorage = class extends FactoryStorage {
 		super();
 		this.#config = config;
 		const isLocalDb = config.url.startsWith("file:") || config.url.includes(":memory:");
-		this.#client = createClient({
+		const client = createClient({
 			url: config.url,
 			...config.authToken ? { authToken: config.authToken } : {},
 			...isLocalDb ? { timeout: DEFAULT_CONNECTION_TIMEOUT_MS } : {}
 		});
+		this.#client = isSingleConnectionDatabase(config) ? gateSingleConnectionClient(client) : client;
 		this.ops = new LibSQLFactoryStorageOps(this.#client, this.#schemas, (fn) => withClientWriteLock(this.#client, fn));
 	}
 	getMastraStorage() {
@@ -14383,15 +14468,15 @@ var LibSQLStore = class extends MastraCompositeStore {
 			mmapSize: config.localPragmas?.mmapSize ?? DEFAULT_LOCAL_MMAP_SIZE
 		};
 		if ("url" in config) {
-			if (config.url.includes(":memory:")) this.shouldCacheInit = false;
 			this.isLocalDb = (config.url.startsWith("file:") || config.url.includes(":memory:")) && !config.syncUrl;
-			this.client = createClient({
+			const client = createClient({
 				url: config.url,
 				...config.authToken ? { authToken: config.authToken } : {},
 				...config.syncUrl ? { syncUrl: config.syncUrl } : {},
 				...config.syncInterval !== void 0 ? { syncInterval: config.syncInterval } : {},
 				...this.isLocalDb ? { timeout: this.connectionTimeoutMs } : {}
 			});
+			this.client = isSingleConnectionDatabase(config) ? gateSingleConnectionClient(client) : client;
 			this.pragmasReady = this.isLocalDb ? this.applyLocalPragmas() : Promise.resolve();
 		} else {
 			this.client = config.client;