@elizaos/plugin-sql 2.0.0-alpha.2 → 2.0.0-alpha.4

package/dist/browser/index.browser.js

@@ -37,14 +37,14 @@ var init_agent = __esm(() => {
 });
 
 // schema/server.ts
-import { sql as sql15 } from "drizzle-orm";
-import { pgTable as pgTable17, timestamp as timestamp15, uuid as uuid15 } from "drizzle-orm/pg-core";
+import { sql as sql17 } from "drizzle-orm";
+import { pgTable as pgTable19, timestamp as timestamp17, uuid as uuid17 } from "drizzle-orm/pg-core";
 var serverTable;
 var init_server = __esm(() => {
-  serverTable = pgTable17("servers", {
-    id: uuid15("id").primaryKey(),
-    createdAt: timestamp15("created_at", { withTimezone: true }).default(sql15`now()`).notNull(),
-    updatedAt: timestamp15("updated_at", { withTimezone: true }).default(sql15`now()`).notNull()
+  serverTable = pgTable19("servers", {
+    id: uuid17("id").primaryKey(),
+    createdAt: timestamp17("created_at", { withTimezone: true }).default(sql17`now()`).notNull(),
+    updatedAt: timestamp17("updated_at", { withTimezone: true }).default(sql17`now()`).notNull()
   });
 });
 
@@ -52,27 +52,27 @@ var init_server = __esm(() => {
 function getDb(adapter) {
   return adapter.db;
 }
-function getRow(result, index5 = 0) {
-  return result.rows[index5];
+function getRow(result, index7 = 0) {
+  return result.rows[index7];
 }
 
 // migrations.ts
 import { logger } from "@elizaos/core";
-import { sql as sql17 } from "drizzle-orm";
+import { sql as sql19 } from "drizzle-orm";
 function getRows(result) {
   return result.rows;
 }
 async function migrateToEntityRLS(adapter) {
   const db = getDb(adapter);
   try {
-    await db.execute(sql17`SELECT 1 FROM pg_tables LIMIT 1`);
+    await db.execute(sql19`SELECT 1 FROM pg_tables LIMIT 1`);
   } catch {
     logger.debug("[Migration] ⊘ Not PostgreSQL, skipping PostgreSQL-specific migrations");
     return;
   }
   let schemaAlreadyMigrated = false;
   try {
-    const migrationCheck = await db.execute(sql17`
+    const migrationCheck = await db.execute(sql19`
       SELECT column_name FROM information_schema.columns
       WHERE table_schema = 'public'
         AND table_name = 'rooms'
@@ -94,7 +94,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger.debug("[Migration] → Schema migrated but RLS disabled, cleaning up...");
     try {
-      const tablesWithRls = await db.execute(sql17`
+      const tablesWithRls = await db.execute(sql19`
         SELECT c.relname as tablename
         FROM pg_class c
         JOIN pg_namespace n ON n.oid = c.relnamespace
@@ -107,7 +107,7 @@ async function migrateToEntityRLS(adapter) {
         for (const row of tablesWithRls.rows) {
           const tableName = row.tablename;
           try {
-            await db.execute(sql17.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
+            await db.execute(sql19.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
           } catch {}
         }
         logger.debug(`[Migration] ✓ RLS cleanup completed (${tablesWithRls.rows.length} tables)`);
@@ -123,14 +123,14 @@ async function migrateToEntityRLS(adapter) {
   try {
     logger.debug("[Migration] → Clearing RuntimeMigrator snapshot cache...");
     try {
-      await db.execute(sql17`DELETE FROM migrations._snapshots WHERE plugin_name = '@elizaos/plugin-sql'`);
+      await db.execute(sql19`DELETE FROM migrations._snapshots WHERE plugin_name = '@elizaos/plugin-sql'`);
       logger.debug("[Migration] ✓ Snapshot cache cleared");
     } catch (_error) {
       logger.debug("[Migration] ⊘ No snapshot cache to clear (migrations schema not yet created)");
     }
     logger.debug("[Migration] → Checking for Row Level Security to disable...");
     try {
-      const tablesWithRls = await db.execute(sql17`
+      const tablesWithRls = await db.execute(sql19`
         SELECT c.relname as tablename
         FROM pg_class c
         JOIN pg_namespace n ON n.oid = c.relnamespace
@@ -143,7 +143,7 @@ async function migrateToEntityRLS(adapter) {
         for (const row of tablesWithRls.rows) {
           const tableName = row.tablename;
           try {
-            await db.execute(sql17.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
+            await db.execute(sql19.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
             logger.debug(`[Migration] ✓ Disabled RLS on ${tableName}`);
           } catch (_error) {
             logger.debug(`[Migration] ⊘ Could not disable RLS on ${tableName}`);
@@ -159,7 +159,7 @@ async function migrateToEntityRLS(adapter) {
     const tablesToMigrate = ["channels", "worlds", "rooms"];
     for (const tableName of tablesToMigrate) {
       try {
-        const columnsResult = await db.execute(sql17`
+        const columnsResult = await db.execute(sql19`
           SELECT column_name, data_type, is_nullable
           FROM information_schema.columns
           WHERE table_schema = 'public'
@@ -175,19 +175,19 @@ async function migrateToEntityRLS(adapter) {
         const oldColumnName = serverIdSnake ? "server_id" : "serverId";
         if (serverId && !messageServerId) {
           logger.debug(`[Migration] → Renaming ${tableName}.${oldColumnName} to message_server_id...`);
-          await db.execute(sql17.raw(`ALTER TABLE "${tableName}" RENAME COLUMN "${oldColumnName}" TO "message_server_id"`));
+          await db.execute(sql19.raw(`ALTER TABLE "${tableName}" RENAME COLUMN "${oldColumnName}" TO "message_server_id"`));
           logger.debug(`[Migration] ✓ Renamed ${tableName}.${oldColumnName} → message_server_id`);
           if (serverId.data_type === "text") {
             try {
               logger.debug(`[Migration] → Dropping DEFAULT constraint on ${tableName}.message_server_id...`);
-              await db.execute(sql17.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
+              await db.execute(sql19.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
               logger.debug(`[Migration] ✓ Dropped DEFAULT constraint`);
             } catch {
               logger.debug(`[Migration] ⊘ No DEFAULT constraint to drop on ${tableName}.message_server_id`);
             }
             try {
               logger.debug(`[Migration] → Converting ${tableName}.message_server_id from text to uuid...`);
-              await db.execute(sql17.raw(`
+              await db.execute(sql19.raw(`
                   ALTER TABLE "${tableName}"
                   ALTER COLUMN "message_server_id" TYPE uuid
                   USING CASE
@@ -204,29 +204,29 @@ async function migrateToEntityRLS(adapter) {
             }
           }
           if (tableName === "channels") {
-            const nullCountResult = await db.execute(sql17.raw(`SELECT COUNT(*) as count FROM "${tableName}" WHERE "message_server_id" IS NULL`));
+            const nullCountResult = await db.execute(sql19.raw(`SELECT COUNT(*) as count FROM "${tableName}" WHERE "message_server_id" IS NULL`));
             const nullCount = nullCountResult.rows?.[0]?.count;
             if (nullCount && parseInt(nullCount, 10) > 0) {
               logger.warn(`[Migration] ⚠️ ${tableName} has ${nullCount} rows with NULL message_server_id - these will be deleted`);
-              await db.execute(sql17.raw(`DELETE FROM "${tableName}" WHERE "message_server_id" IS NULL`));
+              await db.execute(sql19.raw(`DELETE FROM "${tableName}" WHERE "message_server_id" IS NULL`));
               logger.debug(`[Migration] ✓ Deleted ${nullCount} rows with NULL message_server_id from ${tableName}`);
             }
             logger.debug(`[Migration] → Making ${tableName}.message_server_id NOT NULL...`);
-            await db.execute(sql17.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" SET NOT NULL`));
+            await db.execute(sql19.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" SET NOT NULL`));
             logger.debug(`[Migration] ✓ Set ${tableName}.message_server_id NOT NULL`);
           }
         } else if (serverId && messageServerId) {
           logger.debug(`[Migration] → ${tableName} has both columns, dropping ${oldColumnName}...`);
-          await db.execute(sql17.raw(`ALTER TABLE "${tableName}" DROP COLUMN "${oldColumnName}" CASCADE`));
+          await db.execute(sql19.raw(`ALTER TABLE "${tableName}" DROP COLUMN "${oldColumnName}" CASCADE`));
           logger.debug(`[Migration] ✓ Dropped ${tableName}.${oldColumnName}`);
         } else if (!serverId && messageServerId) {
           if (messageServerId.data_type === "text") {
             logger.debug(`[Migration] → ${tableName}.message_server_id exists but is TEXT, needs UUID conversion...`);
             logger.debug(`[Migration] → Dropping DEFAULT constraint on ${tableName}.message_server_id...`);
-            await db.execute(sql17.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
+            await db.execute(sql19.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
             logger.debug(`[Migration] ✓ Dropped DEFAULT constraint`);
             logger.debug(`[Migration] → Converting ${tableName}.message_server_id from text to uuid (generating UUIDs from text)...`);
-            await db.execute(sql17.raw(`
+            await db.execute(sql19.raw(`
               ALTER TABLE "${tableName}"
               ALTER COLUMN "message_server_id" TYPE uuid
               USING CASE
@@ -248,7 +248,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger.debug("[Migration] → Dropping all remaining RLS-managed server_id columns...");
     try {
-      const serverIdColumnsResult = await db.execute(sql17`
+      const serverIdColumnsResult = await db.execute(sql19`
         SELECT table_name
         FROM information_schema.columns
         WHERE table_schema = 'public'
@@ -270,7 +270,7 @@ async function migrateToEntityRLS(adapter) {
       for (const row of tablesToClean) {
         const tableName = row.table_name;
         try {
-          await db.execute(sql17.raw(`ALTER TABLE "${tableName}" DROP COLUMN IF EXISTS server_id CASCADE`));
+          await db.execute(sql19.raw(`ALTER TABLE "${tableName}" DROP COLUMN IF EXISTS server_id CASCADE`));
           logger.debug(`[Migration] ✓ Dropped server_id from ${tableName}`);
         } catch (_error) {
           logger.debug(`[Migration] ⊘ Could not drop server_id from ${tableName}`);
@@ -281,7 +281,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger.debug("[Migration] → Checking agents.owner_id → server_id rename...");
     try {
-      const agentsColumnsResult = await db.execute(sql17`
+      const agentsColumnsResult = await db.execute(sql19`
         SELECT column_name
         FROM information_schema.columns
         WHERE table_schema = 'public'
@@ -294,11 +294,11 @@ async function migrateToEntityRLS(adapter) {
       const hasServerId = agentsColumns.some((c) => c.column_name === "server_id");
       if (hasOwnerId && !hasServerId) {
         logger.debug("[Migration] → Renaming agents.owner_id to server_id...");
-        await db.execute(sql17.raw(`ALTER TABLE "agents" RENAME COLUMN "owner_id" TO "server_id"`));
+        await db.execute(sql19.raw(`ALTER TABLE "agents" RENAME COLUMN "owner_id" TO "server_id"`));
         logger.debug("[Migration] ✓ Renamed agents.owner_id → server_id");
       } else if (hasOwnerId && hasServerId) {
         logger.debug("[Migration] → Both owner_id and server_id exist, dropping owner_id...");
-        await db.execute(sql17.raw(`ALTER TABLE "agents" DROP COLUMN "owner_id" CASCADE`));
+        await db.execute(sql19.raw(`ALTER TABLE "agents" DROP COLUMN "owner_id" CASCADE`));
         logger.debug("[Migration] ✓ Dropped agents.owner_id");
       } else {
         logger.debug("[Migration] ⊘ agents table already has server_id (or no owner_id), skipping");
@@ -308,7 +308,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger.debug("[Migration] → Checking for owners → servers data migration...");
     try {
-      const ownersTableResult = await db.execute(sql17`
+      const ownersTableResult = await db.execute(sql19`
         SELECT table_name
         FROM information_schema.tables
         WHERE table_schema = 'public'
@@ -316,7 +316,7 @@ async function migrateToEntityRLS(adapter) {
       `);
       if (ownersTableResult.rows && ownersTableResult.rows.length > 0) {
         logger.debug("[Migration] → Ensuring servers table exists...");
-        await db.execute(sql17.raw(`
+        await db.execute(sql19.raw(`
           CREATE TABLE IF NOT EXISTS "servers" (
             "id" uuid PRIMARY KEY,
             "created_at" timestamp with time zone DEFAULT now() NOT NULL,
@@ -324,7 +324,7 @@ async function migrateToEntityRLS(adapter) {
           )
         `));
         logger.debug("[Migration] → Migrating owners data to servers...");
-        await db.execute(sql17.raw(`
+        await db.execute(sql19.raw(`
           INSERT INTO "servers" ("id", "created_at", "updated_at")
           SELECT "id", COALESCE("created_at", now()), COALESCE("updated_at", now())
           FROM "owners"
@@ -332,7 +332,7 @@ async function migrateToEntityRLS(adapter) {
         `));
         logger.debug("[Migration] ✓ Migrated owners data to servers");
         logger.debug("[Migration] → Dropping obsolete owners table...");
-        await db.execute(sql17.raw(`DROP TABLE IF EXISTS "owners" CASCADE`));
+        await db.execute(sql19.raw(`DROP TABLE IF EXISTS "owners" CASCADE`));
         logger.debug("[Migration] ✓ Dropped obsolete owners table");
       } else {
         logger.debug("[Migration] ⊘ owners table not found, skipping");
@@ -342,7 +342,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger.debug("[Migration] → Checking server_agents table rename...");
     try {
-      const tablesResult = await db.execute(sql17`
+      const tablesResult = await db.execute(sql19`
         SELECT table_name
         FROM information_schema.tables
         WHERE table_schema = 'public'
@@ -354,16 +354,16 @@ async function migrateToEntityRLS(adapter) {
       const hasMessageServerAgents = tables.some((t) => t.table_name === "message_server_agents");
       if (hasServerAgents && !hasMessageServerAgents) {
         logger.debug("[Migration] → Renaming server_agents to message_server_agents...");
-        await db.execute(sql17.raw(`ALTER TABLE "server_agents" RENAME TO "message_server_agents"`));
+        await db.execute(sql19.raw(`ALTER TABLE "server_agents" RENAME TO "message_server_agents"`));
         logger.debug("[Migration] ✓ Renamed server_agents → message_server_agents");
         logger.debug("[Migration] → Renaming message_server_agents.server_id to message_server_id...");
-        await db.execute(sql17.raw(`ALTER TABLE "message_server_agents" RENAME COLUMN "server_id" TO "message_server_id"`));
+        await db.execute(sql19.raw(`ALTER TABLE "message_server_agents" RENAME COLUMN "server_id" TO "message_server_id"`));
         logger.debug("[Migration] ✓ Renamed message_server_agents.server_id → message_server_id");
       } else if (!hasServerAgents && !hasMessageServerAgents) {
         logger.debug("[Migration] ⊘ No server_agents table to migrate");
       } else if (hasMessageServerAgents) {
         logger.debug("[Migration] → Checking message_server_agents columns...");
-        const columnsResult = await db.execute(sql17`
+        const columnsResult = await db.execute(sql19`
           SELECT column_name
           FROM information_schema.columns
           WHERE table_schema = 'public'
@@ -376,11 +376,11 @@ async function migrateToEntityRLS(adapter) {
         const hasMessageServerId = columns.some((c) => c.column_name === "message_server_id");
         if (hasServerId && !hasMessageServerId) {
           logger.debug("[Migration] → Renaming message_server_agents.server_id to message_server_id...");
-          await db.execute(sql17.raw(`ALTER TABLE "message_server_agents" RENAME COLUMN "server_id" TO "message_server_id"`));
+          await db.execute(sql19.raw(`ALTER TABLE "message_server_agents" RENAME COLUMN "server_id" TO "message_server_id"`));
           logger.debug("[Migration] ✓ Renamed message_server_agents.server_id → message_server_id");
         } else if (!hasServerId && !hasMessageServerId) {
           logger.debug("[Migration] → message_server_agents exists without required columns, truncating...");
-          await db.execute(sql17`TRUNCATE TABLE message_server_agents CASCADE`);
+          await db.execute(sql19`TRUNCATE TABLE message_server_agents CASCADE`);
           logger.debug("[Migration] ✓ Truncated message_server_agents");
         } else {
           logger.debug("[Migration] ⊘ message_server_agents already has correct schema");
@@ -391,7 +391,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger.debug("[Migration] → Checking channel_participants table...");
     try {
-      const columnsResult = await db.execute(sql17`
+      const columnsResult = await db.execute(sql19`
         SELECT column_name
         FROM information_schema.columns
         WHERE table_schema = 'public'
@@ -404,11 +404,11 @@ async function migrateToEntityRLS(adapter) {
       const hasEntityId = columns.some((c) => c.column_name === "entity_id");
       if (hasUserId && !hasEntityId) {
         logger.debug("[Migration] → Renaming channel_participants.user_id to entity_id...");
-        await db.execute(sql17.raw(`ALTER TABLE "channel_participants" RENAME COLUMN "user_id" TO "entity_id"`));
+        await db.execute(sql19.raw(`ALTER TABLE "channel_participants" RENAME COLUMN "user_id" TO "entity_id"`));
         logger.debug("[Migration] ✓ Renamed channel_participants.user_id → entity_id");
       } else if (!hasUserId && !hasEntityId) {
         logger.debug("[Migration] → channel_participants exists without entity_id or user_id, truncating...");
-        await db.execute(sql17`TRUNCATE TABLE channel_participants CASCADE`);
+        await db.execute(sql19`TRUNCATE TABLE channel_participants CASCADE`);
         logger.debug("[Migration] ✓ Truncated channel_participants");
       } else {
         logger.debug("[Migration] ⊘ channel_participants already has entity_id column");
@@ -418,7 +418,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger.debug("[Migration] → Discovering and dropping all regular indexes...");
     try {
-      const indexesResult = await db.execute(sql17`
+      const indexesResult = await db.execute(sql19`
         SELECT i.relname AS index_name
         FROM pg_index idx
         JOIN pg_class i ON i.oid = idx.indexrelid
@@ -435,7 +435,7 @@ async function migrateToEntityRLS(adapter) {
       for (const row of indexesToDrop) {
         const indexName = row.index_name;
         try {
-          await db.execute(sql17.raw(`DROP INDEX IF EXISTS "${indexName}"`));
+          await db.execute(sql19.raw(`DROP INDEX IF EXISTS "${indexName}"`));
           logger.debug(`[Migration] ✓ Dropped index ${indexName}`);
         } catch (_error) {
           logger.debug(`[Migration] ⊘ Could not drop index ${indexName}`);
@@ -500,14 +500,14 @@ async function migrateToEntityRLS(adapter) {
     ];
     for (const rename of columnRenames) {
       try {
-        const tableExistsResult = await db.execute(sql17`
+        const tableExistsResult = await db.execute(sql19`
           SELECT 1 FROM information_schema.tables
           WHERE table_schema = 'public' AND table_name = ${rename.table}
         `);
         if (!tableExistsResult.rows || tableExistsResult.rows.length === 0) {
           continue;
         }
-        const columnsResult = await db.execute(sql17`
+        const columnsResult = await db.execute(sql19`
           SELECT column_name
           FROM information_schema.columns
           WHERE table_schema = 'public'
@@ -520,11 +520,11 @@ async function migrateToEntityRLS(adapter) {
         const hasNewColumn = columns.some((c) => c.column_name === rename.to);
         if (hasOldColumn && !hasNewColumn) {
           logger.debug(`[Migration] → Renaming ${rename.table}.${rename.from} to ${rename.to}...`);
-          await db.execute(sql17.raw(`ALTER TABLE "${rename.table}" RENAME COLUMN "${rename.from}" TO "${rename.to}"`));
+          await db.execute(sql19.raw(`ALTER TABLE "${rename.table}" RENAME COLUMN "${rename.from}" TO "${rename.to}"`));
           logger.debug(`[Migration] ✓ Renamed ${rename.table}.${rename.from} → ${rename.to}`);
         } else if (hasOldColumn && hasNewColumn) {
           logger.debug(`[Migration] → Both columns exist, dropping ${rename.table}.${rename.from}...`);
-          await db.execute(sql17.raw(`ALTER TABLE "${rename.table}" DROP COLUMN "${rename.from}" CASCADE`));
+          await db.execute(sql19.raw(`ALTER TABLE "${rename.table}" DROP COLUMN "${rename.from}" CASCADE`));
           logger.debug(`[Migration] ✓ Dropped ${rename.table}.${rename.from}`);
         }
       } catch (error) {
@@ -542,17 +542,17 @@ var init_migrations = () => {};
 
 // rls.ts
 import { logger as logger2, validateUuid } from "@elizaos/core";
-import { eq, sql as sql18 } from "drizzle-orm";
+import { eq, sql as sql20 } from "drizzle-orm";
 async function installRLSFunctions(adapter) {
   const db = getDb(adapter);
-  await db.execute(sql18`
+  await db.execute(sql20`
     CREATE TABLE IF NOT EXISTS servers (
       id UUID PRIMARY KEY,
       created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
       updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
     )
   `);
-  await db.execute(sql18`
+  await db.execute(sql20`
     CREATE OR REPLACE FUNCTION current_server_id() RETURNS UUID AS $$
     DECLARE
       app_name TEXT;
@@ -567,7 +567,7 @@ async function installRLSFunctions(adapter) {
     END;
     $$ LANGUAGE plpgsql STABLE;
   `);
-  await db.execute(sql18`
+  await db.execute(sql20`
     CREATE OR REPLACE FUNCTION add_server_isolation(
       schema_name text,
       table_name text
@@ -611,7 +611,7 @@ async function installRLSFunctions(adapter) {
     END;
     $$ LANGUAGE plpgsql;
   `);
-  await db.execute(sql18`
+  await db.execute(sql20`
     CREATE OR REPLACE FUNCTION apply_rls_to_all_tables() RETURNS void AS $$
     DECLARE
       tbl record;
@@ -641,7 +641,7 @@ async function installRLSFunctions(adapter) {
 async function applyRLSToNewTables(adapter) {
   const db = getDb(adapter);
   try {
-    await db.execute(sql18`SELECT apply_rls_to_all_tables()`);
+    await db.execute(sql20`SELECT apply_rls_to_all_tables()`);
     logger2.info({ src: "plugin:sql" }, "RLS applied to all tables");
   } catch (error) {
     logger2.warn({ src: "plugin:sql", error: String(error) }, "Failed to apply RLS to some tables");
@@ -650,7 +650,7 @@ async function applyRLSToNewTables(adapter) {
 async function installEntityRLS(adapter) {
   const db = getDb(adapter);
   logger2.info("[Entity RLS] Installing entity RLS functions and policies...");
-  await db.execute(sql18`
+  await db.execute(sql20`
     CREATE OR REPLACE FUNCTION current_entity_id()
     RETURNS UUID AS $$
     DECLARE
@@ -672,7 +672,7 @@ async function installEntityRLS(adapter) {
     $$ LANGUAGE plpgsql STABLE;
   `);
   logger2.info("[Entity RLS] Created current_entity_id() function");
-  await db.execute(sql18`
+  await db.execute(sql20`
     CREATE OR REPLACE FUNCTION add_entity_isolation(
       schema_name text,
       table_name text,
@@ -829,7 +829,7 @@ async function installEntityRLS(adapter) {
     $$ LANGUAGE plpgsql;
   `);
   logger2.info("[Entity RLS] Created add_entity_isolation() function");
-  await db.execute(sql18`
+  await db.execute(sql20`
     CREATE OR REPLACE FUNCTION apply_entity_rls_to_all_tables() RETURNS void AS $$
     DECLARE
       tbl record;
@@ -873,7 +873,7 @@ async function installEntityRLS(adapter) {
 async function applyEntityRLSToAllTables(adapter) {
   const db = getDb(adapter);
   try {
-    await db.execute(sql18`SELECT apply_entity_rls_to_all_tables()`);
+    await db.execute(sql20`SELECT apply_entity_rls_to_all_tables()`);
     logger2.info("[Entity RLS] Applied entity RLS to all eligible tables");
   } catch (error) {
     logger2.warn("[Entity RLS] Failed to apply entity RLS to some tables:", String(error));
@@ -1466,7 +1466,7 @@ function hasChanges(previousSnapshot, currentSnapshot) {
   const currHash = hashSnapshot(currentSnapshot);
   return prevHash !== currHash;
 }
-var sqlToStr = (sql19, _casing) => {
+var sqlToStr = (sql21, _casing) => {
   const config = {
     escapeName: () => {
       throw new Error("we don't support params for `sql` default values");
@@ -1479,7 +1479,7 @@ var sqlToStr = (sql19, _casing) => {
     },
     casing: undefined
   };
-  return sql19.toQuery(config).sql;
+  return sql21.toQuery(config).sql;
 };
 var init_snapshot_generator = () => {};
 
@@ -1669,14 +1669,14 @@ async function generateMigrationSQL(previousSnapshot, currentSnapshot, diff) {
     const alterStatements = generateAlterColumnSQL(modified.table, modified.column, modified.changes);
     statements.push(...alterStatements);
   }
-  for (const index5 of diff.indexes.deleted) {
-    statements.push(generateDropIndexSQL(index5));
+  for (const index7 of diff.indexes.deleted) {
+    statements.push(generateDropIndexSQL(index7));
   }
   for (const alteredIndex of diff.indexes.altered) {
     statements.push(generateDropIndexSQL(alteredIndex.old));
   }
-  for (const index5 of diff.indexes.created) {
-    statements.push(generateCreateIndexSQL(index5));
+  for (const index7 of diff.indexes.created) {
+    statements.push(generateCreateIndexSQL(index7));
   }
   for (const alteredIndex of diff.indexes.altered) {
     statements.push(generateCreateIndexSQL(alteredIndex.new));
@@ -1773,18 +1773,18 @@ function generateCreateTableSQL(fullTableName, table) {
   return { tableSQL, fkSQLs };
 }
 function generateColumnDefinition(name, def) {
-  let sql19 = `"${name}" ${def.type}`;
+  let sql21 = `"${name}" ${def.type}`;
   if (def.primaryKey && !def.type.includes("SERIAL")) {
-    sql19 += " PRIMARY KEY";
+    sql21 += " PRIMARY KEY";
   }
   if (def.notNull) {
-    sql19 += " NOT NULL";
+    sql21 += " NOT NULL";
   }
   if (def.default !== undefined) {
     const defaultValue = formatDefaultValue(def.default, def.type);
-    sql19 += ` DEFAULT ${defaultValue}`;
+    sql21 += ` DEFAULT ${defaultValue}`;
   }
-  return sql19;
+  return sql21;
 }
 function generateAddColumnSQL(table, column, definition) {
   const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
@@ -1920,18 +1920,18 @@ function formatDefaultValue(value, type) {
   }
   return String(value);
 }
-function generateCreateIndexSQL(index5) {
-  const unique3 = index5.isUnique ? "UNIQUE " : "";
-  const method = index5.method || "btree";
-  const columns = index5.columns.map((c) => {
+function generateCreateIndexSQL(index7) {
+  const unique3 = index7.isUnique ? "UNIQUE " : "";
+  const method = index7.method || "btree";
+  const columns = index7.columns.map((c) => {
     if (c.isExpression) {
       return c.expression;
     }
     return `"${c.expression}"${c.asc === false ? " DESC" : ""}`;
   }).join(", ");
-  const indexName = index5.name.includes(".") ? index5.name.split(".")[1] : index5.name;
+  const indexName = index7.name.includes(".") ? index7.name.split(".")[1] : index7.name;
   let tableRef;
-  const indexTable = index5.table;
+  const indexTable = index7.table;
   if (indexTable?.includes(".")) {
     const [schema, table] = indexTable.split(".");
     tableRef = `"${schema}"."${table}"`;
@@ -1940,8 +1940,8 @@ function generateCreateIndexSQL(index5) {
   }
   return `CREATE ${unique3}INDEX "${indexName}" ON ${tableRef} USING ${method} (${columns});`;
 }
-function generateDropIndexSQL(index5) {
-  const indexNameFull = typeof index5 === "string" ? index5 : index5.name;
+function generateDropIndexSQL(index7) {
+  const indexNameFull = typeof index7 === "string" ? index7 : index7.name;
   const indexName = indexNameFull.includes(".") ? indexNameFull.split(".")[1] : indexNameFull;
   return `DROP INDEX IF EXISTS "${indexName}";`;
 }
@@ -1951,14 +1951,14 @@ function generateCreateForeignKeySQL(fk) {
   const tableFrom = fk.tableFrom;
   const columnsFrom = fk.columnsFrom.map((c) => `"${c}"`).join(", ");
   const columnsTo = fk.columnsTo.map((c) => `"${c}"`).join(", ");
-  let sql19 = `ALTER TABLE "${schemaFrom}"."${tableFrom}" ADD CONSTRAINT "${fk.name}" FOREIGN KEY (${columnsFrom}) REFERENCES "${schemaTo}"."${fk.tableTo}" (${columnsTo})`;
+  let sql21 = `ALTER TABLE "${schemaFrom}"."${tableFrom}" ADD CONSTRAINT "${fk.name}" FOREIGN KEY (${columnsFrom}) REFERENCES "${schemaTo}"."${fk.tableTo}" (${columnsTo})`;
   if (fk.onDelete) {
-    sql19 += ` ON DELETE ${fk.onDelete}`;
+    sql21 += ` ON DELETE ${fk.onDelete}`;
   }
   if (fk.onUpdate) {
-    sql19 += ` ON UPDATE ${fk.onUpdate}`;
+    sql21 += ` ON UPDATE ${fk.onUpdate}`;
   }
-  return `${sql19};`;
+  return `${sql21};`;
 }
 function generateDropForeignKeySQL(fk) {
   const [schema, tableName] = fk.tableFrom ? fk.tableFrom.includes(".") ? fk.tableFrom.split(".") : ["public", fk.tableFrom] : ["public", ""];
@@ -1969,12 +1969,12 @@ function generateCreateUniqueConstraintSQL(constraint) {
   const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
   const name = constraint.name;
   const columns = constraint.columns.map((c) => `"${c}"`).join(", ");
-  let sql19 = `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${name}" UNIQUE`;
+  let sql21 = `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${name}" UNIQUE`;
   if (constraint.nullsNotDistinct) {
-    sql19 += ` NULLS NOT DISTINCT`;
+    sql21 += ` NULLS NOT DISTINCT`;
   }
-  sql19 += ` (${columns});`;
-  return sql19;
+  sql21 += ` (${columns});`;
+  return sql21;
 }
 function generateDropUniqueConstraintSQL(constraint) {
   const table = constraint.table || "";
@@ -1997,7 +1997,7 @@ var init_sql_generator = () => {};
 
 // runtime-migrator/drizzle-adapters/database-introspector.ts
 import { logger as logger4 } from "@elizaos/core";
-import { sql as sql19 } from "drizzle-orm";
+import { sql as sql21 } from "drizzle-orm";
 function getRows2(result) {
   return result.rows;
 }
@@ -2126,7 +2126,7 @@ class DatabaseIntrospector {
     };
   }
   async getTables(schemaName) {
-    const result = await this.db.execute(sql19`SELECT 
+    const result = await this.db.execute(sql21`SELECT 
             table_schema,
             table_name
           FROM information_schema.tables
@@ -2136,7 +2136,7 @@ class DatabaseIntrospector {
     return getRows2(result);
   }
   async getColumns(schemaName, tableName) {
-    const result = await this.db.execute(sql19`SELECT 
+    const result = await this.db.execute(sql21`SELECT 
             a.attname AS column_name,
             CASE 
               WHEN a.attnotnull THEN 'NO'
@@ -2179,7 +2179,7 @@ class DatabaseIntrospector {
     return getRows2(result);
   }
   async getIndexes(schemaName, tableName) {
-    const result = await this.db.execute(sql19`SELECT 
+    const result = await this.db.execute(sql21`SELECT 
             i.relname AS name,
             idx.indisunique AS is_unique,
             idx.indisprimary AS is_primary,
@@ -2203,7 +2203,7 @@ class DatabaseIntrospector {
     return getRows2(result);
   }
   async getForeignKeys(schemaName, tableName) {
-    const result = await this.db.execute(sql19`SELECT
+    const result = await this.db.execute(sql21`SELECT
             con.conname AS name,
             att.attname AS column_name,
             fnsp.nspname AS foreign_table_schema,
@@ -2238,7 +2238,7 @@ class DatabaseIntrospector {
     return getRows2(result);
   }
   async getPrimaryKeys(schemaName, tableName) {
-    const result = await this.db.execute(sql19`SELECT 
+    const result = await this.db.execute(sql21`SELECT 
             con.conname AS name,
             ARRAY(
               SELECT a.attname
@@ -2256,7 +2256,7 @@ class DatabaseIntrospector {
     return getRows2(result);
   }
   async getUniqueConstraints(schemaName, tableName) {
-    const result = await this.db.execute(sql19`SELECT 
+    const result = await this.db.execute(sql21`SELECT 
             con.conname AS name,
             ARRAY(
               SELECT a.attname
@@ -2274,7 +2274,7 @@ class DatabaseIntrospector {
     return getRows2(result);
   }
   async getCheckConstraints(schemaName, tableName) {
-    const result = await this.db.execute(sql19`SELECT 
+    const result = await this.db.execute(sql21`SELECT 
             con.conname AS name,
             pg_get_constraintdef(con.oid) AS definition
           FROM pg_constraint con
@@ -2286,7 +2286,7 @@ class DatabaseIntrospector {
     return getRows2(result);
   }
   async getEnums(schemaName) {
-    const result = await this.db.execute(sql19`SELECT 
+    const result = await this.db.execute(sql21`SELECT 
             n.nspname AS schema,
             t.typname AS name,
             e.enumlabel AS value,
@@ -2318,7 +2318,7 @@ class DatabaseIntrospector {
   }
   async hasExistingTables(pluginName) {
     const schemaName = pluginName === "@elizaos/plugin-sql" ? "public" : this.deriveSchemaName(pluginName);
-    const result = await this.db.execute(sql19`SELECT COUNT(*) AS count
+    const result = await this.db.execute(sql21`SELECT COUNT(*) AS count
           FROM information_schema.tables
           WHERE table_schema = ${schemaName}
             AND table_type = 'BASE TABLE'`);
@@ -2334,7 +2334,7 @@ var init_database_introspector = () => {};
 
 // runtime-migrator/extension-manager.ts
 import { logger as logger5 } from "@elizaos/core";
-import { sql as sql20 } from "drizzle-orm";
+import { sql as sql22 } from "drizzle-orm";
 
 class ExtensionManager {
   db;
@@ -2348,7 +2348,7 @@ class ExtensionManager {
           logger5.warn({ src: "plugin:sql", extension }, "Invalid extension name - contains invalid characters");
           continue;
         }
-        await this.db.execute(sql20`CREATE EXTENSION IF NOT EXISTS ${sql20.identifier(extension)}`);
+        await this.db.execute(sql22`CREATE EXTENSION IF NOT EXISTS ${sql22.identifier(extension)}`);
         logger5.debug({ src: "plugin:sql", extension }, "Extension installed");
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -2404,7 +2404,7 @@ function normalizeSchemaName(input) {
 var init_schema_transformer = () => {};
 
 // runtime-migrator/storage/journal-storage.ts
-import { sql as sql21 } from "drizzle-orm";
+import { sql as sql23 } from "drizzle-orm";
 
 class JournalStorage {
   db;
@@ -2412,7 +2412,7 @@ class JournalStorage {
     this.db = db;
   }
   async loadJournal(pluginName) {
-    const result = await this.db.execute(sql21`SELECT version, dialect, entries 
+    const result = await this.db.execute(sql23`SELECT version, dialect, entries 
           FROM migrations._journal 
           WHERE plugin_name = ${pluginName}`);
     if (result.rows.length === 0) {
@@ -2429,7 +2429,7 @@ class JournalStorage {
     };
   }
   async saveJournal(pluginName, journal) {
-    await this.db.execute(sql21`INSERT INTO migrations._journal (plugin_name, version, dialect, entries)
+    await this.db.execute(sql23`INSERT INTO migrations._journal (plugin_name, version, dialect, entries)
           VALUES (${pluginName}, ${journal.version}, ${journal.dialect}, ${JSON.stringify(journal.entries)}::jsonb)
           ON CONFLICT (plugin_name) 
           DO UPDATE SET 
@@ -2471,7 +2471,7 @@ class JournalStorage {
 var init_journal_storage = () => {};
 
 // runtime-migrator/storage/migration-tracker.ts
-import { sql as sql22 } from "drizzle-orm";
+import { sql as sql24 } from "drizzle-orm";
 
 class MigrationTracker {
   db;
@@ -2479,11 +2479,11 @@ class MigrationTracker {
     this.db = db;
   }
   async ensureSchema() {
-    await this.db.execute(sql22`CREATE SCHEMA IF NOT EXISTS migrations`);
+    await this.db.execute(sql24`CREATE SCHEMA IF NOT EXISTS migrations`);
   }
   async ensureTables() {
     await this.ensureSchema();
-    await this.db.execute(sql22`
+    await this.db.execute(sql24`
       CREATE TABLE IF NOT EXISTS migrations._migrations (
         id SERIAL PRIMARY KEY,
         plugin_name TEXT NOT NULL,
@@ -2491,7 +2491,7 @@ class MigrationTracker {
         created_at BIGINT NOT NULL
       )
     `);
-    await this.db.execute(sql22`
+    await this.db.execute(sql24`
       CREATE TABLE IF NOT EXISTS migrations._journal (
         plugin_name TEXT PRIMARY KEY,
         version TEXT NOT NULL,
@@ -2499,7 +2499,7 @@ class MigrationTracker {
         entries JSONB NOT NULL DEFAULT '[]'
       )
     `);
-    await this.db.execute(sql22`
+    await this.db.execute(sql24`
       CREATE TABLE IF NOT EXISTS migrations._snapshots (
         id SERIAL PRIMARY KEY,
         plugin_name TEXT NOT NULL,
@@ -2511,7 +2511,7 @@ class MigrationTracker {
     `);
   }
   async getLastMigration(pluginName) {
-    const result = await this.db.execute(sql22`SELECT id, hash, created_at
+    const result = await this.db.execute(sql24`SELECT id, hash, created_at
           FROM migrations._migrations
           WHERE plugin_name = ${pluginName}
           ORDER BY created_at DESC
@@ -2519,14 +2519,14 @@ class MigrationTracker {
     return getRow(result) || null;
   }
   async recordMigration(pluginName, hash, createdAt) {
-    await this.db.execute(sql22`INSERT INTO migrations._migrations (plugin_name, hash, created_at) 
+    await this.db.execute(sql24`INSERT INTO migrations._migrations (plugin_name, hash, created_at) 
           VALUES (${pluginName}, ${hash}, ${createdAt})`);
   }
 }
 var init_migration_tracker = () => {};
 
 // runtime-migrator/storage/snapshot-storage.ts
-import { sql as sql23 } from "drizzle-orm";
+import { sql as sql25 } from "drizzle-orm";
 
 class SnapshotStorage {
   db;
@@ -2534,7 +2534,7 @@ class SnapshotStorage {
     this.db = db;
   }
   async saveSnapshot(pluginName, idx, snapshot) {
-    await this.db.execute(sql23`INSERT INTO migrations._snapshots (plugin_name, idx, snapshot)
+    await this.db.execute(sql25`INSERT INTO migrations._snapshots (plugin_name, idx, snapshot)
           VALUES (${pluginName}, ${idx}, ${JSON.stringify(snapshot)}::jsonb)
           ON CONFLICT (plugin_name, idx) 
           DO UPDATE SET 
@@ -2542,7 +2542,7 @@ class SnapshotStorage {
             created_at = NOW()`);
   }
   async loadSnapshot(pluginName, idx) {
-    const result = await this.db.execute(sql23`SELECT snapshot 
+    const result = await this.db.execute(sql25`SELECT snapshot 
           FROM migrations._snapshots 
           WHERE plugin_name = ${pluginName} AND idx = ${idx}`);
     if (result.rows.length === 0) {
@@ -2551,7 +2551,7 @@ class SnapshotStorage {
     return result.rows[0].snapshot;
   }
   async getLatestSnapshot(pluginName) {
-    const result = await this.db.execute(sql23`SELECT snapshot 
+    const result = await this.db.execute(sql25`SELECT snapshot 
           FROM migrations._snapshots 
           WHERE plugin_name = ${pluginName}
           ORDER BY idx DESC
@@ -2562,7 +2562,7 @@ class SnapshotStorage {
     return result.rows[0].snapshot;
   }
   async getAllSnapshots(pluginName) {
-    const result = await this.db.execute(sql23`SELECT snapshot 
+    const result = await this.db.execute(sql25`SELECT snapshot 
           FROM migrations._snapshots 
           WHERE plugin_name = ${pluginName}
           ORDER BY idx ASC`);
@@ -2573,7 +2573,7 @@ var init_snapshot_storage = () => {};
 
 // runtime-migrator/runtime-migrator.ts
 import { logger as logger7 } from "@elizaos/core";
-import { sql as sql24 } from "drizzle-orm";
+import { sql as sql26 } from "drizzle-orm";
 
 class RuntimeMigrator {
   db;
@@ -2611,7 +2611,7 @@ class RuntimeMigrator {
     }
     for (const schemaName of schemasToCreate) {
       logger7.debug({ src: "plugin:sql", schemaName }, "Ensuring schema exists");
-      await this.db.execute(sql24.raw(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`));
+      await this.db.execute(sql26.raw(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`));
     }
   }
   validateSchemaUsage(pluginName, snapshot) {
@@ -2765,11 +2765,11 @@ class RuntimeMigrator {
         try {
           logger7.debug({ src: "plugin:sql", pluginName }, "Using PostgreSQL advisory locks");
           const lockIdStr = lockId.toString();
-          const lockResult = await this.db.execute(sql24`SELECT pg_try_advisory_lock(CAST(${lockIdStr} AS bigint)) as acquired`);
+          const lockResult = await this.db.execute(sql26`SELECT pg_try_advisory_lock(CAST(${lockIdStr} AS bigint)) as acquired`);
           lockAcquired = getRow(lockResult)?.acquired === true;
           if (!lockAcquired) {
             logger7.info({ src: "plugin:sql", pluginName }, "Migration already in progress, waiting for lock");
-            await this.db.execute(sql24`SELECT pg_advisory_lock(CAST(${lockIdStr} AS bigint))`);
+            await this.db.execute(sql26`SELECT pg_advisory_lock(CAST(${lockIdStr} AS bigint))`);
             lockAcquired = true;
             logger7.info({ src: "plugin:sql", pluginName }, "Lock acquired");
           } else {
@@ -2900,7 +2900,7 @@ class RuntimeMigrator {
       if (lockAcquired && isRealPostgres) {
         try {
           const lockIdStr = lockId.toString();
-          await this.db.execute(sql24`SELECT pg_advisory_unlock(CAST(${lockIdStr} AS bigint))`);
+          await this.db.execute(sql26`SELECT pg_advisory_unlock(CAST(${lockIdStr} AS bigint))`);
           logger7.debug({ src: "plugin:sql", pluginName }, "Advisory lock released");
         } catch (unlockError) {
           logger7.warn({
@@ -2915,23 +2915,23 @@ class RuntimeMigrator {
   async executeMigration(pluginName, snapshot, hash, sqlStatements) {
     let transactionStarted = false;
     try {
-      await this.db.execute(sql24`BEGIN`);
+      await this.db.execute(sql26`BEGIN`);
       transactionStarted = true;
       for (const stmt of sqlStatements) {
         logger7.debug({ src: "plugin:sql", statement: stmt }, "Executing SQL statement");
-        await this.db.execute(sql24.raw(stmt));
+        await this.db.execute(sql26.raw(stmt));
       }
       const idx = await this.journalStorage.getNextIdx(pluginName);
       await this.migrationTracker.recordMigration(pluginName, hash, Date.now());
       const tag = this.generateMigrationTag(idx, pluginName);
       await this.journalStorage.updateJournal(pluginName, idx, tag, true);
       await this.snapshotStorage.saveSnapshot(pluginName, idx, snapshot);
-      await this.db.execute(sql24`COMMIT`);
+      await this.db.execute(sql26`COMMIT`);
       logger7.info({ src: "plugin:sql", pluginName, tag }, "Recorded migration");
     } catch (error) {
       if (transactionStarted) {
         try {
-          await this.db.execute(sql24`ROLLBACK`);
+          await this.db.execute(sql26`ROLLBACK`);
           logger7.error({
             src: "plugin:sql",
             error: error instanceof Error ? error.message : String(error)
@@ -2948,8 +2948,8 @@ class RuntimeMigrator {
   }
   generateMigrationTag(idx, pluginName) {
     const prefix = idx.toString().padStart(4, "0");
-    const timestamp17 = Date.now().toString(36);
-    return `${prefix}_${pluginName}_${timestamp17}`;
+    const timestamp19 = Date.now().toString(36);
+    return `${prefix}_${pluginName}_${timestamp19}`;
   }
   async getStatus(pluginName) {
     const lastMigration = await this.migrationTracker.getLastMigration(pluginName);
@@ -2964,9 +2964,9 @@ class RuntimeMigrator {
   }
   async reset(pluginName) {
     logger7.warn({ src: "plugin:sql", pluginName }, "Resetting migrations");
-    await this.db.execute(sql24`DELETE FROM migrations._migrations WHERE plugin_name = ${pluginName}`);
-    await this.db.execute(sql24`DELETE FROM migrations._journal WHERE plugin_name = ${pluginName}`);
-    await this.db.execute(sql24`DELETE FROM migrations._snapshots WHERE plugin_name = ${pluginName}`);
+    await this.db.execute(sql26`DELETE FROM migrations._migrations WHERE plugin_name = ${pluginName}`);
+    await this.db.execute(sql26`DELETE FROM migrations._journal WHERE plugin_name = ${pluginName}`);
+    await this.db.execute(sql26`DELETE FROM migrations._snapshots WHERE plugin_name = ${pluginName}`);
     logger7.warn({ src: "plugin:sql", pluginName }, "Reset complete");
   }
   async checkMigration(pluginName, schema) {
@@ -3147,10 +3147,10 @@ import {
   lt,
   lte,
   or,
-  sql as sql25
+  sql as sql27
 } from "drizzle-orm";
 
-// ../../../node_modules/uuid/dist/stringify.js
+// ../../../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist/stringify.js
 var byteToHex = [];
 for (let i = 0;i < 256; ++i) {
   byteToHex.push((i + 256).toString(16).slice(1));
@@ -3159,7 +3159,7 @@ function unsafeStringify(arr, offset = 0) {
   return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
 }
 
-// ../../../node_modules/uuid/dist/rng.js
+// ../../../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist/rng.js
 var getRandomValues;
 var rnds8 = new Uint8Array(16);
 function rng() {
@@ -3172,11 +3172,11 @@ function rng() {
   return getRandomValues(rnds8);
 }
 
-// ../../../node_modules/uuid/dist/native.js
+// ../../../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist/native.js
 var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
 var native_default = { randomUUID };
 
-// ../../../node_modules/uuid/dist/v4.js
+// ../../../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist/v4.js
 function _v4(options, buf, offset) {
   options = options || {};
   const rnds = options.random ?? options.rng?.() ?? rng();
@@ -3361,6 +3361,8 @@ __export(exports_schema, {
   roomTable: () => roomTable,
   relationshipTable: () => relationshipTable,
   participantTable: () => participantTable,
+  pairingRequestTable: () => pairingRequestTable,
+  pairingAllowlistTable: () => pairingAllowlistTable,
   messageTable: () => messageTable,
   messageServerTable: () => messageServerTable,
   messageServerAgentsTable: () => messageServerAgentsTable,
@@ -3503,26 +3505,59 @@ var messageServerAgentsTable = pgTable14("message_server_agents", {
   messageServerId: uuid12("message_server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
   agentId: uuid12("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" })
 }, (table) => [primaryKey3({ columns: [table.messageServerId, table.agentId] })]);
-// schema/participant.ts
+// schema/pairingAllowlist.ts
 init_agent();
 import { sql as sql13 } from "drizzle-orm";
-import { foreignKey as foreignKey4, index as index3, pgTable as pgTable15, text as text13, timestamp as timestamp13, uuid as uuid13 } from "drizzle-orm/pg-core";
-var participantTable = pgTable15("participants", {
-  id: uuid13("id").notNull().primaryKey().default(sql13`gen_random_uuid()`),
+import { index as index3, jsonb as jsonb12, pgTable as pgTable15, text as text13, timestamp as timestamp13, uniqueIndex, uuid as uuid13 } from "drizzle-orm/pg-core";
+var pairingAllowlistTable = pgTable15("pairing_allowlist", {
+  id: uuid13("id").primaryKey().defaultRandom(),
+  channel: text13("channel").notNull(),
+  senderId: text13("sender_id").notNull(),
   createdAt: timestamp13("created_at", { withTimezone: true }).default(sql13`now()`).notNull(),
-  entityId: uuid13("entity_id").references(() => entityTable.id, {
+  metadata: jsonb12("metadata").default(sql13`'{}'::jsonb`),
+  agentId: uuid13("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" })
+}, (table) => [
+  index3("pairing_allowlist_channel_agent_idx").on(table.channel, table.agentId),
+  uniqueIndex("pairing_allowlist_sender_channel_agent_idx").on(table.senderId, table.channel, table.agentId)
+]);
+// schema/pairingRequest.ts
+init_agent();
+import { sql as sql14 } from "drizzle-orm";
+import { index as index4, jsonb as jsonb13, pgTable as pgTable16, text as text14, timestamp as timestamp14, uniqueIndex as uniqueIndex2, uuid as uuid14 } from "drizzle-orm/pg-core";
+var pairingRequestTable = pgTable16("pairing_requests", {
+  id: uuid14("id").primaryKey().defaultRandom(),
+  channel: text14("channel").notNull(),
+  senderId: text14("sender_id").notNull(),
+  code: text14("code").notNull(),
+  createdAt: timestamp14("created_at", { withTimezone: true }).default(sql14`now()`).notNull(),
+  lastSeenAt: timestamp14("last_seen_at", { withTimezone: true }).default(sql14`now()`).notNull(),
+  metadata: jsonb13("metadata").default(sql14`'{}'::jsonb`),
+  agentId: uuid14("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" })
+}, (table) => [
+  index4("pairing_requests_channel_agent_idx").on(table.channel, table.agentId),
+  uniqueIndex2("pairing_requests_code_channel_agent_idx").on(table.code, table.channel, table.agentId),
+  uniqueIndex2("pairing_requests_sender_channel_agent_idx").on(table.senderId, table.channel, table.agentId)
+]);
+// schema/participant.ts
+init_agent();
+import { sql as sql15 } from "drizzle-orm";
+import { foreignKey as foreignKey4, index as index5, pgTable as pgTable17, text as text15, timestamp as timestamp15, uuid as uuid15 } from "drizzle-orm/pg-core";
+var participantTable = pgTable17("participants", {
+  id: uuid15("id").notNull().primaryKey().default(sql15`gen_random_uuid()`),
+  createdAt: timestamp15("created_at", { withTimezone: true }).default(sql15`now()`).notNull(),
+  entityId: uuid15("entity_id").references(() => entityTable.id, {
     onDelete: "cascade"
   }),
-  roomId: uuid13("room_id").references(() => roomTable.id, {
+  roomId: uuid15("room_id").references(() => roomTable.id, {
     onDelete: "cascade"
   }),
-  agentId: uuid13("agent_id").references(() => agentTable.id, {
+  agentId: uuid15("agent_id").references(() => agentTable.id, {
     onDelete: "cascade"
   }),
-  roomState: text13("room_state")
+  roomState: text15("room_state")
 }, (table) => [
-  index3("idx_participants_user").on(table.entityId),
-  index3("idx_participants_room").on(table.roomId),
+  index5("idx_participants_user").on(table.entityId),
+  index5("idx_participants_room").on(table.roomId),
   foreignKey4({
     name: "fk_room",
     columns: [table.roomId],
@@ -3536,27 +3571,27 @@ var participantTable = pgTable15("participants", {
 ]);
 // schema/relationship.ts
 init_agent();
-import { sql as sql14 } from "drizzle-orm";
+import { sql as sql16 } from "drizzle-orm";
 import {
   foreignKey as foreignKey5,
-  index as index4,
-  jsonb as jsonb12,
-  pgTable as pgTable16,
-  text as text14,
-  timestamp as timestamp14,
+  index as index6,
+  jsonb as jsonb14,
+  pgTable as pgTable18,
+  text as text16,
+  timestamp as timestamp16,
   unique as unique2,
-  uuid as uuid14
+  uuid as uuid16
 } from "drizzle-orm/pg-core";
-var relationshipTable = pgTable16("relationships", {
-  id: uuid14("id").notNull().primaryKey().default(sql14`gen_random_uuid()`),
-  createdAt: timestamp14("created_at", { withTimezone: true }).default(sql14`now()`).notNull(),
-  sourceEntityId: uuid14("source_entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
-  targetEntityId: uuid14("target_entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
-  agentId: uuid14("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
-  tags: text14("tags").array(),
-  metadata: jsonb12("metadata")
+var relationshipTable = pgTable18("relationships", {
+  id: uuid16("id").notNull().primaryKey().default(sql16`gen_random_uuid()`),
+  createdAt: timestamp16("created_at", { withTimezone: true }).default(sql16`now()`).notNull(),
+  sourceEntityId: uuid16("source_entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  targetEntityId: uuid16("target_entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  agentId: uuid16("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  tags: text16("tags").array(),
+  metadata: jsonb14("metadata")
 }, (table) => [
-  index4("idx_relationships_users").on(table.sourceEntityId, table.targetEntityId),
+  index6("idx_relationships_users").on(table.sourceEntityId, table.targetEntityId),
   unique2("unique_relationship").on(table.sourceEntityId, table.targetEntityId, table.agentId),
   foreignKey5({
     name: "fk_user_a",
@@ -3575,20 +3610,20 @@ init_server();
 
 // schema/tasks.ts
 init_agent();
-import { sql as sql16 } from "drizzle-orm";
-import { jsonb as jsonb13, pgTable as pgTable18, text as text15, timestamp as timestamp16, uuid as uuid16 } from "drizzle-orm/pg-core";
-var taskTable = pgTable18("tasks", {
-  id: uuid16("id").primaryKey().defaultRandom(),
-  name: text15("name").notNull(),
-  description: text15("description"),
-  roomId: uuid16("room_id"),
-  worldId: uuid16("world_id"),
-  entityId: uuid16("entity_id"),
-  agentId: uuid16("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
-  tags: text15("tags").array().default(sql16`'{}'::text[]`),
-  metadata: jsonb13("metadata").default(sql16`'{}'::jsonb`),
-  createdAt: timestamp16("created_at", { withTimezone: true }).defaultNow(),
-  updatedAt: timestamp16("updated_at", { withTimezone: true }).defaultNow()
+import { sql as sql18 } from "drizzle-orm";
+import { jsonb as jsonb15, pgTable as pgTable20, text as text17, timestamp as timestamp18, uuid as uuid18 } from "drizzle-orm/pg-core";
+var taskTable = pgTable20("tasks", {
+  id: uuid18("id").primaryKey().defaultRandom(),
+  name: text17("name").notNull(),
+  description: text17("description"),
+  roomId: uuid18("room_id"),
+  worldId: uuid18("world_id"),
+  entityId: uuid18("entity_id"),
+  agentId: uuid18("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  tags: text17("tags").array().default(sql18`'{}'::text[]`),
+  metadata: jsonb15("metadata").default(sql18`'{}'::jsonb`),
+  createdAt: timestamp18("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp18("updated_at", { withTimezone: true }).defaultNow()
 });
 // base.ts
 class BaseDrizzleAdapter extends DatabaseAdapter {
@@ -3998,11 +4033,11 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async getEntitiesByNames(params) {
     return this.withDatabase(async () => {
       const { names, agentId } = params;
-      const nameConditions = names.map((name) => sql25`${name} = ANY(${entityTable.names})`);
-      const query = sql25`
+      const nameConditions = names.map((name) => sql27`${name} = ANY(${entityTable.names})`);
+      const query = sql27`
         SELECT * FROM ${entityTable}
         WHERE ${entityTable.agentId} = ${agentId}
-        AND (${sql25.join(nameConditions, sql25` OR `)})
+        AND (${sql27.join(nameConditions, sql27` OR `)})
       `;
       const result = await this.db.execute(query);
       return result.rows.map((row) => ({
@@ -4025,7 +4060,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           metadata: row.metadata || {}
         }));
       }
-      const searchQuery = sql25`
+      const searchQuery = sql27`
         SELECT * FROM ${entityTable}
         WHERE ${entityTable.agentId} = ${agentId}
         AND EXISTS (
@@ -4281,7 +4316,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async getCachedEmbeddings(opts) {
     return this.withDatabase(async () => {
       try {
-        const results = await this.db.execute(sql25`
+        const results = await this.db.execute(sql27`
                     WITH content_text AS (
                         SELECT
                             m.id,
@@ -4341,7 +4376,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         const jsonString = JSON.stringify(sanitizedBody);
         await this.withEntityContext(params.entityId, async (tx) => {
           await tx.insert(logTable).values({
-            body: sql25`${jsonString}::jsonb`,
+            body: sql27`${jsonString}::jsonb`,
             entityId: params.entityId,
             roomId: params.roomId,
             type: params.type
@@ -4415,7 +4450,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       const runMap = new Map;
       const conditions = [
         eq2(logTable.type, "run_event"),
-        sql25`${logTable.body} ? 'runId'`,
+        sql27`${logTable.body} ? 'runId'`,
         eq2(roomTable.agentId, this.agentId)
       ];
       if (params.roomId) {
@@ -4430,9 +4465,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       const whereClause = and(...conditions);
       const eventLimit = Math.max(limit * 20, 200);
       const runEventRows = await tx.select({
-        runId: sql25`(${logTable.body} ->> 'runId')`,
-        status: sql25`(${logTable.body} ->> 'status')`,
-        messageId: sql25`(${logTable.body} ->> 'messageId')`,
+        runId: sql27`(${logTable.body} ->> 'runId')`,
+        status: sql27`(${logTable.body} ->> 'status')`,
+        messageId: sql27`(${logTable.body} ->> 'messageId')`,
         rawBody: logTable.body,
         createdAt: logTable.createdAt,
         roomId: logTable.roomId,
@@ -4479,18 +4514,18 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           }
         }
         const createdAt = row.createdAt instanceof Date ? row.createdAt : new Date(row.createdAt);
-        const timestamp17 = createdAt.getTime();
+        const timestamp19 = createdAt.getTime();
         const bodyStatus = body?.status;
         const eventStatus = row.status ?? bodyStatus;
         if (eventStatus === "started") {
           const currentStartedAt = summary.startedAt === null ? null : typeof summary.startedAt === "bigint" ? Number(summary.startedAt) : summary.startedAt;
-          summary.startedAt = currentStartedAt === null ? timestamp17 : Math.min(currentStartedAt, timestamp17);
+          summary.startedAt = currentStartedAt === null ? timestamp19 : Math.min(currentStartedAt, timestamp19);
         } else if (eventStatus === "completed" || eventStatus === "timeout" || eventStatus === "error") {
           summary.status = eventStatus;
-          summary.endedAt = timestamp17;
+          summary.endedAt = timestamp19;
           if (summary.startedAt !== null) {
             const startedAtNum = typeof summary.startedAt === "bigint" ? Number(summary.startedAt) : summary.startedAt;
-            summary.durationMs = Math.max(timestamp17 - startedAtNum, 0);
+            summary.durationMs = Math.max(timestamp19 - startedAtNum, 0);
           }
         }
         runMap.set(runId, summary);
@@ -4518,8 +4553,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       }
       const runIds = limitedRuns.map((run) => run.runId).filter(Boolean);
       if (runIds.length > 0) {
-        const runIdArray = sql25`array[${sql25.join(runIds.map((id) => sql25`${id}`), sql25`, `)}]::text[]`;
-        const actionSummary = await this.db.execute(sql25`
+        const runIdArray = sql27`array[${sql27.join(runIds.map((id) => sql27`${id}`), sql27`, `)}]::text[]`;
+        const actionSummary = await this.db.execute(sql27`
           SELECT
             body->>'runId' as "runId",
             COUNT(*)::int as "actions",
@@ -4539,7 +4574,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           counts.errors += Number(row.errors ?? 0);
           counts.modelCalls += Number(row.modelCalls ?? 0);
         }
-        const evaluatorSummary = await this.db.execute(sql25`
+        const evaluatorSummary = await this.db.execute(sql27`
           SELECT
             body->>'runId' as "runId",
             COUNT(*)::int as "evaluators"
@@ -4555,7 +4590,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
             continue;
           counts.evaluators += Number(row.evaluators ?? 0);
         }
-        const genericSummary = await this.db.execute(sql25`
+        const genericSummary = await this.db.execute(sql27`
           SELECT
             body->>'runId' as "runId",
             COUNT(*) FILTER (WHERE type LIKE 'useModel:%')::int as "modelLogs",
@@ -4609,7 +4644,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async searchMemoriesByEmbedding(embedding, params) {
     return this.withDatabase(async () => {
       const cleanVector = embedding.map((n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0);
-      const similarity = sql25`1 - (${cosineDistance(embeddingTable[this.embeddingDimension], cleanVector)})`;
+      const similarity = sql27`1 - (${cosineDistance(embeddingTable[this.embeddingDimension], cleanVector)})`;
       const conditions = [eq2(memoryTable.type, params.tableName)];
       if (params.unique) {
         conditions.push(eq2(memoryTable.unique, true));
@@ -4675,8 +4710,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         {
           id: memoryId,
           type: tableName,
-          content: sql25`${contentToInsert}::jsonb`,
-          metadata: sql25`${metadataToInsert}::jsonb`,
+          content: sql27`${contentToInsert}::jsonb`,
+          metadata: sql27`${metadataToInsert}::jsonb`,
           entityId: memory.entityId,
           roomId: memory.roomId,
           worldId: memory.worldId,
@@ -4706,15 +4741,15 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
             const contentToUpdate = typeof memory.content === "string" ? memory.content : JSON.stringify(memory.content ?? {});
             const metadataToUpdate = typeof memory.metadata === "string" ? memory.metadata : JSON.stringify(memory.metadata ?? {});
             await tx.update(memoryTable).set({
-              content: sql25`${contentToUpdate}::jsonb`,
+              content: sql27`${contentToUpdate}::jsonb`,
               ...memory.metadata && {
-                metadata: sql25`${metadataToUpdate}::jsonb`
+                metadata: sql27`${metadataToUpdate}::jsonb`
               }
             }).where(eq2(memoryTable.id, memory.id));
           } else if (memory.metadata) {
             const metadataToUpdate = typeof memory.metadata === "string" ? memory.metadata : JSON.stringify(memory.metadata ?? {});
             await tx.update(memoryTable).set({
-              metadata: sql25`${metadataToUpdate}::jsonb`
+              metadata: sql27`${metadataToUpdate}::jsonb`
             }).where(eq2(memoryTable.id, memory.id));
           }
           if (memory.embedding && Array.isArray(memory.embedding)) {
@@ -4781,7 +4816,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     }
   }
   async getMemoryFragments(tx, documentId) {
-    const fragments = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq2(memoryTable.agentId, this.agentId), sql25`${memoryTable.metadata}->>'documentId' = ${documentId}`));
+    const fragments = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq2(memoryTable.agentId, this.agentId), sql27`${memoryTable.metadata}->>'documentId' = ${documentId}`));
     return fragments.map((f) => ({ id: f.id }));
   }
   async deleteAllMemories(roomId, tableName) {
@@ -4809,7 +4844,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       if (unique3) {
         conditions.push(eq2(memoryTable.unique, true));
       }
-      const result = await this.db.select({ count: sql25`count(*)` }).from(memoryTable).where(and(...conditions));
+      const result = await this.db.select({ count: sql27`count(*)` }).from(memoryTable).where(and(...conditions));
       const result0 = result[0];
       return Number(result0?.count ?? 0);
     });
@@ -5080,13 +5115,13 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       const { entityId, tags } = params;
       let query;
       if (tags && tags.length > 0) {
-        query = sql25`
+        query = sql27`
           SELECT * FROM ${relationshipTable}
           WHERE (${relationshipTable.sourceEntityId} = ${entityId} OR ${relationshipTable.targetEntityId} = ${entityId})
-          AND ${relationshipTable.tags} && CAST(ARRAY[${sql25.join(tags, sql25`, `)}] AS text[])
+          AND ${relationshipTable.tags} && CAST(ARRAY[${sql27.join(tags, sql27`, `)}] AS text[])
         `;
       } else {
-        query = sql25`
+        query = sql27`
           SELECT * FROM ${relationshipTable}
           WHERE ${relationshipTable.sourceEntityId} = ${entityId} OR ${relationshipTable.targetEntityId} = ${entityId}
         `;
@@ -5228,7 +5263,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withRetry(async () => {
       return this.withDatabase(async () => {
         const result = await this.db.select().from(taskTable).where(and(eq2(taskTable.agentId, this.agentId), ...params.roomId ? [eq2(taskTable.roomId, params.roomId)] : [], ...params.tags && params.tags.length > 0 ? [
-          sql25`${taskTable.tags} @> ARRAY[${sql25.join(params.tags.map((t) => sql25`${t}`), sql25`, `)}]::text[]`
+          sql27`${taskTable.tags} @> ARRAY[${sql27.join(params.tags.map((t) => sql27`${t}`), sql27`, `)}]::text[]`
         ] : []));
         return result.map((row) => ({
           id: row.id,
@@ -5418,7 +5453,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async getMessageServerByRlsServerId(rlsServerId) {
     return this.withDatabase(async () => {
-      const results = await this.db.execute(sql25`
+      const results = await this.db.execute(sql27`
         SELECT id, name, source_type, source_id, metadata, created_at, updated_at
         FROM message_servers
         WHERE server_id = ${rlsServerId}
@@ -5697,6 +5732,82 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       }, ids);
     });
   }
+  async getPairingRequests(channel, agentId) {
+    return this.withDatabase(async () => {
+      const results = await this.db.select().from(pairingRequestTable).where(and(eq2(pairingRequestTable.channel, channel), eq2(pairingRequestTable.agentId, agentId))).orderBy(pairingRequestTable.createdAt);
+      return results.map((row) => ({
+        id: row.id,
+        channel: row.channel,
+        senderId: row.senderId,
+        code: row.code,
+        createdAt: row.createdAt,
+        lastSeenAt: row.lastSeenAt,
+        metadata: row.metadata || undefined,
+        agentId: row.agentId
+      }));
+    });
+  }
+  async createPairingRequest(request) {
+    return this.withDatabase(async () => {
+      const id = request.id || v4_default();
+      await this.db.insert(pairingRequestTable).values({
+        id,
+        channel: request.channel,
+        senderId: request.senderId,
+        code: request.code,
+        createdAt: request.createdAt,
+        lastSeenAt: request.lastSeenAt,
+        metadata: request.metadata || {},
+        agentId: request.agentId
+      });
+      return id;
+    });
+  }
+  async updatePairingRequest(request) {
+    return this.withDatabase(async () => {
+      await this.db.update(pairingRequestTable).set({
+        lastSeenAt: request.lastSeenAt,
+        metadata: request.metadata || {}
+      }).where(eq2(pairingRequestTable.id, request.id));
+    });
+  }
+  async deletePairingRequest(id) {
+    return this.withDatabase(async () => {
+      await this.db.delete(pairingRequestTable).where(eq2(pairingRequestTable.id, id));
+    });
+  }
+  async getPairingAllowlist(channel, agentId) {
+    return this.withDatabase(async () => {
+      const results = await this.db.select().from(pairingAllowlistTable).where(and(eq2(pairingAllowlistTable.channel, channel), eq2(pairingAllowlistTable.agentId, agentId))).orderBy(pairingAllowlistTable.createdAt);
+      return results.map((row) => ({
+        id: row.id,
+        channel: row.channel,
+        senderId: row.senderId,
+        createdAt: row.createdAt,
+        metadata: row.metadata || undefined,
+        agentId: row.agentId
+      }));
+    });
+  }
+  async createPairingAllowlistEntry(entry) {
+    return this.withDatabase(async () => {
+      const id = entry.id || v4_default();
+      await this.db.insert(pairingAllowlistTable).values({
+        id,
+        channel: entry.channel,
+        senderId: entry.senderId,
+        createdAt: entry.createdAt,
+        metadata: entry.metadata || {},
+        agentId: entry.agentId
+      }).onConflictDoNothing();
+      return id;
+    });
+  }
+  async deletePairingAllowlistEntry(id) {
+    return this.withDatabase(async () => {
+      await this.db.delete(pairingAllowlistTable).where(eq2(pairingAllowlistTable.id, id));
+    });
+  }
 }
 
 // pglite/adapter.ts
@@ -5840,5 +5951,5 @@ export {
   DatabaseMigrationService
 };
 
-//# debugId=33D355E5927A96C264756E2164756E21
+//# debugId=6C9E79385428E37A64756E2164756E21
 //# sourceMappingURL=index.browser.js.map