@deepagents/context 7.1.2 → 7.1.4

package/dist/index.js

@@ -3299,7 +3299,10 @@ var SavePipeline = class _SavePipeline {
 };
 
 // packages/context/src/lib/store/sqlite.store.ts
-import { DatabaseSync } from "node:sqlite";
+import { transaction } from "@zukhruf/sqlite-transaction";
+import {
+  DatabaseSync
+} from "node:sqlite";
 import { z as z4 } from "zod";
 
 // packages/context/src/lib/store/columns.ts
@@ -3448,92 +3451,82 @@ function toMessage(row) {
     createdAt: row.createdAt
   };
 }
+var SearchQuerySyntaxError = class extends Error {
+  constructor(query, options) {
+    super(
+      `The search query ${JSON.stringify(query)} is not valid FTS5 syntax. Put a term that has characters such as - or : in double quotes: "well-known" finds the term well-known.`,
+      options
+    );
+    this.name = "SearchQuerySyntaxError";
+  }
+};
+function isFts5QueryError(error) {
+  return error instanceof Error && "errcode" in error && error.errcode === 1 && /^(fts5: syntax error near |no such column: |unterminated string$|unknown special query: |expected integer, got )/.test(
+    error.message
+  );
+}
 var SqliteContextStore = class extends ContextStore {
   #db;
-  #statements = /* @__PURE__ */ new Map();
-  /**
-   * Get or create a prepared statement.
-   * Statements are cached for the lifetime of the store to avoid
-   * repeated SQL parsing and compilation overhead.
-   */
-  #stmt(sql) {
-    let stmt = this.#statements.get(sql);
-    if (!stmt) {
-      stmt = this.#db.prepare(sql);
-      this.#statements.set(sql, stmt);
-    }
-    return stmt;
-  }
+  #sql;
   constructor(pathOrDb) {
     super();
     this.#db = typeof pathOrDb === "string" ? new DatabaseSync(pathOrDb) : pathOrDb;
     this.#db.exec(ddl_sqlite_default);
-  }
-  /**
-   * Execute a function within a transaction.
-   * Automatically commits on success or rolls back on error.
-   */
-  #useTransaction(fn, mode = "deferred") {
-    this.#db.exec(
-      mode === "immediate" ? "BEGIN IMMEDIATE" : "BEGIN TRANSACTION"
-    );
-    try {
-      const result = fn();
-      this.#db.exec("COMMIT");
-      return result;
-    } catch (error) {
-      try {
-        this.#db.exec("ROLLBACK");
-      } catch {
-      }
-      throw error;
-    }
+    this.#sql = this.#db.createTagStore();
   }
   // ==========================================================================
   // Chat Operations
   // ==========================================================================
   async createChat(chat2) {
-    return this.#useTransaction(() => {
-      const created = storedChat.parse(
-        this.#db.prepare(
-          `INSERT INTO chats (id, userId, title, metadata)
+    return transaction(
+      this.#db,
+      () => {
+        const created = storedChat.parse(
+          this.#db.prepare(
+            `INSERT INTO chats (id, userId, title, metadata)
            VALUES (?, ?, ?, ?)
            RETURNING *`
-        ).get(
-          chat2.id,
-          chat2.userId,
-          chat2.title ?? null,
-          chat2.metadata ? JSON.stringify(chat2.metadata) : null
-        )
-      );
-      this.#db.prepare(
-        `INSERT INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
+          ).get(
+            chat2.id,
+            chat2.userId,
+            chat2.title ?? null,
+            chat2.metadata ? JSON.stringify(chat2.metadata) : null
+          )
+        );
+        this.#db.prepare(
+          `INSERT INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
            VALUES (?, ?, 'main', NULL, 1, ?)`
-      ).run(crypto.randomUUID(), chat2.id, Date.now());
-      return created;
-    });
+        ).run(crypto.randomUUID(), chat2.id, Date.now());
+        return created;
+      },
+      { mode: "deferred" }
+    );
   }
   async upsertChat(chat2) {
-    return this.#useTransaction(() => {
-      const upserted = storedChat.parse(
-        this.#db.prepare(
-          `INSERT INTO chats (id, userId, title, metadata)
+    return transaction(
+      this.#db,
+      () => {
+        const upserted = storedChat.parse(
+          this.#db.prepare(
+            `INSERT INTO chats (id, userId, title, metadata)
            VALUES (?, ?, ?, ?)
            ON CONFLICT(id) DO UPDATE SET id = excluded.id
            RETURNING *`
-        ).get(
-          chat2.id,
-          chat2.userId,
-          chat2.title ?? null,
-          chat2.metadata ? JSON.stringify(chat2.metadata) : null
-        )
-      );
-      this.#db.prepare(
-        `INSERT OR IGNORE INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
+          ).get(
+            chat2.id,
+            chat2.userId,
+            chat2.title ?? null,
+            chat2.metadata ? JSON.stringify(chat2.metadata) : null
+          )
+        );
+        this.#db.prepare(
+          `INSERT OR IGNORE INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
            VALUES (?, ?, 'main', NULL, 1, ?)`
