@mastra/libsql 1.20.0 → 1.21.0-alpha.1

package/dist/index.cjs

@@ -269,7 +269,7 @@ const FILTER_OPERATORS = {
 			transformValue: () => {
 				if (Array.isArray(value)) return [JSON.stringify(value)];
 				if (typeof value === "object" && value !== null) return [JSON.stringify(value)];
-				if (typeof value === "string") return [escapeLikePattern(value)];
+				if (typeof value === "string") return [escapeLikePattern$1(value)];
 				return [value];
 			}
 		};
@@ -286,7 +286,7 @@ const parseJsonPathKey = (key) => {
 const getJsonPath = (key) => {
 	return `'$.${parseJsonPathKey(key)}'`;
 };
-function escapeLikePattern(str) {
+function escapeLikePattern$1(str) {
 	return str.replace(/([%_\\])/g, "\\$1");
 }
 function buildFilterQuery(filter) {
@@ -2021,6 +2021,7 @@ var AgentsLibSQL = class extends _mastra_core_storage.AgentsStorage {
 				"workspace",
 				"skills",
 				"skillsFormat",
+				"durable",
 				"browser",
 				"toolProviders"
 			]
@@ -2456,6 +2457,7 @@ var AgentsLibSQL = class extends _mastra_core_storage.AgentsStorage {
 					workspace: input.workspace ?? null,
 					skills: input.skills ?? null,
 					skillsFormat: input.skillsFormat ?? null,
+					durable: input.durable ?? null,
 					browser: input.browser ?? null,
 					changedFields: input.changedFields ?? null,
 					changeMessage: input.changeMessage ?? null,
@@ -2691,6 +2693,7 @@ var AgentsLibSQL = class extends _mastra_core_storage.AgentsStorage {
 			workspace: this.parseJson(row.workspace, "workspace"),
 			skills: this.parseJson(row.skills, "skills"),
 			skillsFormat: row.skillsFormat,
+			durable: this.parseJson(row.durable, "durable"),
 			browser: this.parseJson(row.browser, "browser"),
 			changedFields: this.parseJson(row.changedFields, "changedFields"),
 			changeMessage: row.changeMessage,
@@ -2854,7 +2857,7 @@ function serializeJson(v) {
 	if (typeof v === "object" && v != null) return JSON.stringify(v);
 	return v ?? null;
 }
-function parseJson$3(val) {
+function parseJson$4(val) {
 	if (val == null) return void 0;
 	if (typeof val === "string") try {
 		return JSON.parse(val);
@@ -2869,14 +2872,14 @@ function rowToTask(row) {
 		status: String(row.status),
 		toolName: String(row.tool_name),
 		toolCallId: String(row.tool_call_id),
-		args: parseJson$3(row.args) ?? {},
+		args: parseJson$4(row.args) ?? {},
 		agentId: String(row.agent_id),
 		threadId: row.thread_id != null ? String(row.thread_id) : void 0,
 		resourceId: row.resource_id != null ? String(row.resource_id) : void 0,
 		runId: String(row.run_id),
-		result: parseJson$3(row.result),
-		error: parseJson$3(row.error),
-		suspendPayload: parseJson$3(row.suspend_payload),
+		result: parseJson$4(row.result),
+		error: parseJson$4(row.error),
+		suspendPayload: parseJson$4(row.suspend_payload),
 		retryCount: Number(row.retry_count),
 		maxRetries: Number(row.max_retries),
 		timeoutMs: Number(row.timeout_ms),
@@ -5537,10 +5540,10 @@ var FavoritesLibSQL = class extends _mastra_core_storage.FavoritesStorage {
 };
 //#endregion
 //#region src/storage/domains/harness/index.ts
-const toDate = (value) => new Date(value);
+const toDate$1 = (value) => new Date(value);
 const toOptionalDate = (value) => {
 	if (value == null) return void 0;
-	return toDate(value);
+	return toDate$1(value);
 };
 function cloneJson(value) {
 	return value === void 0 ? void 0 : structuredClone(value);
@@ -5551,8 +5554,8 @@ function hydratePendingItem(item) {
 		kind: item.kind,
 		status: item.status,
 		sessionId: item.sessionId,
-		createdAt: toDate(item.createdAt),
-		updatedAt: toDate(item.updatedAt)
+		createdAt: toDate$1(item.createdAt),
+		updatedAt: toDate$1(item.updatedAt)
 	};
 	if (item.runId !== void 0) record.runId = item.runId;
 	if (item.traceId !== void 0) record.traceId = item.traceId;
@@ -5570,8 +5573,8 @@ function rowToSession(row) {
 		origin: row.origin,
 		modeId: row.modeId,
 		modelId: row.modelId,
-		createdAt: toDate(row.createdAt),
-		lastActivityAt: toDate(row.lastActivityAt)
+		createdAt: toDate$1(row.createdAt),
+		lastActivityAt: toDate$1(row.lastActivityAt)
 	};
 	if (row.parentSessionId != null) record.parentSessionId = row.parentSessionId;
 	if (row.subagentDepth != null) record.subagentDepth = row.subagentDepth;
@@ -5681,6 +5684,841 @@ var HarnessLibSQL = class HarnessLibSQL extends _mastra_core_storage.HarnessStor
 	}
 };
 //#endregion
+//#region src/storage/domains/knowledge/index.ts
+const visibleSql = `(scopeKey = ? OR substr(?, 1, length(scopeKey) + 1) = scopeKey || char(31))`;
+function parseJson$3(value) {
+	if (typeof value === "string") return JSON.parse(value);
+	if (value instanceof Uint8Array) return JSON.parse(new TextDecoder().decode(value));
+	if (value instanceof ArrayBuffer) return JSON.parse(new TextDecoder().decode(value));
+	return value;
+}
+function toDate(value) {
+	return new Date(String(value));
+}
+function optionalDate(value) {
+	return value == null ? void 0 : toDate(value);
+}
+function canonicalName(name) {
+	return name.trim().toLocaleLowerCase();
+}
+function escapeLikePattern(value) {
+	return value.replaceAll("=", "==").replaceAll("%", "=%").replaceAll("_", "=_");
+}
+function nodeReferenceId(node) {
+	return typeof node === "string" ? node : node.id;
+}
+function parseNode(row) {
+	return {
+		id: String(row.id),
+		type: "node",
+		name: String(row.name),
+		kind: row.kind == null ? "" : String(row.kind),
+		content: row.content == null ? void 0 : String(row.content),
+		scope: parseJson$3(row.scopeJson ?? row.scope),
+		version: Number(row.version),
+		mergedInto: row.mergedInto == null ? void 0 : String(row.mergedInto),
+		createdAt: toDate(row.createdAt),
+		updatedAt: toDate(row.updatedAt)
+	};
+}
+function parseKnowledge(row) {
+	return {
+		id: String(row.id),
+		node: String(row.node),
+		text: String(row.text),
+		scope: parseJson$3(row.scopeJson ?? row.scope),
+		sourceThreadId: String(row.sourceThreadId),
+		capturedAt: toDate(row.capturedAt),
+		when: optionalDate(row.when),
+		maxScope: row.maxScope == null ? void 0 : String(row.maxScope),
+		metadata: (row.metadataJson ?? row.metadata) == null ? void 0 : parseJson$3(row.metadataJson ?? row.metadata),
+		deletedAt: optionalDate(row.deletedAt),
+		deletedBy: row.deletedBy == null ? void 0 : String(row.deletedBy)
+	};
+}
+function parseOutbox(row) {
+	return {
+		id: String(row.id),
+		idempotencyKey: String(row.idempotencyKey),
+		documentId: String(row.documentId),
+		documentType: String(row.documentType),
+		operation: String(row.operation),
+		scope: parseJson$3(row.scopeJson ?? row.scope),
+		status: String(row.status),
+		attempts: Number(row.attempts),
+		availableAt: toDate(row.availableAt),
+		claimedAt: optionalDate(row.claimedAt),
+		claimedBy: row.claimedBy == null ? void 0 : String(row.claimedBy),
+		createdAt: toDate(row.createdAt),
+		completedAt: optionalDate(row.completedAt)
+	};
+}
+var KnowledgeLibSQL = class extends _mastra_core_storage.KnowledgeStorage {
+	#client;
+	#db;
+	constructor(config) {
+		super();
+		this.#client = resolveClient(config);
+		this.#db = new LibSQLDB({
+			client: this.#client,
+			maxRetries: config.maxRetries,
+			initialBackoffMs: config.initialBackoffMs
+		});
+	}
+	async init() {
+		await this.#db.createTable({
+			tableName: _mastra_core_storage.TABLE_KNOWLEDGE_NODES,
+			schema: _mastra_core_storage.KNOWLEDGE_NODES_SCHEMA
+		});
+		await this.#db.createTable({
+			tableName: _mastra_core_storage.TABLE_KNOWLEDGE_RECORDS,
+			schema: _mastra_core_storage.KNOWLEDGE_RECORDS_SCHEMA
+		});
+		await this.#db.createTable({
+			tableName: _mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS,
+			schema: _mastra_core_storage.KNOWLEDGE_MENTIONS_SCHEMA,
+			compositePrimaryKey: [
+				"sourceType",
+				"sourceId",
+				"recordId"
+			]
+		});
+		await this.#db.createTable({
+			tableName: _mastra_core_storage.TABLE_KNOWLEDGE_CURSORS,
+			schema: _mastra_core_storage.KNOWLEDGE_CURSORS_SCHEMA,
+			compositePrimaryKey: ["sourceThreadId", "agent"]
+		});
+		await this.#db.createTable({
+			tableName: _mastra_core_storage.TABLE_KNOWLEDGE_ACTIVITY,
+			schema: _mastra_core_storage.KNOWLEDGE_ACTIVITY_SCHEMA
+		});
+		await this.#db.createTable({
+			tableName: _mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX,
+			schema: _mastra_core_storage.KNOWLEDGE_SEMANTIC_OUTBOX_SCHEMA
+		});
+		await this.#client.batch([
+			{
+				sql: `CREATE UNIQUE INDEX IF NOT EXISTS idx_knowledge_nodes_identity ON "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" (type, scopeKey, canonicalName)`,
+				args: []
+			},
+			{
+				sql: `CREATE INDEX IF NOT EXISTS idx_knowledge_nodes_scope ON "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" (scopeKey, type)`,
+				args: []
+			},
+			{
+				sql: `CREATE INDEX IF NOT EXISTS idx_knowledge_records_node_latest ON "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" (node, id DESC)`,
+				args: []
+			},
+			{
+				sql: `CREATE INDEX IF NOT EXISTS idx_knowledge_records_thread_latest ON "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" (sourceThreadId, id DESC)`,
+				args: []
+			},
+			{
+				sql: `CREATE INDEX IF NOT EXISTS idx_knowledge_mentions_record ON "${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}" (recordId, sourceType, sourceId)`,
+				args: []
+			},
+			{
+				sql: `CREATE INDEX IF NOT EXISTS idx_knowledge_activity_latest ON "${_mastra_core_storage.TABLE_KNOWLEDGE_ACTIVITY}" (id DESC)`,
+				args: []
+			},
+			{
+				sql: `CREATE UNIQUE INDEX IF NOT EXISTS idx_knowledge_outbox_idempotency ON "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" (idempotencyKey)`,
+				args: []
+			},
+			{
+				sql: `CREATE INDEX IF NOT EXISTS idx_knowledge_outbox_claim ON "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" (status, availableAt, createdAt)`,
+				args: []
+			}
+		], "write");
+	}
+	async dangerouslyClearAll() {
+		await this.#transaction(async (tx) => {
+			for (const table of [
+				_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS,
+				_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS,
+				_mastra_core_storage.TABLE_KNOWLEDGE_NODES,
+				_mastra_core_storage.TABLE_KNOWLEDGE_CURSORS,
+				_mastra_core_storage.TABLE_KNOWLEDGE_ACTIVITY,
+				_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX
+			]) await tx.execute(`DELETE FROM "${table}"`);
+		});
+	}
+	async createNode(input) {
+		const scope = (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope);
+		return this.#transaction(async (tx) => {
+			const existing = await this.#getNodeByName(tx, input.name, scope);
+			if (existing) {
+				const terminal = await this.#resolveTerminalNode(tx, existing.id);
+				if (!(0, _mastra_core_storage.isKnowledgeScopeVisible)(terminal.scope, scope)) throw new Error(`Merged knowledge node is not visible from scope: ${input.name}`);
+				return terminal;
+			}
+			const now = /* @__PURE__ */ new Date();
+			const node = {
+				id: input.id ?? crypto.randomUUID(),
+				type: "node",
+				name: input.name.trim(),
+				kind: input.kind,
+				content: input.content,
+				scope,
+				version: 1,
+				createdAt: now,
+				updatedAt: now
+			};
+			await tx.execute({
+				sql: `INSERT INTO "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" (id,type,name,canonicalName,kind,content,scope,scopeKey,version,mergedInto,createdAt,updatedAt) VALUES (?,?,?,?,?,?,jsonb(?),?,?,NULL,?,?)`,
+				args: [
+					node.id,
+					"node",
+					node.name,
+					canonicalName(node.name),
+					node.kind,
+					node.content ?? null,
+					JSON.stringify(scope),
+					(0, _mastra_core_storage.knowledgeScopeKey)(scope),
+					node.version,
+					now.toISOString(),
+					now.toISOString()
+				]
+			});
+			await this.#replaceMentions(tx, "node", node.id, node.content ?? "", input.resolutionScope ?? scope, scope);
+			await this.#activity(tx, "node-created", "node", node.id, scope);
+			await this.#outbox(tx, "node", node.id, "upsert", node.version, scope);
+			return node;
+		});
+	}
+	async getNode(id) {
+		return this.#getNode(this.#client, id);
+	}
+	async getNodeByName(input) {
+		return this.#getNodeByName(this.#client, input.name, (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope));
+	}
+	async resolveNode(input) {
+		return this.#resolveNode(this.#client, input.name, (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope));
+	}
+	async listNodes(input) {
+		const key = (0, _mastra_core_storage.knowledgeScopeKey)((0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope));
+		const clauses = [
+			`type = 'node'`,
+			"mergedInto IS NULL",
+			visibleSql
+		];
+		const args = [key, key];
+		if (input.namePrefix) {
+			clauses.push("canonicalName LIKE ? ESCAPE '='");
+			args.push(`${escapeLikePattern(canonicalName(input.namePrefix))}%`);
+		}
+		if (input.kind) {
+			clauses.push("kind = ?");
+			args.push(input.kind);
+		}
+		if (input.hasContent !== void 0) clauses.push(input.hasContent ? "content IS NOT NULL AND content <> ''" : "(content IS NULL OR content = '')");
+		if (input.cursor) {
+			const cursor = (0, _mastra_core_storage.parseKnowledgeNodeCursor)(input.cursor, {
+				namePrefix: input.namePrefix,
+				kind: input.kind,
+				hasContent: input.hasContent
+			});
+			clauses.push("(updatedAt < ? OR (updatedAt = ? AND (name > ? OR (name = ? AND id > ?))))");
+			const updatedAt = cursor.updatedAt.toISOString();
+			args.push(updatedAt, updatedAt, cursor.name, cursor.name, cursor.id);
+		}
+		args.push(input.limit ?? 100);
+		return (await this.#client.execute({
+			sql: `SELECT *, json(scope) AS scopeJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" WHERE ${clauses.join(" AND ")} ORDER BY updatedAt DESC, name ASC, id ASC LIMIT ?`,
+			args
+		})).rows.map(parseNode);
+	}
+	async updateNode(input) {
+		return this.#transaction(async (tx) => {
+			const existing = await this.#getNode(tx, input.id);
+			if (!existing) throw new _mastra_core_storage.KnowledgeNotFoundError("node", input.id);
+			if (existing.mergedInto) throw new Error(`Cannot update merged knowledge node: ${input.id}`);
+			const scope = (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope ?? existing.scope);
+			const name = (input.name ?? existing.name).trim();
+			const content = input.content ?? existing.content;
+			const now = /* @__PURE__ */ new Date();
+			if ((await tx.execute({
+				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" SET name=?,canonicalName=?,kind=?,content=?,scope=jsonb(?),scopeKey=?,version=version+1,updatedAt=? WHERE id=? AND type='node' AND version=?`,
+				args: [
+					name,
+					canonicalName(name),
+					input.kind ?? existing.kind,
+					content ?? null,
+					JSON.stringify(scope),
+					(0, _mastra_core_storage.knowledgeScopeKey)(scope),
+					now.toISOString(),
+					input.id,
+					input.version
+				]
+			})).rowsAffected === 0) throw new _mastra_core_storage.KnowledgeConflictError(input.id);
+			if (input.content !== void 0 || input.name !== void 0 || input.scope !== void 0) await this.#replaceMentions(tx, "node", input.id, content ?? "", input.resolutionScope ?? scope, scope);
+			await this.#activity(tx, "node-updated", "node", input.id, scope);
+			if ((0, _mastra_core_storage.knowledgeScopeKey)(existing.scope) !== (0, _mastra_core_storage.knowledgeScopeKey)(scope)) {
+				await this.#outbox(tx, "node", input.id, "delete", (0, _mastra_core_storage.createKnowledgeUlid)(), existing.scope);
+				const knowledge = await tx.execute({
+					sql: `SELECT id,json(scope) AS scopeJson,deletedAt FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" WHERE node=?`,
+					args: [input.id]
+				});
+				for (const row of knowledge.rows) {
+					const recordScope = parseJson$3(row.scopeJson);
+					await this.#outbox(tx, "record", String(row.id), "delete", (0, _mastra_core_storage.createKnowledgeUlid)(), recordScope);
+					if (row.deletedAt == null) await this.#outbox(tx, "record", String(row.id), "upsert", (0, _mastra_core_storage.createKnowledgeUlid)(), recordScope);
+				}
+			}
+			await this.#outbox(tx, "node", input.id, "upsert", input.version + 1, scope);
+			return {
+				...existing,
+				name,
+				kind: input.kind ?? existing.kind,
+				content,
+				scope,
+				version: input.version + 1,
+				updatedAt: now
+			};
+		});
+	}
+	async mergeNodes(input) {
+		if (input.sourceId === input.targetId) throw new Error("Cannot merge a knowledge node into itself");
+		return this.#transaction(async (tx) => {
+			const source = await this.#getNode(tx, input.sourceId);
+			if (!source) throw new _mastra_core_storage.KnowledgeNotFoundError("node", input.sourceId);
+			const target = await this.#resolveTerminalNode(tx, input.targetId);
+			if (!target) throw new _mastra_core_storage.KnowledgeNotFoundError("node", input.targetId);
+			if (target.id === source.id) throw new Error("Cannot create a knowledge merge cycle");
+			if (!(0, _mastra_core_storage.isKnowledgeScopeVisible)(target.scope, source.scope)) throw new Error("Cannot merge a knowledge node into a target that is narrower than its source scope");
+			const affected = await tx.execute({
+				sql: `SELECT DISTINCT m.sourceType,m.sourceId,json(COALESCE(f.scope,r.scope)) AS scopeJson,CASE WHEN f.deletedAt IS NULL THEN 0 ELSE 1 END AS deleted FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}" m LEFT JOIN "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" f ON m.sourceType='record' AND f.id=m.sourceId LEFT JOIN "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" r ON m.sourceType='node' AND r.id=m.sourceId WHERE m.recordId=?`,
+				args: [source.id]
+			});
+			const movedKnowledge = await tx.execute({
+				sql: `SELECT id,json(scope) AS scopeJson,deletedAt FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" WHERE node=?`,
+				args: [source.id]
+			});
+			if ((await tx.execute({
+				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" SET mergedInto=?,version=version+1,updatedAt=? WHERE id=? AND type='node' AND version=? AND mergedInto IS NULL`,
+				args: [
+					target.id,
+					(/* @__PURE__ */ new Date()).toISOString(),
+					source.id,
+					input.sourceVersion
+				]
+			})).rowsAffected === 0) throw new _mastra_core_storage.KnowledgeConflictError(source.id);
+			await tx.execute({
+				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" SET node=? WHERE node=?`,
+				args: [target.id, source.id]
+			});
+			await tx.execute({
+				sql: `DELETE FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}" WHERE recordId=? AND EXISTS (SELECT 1 FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}" target WHERE target.sourceType="${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}".sourceType AND target.sourceId="${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}".sourceId AND target.recordId=?)`,
+				args: [source.id, target.id]
+			});
+			await tx.execute({
+				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}" SET recordId=? WHERE recordId=?`,
+				args: [target.id, source.id]
+			});
+			for (const row of movedKnowledge.rows) await this.#outbox(tx, "record", String(row.id), row.deletedAt == null ? "upsert" : "delete", (0, _mastra_core_storage.createKnowledgeUlid)(), parseJson$3(row.scopeJson));
+			for (const row of affected.rows) await this.#outbox(tx, String(row.sourceType), String(row.sourceId), Number(row.deleted) ? "delete" : "upsert", (0, _mastra_core_storage.createKnowledgeUlid)(), parseJson$3(row.scopeJson));
+			await this.#activity(tx, "node-merged", "node", source.id, source.scope);
+			await this.#outbox(tx, "node", source.id, "delete", input.sourceVersion + 1, source.scope);
+			await this.#outbox(tx, "node", target.id, "upsert", (0, _mastra_core_storage.createKnowledgeUlid)(), target.scope);
+			return target;
+		});
+	}
+	async appendKnowledge(input) {
+		const scope = (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope);
+		const resolutionScope = (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.resolutionScope);
+		const defaultScope = (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.defaultScope);
+		(0, _mastra_core_storage.assertKnowledgeScopeWithinCeiling)(scope, input.maxScope);
+		return this.#transaction(async (tx) => {
+			const node = nodeReferenceId(input.node);
+			const parent = await this.#resolveTerminalNode(tx, node);
+			if (!parent) throw new _mastra_core_storage.KnowledgeNotFoundError("node", node);
+			const record = {
+				id: input.id ?? (0, _mastra_core_storage.createKnowledgeUlid)(),
+				node: parent.id,
+				text: input.text,
+				scope,
+				sourceThreadId: input.sourceThreadId,
+				capturedAt: /* @__PURE__ */ new Date(),
+				when: input.when ? new Date(input.when) : void 0,
+				maxScope: input.maxScope,
+				metadata: input.metadata
+			};
+			await tx.execute({
+				sql: `INSERT INTO "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" (id,node,text,scope,scopeKey,sourceThreadId,capturedAt,"when",maxScope,metadata,deletedAt,deletedBy) VALUES (?,?,?,jsonb(?),?,?,?,?,?,jsonb(?),NULL,NULL)`,
+				args: [
+					record.id,
+					record.node,
+					record.text,
+					JSON.stringify(scope),
+					(0, _mastra_core_storage.knowledgeScopeKey)(scope),
+					record.sourceThreadId,
+					record.capturedAt.toISOString(),
+					record.when?.toISOString() ?? null,
+					record.maxScope ?? null,
+					record.metadata ? JSON.stringify(record.metadata) : null
+				]
+			});
+			await this.#replaceMentions(tx, "record", record.id, record.text, resolutionScope, defaultScope);
+			await this.#activity(tx, "record-created", "record", record.id, scope, record.sourceThreadId);
+			await this.#outbox(tx, "record", record.id, "upsert", record.id, scope);
+			return record;
+		});
+	}
+	async getKnowledge(input) {
+		const result = await this.#client.execute({
+			sql: `SELECT *,json(scope) AS scopeJson,json(metadata) AS metadataJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" WHERE id=?${input.includeDeleted ? "" : " AND deletedAt IS NULL"}`,
+			args: [input.id]
+		});
+		return result.rows[0] ? parseKnowledge(result.rows[0]) : null;
+	}
+	async listKnowledgeAbout(input) {
+		return this.#queryKnowledge(input, "about");
+	}
+	async listKnowledgeMentioning(input) {
+		return this.#queryKnowledge(input, "mentioning");
+	}
+	async listKnowledgeRelatedTo(input) {
+		return this.#queryKnowledge(input, "related");
+	}
+	async knowledgeBySource(input) {
+		const key = (0, _mastra_core_storage.knowledgeScopeKey)((0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope));
+		const args = [
+			input.sourceThreadId,
+			key,
+			key
+		];
+		if (input.after) args.push(input.after);
+		const limit = input.limit ?? 100;
+		args.push(limit + 1);
+		const records = (await this.#client.execute({
+			sql: `SELECT *,json(scope) AS scopeJson,json(metadata) AS metadataJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" WHERE sourceThreadId=? AND ${visibleSql}${input.includeDeleted ? "" : " AND deletedAt IS NULL"}${input.after ? " AND id > ?" : ""} ORDER BY id ASC LIMIT ?`,
+			args
+		})).rows.map(parseKnowledge);
+		return {
+			records: records.slice(0, limit),
+			nextCursor: records.length > limit ? records[limit - 1]?.id : void 0
+		};
+	}
+	async removeKnowledge(input) {
+		return this.#transaction(async (tx) => {
+			const record = await this.#getKnowledge(tx, input.id, true);
+			if (!record) throw new _mastra_core_storage.KnowledgeNotFoundError("record", input.id);
+			if (record.deletedAt) return record;
+			const deletedAt = /* @__PURE__ */ new Date();
+			await tx.execute({
+				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" SET deletedAt=?,deletedBy=? WHERE id=? AND deletedAt IS NULL`,
+				args: [
+					deletedAt.toISOString(),
+					input.deletedBy,
+					input.id
+				]
+			});
+			await this.#activity(tx, "record-deleted", "record", input.id, record.scope, record.sourceThreadId);
+			await this.#outbox(tx, "record", input.id, "delete", deletedAt.toISOString(), record.scope);
+			return {
+				...record,
+				deletedAt,
+				deletedBy: input.deletedBy
+			};
+		});
+	}
+	async restoreKnowledge(input) {
+		return this.#transaction(async (tx) => {
+			const record = await this.#getKnowledge(tx, input.id, true);
+			if (!record) throw new _mastra_core_storage.KnowledgeNotFoundError("record", input.id);
+			if (!record.deletedAt) return record;
+			await tx.execute({
+				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" SET deletedAt=NULL,deletedBy=NULL WHERE id=?`,
+				args: [input.id]
+			});
+			await this.#activity(tx, "record-restored", "record", input.id, record.scope, record.sourceThreadId);
+			await this.#outbox(tx, "record", input.id, "upsert", (0, _mastra_core_storage.createKnowledgeUlid)(), record.scope);
+			return {
+				...record,
+				deletedAt: void 0,
+				deletedBy: void 0
+			};
+		});
+	}
+	async rescopeKnowledge(input) {
+		const scope = (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope);
+		return this.#transaction(async (tx) => {
+			const record = await this.#getKnowledge(tx, input.id, true);
+			if (!record) throw new _mastra_core_storage.KnowledgeNotFoundError("record", input.id);
+			(0, _mastra_core_storage.assertKnowledgeScopeWithinCeiling)(scope, record.maxScope);
+			await tx.execute({
+				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" SET scope=jsonb(?),scopeKey=? WHERE id=?`,
+				args: [
+					JSON.stringify(scope),
+					(0, _mastra_core_storage.knowledgeScopeKey)(scope),
+					input.id
+				]
+			});
+			await this.#activity(tx, "record-rescoped", "record", input.id, scope, record.sourceThreadId);
+			if ((0, _mastra_core_storage.knowledgeScopeKey)(record.scope) !== (0, _mastra_core_storage.knowledgeScopeKey)(scope)) await this.#outbox(tx, "record", input.id, "delete", (0, _mastra_core_storage.createKnowledgeUlid)(), record.scope);
+			if (!record.deletedAt) await this.#outbox(tx, "record", input.id, "upsert", (0, _mastra_core_storage.createKnowledgeUlid)(), scope);
+			return {
+				...record,
+				scope
+			};
+		});
+	}
+	async raiseKnowledgeCeiling(input) {
+		return this.#transaction(async (tx) => {
+			const record = await this.#getKnowledge(tx, input.id, true);
+			if (!record) throw new _mastra_core_storage.KnowledgeNotFoundError("record", input.id);
+			(0, _mastra_core_storage.assertKnowledgeScopeWithinCeiling)(record.scope, input.maxScope);
+			(0, _mastra_core_storage.assertKnowledgeCeilingRaised)(record.maxScope, input.maxScope);
+			await tx.execute({
+				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" SET maxScope=? WHERE id=?`,
+				args: [input.maxScope ?? null, input.id]
+			});
+			return {
+				...record,
+				maxScope: input.maxScope
+			};
+		});
+	}
+	async search(input) {
+		const key = (0, _mastra_core_storage.knowledgeScopeKey)((0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope));
+		const normalizedQuery = input.query.trim().toLocaleLowerCase();
+		if (!normalizedQuery) return [];
+		const query = `%${escapeLikePattern(normalizedQuery)}%`;
+		const results = (await this.#client.execute({
+			sql: `SELECT *,json(scope) AS scopeJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" WHERE mergedInto IS NULL AND ${visibleSql} AND (canonicalName LIKE ? ESCAPE '=' OR lower(COALESCE(kind,'')) LIKE ? ESCAPE '=' OR lower(COALESCE(content,'')) LIKE ? ESCAPE '=') ORDER BY updatedAt DESC LIMIT ?`,
+			args: [
+				key,
+				key,
+				query,
+				query,
+				query,
+				input.limit ?? 20
+			]
+		})).rows.map((row) => ({
+			type: String(row.type),
+			id: String(row.id),
+			recordId: String(row.id),
+			name: String(row.name),
+			text: row.content ? `${String(row.name)}\n${String(row.content)}` : String(row.name),
+			scope: parseJson$3(row.scopeJson)
+		}));
+		if (results.length < (input.limit ?? 20)) {
+			const knowledge = await this.#client.execute({
+				sql: `SELECT k.*,json(k.scope) AS scopeJson,json(k.metadata) AS metadataJson,n.name FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" k JOIN "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" n ON n.id=k.node AND n.type='node' AND n.mergedInto IS NULL WHERE k.deletedAt IS NULL AND ${visibleSql.replaceAll("scopeKey", "k.scopeKey")} AND lower(k.text) LIKE ? ESCAPE '=' ORDER BY k.id DESC LIMIT ?`,
+				args: [
+					key,
+					key,
+					query,
+					(input.limit ?? 20) - results.length
+				]
+			});
+			results.push(...knowledge.rows.map((row) => ({
+				type: "record",
+				id: String(row.id),
+				recordId: String(row.node),
+				name: String(row.name),
+				text: String(row.text),
+				scope: parseJson$3(row.scopeJson)
+			})));
+		}
+		return results;
+	}
+	async getCurationCursor(input) {
+		const row = (await this.#client.execute({
+			sql: `SELECT * FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_CURSORS}" WHERE sourceThreadId=? AND agent=?`,
+			args: [input.sourceThreadId, input.agent]
+		})).rows[0];
+		return row ? {
+			sourceThreadId: String(row.sourceThreadId),
+			agent: String(row.agent),
+			lastKnowledgeId: String(row.lastKnowledgeId),
+			updatedAt: toDate(row.updatedAt)
+		} : null;
+	}
+	async advanceCurationCursor(input) {
+		const updatedAt = /* @__PURE__ */ new Date();
+		if ((await this.#db.executeWriteOperationWithRetry(() => withClientWriteLock(this.#client, () => this.#client.execute({
+			sql: `INSERT INTO "${_mastra_core_storage.TABLE_KNOWLEDGE_CURSORS}" (sourceThreadId,agent,lastKnowledgeId,updatedAt) VALUES (?,?,?,?) ON CONFLICT(sourceThreadId,agent) DO UPDATE SET lastKnowledgeId=excluded.lastKnowledgeId,updatedAt=excluded.updatedAt WHERE excluded.lastKnowledgeId >= "${_mastra_core_storage.TABLE_KNOWLEDGE_CURSORS}".lastKnowledgeId`,
+			args: [
+				input.sourceThreadId,
+				input.agent,
+				input.lastKnowledgeId,
+				updatedAt.toISOString()
+			]
+		})), "advance knowledge curation cursor")).rowsAffected === 0) throw new Error("Knowledge curation cursor cannot move backwards");
+		return {
+			...input,
+			updatedAt
+		};
+	}
+	async listActivity(input) {
+		const key = (0, _mastra_core_storage.knowledgeScopeKey)((0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope));
+		return (await this.#client.execute({
+			sql: `SELECT *,json(scope) AS scopeJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_ACTIVITY}" WHERE ${visibleSql}${input.after ? " AND id < ?" : ""} ORDER BY id DESC LIMIT ?`,
+			args: [
+				key,
+				key,
+				...input.after ? [input.after] : [],
+				input.limit ?? 100
+			]
+		})).rows.map((row) => ({
+			id: String(row.id),
+			action: String(row.action),
+			recordType: String(row.recordType),
+			recordId: String(row.recordId),
+			scope: parseJson$3(row.scopeJson),
+			sourceThreadId: row.sourceThreadId == null ? void 0 : String(row.sourceThreadId),
+			createdAt: toDate(row.createdAt)
+		}));
+	}
+	async listSemanticOutbox(input = {}) {
+		const clauses = [];
+		const args = [];
+		if (input.status) {
+			clauses.push("status=?");
+			args.push(input.status);
+		}
+		if (input.scope) {
+			const key = (0, _mastra_core_storage.knowledgeScopeKey)((0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope));
+			clauses.push(visibleSql);
+			args.push(key, key);
+		}
+		args.push(input.limit ?? 100);
+		return (await this.#client.execute({
+			sql: `SELECT *,json(scope) AS scopeJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}"${clauses.length ? ` WHERE ${clauses.join(" AND ")}` : ""} ORDER BY createdAt ASC,id ASC LIMIT ?`,
+			args
+		})).rows.map(parseOutbox);
+	}
+	async claimSemanticOutbox(input) {
+		const now = input.now ?? /* @__PURE__ */ new Date();
+		const stale = new Date(now.getTime() - (input.claimTimeoutMs ?? 6e4));
+		return this.#transaction(async (tx) => {
+			const clauses = [
+				`availableAt <= ?`,
+				`(status='pending' OR (status='processing' AND claimedAt <= ?))`,
+				`NOT EXISTS (SELECT 1 FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" AS earlier WHERE earlier.documentId = "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}".documentId AND earlier.status != 'completed' AND (earlier.createdAt < "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}".createdAt OR (earlier.createdAt = "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}".createdAt AND earlier.id < "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}".id)))`
+			];
+			const args = [now.toISOString(), stale.toISOString()];
+			if (input.scope) {
+				const key = (0, _mastra_core_storage.knowledgeScopeKey)((0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope));
+				clauses.push(visibleSql);
+				args.push(key, key);
+			}
+			args.push(input.limit ?? 100);
+			const ids = (await tx.execute({
+				sql: `SELECT id FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" WHERE ${clauses.join(" AND ")} ORDER BY createdAt ASC,id ASC LIMIT ?`,
+				args
+			})).rows.map((row) => String(row.id));
+			for (const id of ids) await tx.execute({
+				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" SET status='processing',attempts=attempts+1,claimedAt=?,claimedBy=? WHERE id=?`,
+				args: [
+					now.toISOString(),
+					input.workerId,
+					id
+				]
+			});
+			if (!ids.length) return [];
+			return (await tx.execute({
+				sql: `SELECT *,json(scope) AS scopeJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" WHERE id IN (${ids.map(() => "?").join(",")}) ORDER BY createdAt ASC,id ASC`,
+				args: ids
+			})).rows.map(parseOutbox);
+		});
+	}
+	async completeSemanticOutbox(input) {
+		if (!input.ids.length) return;
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		await this.#transaction(async (tx) => {
+			for (const id of input.ids) await tx.execute({
+				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" SET status='completed',completedAt=? WHERE id=? AND status='processing' AND claimedBy=?`,
+				args: [
+					now,
+					id,
+					input.workerId
+				]
+			});
+		});
+	}
+	async releaseSemanticOutbox(input) {
+		if (!input.ids.length) return;
+		await this.#transaction(async (tx) => {
+			for (const id of input.ids) await tx.execute({
+				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" SET status='pending',availableAt=?,claimedAt=NULL,claimedBy=NULL WHERE id=? AND status='processing' AND claimedBy=?`,
+				args: [
+					(input.retryAt ?? /* @__PURE__ */ new Date()).toISOString(),
+					id,
+					input.workerId
+				]
+			});
+		});
+	}
+	async #transaction(operation) {
+		return this.#db.executeWriteOperationWithRetry(() => withClientWriteLock(this.#client, async () => {
+			const tx = await this.#client.transaction("write");
+			try {
+				const result = await operation(tx);
+				await tx.commit();
+				return result;
+			} catch (error) {
+				if (!tx.closed) await tx.rollback();
+				throw error;
+			}
+		}), "write knowledge state");
+	}
+	async #getNode(executor, id) {
+		const result = await executor.execute({
+			sql: `SELECT *,json(scope) AS scopeJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" WHERE id=? AND type='node'`,
+			args: [id]
+		});
+		return result.rows[0] ? parseNode(result.rows[0]) : null;
+	}
+	async #getNodeByName(executor, name, scope) {
+		const result = await executor.execute({
+			sql: `SELECT *,json(scope) AS scopeJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" WHERE type='node' AND scopeKey=? AND canonicalName=?`,
+			args: [(0, _mastra_core_storage.knowledgeScopeKey)(scope), canonicalName(name)]
+		});
+		return result.rows[0] ? parseNode(result.rows[0]) : null;
+	}
+	async #resolveNode(executor, name, scope) {
+		for (let length = scope.length; length > 0; length--) {
+			const node = await this.#getNodeByName(executor, name, scope.slice(0, length));
+			if (node) {
+				const terminal = await this.#resolveTerminalNode(executor, node.id);
+				if (terminal && (0, _mastra_core_storage.isKnowledgeScopeVisible)(terminal.scope, scope)) return terminal;
+			}
+		}
+		return null;
+	}
+	async #resolveTerminalNode(executor, id) {
+		let node = await this.#getNode(executor, id);
+		const seen = /* @__PURE__ */ new Set();
+		while (node?.mergedInto) {
+			if (seen.has(node.id)) throw new Error(`Knowledge merge cycle detected at ${node.id}`);
+			seen.add(node.id);
+			node = await this.#getNode(executor, node.mergedInto);
+		}
+		return node;
+	}
+	async #getKnowledge(executor, id, includeDeleted) {
+		const result = await executor.execute({
+			sql: `SELECT *,json(scope) AS scopeJson,json(metadata) AS metadataJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" WHERE id=?${includeDeleted ? "" : " AND deletedAt IS NULL"}`,
+			args: [id]
+		});
+		return result.rows[0] ? parseKnowledge(result.rows[0]) : null;
+	}
+	async #queryKnowledge(input, relationship) {
+		const scope = (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope);
+		const node = await this.#resolveTerminalNode(this.#client, nodeReferenceId(input.node));
+		if (!node) return { records: [] };
+		const key = (0, _mastra_core_storage.knowledgeScopeKey)(scope);
+		const includesMentions = relationship !== "about";
+		const relationSql = relationship === "about" ? "k.node=?" : relationship === "mentioning" ? "m.recordId=?" : "(k.node=? OR m.recordId=?)";
+		const args = [
+			node.id,
+			...relationship === "related" ? [node.id] : [],
+			key,
+			key
+		];
+		if (input.after) args.push(input.after);
+		args.push((input.limit ?? 100) + 1);
+		const result = await this.#client.execute({
+			sql: `SELECT DISTINCT k.*,json(k.scope) AS scopeJson,json(k.metadata) AS metadataJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" k${includesMentions ? ` LEFT JOIN "${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}" m ON m.sourceType='record' AND m.sourceId=k.id` : ""} WHERE ${relationSql} AND ${visibleSql.replaceAll("scopeKey", "k.scopeKey")}${input.includeDeleted ? "" : " AND k.deletedAt IS NULL"}${input.after ? " AND k.id < ?" : ""} ORDER BY k.id DESC LIMIT ?`,
+			args
+		});
+		const limit = input.limit ?? 100;
+		const rows = result.rows.slice(0, limit);
+		return {
+			records: rows.map(parseKnowledge),
+			nextCursor: result.rows.length > limit ? String(rows.at(-1)?.id) : void 0
+		};
+	}
+	async #replaceMentions(tx, sourceType, sourceId, text, resolutionScope, defaultScope) {
+		await tx.execute({
+			sql: `DELETE FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}" WHERE sourceType=? AND sourceId=?`,
+			args: [sourceType, sourceId]
+		});
+		for (const name of (0, _mastra_core_storage.parseKnowledgeWikilinks)(text)) {
+			let node = await this.#resolveNode(tx, name, resolutionScope);
+			if (!node) {
+				node = await this.#getNodeByName(tx, name, defaultScope);
+				if (node) node = await this.#resolveTerminalNode(tx, node.id);
+				if (!node) {
+					const now = /* @__PURE__ */ new Date();
+					node = {
+						id: crypto.randomUUID(),
+						type: "node",
+						name,
+						kind: "node",
+						scope: defaultScope,
+						version: 1,
+						createdAt: now,
+						updatedAt: now
+					};
+					await tx.execute({
+						sql: `INSERT INTO "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" (id,type,name,canonicalName,kind,content,scope,scopeKey,version,mergedInto,createdAt,updatedAt) VALUES (?,?,?,?,?,NULL,jsonb(?),?,?,NULL,?,?)`,
+						args: [
+							node.id,
+							"node",
+							node.name,
+							canonicalName(node.name),
+							node.kind,
+							JSON.stringify(defaultScope),
+							(0, _mastra_core_storage.knowledgeScopeKey)(defaultScope),
+							1,
+							now.toISOString(),
+							now.toISOString()
+						]
+					});
+					await this.#activity(tx, "node-created", "node", node.id, defaultScope);
+					await this.#outbox(tx, "node", node.id, "upsert", 1, defaultScope);
+				}
+			}
+			await tx.execute({
+				sql: `INSERT OR IGNORE INTO "${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}" (sourceType,sourceId,recordId) VALUES (?,?,?)`,
+				args: [
+					sourceType,
+					sourceId,
+					node.id
+				]
+			});
+		}
+	}
+	async #activity(executor, action, recordType, recordId, scope, sourceThreadId) {
+		const now = /* @__PURE__ */ new Date();
+		await executor.execute({
+			sql: `INSERT INTO "${_mastra_core_storage.TABLE_KNOWLEDGE_ACTIVITY}" (id,action,recordType,recordId,scope,scopeKey,sourceThreadId,createdAt) VALUES (?,?,?,?,jsonb(?),?,?,?)`,
+			args: [
+				(0, _mastra_core_storage.createKnowledgeUlid)(),
+				action,
+				recordType,
+				recordId,
+				JSON.stringify(scope),
+				(0, _mastra_core_storage.knowledgeScopeKey)(scope),
+				sourceThreadId ?? null,
+				now.toISOString()
+			]
+		});
+	}
+	async #outbox(executor, documentType, id, operation, version, scope) {
+		const documentId = (0, _mastra_core_storage.knowledgeSemanticDocumentId)(documentType, id);
+		const idempotencyKey = (0, _mastra_core_storage.knowledgeSemanticIdempotencyKey)(documentId, operation, version);
+		const now = /* @__PURE__ */ new Date();
+		await executor.execute({
+			sql: `INSERT OR IGNORE INTO "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" (id,idempotencyKey,documentId,documentType,operation,scope,scopeKey,status,attempts,availableAt,claimedAt,claimedBy,createdAt,completedAt) VALUES (?,?,?,?,?,jsonb(?),?,'pending',0,?,NULL,NULL,?,NULL)`,
+			args: [
+				(0, _mastra_core_storage.createKnowledgeUlid)(),
+				idempotencyKey,
+				documentId,
+				documentType,
+				operation,
+				JSON.stringify(scope),
+				(0, _mastra_core_storage.knowledgeScopeKey)(scope),
+				now.toISOString(),
+				now.toISOString()
+			]
+		});
+	}
+};
+//#endregion
 //#region src/storage/domains/mcp-clients/index.ts
 var MCPClientsLibSQL = class extends _mastra_core_storage.MCPClientsStorage {
 	#db;
@@ -13206,6 +14044,7 @@ var LibSQLStore = class extends _mastra_core_storage.MastraCompositeStore {
 		const workflows = new WorkflowsLibSQL(domainConfig);
 		const workflowDefinitions = new WorkflowDefinitionsLibSQL(domainConfig);
 		const memory = new MemoryLibSQL(domainConfig);
+		const knowledge = new KnowledgeLibSQL(domainConfig);
 		const observability = new ObservabilityLibSQL(domainConfig);
 		const agents = new AgentsLibSQL(domainConfig);
 		const channels = new ChannelsLibSQL(domainConfig);
@@ -13230,6 +14069,7 @@ var LibSQLStore = class extends _mastra_core_storage.MastraCompositeStore {
 			workflows,
 			workflowDefinitions,
 			memory,
+			knowledge,
 			observability,
 			agents,
 			channels,
@@ -13427,6 +14267,7 @@ exports.LibSQLStore = LibSQLStore;
 exports.ExperimentsLibSQL = ExperimentsLibSQL;
 exports.FavoritesLibSQL = FavoritesLibSQL;
 exports.HarnessLibSQL = HarnessLibSQL;
+exports.KnowledgeLibSQL = KnowledgeLibSQL;
 exports.LIBSQL_PROMPT = LIBSQL_PROMPT;
 exports.LibSQLFactoryStorage = LibSQLFactoryStorage;
 exports.LibSQLVector = LibSQLVector;