-      ).run(crypto.randomUUID(), chat2.id, Date.now());
-      return upserted;
-    });
+        ).run(crypto.randomUUID(), chat2.id, Date.now());
+        return upserted;
+      },
+      { mode: "deferred" }
+    );
   }
   #getChat(chatId) {
     return storedChat.optional().parse(this.#db.prepare("SELECT * FROM chats WHERE id = ?").get(chatId));
@@ -3542,30 +3535,36 @@ var SqliteContextStore = class extends ContextStore {
     return this.#getChat(chatId);
   }
   async updateChat(chatId, update) {
-    return this.#useTransaction(() => {
-      const current = this.#getChat(chatId);
-      if (!current) {
-        throw new Error(`updateChat: chat "${chatId}" not found`);
-      }
-      const updates = update(current);
-      if (updates === void 0) return current;
-      const setClauses = ["updatedAt = strftime('%s', 'now') * 1000"];
-      const params = [];
-      if (updates.title !== void 0) {
-        setClauses.push("title = ?");
-        params.push(updates.title);
-      }
-      if (updates.metadata !== void 0) {
-        setClauses.push("metadata = ?");
-        params.push(JSON.stringify(updates.metadata));
-      }
-      params.push(chatId);
-      return storedChat.parse(
-        this.#db.prepare(
-          `UPDATE chats SET ${setClauses.join(", ")} WHERE id = ? RETURNING *`
-        ).get(...params)
-      );
-    }, "immediate");
+    return transaction(
+      this.#db,
+      () => {
+        const current = this.#getChat(chatId);
+        if (!current) {
+          throw new Error(`updateChat: chat "${chatId}" not found`);
+        }
+        const updates = update(current);
+        if (updates === void 0) return current;
+        const setClauses = [
+          "updatedAt = strftime('%s', 'now') * 1000"
+        ];
+        const params = [];
+        if (updates.title !== void 0) {
+          setClauses.push("title = ?");
+          params.push(updates.title);
+        }
+        if (updates.metadata !== void 0) {
+          setClauses.push("metadata = ?");
+          params.push(JSON.stringify(updates.metadata));
+        }
+        params.push(chatId);
+        return storedChat.parse(
+          this.#db.prepare(
+            `UPDATE chats SET ${setClauses.join(", ")} WHERE id = ? RETURNING *`
+          ).get(...params)
+        );
+      },
+      { mode: "immediate" }
+    );
   }
   async listChats(options) {
     const params = [];
@@ -3612,25 +3611,29 @@ var SqliteContextStore = class extends ContextStore {
     );
   }
   async deleteChat(chatId, options) {
-    return this.#useTransaction(() => {
-      const messageIds = z4.array(idRow).parse(
-        this.#db.prepare("SELECT id FROM messages WHERE chatId = ?").all(chatId)
-      );
-      let sql = "DELETE FROM chats WHERE id = ?";
-      const params = [chatId];
-      if (options?.userId !== void 0) {
-        sql += " AND userId = ?";
-        params.push(options.userId);
-      }
-      const result = this.#db.prepare(sql).run(...params);
-      if (result.changes > 0 && messageIds.length > 0) {
-        const placeholders = messageIds.map(() => "?").join(", ");
-        this.#db.prepare(
-          `DELETE FROM messages_fts WHERE messageId IN (${placeholders})`
-        ).run(...messageIds.map((m) => m.id));
-      }
-      return result.changes > 0;
-    });
+    return transaction(
+      this.#db,
+      () => {
+        const messageIds = z4.array(idRow).parse(
+          this.#db.prepare("SELECT id FROM messages WHERE chatId = ?").all(chatId)
+        );
+        let sql = "DELETE FROM chats WHERE id = ?";
+        const params = [chatId];
+        if (options?.userId !== void 0) {
+          sql += " AND userId = ?";
+          params.push(options.userId);
+        }
+        const result = this.#db.prepare(sql).run(...params);
+        if (result.changes > 0 && messageIds.length > 0) {
+          const placeholders = messageIds.map(() => "?").join(", ");
+          this.#db.prepare(
+            `DELETE FROM messages_fts WHERE messageId IN (${placeholders})`
+          ).run(...messageIds.map((m) => m.id));
+        }
+        return result.changes > 0;
+      },
+      { mode: "deferred" }
+    );
   }
   // ==========================================================================
   // Message Operations (Graph Nodes)
@@ -3639,59 +3642,48 @@ var SqliteContextStore = class extends ContextStore {
     if (message2.parentId === message2.id) {
       throw new Error(`Message ${message2.id} cannot be its own parent`);
     }
-    this.#stmt(
-      `INSERT INTO messages (id, chatId, parentId, name, type, data, createdAt)
-       VALUES (?, ?, ?, ?, ?, ?, ?)
+    this.#sql.run`INSERT INTO messages (id, chatId, parentId, name, type, data, createdAt)
+       VALUES (${message2.id}, ${message2.chatId}, ${message2.parentId}, ${message2.name}, ${message2.type ?? null}, ${JSON.stringify(message2.data)}, ${message2.createdAt})
        ON CONFLICT(id) DO UPDATE SET
          name = excluded.name,
          type = excluded.type,
-         data = excluded.data`
-    ).run(
-      message2.id,
-      message2.chatId,
-      message2.parentId,
-      message2.name,
-      message2.type ?? null,
-      JSON.stringify(message2.data),
-      message2.createdAt
-    );
+         data = excluded.data`;
     const content = typeof message2.data === "string" ? message2.data : JSON.stringify(message2.data);
-    this.#stmt(`DELETE FROM messages_fts WHERE messageId = ?`).run(message2.id);
-    this.#stmt(
-      `INSERT INTO messages_fts(messageId, chatId, name, content)
-       VALUES (?, ?, ?, ?)`
-    ).run(message2.id, message2.chatId, message2.name, content);
+    this.#sql.run`DELETE FROM messages_fts WHERE messageId = ${message2.id}`;
+    this.#sql.run`INSERT INTO messages_fts(messageId, chatId, name, content)
+       VALUES (${message2.id}, ${message2.chatId}, ${message2.name}, ${content})`;
   }
   async addMessage(message2) {
     this.#insertMessage(message2);
   }
   async addMessages(messages) {
     if (messages.length === 0) return;
-    this.#useTransaction(() => {
-      for (const message2 of messages) {
-        this.#insertMessage(message2);
-      }
-    });
+    transaction(
+      this.#db,
+      () => {
+        for (const message2 of messages) {
+          this.#insertMessage(message2);
+        }
+      },
+      { mode: "deferred" }
+    );
   }
   async setMessageParent(messageId, parentId) {
     if (parentId === messageId) {
       throw new Error(`Message ${messageId} cannot be its own parent`);
     }
-    const result = this.#stmt(
-      "UPDATE messages SET parentId = ? WHERE id = ?"
-    ).run(parentId, messageId);
+    const result = this.#sql.run`UPDATE messages SET parentId = ${parentId} WHERE id = ${messageId}`;
     if (result.changes === 0) {
       throw new Error(`Message ${messageId} not found`);
     }
   }
   async getMessage(messageId) {
-    return storedMessage.optional().parse(this.#stmt("SELECT * FROM messages WHERE id = ?").get(messageId));
+    return storedMessage.optional().parse(this.#sql.get`SELECT * FROM messages WHERE id = ${messageId}`);
   }
   async getMessageChain(headId) {
     return z4.array(storedMessage).parse(
-      this.#stmt(
-        `WITH RECURSIVE chain AS (
-        SELECT *, 0 as depth FROM messages WHERE id = ?
+      this.#sql.all`WITH RECURSIVE chain AS (
+        SELECT *, 0 as depth FROM messages WHERE id = ${headId}
         UNION ALL
         SELECT m.*, c.depth + 1 FROM messages m
         INNER JOIN chain c ON m.id = c.parentId
@@ -3699,14 +3691,11 @@ var SqliteContextStore = class extends ContextStore {
       )
       SELECT * FROM chain
       ORDER BY depth DESC`
-      ).all(headId)
     );
   }
   async hasChildren(messageId) {
     const row = hasChildrenRow.parse(
-      this.#stmt(
-        "SELECT EXISTS(SELECT 1 FROM messages WHERE parentId = ?) as hasChildren"
-      ).get(messageId)
+      this.#sql.get`SELECT EXISTS(SELECT 1 FROM messages WHERE parentId = ${messageId}) as hasChildren`
     );
     return row.hasChildren === 1;
   }
@@ -3744,9 +3733,7 @@ var SqliteContextStore = class extends ContextStore {
   }
   async getActiveBranch(chatId) {
     return storedBranch.optional().parse(
-      this.#stmt(
-        "SELECT * FROM branches WHERE chatId = ? AND isActive = 1"
-      ).get(chatId)
+      this.#sql.get`SELECT * FROM branches WHERE chatId = ${chatId} AND isActive = 1`
     );
   }
   async setActiveBranch(chatId, branchId) {
@@ -3754,9 +3741,7 @@ var SqliteContextStore = class extends ContextStore {
     this.#db.prepare("UPDATE branches SET isActive = 1 WHERE id = ?").run(branchId);
   }
   async updateBranchHead(branchId, messageId, expectedHeadMessageId) {
-    const result = this.#stmt(
-      "UPDATE branches SET headMessageId = ? WHERE id = ? AND headMessageId IS ?"
-    ).run(messageId, branchId, expectedHeadMessageId);
+    const result = this.#sql.run`UPDATE branches SET headMessageId = ${messageId} WHERE id = ${branchId} AND headMessageId IS ${expectedHeadMessageId}`;
     return result.changes > 0;
   }
   async listBranches(chatId) {
@@ -3852,7 +3837,15 @@ var SqliteContextStore = class extends ContextStore {
     }
     sql += " ORDER BY fts.rank LIMIT ?";
     params.push(limit);
-    return z4.array(searchResult).parse(this.#db.prepare(sql).all(...params));
+    const statement2 = this.#db.prepare(sql);
+    try {
+      return z4.array(searchResult).parse(statement2.all(...params));
+    } catch (error) {
+      if (isFts5QueryError(error)) {
+        throw new SearchQuerySyntaxError(query, { cause: error });
+      }
+      throw error;
+    }
   }
   // ==========================================================================
   // Visualization Operations
@@ -11212,6 +11205,16 @@ function soul() {
   return fragment("soul_protocol", ...children);
 }
 
+// packages/context/src/lib/store/postgres-schema-lock.ts
+function lockSchemaDDL(ddl, schema) {
+  if (schema !== void 0 && !/^[a-zA-Z_]\w*$/.test(schema)) {
+    throw new Error(`Invalid schema name: "${schema}"`);
+  }
+  const key = schema === void 0 ? `coalesce(current_schema(), '')` : `'${schema}'`;
+  return `SELECT pg_advisory_xact_lock(hashtextextended('deepagents:schema-ddl:' || ${key}, 0));
+${ddl}`;
+}
+
 // packages/context/src/lib/store/postgres.store.ts
 import { createRequire } from "node:module";
 import { z as z14 } from "zod";
@@ -11467,8 +11470,7 @@ var PostgresContextStore = class _PostgresContextStore extends ContextStore {
     return store;
   }
   async #initialize() {
-    const ddl = storeDDL(this.#schema);
-    await this.#pool.query(ddl);
+    await this.#pool.query(lockSchemaDDL(storeDDL(this.#schema), this.#schema));
   }
   /**
    * Execute a function within a transaction.
@@ -12095,6 +12097,38 @@ END;
 `;
 }
 
+// packages/context/src/lib/store/sqlserver-schema-lock.ts
+async function withSqlServerSchemaLock(mssql, pool, schema, run) {
+  const holder = new mssql.Transaction(pool);
+  await holder.begin();
+  let result;
+  try {
+    const lock = new mssql.Request(holder);
+    lock.input(
+      "resource",
+      mssql.NVarChar(255),
+      `deepagents:schema-ddl:${schema}`
+    );
+    const { recordset } = await lock.query(`
+      DECLARE @status int;
+      EXEC @status = sp_getapplock @Resource = @resource, @LockMode = 'Exclusive', @LockOwner = 'Transaction', @LockTimeout = -1;
+      SELECT @status AS status;
+    `);
+    if (recordset[0].status < 0) {
+      throw new Error(
+        `Could not lock the DDL of schema "${schema}": sp_getapplock returned ${recordset[0].status}.`
+      );
+    }
+    result = await run();
+  } catch (error) {
+    await holder.rollback().catch(() => {
+    });
+    throw error;
+  }
+  await holder.rollback();
+  return result;
+}
+
 // packages/context/src/lib/store/sqlserver.store.ts
 var chatColumns3 = z15.object({
   id: z15.string(),
@@ -12242,22 +12276,29 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
     if (this.#ownsPool) {
       await this.#pool.connect();
     }
-    const schemaReq = this.#pool.request();
-    schemaReq.input("schema", this.#schema);
-    await schemaReq.query(`
-      IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = @schema)
-      BEGIN
-        DECLARE @sql NVARCHAR(MAX) = N'CREATE SCHEMA ' + QUOTENAME(@schema);
-        EXEC sp_executesql @sql;
-      END
-    `);
-    const ddl = storeDDL2(this.#schema);
-    const batches = ddl.split(/\bGO\b/i).filter((b) => b.trim());
-    for (const batch of batches) {
-      if (batch.trim()) {
-        await this.#pool.request().batch(batch);
+    await withSqlServerSchemaLock(
+      _SqlServerContextStore.#requireMssql(),
+      this.#pool,
+      this.#schema,
+      async () => {
+        const schemaReq = this.#pool.request();
+        schemaReq.input("schema", this.#schema);
+        await schemaReq.query(`
+          IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = @schema)
+          BEGIN
+            DECLARE @sql NVARCHAR(MAX) = N'CREATE SCHEMA ' + QUOTENAME(@schema);
+            EXEC sp_executesql @sql;
+          END
+        `);
+        const ddl = storeDDL2(this.#schema);
+        const batches = ddl.split(/\bGO\b/i).filter((b) => b.trim());
+        for (const batch of batches) {
+          if (batch.trim()) {
+            await this.#pool.request().batch(batch);
+          }
+        }
       }
-    }
+    );
   }
   /**
    * Execute a function within a transaction.
@@ -12265,14 +12306,14 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
    */
   async #useTransaction(fn) {
     const mssql = _SqlServerContextStore.#requireMssql();
-    const transaction = new mssql.Transaction(this.#pool);
+    const transaction3 = new mssql.Transaction(this.#pool);
     try {
-      await transaction.begin();
-      const result = await fn(transaction);
-      await transaction.commit();
+      await transaction3.begin();
+      const result = await fn(transaction3);
+      await transaction3.commit();
       return result;
     } catch (error) {
-      await transaction.rollback();
+      await transaction3.rollback();
       throw error;
     }
   }
@@ -12307,9 +12348,9 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
   // Chat Operations
   // ==========================================================================
   async createChat(chat2) {
-    return this.#useTransaction(async (transaction) => {
+    return this.#useTransaction(async (transaction3) => {
       const mssql = _SqlServerContextStore.#requireMssql();
-      const request = transaction.request();
+      const request = transaction3.request();
       request.input("p0", mssql.NVarChar, chat2.id);
       request.input("p1", mssql.NVarChar, chat2.userId);
       request.input("p2", mssql.NVarChar, chat2.title ?? null);
@@ -12324,7 +12365,7 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
         VALUES (@p0, @p1, @p2, @p3)
       `);
       const created = storedChat3.parse(result.recordset[0]);
-      const branchRequest = transaction.request();
+      const branchRequest = transaction3.request();
       branchRequest.input("p0", mssql.NVarChar, crypto.randomUUID());
       branchRequest.input("p1", mssql.NVarChar, chat2.id);
       branchRequest.input("p2", mssql.BigInt, Date.now());
@@ -12336,9 +12377,9 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
     });
   }
   async upsertChat(chat2) {
-    return this.#useTransaction(async (transaction) => {
+    return this.#useTransaction(async (transaction3) => {
       const mssql = _SqlServerContextStore.#requireMssql();
-      const request = transaction.request();
+      const request = transaction3.request();
       request.input("p0", mssql.NVarChar, chat2.id);
       request.input("p1", mssql.NVarChar, chat2.userId);
       request.input("p2", mssql.NVarChar, chat2.title ?? null);
@@ -12360,7 +12401,7 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
         OUTPUT INSERTED.*;
       `);
       const upserted = storedChat3.parse(result.recordset[0]);
-      const branchRequest = transaction.request();
+      const branchRequest = transaction3.request();
       branchRequest.input("p0", mssql.NVarChar, crypto.randomUUID());
       branchRequest.input("p1", mssql.NVarChar, chat2.id);
       branchRequest.input("p2", mssql.BigInt, Date.now());
@@ -12383,9 +12424,9 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
     return chat2;
   }
   async updateChat(chatId, update) {
-    return this.#useTransaction(async (transaction) => {
+    return this.#useTransaction(async (transaction3) => {
       const mssql = _SqlServerContextStore.#requireMssql();
-      const read = transaction.request();
+      const read = transaction3.request();
       read.input("chatId", mssql.NVarChar, chatId);
       const result = await read.query(`
         SELECT *
@@ -12402,7 +12443,7 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
         "updatedAt = DATEDIFF_BIG(ms, '1970-01-01', GETUTCDATE())"
       ];
       let paramIndex = 0;
-      const write = transaction.request();
+      const write = transaction3.request();
       if (updates.title !== void 0) {
         const name = `p${paramIndex++}`;
         setClauses.push(`title = @${name}`);
@@ -12467,9 +12508,9 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
     );
   }
   async deleteChat(chatId, options) {
-    return this.#useTransaction(async (transaction) => {
+    return this.#useTransaction(async (transaction3) => {
       const mssql = _SqlServerContextStore.#requireMssql();
-      const request = transaction.request();
+      const request = transaction3.request();
       request.input("p0", mssql.NVarChar, chatId);
       let sql = `DELETE FROM ${this.#t("chats")} WHERE id = @p0`;
       if (options?.userId !== void 0) {
@@ -12487,9 +12528,9 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
     if (message2.parentId === message2.id) {
       throw new Error(`Message ${message2.id} cannot be its own parent`);
     }
-    await this.#useTransaction(async (transaction) => {
+    await this.#useTransaction(async (transaction3) => {
       const mssql = _SqlServerContextStore.#requireMssql();
-      const request = transaction.request();
+      const request = transaction3.request();
       request.input("p0", mssql.NVarChar, message2.id);
       request.input("p1", mssql.NVarChar, message2.chatId);
       request.input("p2", mssql.NVarChar, message2.parentId);
@@ -12508,7 +12549,7 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
           VALUES (@p0, @p1, @p2, @p3, @p4, @p5, @p6);
       `);
       const content = typeof message2.data === "string" ? message2.data : JSON.stringify(message2.data);
-      const ftsRequest = transaction.request();
+      const ftsRequest = transaction3.request();
       ftsRequest.input("p0", mssql.NVarChar, message2.id);
       ftsRequest.input("p1", mssql.NVarChar, message2.chatId);
       ftsRequest.input("p2", mssql.NVarChar, message2.name);
@@ -12616,14 +12657,14 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
     return branch;
   }
   async setActiveBranch(chatId, branchId) {
-    await this.#useTransaction(async (transaction) => {
+    await this.#useTransaction(async (transaction3) => {
       const mssql = _SqlServerContextStore.#requireMssql();
-      const deactivateRequest = transaction.request();
+      const deactivateRequest = transaction3.request();
       deactivateRequest.input("p0", mssql.NVarChar, chatId);
       await deactivateRequest.query(
         `UPDATE ${this.#t("branches")} SET isActive = 0 WHERE chatId = @p0`
       );
-      const activateRequest = transaction.request();
+      const activateRequest = transaction3.request();
       activateRequest.input("p0", mssql.NVarChar, branchId);
       await activateRequest.query(
         `UPDATE ${this.#t("branches")} SET isActive = 1 WHERE id = @p0`
@@ -12686,9 +12727,9 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
   // Checkpoint Operations
   // ==========================================================================
   async createCheckpoint(checkpoint) {
-    await this.#useTransaction(async (transaction) => {
+    await this.#useTransaction(async (transaction3) => {
       const mssql = _SqlServerContextStore.#requireMssql();
-      const request = transaction.request();
+      const request = transaction3.request();
       request.input("p0", mssql.NVarChar, checkpoint.id);
       request.input("p1", mssql.NVarChar, checkpoint.chatId);
       request.input("p2", mssql.NVarChar, checkpoint.name);
@@ -13295,7 +13336,10 @@ var PostgresNotifyChangeSource = class _PostgresNotifyChangeSource {
     const source = new _PostgresNotifyChangeSource(options);
     try {
       await source.#pool.query(
-        postgresStreamNotifyDDL(source.#schema, source.#channel)
+        lockSchemaDDL(
+          postgresStreamNotifyDDL(source.#schema, source.#channel),
+          source.#schema
+        )
       );
     } catch (error) {
       await source.close();
@@ -13549,7 +13593,9 @@ var PostgresStreamStore = class _PostgresStreamStore extends StreamStore {
     return store;
   }
   async #initialize() {
-    await this.#pool.query(postgresStreamDDL(this.#schema));
+    await this.#pool.query(
+      lockSchemaDDL(postgresStreamDDL(this.#schema), this.#schema)
+    );
   }
   async close() {
     if (this.#ownsPool && !this.#pool.ending) {
@@ -13842,7 +13888,10 @@ function assertIdentifier2(value, label) {
 }
 
 // packages/context/src/lib/stream/sqlite.stream-store.ts
-import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { transaction as transaction2 } from "@zukhruf/sqlite-transaction";
+import {
+  DatabaseSync as DatabaseSync2
+} from "node:sqlite";
 import { z as z19 } from "zod";
 
 // packages/context/src/lib/stream/ddl.stream.sqlite.sql
@@ -13868,55 +13917,27 @@ var chunkRow2 = z19.object({
 });
 var SqliteStreamStore = class extends StreamStore {
   #db;
-  #statements = /* @__PURE__ */ new Map();
-  #stmt(sql) {
-    let stmt = this.#statements.get(sql);
-    if (!stmt) {
-      stmt = this.#db.prepare(sql);
-      this.#statements.set(sql, stmt);
-    }
-    return stmt;
-  }
+  #sql;
   close() {
     if (!this.#db.isOpen) return;
-    this.#statements.clear();
     this.#db.close();
   }
   constructor(pathOrDb) {
     super();
     this.#db = typeof pathOrDb === "string" ? new DatabaseSync2(pathOrDb) : pathOrDb;
     this.#db.exec(ddl_stream_sqlite_default);
+    this.#sql = this.#db.createTagStore();
   }
   async createStream(stream) {
-    this.#stmt(
-      `INSERT INTO streams (id, status, createdAt, startedAt, finishedAt, cancelRequestedAt, error)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`
-    ).run(
-      stream.id,
-      stream.status,
-      stream.createdAt,
-      stream.startedAt,
-      stream.finishedAt,
-      stream.cancelRequestedAt,
-      stream.error
-    );
+    this.#sql.run`INSERT INTO streams (id, status, createdAt, startedAt, finishedAt, cancelRequestedAt, error)
+       VALUES (${stream.id}, ${stream.status}, ${stream.createdAt}, ${stream.startedAt}, ${stream.finishedAt}, ${stream.cancelRequestedAt}, ${stream.error})`;
   }
   async upsertStream(stream) {
     const created = streamRow.optional().parse(
-      this.#stmt(
-        `INSERT INTO streams (id, status, createdAt, startedAt, finishedAt, cancelRequestedAt, error)
-       VALUES (?, ?, ?, ?, ?, ?, ?)
+      this.#sql.get`INSERT INTO streams (id, status, createdAt, startedAt, finishedAt, cancelRequestedAt, error)
+       VALUES (${stream.id}, ${stream.status}, ${stream.createdAt}, ${stream.startedAt}, ${stream.finishedAt}, ${stream.cancelRequestedAt}, ${stream.error})
        ON CONFLICT(id) DO NOTHING
        RETURNING *`
-      ).get(
-        stream.id,
-        stream.status,
-        stream.createdAt,
-        stream.startedAt,
-        stream.finishedAt,
-        stream.cancelRequestedAt,
-        stream.error
-      )
     );
     if (created) {
       return { stream: created, created: true };
@@ -13930,137 +13951,107 @@ var SqliteStreamStore = class extends StreamStore {
     return { stream: existing, created: false };
   }
   async getStream(streamId) {
-    return streamRow.optional().parse(this.#stmt("SELECT * FROM streams WHERE id = ?").get(streamId));
+    return streamRow.optional().parse(this.#sql.get`SELECT * FROM streams WHERE id = ${streamId}`);
   }
   async getStreamStatus(streamId) {
-    const row = statusRow2.optional().parse(
-      this.#stmt("SELECT status FROM streams WHERE id = ?").get(streamId)
-    );
+    const row = statusRow2.optional().parse(this.#sql.get`SELECT status FROM streams WHERE id = ${streamId}`);
     return row?.status;
   }
   async listStreamIds(options) {
-    let sql = "SELECT id FROM streams";
-    const params = [];
-    if (options?.status) {
-      sql += " WHERE status = ?";
-      params.push(options.status);
-    }
-    sql += " ORDER BY createdAt ASC, id ASC";
-    const rows = z19.array(idRow5).parse(this.#stmt(sql).all(...params));
+    const rows = z19.array(idRow5).parse(
+      options?.status ? this.#sql.all`SELECT id FROM streams WHERE status = ${options.status} ORDER BY createdAt ASC, id ASC` : this.#sql.all`SELECT id FROM streams ORDER BY createdAt ASC, id ASC`
+    );
     return rows.map((row) => row.id);
   }
   async updateStream(streamId, update) {
-    return this.#transaction(() => {
-      const stream = streamRow.optional().parse(this.#stmt("SELECT * FROM streams WHERE id = ?").get(streamId));
-      if (!stream) {
-        throw new Error(`updateStream: stream "${streamId}" not found`);
-      }
-      const updates = update(stream);
-      if (updates === void 0) return { stream, updated: false };
-      const setClauses = [];
-      const params = [];
-      const set = (column, value) => {
-        setClauses.push(`${column} = ?`);
-        params.push(value);
-      };
-      if (updates.status !== void 0) set("status", updates.status);
-      if (updates.startedAt !== void 0) set("startedAt", updates.startedAt);
-      if (updates.finishedAt !== void 0) {
-        set("finishedAt", updates.finishedAt);
-      }
-      if (updates.cancelRequestedAt !== void 0) {
-        set("cancelRequestedAt", updates.cancelRequestedAt);
-      }
-      if (updates.error !== void 0) set("error", updates.error);
-      if (setClauses.length === 0) return { stream, updated: false };
-      params.push(streamId);
-      const next = streamRow.parse(
-        this.#stmt(
-          `UPDATE streams SET ${setClauses.join(", ")} WHERE id = ? RETURNING *`
-        ).get(...params)
-      );
-      return { stream: next, updated: true };
-    });
+    return transaction2(
+      this.#db,
+      () => {
+        const stream = streamRow.optional().parse(this.#sql.get`SELECT * FROM streams WHERE id = ${streamId}`);
+        if (!stream) {
+          throw new Error(`updateStream: stream "${streamId}" not found`);
+        }
+        const updates = update(stream);
+        if (updates === void 0) return { stream, updated: false };
+        const setClauses = [];
+        const params = [];
+        const set = (column, value) => {
+          setClauses.push(`${column} = ?`);
+          params.push(value);
+        };
+        if (updates.status !== void 0) set("status", updates.status);
+        if (updates.startedAt !== void 0)
+          set("startedAt", updates.startedAt);
+        if (updates.finishedAt !== void 0) {
+          set("finishedAt", updates.finishedAt);
+        }
+        if (updates.cancelRequestedAt !== void 0) {
+          set("cancelRequestedAt", updates.cancelRequestedAt);
+        }
+        if (updates.error !== void 0) set("error", updates.error);
+        if (setClauses.length === 0) return { stream, updated: false };
+        params.push(streamId);
+        const next = streamRow.parse(
+          this.#db.prepare(
+            `UPDATE streams SET ${setClauses.join(", ")} WHERE id = ? RETURNING *`
+          ).get(...params)
+        );
+        return { stream: next, updated: true };
+      },
+      { mode: "immediate" }
+    );
   }
   async updateStreamStatus(streamId, status, options) {
     const now = Date.now();
     switch (status) {
       case "running":
-        this.#stmt(
-          `UPDATE streams SET status = ?, startedAt = ?
-            WHERE id = ? AND status = 'queued'`
-        ).run(status, now, streamId);
+        this.#sql.run`UPDATE streams SET status = ${status}, startedAt = ${now}
+            WHERE id = ${streamId} AND status = 'queued'`;
         break;
       case "completed":
-        this.#stmt(
-          `UPDATE streams SET status = ?, finishedAt = ?
-            WHERE id = ? AND status IN ('queued', 'running')`
-        ).run(status, now, streamId);
+        this.#sql.run`UPDATE streams SET status = ${status}, finishedAt = ${now}
+            WHERE id = ${streamId} AND status IN ('queued', 'running')`;
         break;
       case "failed":
-        this.#stmt(
-          `UPDATE streams SET status = ?, finishedAt = ?, error = ?
-            WHERE id = ? AND status IN ('queued', 'running')`
-        ).run(status, now, options?.error ?? null, streamId);
+        this.#sql.run`UPDATE streams SET status = ${status}, finishedAt = ${now}, error = ${options?.error ?? null}
+            WHERE id = ${streamId} AND status IN ('queued', 'running')`;
         break;
       case "cancelled":
-        this.#stmt(
-          `UPDATE streams SET status = ?, cancelRequestedAt = ?, finishedAt = ?
-            WHERE id = ? AND status IN ('queued', 'running')`
-        ).run(status, now, now, streamId);
+        this.#sql.run`UPDATE streams SET status = ${status}, cancelRequestedAt = ${now}, finishedAt = ${now}
+            WHERE id = ${streamId} AND status IN ('queued', 'running')`;
         break;
       default:
-        this.#stmt(
-          `UPDATE streams SET status = ?
-            WHERE id = ? AND status = 'queued'`
-        ).run(status, streamId);
+        this.#sql.run`UPDATE streams SET status = ${status}
+            WHERE id = ${streamId} AND status = 'queued'`;
     }
   }
   async appendChunks(chunks) {
     if (chunks.length === 0) return;
     const failures = collectStreamFailures(chunks);
-    this.#transaction(() => {
-      for (const chunk of chunks) {
-        this.#stmt(
-          `INSERT INTO stream_chunks (streamId, seq, data, createdAt)
-           VALUES (?, ?, ?, ?)`
-        ).run(
-          chunk.streamId,
-          chunk.seq,
-          JSON.stringify(chunk.data),
-          chunk.createdAt
-        );
-      }
-      const failedAt = Date.now();
-      for (const failure of failures) {
-        const result = this.#stmt(
-          `UPDATE streams SET status = ?, finishedAt = ?, error = ?
-            WHERE id = ? AND status IN ('queued', 'running')`
-        ).run("failed", failedAt, failure.error, failure.streamId);
-        if (result.changes !== 1) {
-          const existing = this.#stmt(
-            "SELECT id FROM streams WHERE id = ?"
-          ).get(failure.streamId);
-          if (!existing) {
-            throw new Error(`Stream "${failure.streamId}" not found`);
+    transaction2(
+      this.#db,
+      () => {
+        for (const chunk of chunks) {
+          this.#sql.run`INSERT INTO stream_chunks (streamId, seq, data, createdAt)
+           VALUES (${chunk.streamId}, ${chunk.seq}, ${JSON.stringify(chunk.data)}, ${chunk.createdAt})`;
+        }
+        const failedAt = Date.now();
+        for (const failure of failures) {
+          const result = this.#sql.run`UPDATE streams SET status = 'failed', finishedAt = ${failedAt}, error = ${failure.error}
+            WHERE id = ${failure.streamId} AND status IN ('queued', 'running')`;
+          if (result.changes !== 1) {
+            const existing = this.#sql.get`SELECT id FROM streams WHERE id = ${failure.streamId}`;
+            if (!existing) {
+              throw new Error(`Stream "${failure.streamId}" not found`);
+            }
           }
         }
-      }
-    });
+      },
+      { mode: "immediate" }
+    );
   }
   async getChunks(streamId, fromSeq, limit) {
-    let sql = "SELECT * FROM stream_chunks WHERE streamId = ?";
-    const params = [streamId];
-    if (fromSeq !== void 0) {
-      sql += " AND seq >= ?";
-      params.push(fromSeq);
-    }
-    sql += " ORDER BY seq ASC";
-    if (limit !== void 0) {
-      sql += " LIMIT ?";
-      params.push(limit);
-    }
-    const rows = z19.array(chunkRow2).parse(this.#stmt(sql).all(...params));
+    const rows = z19.array(chunkRow2).parse(this.#chunkRows(streamId, fromSeq, limit));
     return Promise.all(
       rows.map(async (row) => ({
         streamId: row.streamId,
@@ -14070,50 +14061,50 @@ var SqliteStreamStore = class extends StreamStore {
       }))
     );
   }
+  #chunkRows(streamId, fromSeq, limit) {
+    if (fromSeq !== void 0 && limit !== void 0) {
+      return this.#sql.all`SELECT * FROM stream_chunks WHERE streamId = ${streamId} AND seq >= ${fromSeq} ORDER BY seq ASC LIMIT ${limit}`;
+    }
+    if (fromSeq !== void 0) {
+      return this.#sql.all`SELECT * FROM stream_chunks WHERE streamId = ${streamId} AND seq >= ${fromSeq} ORDER BY seq ASC`;
+    }
+    if (limit !== void 0) {
+      return this.#sql.all`SELECT * FROM stream_chunks WHERE streamId = ${streamId} ORDER BY seq ASC LIMIT ${limit}`;
+    }
+    return this.#sql.all`SELECT * FROM stream_chunks WHERE streamId = ${streamId} ORDER BY seq ASC`;
+  }
   async deleteStream(streamId) {
-    this.#stmt("DELETE FROM streams WHERE id = ?").run(streamId);
+    this.#sql.run`DELETE FROM streams WHERE id = ${streamId}`;
   }
   async reopenStream(streamId) {
-    return this.#transaction(() => {
-      const row = statusRow2.optional().parse(this.#stmt("SELECT * FROM streams WHERE id = ?").get(streamId));
-      if (!row) {
-        throw new Error(`Stream "${streamId}" not found`);
-      }
-      if (row.status !== "completed" && row.status !== "failed" && row.status !== "cancelled") {
-        throw new Error(
-          `Cannot reopen stream "${streamId}" with status "${row.status}". Only terminal streams can be reopened.`
-        );
-      }
-      this.#stmt("DELETE FROM streams WHERE id = ?").run(streamId);
-      const now = Date.now();
-      this.#stmt(
-        `INSERT INTO streams (id, status, createdAt, startedAt, finishedAt, cancelRequestedAt, error)
-         VALUES (?, ?, ?, ?, ?, ?, ?)`
-      ).run(streamId, "queued", now, null, null, null, null);
-      return {
-        id: streamId,
-        status: "queued",
-        createdAt: now,
-        startedAt: null,
-        finishedAt: null,
-        cancelRequestedAt: null,
-        error: null
-      };
-    });
-  }
-  #transaction(callback) {
-    this.#db.exec("BEGIN IMMEDIATE");
-    try {
-      const result = callback();
-      this.#db.exec("COMMIT");
-      return result;
-    } catch (error) {
-      try {
-        this.#db.exec("ROLLBACK");
-      } catch {
-      }
-      throw error;
-    }
+    return transaction2(
+      this.#db,
+      () => {
+        const row = statusRow2.optional().parse(this.#sql.get`SELECT * FROM streams WHERE id = ${streamId}`);
+        if (!row) {
+          throw new Error(`Stream "${streamId}" not found`);
+        }
+        if (row.status !== "completed" && row.status !== "failed" && row.status !== "cancelled") {
+          throw new Error(
+            `Cannot reopen stream "${streamId}" with status "${row.status}". Only terminal streams can be reopened.`
+          );
+        }
+        this.#sql.run`DELETE FROM streams WHERE id = ${streamId}`;
+        const now = Date.now();
+        this.#sql.run`INSERT INTO streams (id, status, createdAt, startedAt, finishedAt, cancelRequestedAt, error)
+         VALUES (${streamId}, 'queued', ${now}, NULL, NULL, NULL, NULL)`;
+        return {
+          id: streamId,
+          status: "queued",
+          createdAt: now,
+          startedAt: null,
+          finishedAt: null,
+          cancelRequestedAt: null,
+          error: null
+        };
+      },
+      { mode: "immediate" }
+    );
   }
 };
 
@@ -14580,6 +14571,7 @@ export {
   PostgresNotifyChangeSource,
   PostgresStreamStore,
   RuntimeStrategy,
+  SearchQuerySyntaxError,
   SqlServerContextStore,
   SqliteContextStore,
   SqliteStreamStore,
@@ -14686,6 +14678,7 @@ export {
   isSyntheticReminderMessage,
   lastAssistantLength,
   localeReminder,
+  lockSchemaDDL,
   mapGenerateErrorToCode,
   mergeMessageMetadata,
   mergeReminderMetadata,