@elizaos/plugin-sql 1.7.3-alpha.3 → 1.7.3-alpha.4

package/dist/browser/index.browser.js

@@ -61,6 +61,246 @@ var init_agent = __esm(() => {
   });
 });
 
+// src/schema/entity.ts
+import { sql as sql2 } from "drizzle-orm";
+import { jsonb as jsonb2, pgTable as pgTable2, text as text2, timestamp as timestamp2, unique, uuid as uuid2 } from "drizzle-orm/pg-core";
+var entityTable;
+var init_entity = __esm(() => {
+  init_agent();
+  entityTable = pgTable2("entities", {
+    id: uuid2("id").notNull().primaryKey(),
+    agentId: uuid2("agent_id").notNull().references(() => agentTable.id, {
+      onDelete: "cascade"
+    }),
+    createdAt: timestamp2("created_at").default(sql2`now()`).notNull(),
+    names: text2("names").array().default(sql2`'{}'::text[]`).notNull(),
+    metadata: jsonb2("metadata").$type().default(sql2`'{}'::jsonb`).notNull()
+  }, (table) => {
+    return {
+      idAgentIdUnique: unique("id_agent_id_unique").on(table.id, table.agentId)
+    };
+  });
+});
+
+// src/schema/room.ts
+import { sql as sql3 } from "drizzle-orm";
+import { jsonb as jsonb3, pgTable as pgTable3, text as text3, timestamp as timestamp3, uuid as uuid3 } from "drizzle-orm/pg-core";
+var roomTable;
+var init_room = __esm(() => {
+  init_agent();
+  roomTable = pgTable3("rooms", {
+    id: uuid3("id").notNull().primaryKey().default(sql3`gen_random_uuid()`),
+    agentId: uuid3("agent_id").references(() => agentTable.id, {
+      onDelete: "cascade"
+    }),
+    source: text3("source").notNull(),
+    type: text3("type").notNull(),
+    messageServerId: uuid3("message_server_id"),
+    worldId: uuid3("world_id"),
+    name: text3("name"),
+    metadata: jsonb3("metadata").$type(),
+    channelId: text3("channel_id"),
+    createdAt: timestamp3("created_at").default(sql3`now()`).notNull()
+  });
+});
+
+// src/schema/memory.ts
+import { relations, sql as sql4 } from "drizzle-orm";
+import {
+  boolean as boolean2,
+  check,
+  foreignKey,
+  index,
+  jsonb as jsonb4,
+  pgTable as pgTable4,
+  text as text4,
+  timestamp as timestamp4,
+  uuid as uuid4
+} from "drizzle-orm/pg-core";
+var memoryTable, memoryRelations;
+var init_memory = __esm(() => {
+  init_agent();
+  init_embedding();
+  init_entity();
+  init_room();
+  memoryTable = pgTable4("memories", {
+    id: uuid4("id").primaryKey().notNull(),
+    type: text4("type").notNull(),
+    createdAt: timestamp4("created_at").default(sql4`now()`).notNull(),
+    content: jsonb4("content").$type().notNull(),
+    entityId: uuid4("entity_id").references(() => entityTable.id, {
+      onDelete: "cascade"
+    }),
+    agentId: uuid4("agent_id").references(() => agentTable.id, {
+      onDelete: "cascade"
+    }).notNull(),
+    roomId: uuid4("room_id").references(() => roomTable.id, {
+      onDelete: "cascade"
+    }),
+    worldId: uuid4("world_id"),
+    unique: boolean2("unique").default(true).notNull(),
+    metadata: jsonb4("metadata").$type().default({}).notNull()
+  }, (table) => [
+    index("idx_memories_type_room").on(table.type, table.roomId),
+    index("idx_memories_world_id").on(table.worldId),
+    foreignKey({
+      name: "fk_room",
+      columns: [table.roomId],
+      foreignColumns: [roomTable.id]
+    }).onDelete("cascade"),
+    foreignKey({
+      name: "fk_user",
+      columns: [table.entityId],
+      foreignColumns: [entityTable.id]
+    }).onDelete("cascade"),
+    foreignKey({
+      name: "fk_agent",
+      columns: [table.agentId],
+      foreignColumns: [agentTable.id]
+    }).onDelete("cascade"),
+    index("idx_memories_metadata_type").on(sql4`((metadata->>'type'))`),
+    index("idx_memories_document_id").on(sql4`((metadata->>'documentId'))`),
+    index("idx_fragments_order").on(sql4`((metadata->>'documentId'))`, sql4`((metadata->>'position'))`),
+    check("fragment_metadata_check", sql4`
+            CASE 
+                WHEN metadata->>'type' = 'fragment' THEN
+                    metadata ? 'documentId' AND 
+                    metadata ? 'position'
+                ELSE true
+            END
+        `),
+    check("document_metadata_check", sql4`
+            CASE 
+                WHEN metadata->>'type' = 'document' THEN
+                    metadata ? 'timestamp'
+                ELSE true
+            END
+        `)
+  ]);
+  memoryRelations = relations(memoryTable, ({ one }) => ({
+    embedding: one(embeddingTable)
+  }));
+});
+
+// src/schema/embedding.ts
+import { sql as sql5 } from "drizzle-orm";
+import { check as check2, foreignKey as foreignKey2, index as index2, pgTable as pgTable5, timestamp as timestamp5, uuid as uuid5, vector } from "drizzle-orm/pg-core";
+import { VECTOR_DIMS } from "@elizaos/core";
+var DIMENSION_MAP, embeddingTable;
+var init_embedding = __esm(() => {
+  init_memory();
+  DIMENSION_MAP = {
+    [VECTOR_DIMS.SMALL]: "dim384",
+    [VECTOR_DIMS.MEDIUM]: "dim512",
+    [VECTOR_DIMS.LARGE]: "dim768",
+    [VECTOR_DIMS.XL]: "dim1024",
+    [VECTOR_DIMS.XXL]: "dim1536",
+    [VECTOR_DIMS.XXXL]: "dim3072"
+  };
+  embeddingTable = pgTable5("embeddings", {
+    id: uuid5("id").primaryKey().defaultRandom().notNull(),
+    memoryId: uuid5("memory_id").references(() => memoryTable.id, { onDelete: "cascade" }),
+    createdAt: timestamp5("created_at").default(sql5`now()`).notNull(),
+    dim384: vector("dim_384", { dimensions: VECTOR_DIMS.SMALL }),
+    dim512: vector("dim_512", { dimensions: VECTOR_DIMS.MEDIUM }),
+    dim768: vector("dim_768", { dimensions: VECTOR_DIMS.LARGE }),
+    dim1024: vector("dim_1024", { dimensions: VECTOR_DIMS.XL }),
+    dim1536: vector("dim_1536", { dimensions: VECTOR_DIMS.XXL }),
+    dim3072: vector("dim_3072", { dimensions: VECTOR_DIMS.XXXL })
+  }, (table) => [
+    check2("embedding_source_check", sql5`"memory_id" IS NOT NULL`),
+    index2("idx_embedding_memory").on(table.memoryId),
+    foreignKey2({
+      name: "fk_embedding_memory",
+      columns: [table.memoryId],
+      foreignColumns: [memoryTable.id]
+    }).onDelete("cascade")
+  ]);
+});
+
+// src/schema/cache.ts
+import { sql as sql6 } from "drizzle-orm";
+import { jsonb as jsonb5, pgTable as pgTable6, text as text5, primaryKey, timestamp as timestamp6, uuid as uuid6 } from "drizzle-orm/pg-core";
+var cacheTable;
+var init_cache = __esm(() => {
+  init_agent();
+  cacheTable = pgTable6("cache", {
+    key: text5("key").notNull(),
+    agentId: uuid6("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+    value: jsonb5("value").notNull(),
+    createdAt: timestamp6("created_at", { withTimezone: true }).default(sql6`now()`).notNull(),
+    expiresAt: timestamp6("expires_at", { withTimezone: true })
+  }, (table) => [primaryKey({ columns: [table.key, table.agentId] })]);
+});
+
+// src/schema/world.ts
+import { sql as sql7 } from "drizzle-orm";
+import { jsonb as jsonb6, pgTable as pgTable7, text as text6, timestamp as timestamp7, uuid as uuid7 } from "drizzle-orm/pg-core";
+var worldTable;
+var init_world = __esm(() => {
+  init_agent();
+  worldTable = pgTable7("worlds", {
+    id: uuid7("id").notNull().primaryKey().default(sql7`gen_random_uuid()`),
+    agentId: uuid7("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+    name: text6("name").notNull(),
+    metadata: jsonb6("metadata").$type(),
+    messageServerId: uuid7("message_server_id"),
+    createdAt: timestamp7("created_at").default(sql7`now()`).notNull()
+  });
+});
+
+// src/schema/component.ts
+import { sql as sql8 } from "drizzle-orm";
+import { jsonb as jsonb7, pgTable as pgTable8, text as text7, timestamp as timestamp8, uuid as uuid8 } from "drizzle-orm/pg-core";
+var componentTable;
+var init_component = __esm(() => {
+  init_agent();
+  init_entity();
+  init_room();
+  init_world();
+  componentTable = pgTable8("components", {
+    id: uuid8("id").primaryKey().default(sql8`gen_random_uuid()`).notNull(),
+    entityId: uuid8("entity_id").references(() => entityTable.id, { onDelete: "cascade" }).notNull(),
+    agentId: uuid8("agent_id").references(() => agentTable.id, { onDelete: "cascade" }).notNull(),
+    roomId: uuid8("room_id").references(() => roomTable.id, { onDelete: "cascade" }).notNull(),
+    worldId: uuid8("world_id").references(() => worldTable.id, { onDelete: "cascade" }),
+    sourceEntityId: uuid8("source_entity_id").references(() => entityTable.id, {
+      onDelete: "cascade"
+    }),
+    type: text7("type").notNull(),
+    data: jsonb7("data").default(sql8`'{}'::jsonb`),
+    createdAt: timestamp8("created_at").default(sql8`now()`).notNull()
+  });
+});
+
+// src/schema/log.ts
+import { sql as sql9 } from "drizzle-orm";
+import { foreignKey as foreignKey3, jsonb as jsonb8, pgTable as pgTable9, text as text8, timestamp as timestamp9, uuid as uuid9 } from "drizzle-orm/pg-core";
+var logTable;
+var init_log = __esm(() => {
+  init_entity();
+  init_room();
+  logTable = pgTable9("logs", {
+    id: uuid9("id").defaultRandom().notNull(),
+    createdAt: timestamp9("created_at", { withTimezone: true }).default(sql9`now()`).notNull(),
+    entityId: uuid9("entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+    body: jsonb8("body").notNull(),
+    type: text8("type").notNull(),
+    roomId: uuid9("room_id").notNull().references(() => roomTable.id, { onDelete: "cascade" })
+  }, (table) => [
+    foreignKey3({
+      name: "fk_room",
+      columns: [table.roomId],
+      foreignColumns: [roomTable.id]
+    }).onDelete("cascade"),
+    foreignKey3({
+      name: "fk_user",
+      columns: [table.entityId],
+      foreignColumns: [entityTable.id]
+    }).onDelete("cascade")
+  ]);
+});
+
 // src/schema/server.ts
 import { sql as sql10 } from "drizzle-orm";
 import { pgTable as pgTable10, timestamp as timestamp10, uuid as uuid10 } from "drizzle-orm/pg-core";
@@ -73,16 +313,260 @@ var init_server = __esm(() => {
   });
 });
 
+// src/schema/participant.ts
+import { sql as sql11 } from "drizzle-orm";
+import { foreignKey as foreignKey4, index as index3, pgTable as pgTable11, text as text9, timestamp as timestamp11, uuid as uuid11 } from "drizzle-orm/pg-core";
+var participantTable;
+var init_participant = __esm(() => {
+  init_agent();
+  init_entity();
+  init_room();
+  participantTable = pgTable11("participants", {
+    id: uuid11("id").notNull().primaryKey().default(sql11`gen_random_uuid()`),
+    createdAt: timestamp11("created_at", { withTimezone: true }).default(sql11`now()`).notNull(),
+    entityId: uuid11("entity_id").references(() => entityTable.id, {
+      onDelete: "cascade"
+    }),
+    roomId: uuid11("room_id").references(() => roomTable.id, {
+      onDelete: "cascade"
+    }),
+    agentId: uuid11("agent_id").references(() => agentTable.id, {
+      onDelete: "cascade"
+    }),
+    roomState: text9("room_state")
+  }, (table) => [
+    index3("idx_participants_user").on(table.entityId),
+    index3("idx_participants_room").on(table.roomId),
+    foreignKey4({
+      name: "fk_room",
+      columns: [table.roomId],
+      foreignColumns: [roomTable.id]
+    }).onDelete("cascade"),
+    foreignKey4({
+      name: "fk_user",
+      columns: [table.entityId],
+      foreignColumns: [entityTable.id]
+    }).onDelete("cascade")
+  ]);
+});
+
+// src/schema/relationship.ts
+import { sql as sql12 } from "drizzle-orm";
+import {
+  foreignKey as foreignKey5,
+  index as index4,
+  jsonb as jsonb9,
+  pgTable as pgTable12,
+  text as text10,
+  timestamp as timestamp12,
+  unique as unique2,
+  uuid as uuid12
+} from "drizzle-orm/pg-core";
+var relationshipTable;
+var init_relationship = __esm(() => {
+  init_agent();
+  init_entity();
+  relationshipTable = pgTable12("relationships", {
+    id: uuid12("id").notNull().primaryKey().default(sql12`gen_random_uuid()`),
+    createdAt: timestamp12("created_at", { withTimezone: true }).default(sql12`now()`).notNull(),
+    sourceEntityId: uuid12("source_entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+    targetEntityId: uuid12("target_entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+    agentId: uuid12("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+    tags: text10("tags").array(),
+    metadata: jsonb9("metadata").$type()
+  }, (table) => [
+    index4("idx_relationships_users").on(table.sourceEntityId, table.targetEntityId),
+    unique2("unique_relationship").on(table.sourceEntityId, table.targetEntityId, table.agentId),
+    foreignKey5({
+      name: "fk_user_a",
+      columns: [table.sourceEntityId],
+      foreignColumns: [entityTable.id]
+    }).onDelete("cascade"),
+    foreignKey5({
+      name: "fk_user_b",
+      columns: [table.targetEntityId],
+      foreignColumns: [entityTable.id]
+    }).onDelete("cascade")
+  ]);
+});
+
+// src/schema/tasks.ts
+import { jsonb as jsonb10, pgTable as pgTable13, text as text11, timestamp as timestamp13, uuid as uuid13 } from "drizzle-orm/pg-core";
+import { sql as sql13 } from "drizzle-orm";
+var taskTable;
+var init_tasks = __esm(() => {
+  init_agent();
+  taskTable = pgTable13("tasks", {
+    id: uuid13("id").primaryKey().defaultRandom(),
+    name: text11("name").notNull(),
+    description: text11("description"),
+    roomId: uuid13("room_id"),
+    worldId: uuid13("world_id"),
+    entityId: uuid13("entity_id"),
+    agentId: uuid13("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+    tags: text11("tags").array().default(sql13`'{}'::text[]`),
+    metadata: jsonb10("metadata").$type().default(sql13`'{}'::jsonb`),
+    createdAt: timestamp13("created_at", { withTimezone: true }).defaultNow(),
+    updatedAt: timestamp13("updated_at", { withTimezone: true }).defaultNow()
+  });
+});
+
+// src/schema/user.ts
+import { sql as sql14 } from "drizzle-orm";
+import { index as index5, pgTable as pgTable14, text as text12, timestamp as timestamp14, uuid as uuid14 } from "drizzle-orm/pg-core";
+var userTable;
+var init_user = __esm(() => {
+  userTable = pgTable14("users", {
+    id: uuid14("id").notNull().primaryKey().default(sql14`gen_random_uuid()`),
+    email: text12("email").notNull().unique(),
+    username: text12("username").notNull(),
+    passwordHash: text12("password_hash").notNull(),
+    createdAt: timestamp14("created_at").default(sql14`now()`).notNull(),
+    updatedAt: timestamp14("updated_at").default(sql14`now()`).notNull(),
+    lastLoginAt: timestamp14("last_login_at")
+  }, (table) => ({
+    emailIdx: index5("idx_users_email").on(table.email),
+    usernameIdx: index5("idx_users_username").on(table.username)
+  }));
+});
+
+// src/schema/messageServer.ts
+import { pgTable as pgTable15, text as text13, jsonb as jsonb11, timestamp as timestamp15, uuid as uuid15 } from "drizzle-orm/pg-core";
+import { sql as sql15 } from "drizzle-orm";
+var messageServerTable;
+var init_messageServer = __esm(() => {
+  messageServerTable = pgTable15("message_servers", {
+    id: uuid15("id").primaryKey(),
+    name: text13("name").notNull(),
+    sourceType: text13("source_type").notNull(),
+    sourceId: text13("source_id"),
+    metadata: jsonb11("metadata").$type(),
+    createdAt: timestamp15("created_at", { mode: "date" }).default(sql15`CURRENT_TIMESTAMP`).notNull(),
+    updatedAt: timestamp15("updated_at", { mode: "date" }).default(sql15`CURRENT_TIMESTAMP`).notNull()
+  });
+});
+
+// src/schema/channel.ts
+import { pgTable as pgTable16, text as text14, jsonb as jsonb12, timestamp as timestamp16, uuid as uuid16 } from "drizzle-orm/pg-core";
+import { sql as sql16 } from "drizzle-orm";
+var channelTable;
+var init_channel = __esm(() => {
+  init_messageServer();
+  channelTable = pgTable16("channels", {
+    id: text14("id").primaryKey(),
+    messageServerId: uuid16("message_server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
+    name: text14("name").notNull(),
+    type: text14("type").notNull(),
+    sourceType: text14("source_type"),
+    sourceId: text14("source_id"),
+    topic: text14("topic"),
+    metadata: jsonb12("metadata").$type(),
+    createdAt: timestamp16("created_at", { mode: "date" }).default(sql16`CURRENT_TIMESTAMP`).notNull(),
+    updatedAt: timestamp16("updated_at", { mode: "date" }).default(sql16`CURRENT_TIMESTAMP`).notNull()
+  });
+});
+
+// src/schema/message.ts
+import { pgTable as pgTable17, text as text15, jsonb as jsonb13, timestamp as timestamp17 } from "drizzle-orm/pg-core";
+import { sql as sql17 } from "drizzle-orm";
+var messageTable;
+var init_message = __esm(() => {
+  init_channel();
+  messageTable = pgTable17("central_messages", {
+    id: text15("id").primaryKey(),
+    channelId: text15("channel_id").notNull().references(() => channelTable.id, { onDelete: "cascade" }),
+    authorId: text15("author_id").notNull(),
+    content: text15("content").notNull(),
+    rawMessage: jsonb13("raw_message"),
+    inReplyToRootMessageId: text15("in_reply_to_root_message_id").references(() => messageTable.id, {
+      onDelete: "set null"
+    }),
+    sourceType: text15("source_type"),
+    sourceId: text15("source_id"),
+    metadata: jsonb13("metadata").$type(),
+    createdAt: timestamp17("created_at", { mode: "date" }).default(sql17`CURRENT_TIMESTAMP`).notNull(),
+    updatedAt: timestamp17("updated_at", { mode: "date" }).default(sql17`CURRENT_TIMESTAMP`).notNull()
+  });
+});
+
+// src/schema/channelParticipant.ts
+import { pgTable as pgTable18, text as text16, primaryKey as primaryKey2 } from "drizzle-orm/pg-core";
+var channelParticipantsTable;
+var init_channelParticipant = __esm(() => {
+  init_channel();
+  channelParticipantsTable = pgTable18("channel_participants", {
+    channelId: text16("channel_id").notNull().references(() => channelTable.id, { onDelete: "cascade" }),
+    entityId: text16("entity_id").notNull()
+  }, (table) => [primaryKey2({ columns: [table.channelId, table.entityId] })]);
+});
+
+// src/schema/messageServerAgent.ts
+import { pgTable as pgTable19, uuid as uuid17, primaryKey as primaryKey3 } from "drizzle-orm/pg-core";
+var messageServerAgentsTable;
+var init_messageServerAgent = __esm(() => {
+  init_messageServer();
+  init_agent();
+  messageServerAgentsTable = pgTable19("message_server_agents", {
+    messageServerId: uuid17("message_server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
+    agentId: uuid17("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" })
+  }, (table) => [primaryKey3({ columns: [table.messageServerId, table.agentId] })]);
+});
+
+// src/schema/index.ts
+var exports_schema = {};
+__export(exports_schema, {
+  worldTable: () => worldTable,
+  userTable: () => userTable,
+  taskTable: () => taskTable,
+  serverTable: () => serverTable,
+  roomTable: () => roomTable,
+  relationshipTable: () => relationshipTable,
+  participantTable: () => participantTable,
+  messageTable: () => messageTable,
+  messageServerTable: () => messageServerTable,
+  messageServerAgentsTable: () => messageServerAgentsTable,
+  memoryTable: () => memoryTable,
+  logTable: () => logTable,
+  entityTable: () => entityTable,
+  embeddingTable: () => embeddingTable,
+  componentTable: () => componentTable,
+  channelTable: () => channelTable,
+  channelParticipantsTable: () => channelParticipantsTable,
+  cacheTable: () => cacheTable,
+  agentTable: () => agentTable
+});
+var init_schema = __esm(() => {
+  init_agent();
+  init_cache();
+  init_component();
+  init_embedding();
+  init_entity();
+  init_log();
+  init_memory();
+  init_server();
+  init_participant();
+  init_relationship();
+  init_room();
+  init_world();
+  init_tasks();
+  init_user();
+  init_messageServer();
+  init_channel();
+  init_message();
+  init_channelParticipant();
+  init_messageServerAgent();
+});
+
 // src/types.ts
 function getDb(adapter) {
   return adapter.db;
 }
-function getRow(result, index5 = 0) {
-  return result.rows[index5];
+function getRow(result, index6 = 0) {
+  return result.rows[index6];
 }
 
 // src/runtime-migrator/storage/migration-tracker.ts
-import { sql as sql23 } from "drizzle-orm";
+import { sql as sql24 } from "drizzle-orm";
 
 class MigrationTracker {
   db;
@@ -90,11 +574,11 @@ class MigrationTracker {
     this.db = db;
   }
   async ensureSchema() {
-    await this.db.execute(sql23`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(sql23`
+    await this.db.execute(sql24`
       CREATE TABLE IF NOT EXISTS migrations._migrations (
         id SERIAL PRIMARY KEY,
         plugin_name TEXT NOT NULL,
@@ -102,7 +586,7 @@ class MigrationTracker {
         created_at BIGINT NOT NULL
       )
     `);
-    await this.db.execute(sql23`
+    await this.db.execute(sql24`
       CREATE TABLE IF NOT EXISTS migrations._journal (
         plugin_name TEXT PRIMARY KEY,
         version TEXT NOT NULL,
@@ -110,7 +594,7 @@ class MigrationTracker {
         entries JSONB NOT NULL DEFAULT '[]'
       )
     `);
-    await this.db.execute(sql23`
+    await this.db.execute(sql24`
       CREATE TABLE IF NOT EXISTS migrations._snapshots (
         id SERIAL PRIMARY KEY,
         plugin_name TEXT NOT NULL,
@@ -122,7 +606,7 @@ class MigrationTracker {
     `);
   }
   async getLastMigration(pluginName) {
-    const result = await this.db.execute(sql23`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
@@ -130,14 +614,14 @@ class MigrationTracker {
     return getRow(result) || null;
   }
   async recordMigration(pluginName, hash, createdAt) {
-    await this.db.execute(sql23`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 = () => {};
 
 // src/runtime-migrator/storage/journal-storage.ts
-import { sql as sql24 } from "drizzle-orm";
+import { sql as sql25 } from "drizzle-orm";
 
 class JournalStorage {
   db;
@@ -145,7 +629,7 @@ class JournalStorage {
     this.db = db;
   }
   async loadJournal(pluginName) {
-    const result = await this.db.execute(sql24`SELECT version, dialect, entries 
+    const result = await this.db.execute(sql25`SELECT version, dialect, entries 
           FROM migrations._journal 
           WHERE plugin_name = ${pluginName}`);
     if (result.rows.length === 0) {
@@ -159,7 +643,7 @@ class JournalStorage {
     };
   }
   async saveJournal(pluginName, journal) {
-    await this.db.execute(sql24`INSERT INTO migrations._journal (plugin_name, version, dialect, entries)
+    await this.db.execute(sql25`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 
@@ -201,7 +685,7 @@ class JournalStorage {
 var init_journal_storage = () => {};
 
 // src/runtime-migrator/storage/snapshot-storage.ts
-import { sql as sql25 } from "drizzle-orm";
+import { sql as sql26 } from "drizzle-orm";
 
 class SnapshotStorage {
   db;
@@ -209,7 +693,7 @@ class SnapshotStorage {
     this.db = db;
   }
   async saveSnapshot(pluginName, idx, snapshot) {
-    await this.db.execute(sql25`INSERT INTO migrations._snapshots (plugin_name, idx, snapshot)
+    await this.db.execute(sql26`INSERT INTO migrations._snapshots (plugin_name, idx, snapshot)
           VALUES (${pluginName}, ${idx}, ${JSON.stringify(snapshot)}::jsonb)
           ON CONFLICT (plugin_name, idx) 
           DO UPDATE SET 
@@ -217,7 +701,7 @@ class SnapshotStorage {
             created_at = NOW()`);
   }
   async loadSnapshot(pluginName, idx) {
-    const result = await this.db.execute(sql25`SELECT snapshot 
+    const result = await this.db.execute(sql26`SELECT snapshot 
           FROM migrations._snapshots 
           WHERE plugin_name = ${pluginName} AND idx = ${idx}`);
     if (result.rows.length === 0) {
@@ -226,7 +710,7 @@ class SnapshotStorage {
     return result.rows[0].snapshot;
   }
   async getLatestSnapshot(pluginName) {
-    const result = await this.db.execute(sql25`SELECT snapshot 
+    const result = await this.db.execute(sql26`SELECT snapshot 
           FROM migrations._snapshots 
           WHERE plugin_name = ${pluginName}
           ORDER BY idx DESC
@@ -237,7 +721,7 @@ class SnapshotStorage {
     return result.rows[0].snapshot;
   }
   async getAllSnapshots(pluginName) {
-    const result = await this.db.execute(sql25`SELECT snapshot 
+    const result = await this.db.execute(sql26`SELECT snapshot 
           FROM migrations._snapshots 
           WHERE plugin_name = ${pluginName}
           ORDER BY idx ASC`);
@@ -247,7 +731,7 @@ class SnapshotStorage {
 var init_snapshot_storage = () => {};
 
 // src/runtime-migrator/extension-manager.ts
-import { sql as sql26 } from "drizzle-orm";
+import { sql as sql27 } from "drizzle-orm";
 import { logger as logger8 } from "@elizaos/core";
 
 class ExtensionManager {
@@ -262,7 +746,7 @@ class ExtensionManager {
           logger8.warn({ src: "plugin:sql", extension }, "Invalid extension name - contains invalid characters");
           continue;
         }
-        await this.db.execute(sql26`CREATE EXTENSION IF NOT EXISTS ${sql26.identifier(extension)}`);
+        await this.db.execute(sql27`CREATE EXTENSION IF NOT EXISTS ${sql27.identifier(extension)}`);
         logger8.debug({ src: "plugin:sql", extension }, "Extension installed");
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -1904,12 +2388,12 @@ function objectToString(o) {
 function pad(n) {
   return n < 10 ? "0" + n.toString(10) : n.toString(10);
 }
-function timestamp17() {
+function timestamp18() {
   var d = new Date, time = [pad(d.getHours()), pad(d.getMinutes()), pad(d.getSeconds())].join(":");
   return [d.getDate(), months[d.getMonth()], time].join(" ");
 }
 function log(...args) {
-  console.log("%s - %s", timestamp17(), format.apply(null, args));
+  console.log("%s - %s", timestamp18(), format.apply(null, args));
 }
 function inherits(ctor, superCtor) {
   if (superCtor)
@@ -4675,10 +5159,10 @@ var require_stream = __commonJS((exports, module) => {
           dests[i2].emit("unpipe", this, { hasUnpiped: false });
         return this;
       }
-      let index5 = ArrayPrototypeIndexOf(state.pipes, dest);
-      if (index5 === -1)
+      let index6 = ArrayPrototypeIndexOf(state.pipes, dest);
+      if (index6 === -1)
         return this;
-      if (state.pipes.splice(index5, 1), state.pipes.length === 0)
+      if (state.pipes.splice(index6, 1), state.pipes.length === 0)
         this.pause();
       return dest.emit("unpipe", this, unpipeInfo), this;
     };
@@ -6071,12 +6555,12 @@ var require_stream = __commonJS((exports, module) => {
       if ((options === null || options === undefined ? undefined : options.signal) != null)
         validateAbortSignal2(options.signal, "options.signal");
       return async function* () {
-        let index5 = 0;
+        let index6 = 0;
         for await (let val of this) {
           var _options$signal;
           if (options !== null && options !== undefined && (_options$signal = options.signal) !== null && _options$signal !== undefined && _options$signal.aborted)
             throw new AbortError2({ cause: options.signal.reason });
-          yield [index5++, val];
+          yield [index6++, val];
         }
       }.call(this);
     }
@@ -7381,8 +7865,8 @@ var init_crypto = __esm(() => {
         }
         return this.strip();
       };
-      function parseHex4Bits(string, index5) {
-        var c = string.charCodeAt(index5);
+      function parseHex4Bits(string, index6) {
+        var c = string.charCodeAt(index6);
         if (c >= 65 && c <= 70)
           return c - 55;
         else if (c >= 97 && c <= 102)
@@ -7390,10 +7874,10 @@ var init_crypto = __esm(() => {
         else
           return c - 48 & 15;
       }
-      function parseHexByte(string, lowerBound, index5) {
-        var r = parseHex4Bits(string, index5);
-        if (index5 - 1 >= lowerBound)
-          r |= parseHex4Bits(string, index5 - 1) << 4;
+      function parseHexByte(string, lowerBound, index6) {
+        var r = parseHex4Bits(string, index6);
+        if (index6 - 1 >= lowerBound)
+          r |= parseHex4Bits(string, index6 - 1) << 4;
         return r;
       }
       BN.prototype._parseHex = function(number, start, endian) {
@@ -8955,11 +9439,11 @@ var init_crypto = __esm(() => {
           comb[1] = points[a].toJ().mixedAdd(points[b]), comb[2] = points[a].add(points[b].neg());
         else
           comb[1] = points[a].toJ().mixedAdd(points[b]), comb[2] = points[a].toJ().mixedAdd(points[b].neg());
-        var index5 = [-3, -1, -5, -7, 0, 7, 5, 1, 3], jsf = getJSF(coeffs[a], coeffs[b]);
+        var index6 = [-3, -1, -5, -7, 0, 7, 5, 1, 3], jsf = getJSF(coeffs[a], coeffs[b]);
         max = Math.max(jsf[0].length, max), naf[a] = Array(max), naf[b] = Array(max);
         for (j = 0;j < max; j++) {
           var ja = jsf[0][j] | 0, jb = jsf[1][j] | 0;
-          naf[a][j] = index5[(ja + 1) * 3 + (jb + 1)], naf[b][j] = 0, wnd[a] = comb;
+          naf[a][j] = index6[(ja + 1) * 3 + (jb + 1)], naf[b][j] = 0, wnd[a] = comb;
         }
       }
       var acc = this.jpoint(null, null, null), tmp = this._wnafT4;
@@ -11056,8 +11540,8 @@ var init_crypto = __esm(() => {
         }
         return this.strip();
       };
-      function parseHex4Bits(string, index5) {
-        var c = string.charCodeAt(index5);
+      function parseHex4Bits(string, index6) {
+        var c = string.charCodeAt(index6);
         if (c >= 65 && c <= 70)
           return c - 55;
         else if (c >= 97 && c <= 102)
@@ -11065,10 +11549,10 @@ var init_crypto = __esm(() => {
         else
           return c - 48 & 15;
       }
-      function parseHexByte(string, lowerBound, index5) {
-        var r = parseHex4Bits(string, index5);
-        if (index5 - 1 >= lowerBound)
-          r |= parseHex4Bits(string, index5 - 1) << 4;
+      function parseHexByte(string, lowerBound, index6) {
+        var r = parseHex4Bits(string, index6);
+        if (index6 - 1 >= lowerBound)
+          r |= parseHex4Bits(string, index6 - 1) << 4;
         return r;
       }
       BN.prototype._parseHex = function(number, start, endian) {
@@ -12519,8 +13003,8 @@ var init_crypto = __esm(() => {
         }
         return this.strip();
       };
-      function parseHex4Bits(string, index5) {
-        var c = string.charCodeAt(index5);
+      function parseHex4Bits(string, index6) {
+        var c = string.charCodeAt(index6);
         if (c >= 65 && c <= 70)
           return c - 55;
         else if (c >= 97 && c <= 102)
@@ -12528,10 +13012,10 @@ var init_crypto = __esm(() => {
         else
           return c - 48 & 15;
       }
-      function parseHexByte(string, lowerBound, index5) {
-        var r = parseHex4Bits(string, index5);
-        if (index5 - 1 >= lowerBound)
-          r |= parseHex4Bits(string, index5 - 1) << 4;
+      function parseHexByte(string, lowerBound, index6) {
+        var r = parseHex4Bits(string, index6);
+        if (index6 - 1 >= lowerBound)
+          r |= parseHex4Bits(string, index6 - 1) << 4;
         return r;
       }
       BN.prototype._parseHex = function(number, start, endian) {
@@ -13885,13 +14369,13 @@ var init_crypto = __esm(() => {
     Reporter.prototype.enterKey = function(key) {
       return this._reporterState.path.push(key);
     };
-    Reporter.prototype.exitKey = function(index5) {
+    Reporter.prototype.exitKey = function(index6) {
       var state = this._reporterState;
-      state.path = state.path.slice(0, index5 - 1);
+      state.path = state.path.slice(0, index6 - 1);
     };
-    Reporter.prototype.leaveKey = function(index5, key, value) {
+    Reporter.prototype.leaveKey = function(index6, key, value) {
       var state = this._reporterState;
-      if (this.exitKey(index5), state.obj !== null)
+      if (this.exitKey(index6), state.obj !== null)
         state.obj[key] = value;
     };
     Reporter.prototype.path = function() {
@@ -15260,8 +15744,8 @@ var init_crypto = __esm(() => {
         }
         return this.strip();
       };
-      function parseHex4Bits(string, index5) {
-        var c = string.charCodeAt(index5);
+      function parseHex4Bits(string, index6) {
+        var c = string.charCodeAt(index6);
         if (c >= 65 && c <= 70)
           return c - 55;
         else if (c >= 97 && c <= 102)
@@ -15269,10 +15753,10 @@ var init_crypto = __esm(() => {
         else
           return c - 48 & 15;
       }
-      function parseHexByte(string, lowerBound, index5) {
-        var r = parseHex4Bits(string, index5);
-        if (index5 - 1 >= lowerBound)
-          r |= parseHex4Bits(string, index5 - 1) << 4;
+      function parseHexByte(string, lowerBound, index6) {
+        var r = parseHex4Bits(string, index6);
+        if (index6 - 1 >= lowerBound)
+          r |= parseHex4Bits(string, index6 - 1) << 4;
         return r;
       }
       BN.prototype._parseHex = function(number, start, endian) {
@@ -16664,8 +17148,8 @@ var init_crypto = __esm(() => {
         }
         return this._strip();
       };
-      function parseHex4Bits(string, index5) {
-        var c = string.charCodeAt(index5);
+      function parseHex4Bits(string, index6) {
+        var c = string.charCodeAt(index6);
         if (c >= 48 && c <= 57)
           return c - 48;
         else if (c >= 65 && c <= 70)
@@ -16675,10 +17159,10 @@ var init_crypto = __esm(() => {
         else
           assert(false, "Invalid character in " + string);
       }
-      function parseHexByte(string, lowerBound, index5) {
-        var r = parseHex4Bits(string, index5);
-        if (index5 - 1 >= lowerBound)
-          r |= parseHex4Bits(string, index5 - 1) << 4;
+      function parseHexByte(string, lowerBound, index6) {
+        var r = parseHex4Bits(string, index6);
+        if (index6 - 1 >= lowerBound)
+          r |= parseHex4Bits(string, index6 - 1) << 4;
         return r;
       }
       BN.prototype._parseHex = function(number, start, endian) {
@@ -18584,8 +19068,8 @@ function hasChanges(previousSnapshot, currentSnapshot) {
   const currHash = hashSnapshot(currentSnapshot);
   return prevHash !== currHash;
 }
-var sqlToStr = (sql27, casing) => {
-  return sql27.toQuery({
+var sqlToStr = (sql28, casing) => {
+  return sql28.toQuery({
     escapeName: () => {
       throw new Error("we don't support params for `sql` default values");
     },
@@ -19116,14 +19600,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 index6 of diff.indexes.deleted) {
+    statements.push(generateDropIndexSQL(index6));
   }
   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 index6 of diff.indexes.created) {
+    statements.push(generateCreateIndexSQL(index6));
   }
   for (const alteredIndex of diff.indexes.altered) {
     statements.push(generateCreateIndexSQL(alteredIndex.new));
@@ -19220,18 +19704,18 @@ function generateCreateTableSQL(fullTableName, table) {
   return { tableSQL, fkSQLs };
 }
 function generateColumnDefinition(name, def) {
-  let sql27 = `"${name}" ${def.type}`;
+  let sql28 = `"${name}" ${def.type}`;
   if (def.primaryKey && !def.type.includes("SERIAL")) {
-    sql27 += " PRIMARY KEY";
+    sql28 += " PRIMARY KEY";
   }
   if (def.notNull) {
-    sql27 += " NOT NULL";
+    sql28 += " NOT NULL";
   }
   if (def.default !== undefined) {
     const defaultValue = formatDefaultValue(def.default, def.type);
-    sql27 += ` DEFAULT ${defaultValue}`;
+    sql28 += ` DEFAULT ${defaultValue}`;
   }
-  return sql27;
+  return sql28;
 }
 function generateAddColumnSQL(table, column, definition) {
   const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
@@ -19358,27 +19842,27 @@ 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(index6) {
+  const unique3 = index6.isUnique ? "UNIQUE " : "";
+  const method = index6.method || "btree";
+  const columns = index6.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 = index6.name.includes(".") ? index6.name.split(".")[1] : index6.name;
   let tableRef;
-  if (index5.table && index5.table.includes(".")) {
-    const [schema, table] = index5.table.split(".");
+  if (index6.table && index6.table.includes(".")) {
+    const [schema, table] = index6.table.split(".");
     tableRef = `"${schema}"."${table}"`;
   } else {
-    tableRef = `"${index5.table || ""}"`;
+    tableRef = `"${index6.table || ""}"`;
   }
   return `CREATE ${unique3}INDEX "${indexName}" ON ${tableRef} USING ${method} (${columns});`;
 }
-function generateDropIndexSQL(index5) {
-  const indexName = index5.name ? index5.name.includes(".") ? index5.name.split(".")[1] : index5.name : index5;
+function generateDropIndexSQL(index6) {
+  const indexName = index6.name ? index6.name.includes(".") ? index6.name.split(".")[1] : index6.name : index6;
   return `DROP INDEX IF EXISTS "${indexName}";`;
 }
 function generateCreateForeignKeySQL(fk) {
@@ -19387,14 +19871,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 sql27 = `ALTER TABLE "${schemaFrom}"."${tableFrom}" ADD CONSTRAINT "${fk.name}" FOREIGN KEY (${columnsFrom}) REFERENCES "${schemaTo}"."${fk.tableTo}" (${columnsTo})`;
+  let sql28 = `ALTER TABLE "${schemaFrom}"."${tableFrom}" ADD CONSTRAINT "${fk.name}" FOREIGN KEY (${columnsFrom}) REFERENCES "${schemaTo}"."${fk.tableTo}" (${columnsTo})`;
   if (fk.onDelete) {
-    sql27 += ` ON DELETE ${fk.onDelete}`;
+    sql28 += ` ON DELETE ${fk.onDelete}`;
   }
   if (fk.onUpdate) {
-    sql27 += ` ON UPDATE ${fk.onUpdate}`;
+    sql28 += ` ON UPDATE ${fk.onUpdate}`;
   }
-  return sql27 + ";";
+  return sql28 + ";";
 }
 function generateDropForeignKeySQL(fk) {
   const [schema, tableName] = fk.tableFrom ? fk.tableFrom.includes(".") ? fk.tableFrom.split(".") : ["public", fk.tableFrom] : ["public", ""];
@@ -19405,12 +19889,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 sql27 = `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${name}" UNIQUE`;
+  let sql28 = `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${name}" UNIQUE`;
   if (constraint.nullsNotDistinct) {
-    sql27 += ` NULLS NOT DISTINCT`;
+    sql28 += ` NULLS NOT DISTINCT`;
   }
-  sql27 += ` (${columns});`;
-  return sql27;
+  sql28 += ` (${columns});`;
+  return sql28;
 }
 function generateDropUniqueConstraintSQL(constraint) {
   const table = constraint.table || "";
@@ -19477,7 +19961,7 @@ function normalizeSchemaName(input) {
 var init_schema_transformer = () => {};
 
 // src/runtime-migrator/drizzle-adapters/database-introspector.ts
-import { sql as sql27 } from "drizzle-orm";
+import { sql as sql28 } from "drizzle-orm";
 import { logger as logger11 } from "@elizaos/core";
 
 class DatabaseIntrospector {
@@ -19604,7 +20088,7 @@ class DatabaseIntrospector {
     };
   }
   async getTables(schemaName) {
-    const result = await this.db.execute(sql27`SELECT 
+    const result = await this.db.execute(sql28`SELECT 
             table_schema,
             table_name
           FROM information_schema.tables
@@ -19614,7 +20098,7 @@ class DatabaseIntrospector {
     return result.rows;
   }
   async getColumns(schemaName, tableName) {
-    const result = await this.db.execute(sql27`SELECT 
+    const result = await this.db.execute(sql28`SELECT 
             a.attname AS column_name,
             CASE 
               WHEN a.attnotnull THEN 'NO'
@@ -19657,7 +20141,7 @@ class DatabaseIntrospector {
     return result.rows;
   }
   async getIndexes(schemaName, tableName) {
-    const result = await this.db.execute(sql27`SELECT 
+    const result = await this.db.execute(sql28`SELECT 
             i.relname AS name,
             idx.indisunique AS is_unique,
             idx.indisprimary AS is_primary,
@@ -19681,7 +20165,7 @@ class DatabaseIntrospector {
     return result.rows;
   }
   async getForeignKeys(schemaName, tableName) {
-    const result = await this.db.execute(sql27`SELECT
+    const result = await this.db.execute(sql28`SELECT
             con.conname AS name,
             att.attname AS column_name,
             fnsp.nspname AS foreign_table_schema,
@@ -19716,7 +20200,7 @@ class DatabaseIntrospector {
     return result.rows;
   }
   async getPrimaryKeys(schemaName, tableName) {
-    const result = await this.db.execute(sql27`SELECT 
+    const result = await this.db.execute(sql28`SELECT 
             con.conname AS name,
             ARRAY(
               SELECT a.attname
@@ -19734,7 +20218,7 @@ class DatabaseIntrospector {
     return result.rows;
   }
   async getUniqueConstraints(schemaName, tableName) {
-    const result = await this.db.execute(sql27`SELECT 
+    const result = await this.db.execute(sql28`SELECT 
             con.conname AS name,
             ARRAY(
               SELECT a.attname
@@ -19752,7 +20236,7 @@ class DatabaseIntrospector {
     return result.rows;
   }
   async getCheckConstraints(schemaName, tableName) {
-    const result = await this.db.execute(sql27`SELECT 
+    const result = await this.db.execute(sql28`SELECT 
             con.conname AS name,
             pg_get_constraintdef(con.oid) AS definition
           FROM pg_constraint con
@@ -19764,7 +20248,7 @@ class DatabaseIntrospector {
     return result.rows;
   }
   async getEnums(schemaName) {
-    const result = await this.db.execute(sql27`SELECT 
+    const result = await this.db.execute(sql28`SELECT 
             n.nspname AS schema,
             t.typname AS name,
             e.enumlabel AS value,
@@ -19796,7 +20280,7 @@ class DatabaseIntrospector {
   }
   async hasExistingTables(pluginName) {
     const schemaName = pluginName === "@elizaos/plugin-sql" ? "public" : this.deriveSchemaName(pluginName);
-    const result = await this.db.execute(sql27`SELECT COUNT(*) AS count
+    const result = await this.db.execute(sql28`SELECT COUNT(*) AS count
           FROM information_schema.tables
           WHERE table_schema = ${schemaName}
             AND table_type = 'BASE TABLE'`);
@@ -19810,7 +20294,7 @@ class DatabaseIntrospector {
 var init_database_introspector = () => {};
 
 // src/runtime-migrator/runtime-migrator.ts
-import { sql as sql28 } from "drizzle-orm";
+import { sql as sql29 } from "drizzle-orm";
 import { logger as logger12 } from "@elizaos/core";
 
 class RuntimeMigrator {
@@ -19850,7 +20334,7 @@ class RuntimeMigrator {
     }
     for (const schemaName of schemasToCreate) {
       logger12.debug({ src: "plugin:sql", schemaName }, "Ensuring schema exists");
-      await this.db.execute(sql28.raw(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`));
+      await this.db.execute(sql29.raw(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`));
     }
   }
   validateSchemaUsage(pluginName, snapshot) {
@@ -20008,11 +20492,11 @@ class RuntimeMigrator {
         try {
           logger12.debug({ src: "plugin:sql", pluginName }, "Using PostgreSQL advisory locks");
           const lockIdStr = lockId.toString();
-          const lockResult = await this.db.execute(sql28`SELECT pg_try_advisory_lock(CAST(${lockIdStr} AS bigint)) as acquired`);
+          const lockResult = await this.db.execute(sql29`SELECT pg_try_advisory_lock(CAST(${lockIdStr} AS bigint)) as acquired`);
           lockAcquired = getRow(lockResult)?.acquired === true;
           if (!lockAcquired) {
             logger12.info({ src: "plugin:sql", pluginName }, "Migration already in progress, waiting for lock");
-            await this.db.execute(sql28`SELECT pg_advisory_lock(CAST(${lockIdStr} AS bigint))`);
+            await this.db.execute(sql29`SELECT pg_advisory_lock(CAST(${lockIdStr} AS bigint))`);
             lockAcquired = true;
             logger12.info({ src: "plugin:sql", pluginName }, "Lock acquired");
           } else {
@@ -20143,7 +20627,7 @@ class RuntimeMigrator {
       if (lockAcquired && isRealPostgres) {
         try {
           const lockIdStr = lockId.toString();
-          await this.db.execute(sql28`SELECT pg_advisory_unlock(CAST(${lockIdStr} AS bigint))`);
+          await this.db.execute(sql29`SELECT pg_advisory_unlock(CAST(${lockIdStr} AS bigint))`);
           logger12.debug({ src: "plugin:sql", pluginName }, "Advisory lock released");
         } catch (unlockError) {
           logger12.warn({
@@ -20158,23 +20642,23 @@ class RuntimeMigrator {
   async executeMigration(pluginName, snapshot, hash, sqlStatements) {
     let transactionStarted = false;
     try {
-      await this.db.execute(sql28`BEGIN`);
+      await this.db.execute(sql29`BEGIN`);
       transactionStarted = true;
       for (const stmt of sqlStatements) {
         logger12.debug({ src: "plugin:sql", statement: stmt }, "Executing SQL statement");
-        await this.db.execute(sql28.raw(stmt));
+        await this.db.execute(sql29.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(sql28`COMMIT`);
+      await this.db.execute(sql29`COMMIT`);
       logger12.info({ src: "plugin:sql", pluginName, tag }, "Recorded migration");
     } catch (error) {
       if (transactionStarted) {
         try {
-          await this.db.execute(sql28`ROLLBACK`);
+          await this.db.execute(sql29`ROLLBACK`);
           logger12.error({ src: "plugin:sql", error: error instanceof Error ? error.message : String(error) }, "Migration failed, rolled back");
         } catch (rollbackError) {
           logger12.error({
@@ -20188,8 +20672,8 @@ class RuntimeMigrator {
   }
   generateMigrationTag(idx, pluginName) {
     const prefix = idx.toString().padStart(4, "0");
-    const timestamp18 = Date.now().toString(36);
-    return `${prefix}_${pluginName}_${timestamp18}`;
+    const timestamp19 = Date.now().toString(36);
+    return `${prefix}_${pluginName}_${timestamp19}`;
   }
   async getStatus(pluginName) {
     const lastMigration = await this.migrationTracker.getLastMigration(pluginName);
@@ -20204,9 +20688,9 @@ class RuntimeMigrator {
   }
   async reset(pluginName) {
     logger12.warn({ src: "plugin:sql", pluginName }, "Resetting migrations");
-    await this.db.execute(sql28`DELETE FROM migrations._migrations WHERE plugin_name = ${pluginName}`);
-    await this.db.execute(sql28`DELETE FROM migrations._journal WHERE plugin_name = ${pluginName}`);
-    await this.db.execute(sql28`DELETE FROM migrations._snapshots WHERE plugin_name = ${pluginName}`);
+    await this.db.execute(sql29`DELETE FROM migrations._migrations WHERE plugin_name = ${pluginName}`);
+    await this.db.execute(sql29`DELETE FROM migrations._journal WHERE plugin_name = ${pluginName}`);
+    await this.db.execute(sql29`DELETE FROM migrations._snapshots WHERE plugin_name = ${pluginName}`);
     logger12.warn({ src: "plugin:sql", pluginName }, "Reset complete");
   }
   async checkMigration(pluginName, schema) {
@@ -20255,18 +20739,18 @@ var init_runtime_migrator2 = __esm(() => {
 
 // src/migrations.ts
 import { logger as logger13 } from "@elizaos/core";
-import { sql as sql29 } from "drizzle-orm";
+import { sql as sql30 } from "drizzle-orm";
 async function migrateToEntityRLS(adapter) {
   const db = getDb(adapter);
   try {
-    await db.execute(sql29`SELECT 1 FROM pg_tables LIMIT 1`);
+    await db.execute(sql30`SELECT 1 FROM pg_tables LIMIT 1`);
   } catch {
     logger13.debug("[Migration] ⊘ Not PostgreSQL, skipping PostgreSQL-specific migrations");
     return;
   }
   let schemaAlreadyMigrated = false;
   try {
-    const migrationCheck = await db.execute(sql29`
+    const migrationCheck = await db.execute(sql30`
       SELECT column_name FROM information_schema.columns
       WHERE table_schema = 'public'
         AND table_name = 'rooms'
@@ -20288,7 +20772,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger13.debug("[Migration] → Schema migrated but RLS disabled, cleaning up...");
     try {
-      const tablesWithRls = await db.execute(sql29`
+      const tablesWithRls = await db.execute(sql30`
         SELECT c.relname as tablename
         FROM pg_class c
         JOIN pg_namespace n ON n.oid = c.relnamespace
@@ -20301,7 +20785,7 @@ async function migrateToEntityRLS(adapter) {
         for (const row of tablesWithRls.rows) {
           const tableName = row.tablename;
           try {
-            await db.execute(sql29.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
+            await db.execute(sql30.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
           } catch {}
         }
         logger13.debug(`[Migration] ✓ RLS cleanup completed (${tablesWithRls.rows.length} tables)`);
@@ -20317,14 +20801,14 @@ async function migrateToEntityRLS(adapter) {
   try {
     logger13.debug("[Migration] → Clearing RuntimeMigrator snapshot cache...");
     try {
-      await db.execute(sql29`DELETE FROM migrations._snapshots WHERE plugin_name = '@elizaos/plugin-sql'`);
+      await db.execute(sql30`DELETE FROM migrations._snapshots WHERE plugin_name = '@elizaos/plugin-sql'`);
       logger13.debug("[Migration] ✓ Snapshot cache cleared");
     } catch (error) {
       logger13.debug("[Migration] ⊘ No snapshot cache to clear (migrations schema not yet created)");
     }
     logger13.debug("[Migration] → Checking for Row Level Security to disable...");
     try {
-      const tablesWithRls = await db.execute(sql29`
+      const tablesWithRls = await db.execute(sql30`
         SELECT c.relname as tablename
         FROM pg_class c
         JOIN pg_namespace n ON n.oid = c.relnamespace
@@ -20337,7 +20821,7 @@ async function migrateToEntityRLS(adapter) {
         for (const row of tablesWithRls.rows) {
           const tableName = row.tablename;
           try {
-            await db.execute(sql29.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
+            await db.execute(sql30.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
             logger13.debug(`[Migration] ✓ Disabled RLS on ${tableName}`);
           } catch (error) {
             logger13.debug(`[Migration] ⊘ Could not disable RLS on ${tableName}`);
@@ -20353,7 +20837,7 @@ async function migrateToEntityRLS(adapter) {
     const tablesToMigrate = ["channels", "worlds", "rooms"];
     for (const tableName of tablesToMigrate) {
       try {
-        const columnsResult = await db.execute(sql29`
+        const columnsResult = await db.execute(sql30`
           SELECT column_name, data_type, is_nullable
           FROM information_schema.columns
           WHERE table_schema = 'public'
@@ -20369,19 +20853,19 @@ async function migrateToEntityRLS(adapter) {
         const oldColumnName = serverIdSnake ? "server_id" : "serverId";
         if (serverId && !messageServerId) {
           logger13.debug(`[Migration] → Renaming ${tableName}.${oldColumnName} to message_server_id...`);
-          await db.execute(sql29.raw(`ALTER TABLE "${tableName}" RENAME COLUMN "${oldColumnName}" TO "message_server_id"`));
+          await db.execute(sql30.raw(`ALTER TABLE "${tableName}" RENAME COLUMN "${oldColumnName}" TO "message_server_id"`));
           logger13.debug(`[Migration] ✓ Renamed ${tableName}.${oldColumnName} → message_server_id`);
           if (serverId.data_type === "text") {
             try {
               logger13.debug(`[Migration] → Dropping DEFAULT constraint on ${tableName}.message_server_id...`);
-              await db.execute(sql29.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
+              await db.execute(sql30.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
               logger13.debug(`[Migration] ✓ Dropped DEFAULT constraint`);
             } catch {
               logger13.debug(`[Migration] ⊘ No DEFAULT constraint to drop on ${tableName}.message_server_id`);
             }
             try {
               logger13.debug(`[Migration] → Converting ${tableName}.message_server_id from text to uuid...`);
-              await db.execute(sql29.raw(`
+              await db.execute(sql30.raw(`
                   ALTER TABLE "${tableName}"
                   ALTER COLUMN "message_server_id" TYPE uuid
                   USING CASE
@@ -20398,29 +20882,29 @@ async function migrateToEntityRLS(adapter) {
             }
           }
           if (tableName === "channels") {
-            const nullCountResult = await db.execute(sql29.raw(`SELECT COUNT(*) as count FROM "${tableName}" WHERE "message_server_id" IS NULL`));
+            const nullCountResult = await db.execute(sql30.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) {
               logger13.warn(`[Migration] ⚠️ ${tableName} has ${nullCount} rows with NULL message_server_id - these will be deleted`);
-              await db.execute(sql29.raw(`DELETE FROM "${tableName}" WHERE "message_server_id" IS NULL`));
+              await db.execute(sql30.raw(`DELETE FROM "${tableName}" WHERE "message_server_id" IS NULL`));
               logger13.debug(`[Migration] ✓ Deleted ${nullCount} rows with NULL message_server_id from ${tableName}`);
             }
             logger13.debug(`[Migration] → Making ${tableName}.message_server_id NOT NULL...`);
-            await db.execute(sql29.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" SET NOT NULL`));
+            await db.execute(sql30.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" SET NOT NULL`));
             logger13.debug(`[Migration] ✓ Set ${tableName}.message_server_id NOT NULL`);
           }
         } else if (serverId && messageServerId) {
           logger13.debug(`[Migration] → ${tableName} has both columns, dropping ${oldColumnName}...`);
-          await db.execute(sql29.raw(`ALTER TABLE "${tableName}" DROP COLUMN "${oldColumnName}" CASCADE`));
+          await db.execute(sql30.raw(`ALTER TABLE "${tableName}" DROP COLUMN "${oldColumnName}" CASCADE`));
           logger13.debug(`[Migration] ✓ Dropped ${tableName}.${oldColumnName}`);
         } else if (!serverId && messageServerId) {
           if (messageServerId.data_type === "text") {
             logger13.debug(`[Migration] → ${tableName}.message_server_id exists but is TEXT, needs UUID conversion...`);
             logger13.debug(`[Migration] → Dropping DEFAULT constraint on ${tableName}.message_server_id...`);
-            await db.execute(sql29.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
+            await db.execute(sql30.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
             logger13.debug(`[Migration] ✓ Dropped DEFAULT constraint`);
             logger13.debug(`[Migration] → Converting ${tableName}.message_server_id from text to uuid (generating UUIDs from text)...`);
-            await db.execute(sql29.raw(`
+            await db.execute(sql30.raw(`
               ALTER TABLE "${tableName}"
               ALTER COLUMN "message_server_id" TYPE uuid
               USING CASE
@@ -20442,7 +20926,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger13.debug("[Migration] → Dropping all remaining RLS-managed server_id columns...");
     try {
-      const serverIdColumnsResult = await db.execute(sql29`
+      const serverIdColumnsResult = await db.execute(sql30`
         SELECT table_name
         FROM information_schema.columns
         WHERE table_schema = 'public'
@@ -20464,7 +20948,7 @@ async function migrateToEntityRLS(adapter) {
       for (const row of tablesToClean) {
         const tableName = row.table_name;
         try {
-          await db.execute(sql29.raw(`ALTER TABLE "${tableName}" DROP COLUMN IF EXISTS server_id CASCADE`));
+          await db.execute(sql30.raw(`ALTER TABLE "${tableName}" DROP COLUMN IF EXISTS server_id CASCADE`));
           logger13.debug(`[Migration] ✓ Dropped server_id from ${tableName}`);
         } catch (error) {
           logger13.debug(`[Migration] ⊘ Could not drop server_id from ${tableName}`);
@@ -20475,7 +20959,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger13.debug("[Migration] → Checking agents.owner_id → server_id rename...");
     try {
-      const agentsColumnsResult = await db.execute(sql29`
+      const agentsColumnsResult = await db.execute(sql30`
         SELECT column_name
         FROM information_schema.columns
         WHERE table_schema = 'public'
@@ -20488,11 +20972,11 @@ async function migrateToEntityRLS(adapter) {
       const hasServerId = agentsColumns.some((c) => c.column_name === "server_id");
       if (hasOwnerId && !hasServerId) {
         logger13.debug("[Migration] → Renaming agents.owner_id to server_id...");
-        await db.execute(sql29.raw(`ALTER TABLE "agents" RENAME COLUMN "owner_id" TO "server_id"`));
+        await db.execute(sql30.raw(`ALTER TABLE "agents" RENAME COLUMN "owner_id" TO "server_id"`));
         logger13.debug("[Migration] ✓ Renamed agents.owner_id → server_id");
       } else if (hasOwnerId && hasServerId) {
         logger13.debug("[Migration] → Both owner_id and server_id exist, dropping owner_id...");
-        await db.execute(sql29.raw(`ALTER TABLE "agents" DROP COLUMN "owner_id" CASCADE`));
+        await db.execute(sql30.raw(`ALTER TABLE "agents" DROP COLUMN "owner_id" CASCADE`));
         logger13.debug("[Migration] ✓ Dropped agents.owner_id");
       } else {
         logger13.debug("[Migration] ⊘ agents table already has server_id (or no owner_id), skipping");
@@ -20502,7 +20986,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger13.debug("[Migration] → Checking for owners → servers data migration...");
     try {
-      const ownersTableResult = await db.execute(sql29`
+      const ownersTableResult = await db.execute(sql30`
         SELECT table_name
         FROM information_schema.tables
         WHERE table_schema = 'public'
@@ -20510,7 +20994,7 @@ async function migrateToEntityRLS(adapter) {
       `);
       if (ownersTableResult.rows && ownersTableResult.rows.length > 0) {
         logger13.debug("[Migration] → Ensuring servers table exists...");
-        await db.execute(sql29.raw(`
+        await db.execute(sql30.raw(`
           CREATE TABLE IF NOT EXISTS "servers" (
             "id" uuid PRIMARY KEY,
             "created_at" timestamp with time zone DEFAULT now() NOT NULL,
@@ -20518,7 +21002,7 @@ async function migrateToEntityRLS(adapter) {
           )
         `));
         logger13.debug("[Migration] → Migrating owners data to servers...");
-        await db.execute(sql29.raw(`
+        await db.execute(sql30.raw(`
           INSERT INTO "servers" ("id", "created_at", "updated_at")
           SELECT "id", COALESCE("created_at", now()), COALESCE("updated_at", now())
           FROM "owners"
@@ -20526,7 +21010,7 @@ async function migrateToEntityRLS(adapter) {
         `));
         logger13.debug("[Migration] ✓ Migrated owners data to servers");
         logger13.debug("[Migration] → Dropping obsolete owners table...");
-        await db.execute(sql29.raw(`DROP TABLE IF EXISTS "owners" CASCADE`));
+        await db.execute(sql30.raw(`DROP TABLE IF EXISTS "owners" CASCADE`));
         logger13.debug("[Migration] ✓ Dropped obsolete owners table");
       } else {
         logger13.debug("[Migration] ⊘ owners table not found, skipping");
@@ -20536,7 +21020,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger13.debug("[Migration] → Checking server_agents table rename...");
     try {
-      const tablesResult = await db.execute(sql29`
+      const tablesResult = await db.execute(sql30`
         SELECT table_name
         FROM information_schema.tables
         WHERE table_schema = 'public'
@@ -20548,16 +21032,16 @@ async function migrateToEntityRLS(adapter) {
       const hasMessageServerAgents = tables.some((t) => t.table_name === "message_server_agents");
       if (hasServerAgents && !hasMessageServerAgents) {
         logger13.debug("[Migration] → Renaming server_agents to message_server_agents...");
-        await db.execute(sql29.raw(`ALTER TABLE "server_agents" RENAME TO "message_server_agents"`));
+        await db.execute(sql30.raw(`ALTER TABLE "server_agents" RENAME TO "message_server_agents"`));
         logger13.debug("[Migration] ✓ Renamed server_agents → message_server_agents");
         logger13.debug("[Migration] → Renaming message_server_agents.server_id to message_server_id...");
-        await db.execute(sql29.raw(`ALTER TABLE "message_server_agents" RENAME COLUMN "server_id" TO "message_server_id"`));
+        await db.execute(sql30.raw(`ALTER TABLE "message_server_agents" RENAME COLUMN "server_id" TO "message_server_id"`));
         logger13.debug("[Migration] ✓ Renamed message_server_agents.server_id → message_server_id");
       } else if (!hasServerAgents && !hasMessageServerAgents) {
         logger13.debug("[Migration] ⊘ No server_agents table to migrate");
       } else if (hasMessageServerAgents) {
         logger13.debug("[Migration] → Checking message_server_agents columns...");
-        const columnsResult = await db.execute(sql29`
+        const columnsResult = await db.execute(sql30`
           SELECT column_name
           FROM information_schema.columns
           WHERE table_schema = 'public'
@@ -20570,11 +21054,11 @@ async function migrateToEntityRLS(adapter) {
         const hasMessageServerId = columns.some((c) => c.column_name === "message_server_id");
         if (hasServerId && !hasMessageServerId) {
           logger13.debug("[Migration] → Renaming message_server_agents.server_id to message_server_id...");
-          await db.execute(sql29.raw(`ALTER TABLE "message_server_agents" RENAME COLUMN "server_id" TO "message_server_id"`));
+          await db.execute(sql30.raw(`ALTER TABLE "message_server_agents" RENAME COLUMN "server_id" TO "message_server_id"`));
           logger13.debug("[Migration] ✓ Renamed message_server_agents.server_id → message_server_id");
         } else if (!hasServerId && !hasMessageServerId) {
           logger13.debug("[Migration] → message_server_agents exists without required columns, truncating...");
-          await db.execute(sql29`TRUNCATE TABLE message_server_agents CASCADE`);
+          await db.execute(sql30`TRUNCATE TABLE message_server_agents CASCADE`);
           logger13.debug("[Migration] ✓ Truncated message_server_agents");
         } else {
           logger13.debug("[Migration] ⊘ message_server_agents already has correct schema");
@@ -20585,7 +21069,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger13.debug("[Migration] → Checking channel_participants table...");
     try {
-      const columnsResult = await db.execute(sql29`
+      const columnsResult = await db.execute(sql30`
         SELECT column_name
         FROM information_schema.columns
         WHERE table_schema = 'public'
@@ -20598,11 +21082,11 @@ async function migrateToEntityRLS(adapter) {
       const hasEntityId = columns.some((c) => c.column_name === "entity_id");
       if (hasUserId && !hasEntityId) {
         logger13.debug("[Migration] → Renaming channel_participants.user_id to entity_id...");
-        await db.execute(sql29.raw(`ALTER TABLE "channel_participants" RENAME COLUMN "user_id" TO "entity_id"`));
+        await db.execute(sql30.raw(`ALTER TABLE "channel_participants" RENAME COLUMN "user_id" TO "entity_id"`));
         logger13.debug("[Migration] ✓ Renamed channel_participants.user_id → entity_id");
       } else if (!hasUserId && !hasEntityId) {
         logger13.debug("[Migration] → channel_participants exists without entity_id or user_id, truncating...");
-        await db.execute(sql29`TRUNCATE TABLE channel_participants CASCADE`);
+        await db.execute(sql30`TRUNCATE TABLE channel_participants CASCADE`);
         logger13.debug("[Migration] ✓ Truncated channel_participants");
       } else {
         logger13.debug("[Migration] ⊘ channel_participants already has entity_id column");
@@ -20612,7 +21096,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger13.debug("[Migration] → Discovering and dropping all regular indexes...");
     try {
-      const indexesResult = await db.execute(sql29`
+      const indexesResult = await db.execute(sql30`
         SELECT i.relname AS index_name
         FROM pg_index idx
         JOIN pg_class i ON i.oid = idx.indexrelid
@@ -20629,7 +21113,7 @@ async function migrateToEntityRLS(adapter) {
       for (const row of indexesToDrop) {
         const indexName = row.index_name;
         try {
-          await db.execute(sql29.raw(`DROP INDEX IF EXISTS "${indexName}"`));
+          await db.execute(sql30.raw(`DROP INDEX IF EXISTS "${indexName}"`));
           logger13.debug(`[Migration] ✓ Dropped index ${indexName}`);
         } catch (error) {
           logger13.debug(`[Migration] ⊘ Could not drop index ${indexName}`);
@@ -20686,14 +21170,14 @@ async function migrateToEntityRLS(adapter) {
     ];
     for (const rename of columnRenames) {
       try {
-        const tableExistsResult = await db.execute(sql29`
+        const tableExistsResult = await db.execute(sql30`
           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(sql29`
+        const columnsResult = await db.execute(sql30`
           SELECT column_name
           FROM information_schema.columns
           WHERE table_schema = 'public'
@@ -20706,11 +21190,11 @@ async function migrateToEntityRLS(adapter) {
         const hasNewColumn = columns.some((c) => c.column_name === rename.to);
         if (hasOldColumn && !hasNewColumn) {
           logger13.debug(`[Migration] → Renaming ${rename.table}.${rename.from} to ${rename.to}...`);
-          await db.execute(sql29.raw(`ALTER TABLE "${rename.table}" RENAME COLUMN "${rename.from}" TO "${rename.to}"`));
+          await db.execute(sql30.raw(`ALTER TABLE "${rename.table}" RENAME COLUMN "${rename.from}" TO "${rename.to}"`));
           logger13.debug(`[Migration] ✓ Renamed ${rename.table}.${rename.from} → ${rename.to}`);
         } else if (hasOldColumn && hasNewColumn) {
           logger13.debug(`[Migration] → Both columns exist, dropping ${rename.table}.${rename.from}...`);
-          await db.execute(sql29.raw(`ALTER TABLE "${rename.table}" DROP COLUMN "${rename.from}" CASCADE`));
+          await db.execute(sql30.raw(`ALTER TABLE "${rename.table}" DROP COLUMN "${rename.from}" CASCADE`));
           logger13.debug(`[Migration] ✓ Dropped ${rename.table}.${rename.from}`);
         }
       } catch (error) {
@@ -20728,17 +21212,17 @@ var init_migrations = () => {};
 
 // src/rls.ts
 import { logger as logger14, validateUuid } from "@elizaos/core";
-import { sql as sql30, eq as eq13 } from "drizzle-orm";
+import { sql as sql31, eq as eq13 } from "drizzle-orm";
 async function installRLSFunctions(adapter) {
   const db = getDb(adapter);
-  await db.execute(sql30`
+  await db.execute(sql31`
     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(sql30`
+  await db.execute(sql31`
     CREATE OR REPLACE FUNCTION current_server_id() RETURNS UUID AS $$
     DECLARE
       server_id_text TEXT;
@@ -20757,7 +21241,7 @@ async function installRLSFunctions(adapter) {
     END;
     $$ LANGUAGE plpgsql STABLE;
   `);
-  await db.execute(sql30`
+  await db.execute(sql31`
     CREATE OR REPLACE FUNCTION add_server_isolation(
       schema_name text,
       table_name text
@@ -20820,7 +21304,7 @@ async function installRLSFunctions(adapter) {
     END;
     $$ LANGUAGE plpgsql;
   `);
-  await db.execute(sql30`
+  await db.execute(sql31`
     CREATE OR REPLACE FUNCTION apply_rls_to_all_tables() RETURNS void AS $$
     DECLARE
       tbl record;
@@ -20850,7 +21334,7 @@ async function installRLSFunctions(adapter) {
 async function applyRLSToNewTables(adapter) {
   const db = getDb(adapter);
   try {
-    await db.execute(sql30`SELECT apply_rls_to_all_tables()`);
+    await db.execute(sql31`SELECT apply_rls_to_all_tables()`);
     logger14.info({ src: "plugin:sql" }, "RLS applied to all tables");
   } catch (error) {
     logger14.warn({ src: "plugin:sql", error: String(error) }, "Failed to apply RLS to some tables");
@@ -20859,7 +21343,7 @@ async function applyRLSToNewTables(adapter) {
 async function installEntityRLS(adapter) {
   const db = getDb(adapter);
   logger14.info("[Entity RLS] Installing entity RLS functions and policies...");
-  await db.execute(sql30`
+  await db.execute(sql31`
     CREATE OR REPLACE FUNCTION current_entity_id()
     RETURNS UUID AS $$
     DECLARE
@@ -20881,7 +21365,7 @@ async function installEntityRLS(adapter) {
     $$ LANGUAGE plpgsql STABLE;
   `);
   logger14.info("[Entity RLS] Created current_entity_id() function");
-  await db.execute(sql30`
+  await db.execute(sql31`
     CREATE OR REPLACE FUNCTION add_entity_isolation(
       schema_name text,
       table_name text,
@@ -21061,7 +21545,7 @@ async function installEntityRLS(adapter) {
     $$ LANGUAGE plpgsql;
   `);
   logger14.info("[Entity RLS] Created add_entity_isolation() function");
-  await db.execute(sql30`
+  await db.execute(sql31`
     CREATE OR REPLACE FUNCTION apply_entity_rls_to_all_tables() RETURNS void AS $$
     DECLARE
       tbl record;
@@ -21107,7 +21591,7 @@ async function installEntityRLS(adapter) {
 async function applyEntityRLSToAllTables(adapter) {
   const db = getDb(adapter);
   try {
-    await db.execute(sql30`SELECT apply_entity_rls_to_all_tables()`);
+    await db.execute(sql31`SELECT apply_entity_rls_to_all_tables()`);
     logger14.info("[Entity RLS] Applied entity RLS to all eligible tables");
   } catch (error) {
     logger14.warn("[Entity RLS] Failed to apply entity RLS to some tables:", String(error));
@@ -21233,391 +21717,14 @@ import { logger as logger17 } from "@elizaos/core";
 import { drizzle } from "drizzle-orm/pglite";
 
 // src/base.ts
+init_embedding();
+init_schema();
 import {
   DatabaseAdapter,
   logger as logger16
 } from "@elizaos/core";
-import { and as and11, eq as eq14, inArray as inArray5, sql as sql31 } from "drizzle-orm";
-
-// src/schema/embedding.ts
-import { sql as sql5 } from "drizzle-orm";
-import { check as check2, foreignKey as foreignKey2, index as index2, pgTable as pgTable5, timestamp as timestamp5, uuid as uuid5, vector } from "drizzle-orm/pg-core";
-import { VECTOR_DIMS } from "@elizaos/core";
-
-// src/schema/memory.ts
-init_agent();
-import { relations, sql as sql4 } from "drizzle-orm";
-import {
-  boolean as boolean2,
-  check,
-  foreignKey,
-  index,
-  jsonb as jsonb4,
-  pgTable as pgTable4,
-  text as text4,
-  timestamp as timestamp4,
-  uuid as uuid4
-} from "drizzle-orm/pg-core";
-
-// src/schema/entity.ts
-init_agent();
-import { sql as sql2 } from "drizzle-orm";
-import { jsonb as jsonb2, pgTable as pgTable2, text as text2, timestamp as timestamp2, unique, uuid as uuid2 } from "drizzle-orm/pg-core";
-var entityTable = pgTable2("entities", {
-  id: uuid2("id").notNull().primaryKey(),
-  agentId: uuid2("agent_id").notNull().references(() => agentTable.id, {
-    onDelete: "cascade"
-  }),
-  createdAt: timestamp2("created_at").default(sql2`now()`).notNull(),
-  names: text2("names").array().default(sql2`'{}'::text[]`).notNull(),
-  metadata: jsonb2("metadata").$type().default(sql2`'{}'::jsonb`).notNull()
-}, (table) => {
-  return {
-    idAgentIdUnique: unique("id_agent_id_unique").on(table.id, table.agentId)
-  };
-});
-
-// src/schema/room.ts
-init_agent();
-import { sql as sql3 } from "drizzle-orm";
-import { jsonb as jsonb3, pgTable as pgTable3, text as text3, timestamp as timestamp3, uuid as uuid3 } from "drizzle-orm/pg-core";
-var roomTable = pgTable3("rooms", {
-  id: uuid3("id").notNull().primaryKey().default(sql3`gen_random_uuid()`),
-  agentId: uuid3("agent_id").references(() => agentTable.id, {
-    onDelete: "cascade"
-  }),
-  source: text3("source").notNull(),
-  type: text3("type").notNull(),
-  messageServerId: uuid3("message_server_id"),
-  worldId: uuid3("world_id"),
-  name: text3("name"),
-  metadata: jsonb3("metadata").$type(),
-  channelId: text3("channel_id"),
-  createdAt: timestamp3("created_at").default(sql3`now()`).notNull()
-});
-
-// src/schema/memory.ts
-var memoryTable = pgTable4("memories", {
-  id: uuid4("id").primaryKey().notNull(),
-  type: text4("type").notNull(),
-  createdAt: timestamp4("created_at").default(sql4`now()`).notNull(),
-  content: jsonb4("content").$type().notNull(),
-  entityId: uuid4("entity_id").references(() => entityTable.id, {
-    onDelete: "cascade"
-  }),
-  agentId: uuid4("agent_id").references(() => agentTable.id, {
-    onDelete: "cascade"
-  }).notNull(),
-  roomId: uuid4("room_id").references(() => roomTable.id, {
-    onDelete: "cascade"
-  }),
-  worldId: uuid4("world_id"),
-  unique: boolean2("unique").default(true).notNull(),
-  metadata: jsonb4("metadata").$type().default({}).notNull()
-}, (table) => [
-  index("idx_memories_type_room").on(table.type, table.roomId),
-  index("idx_memories_world_id").on(table.worldId),
-  foreignKey({
-    name: "fk_room",
-    columns: [table.roomId],
-    foreignColumns: [roomTable.id]
-  }).onDelete("cascade"),
-  foreignKey({
-    name: "fk_user",
-    columns: [table.entityId],
-    foreignColumns: [entityTable.id]
-  }).onDelete("cascade"),
-  foreignKey({
-    name: "fk_agent",
-    columns: [table.agentId],
-    foreignColumns: [agentTable.id]
-  }).onDelete("cascade"),
-  index("idx_memories_metadata_type").on(sql4`((metadata->>'type'))`),
-  index("idx_memories_document_id").on(sql4`((metadata->>'documentId'))`),
-  index("idx_fragments_order").on(sql4`((metadata->>'documentId'))`, sql4`((metadata->>'position'))`),
-  check("fragment_metadata_check", sql4`
-            CASE 
-                WHEN metadata->>'type' = 'fragment' THEN
-                    metadata ? 'documentId' AND 
-                    metadata ? 'position'
-                ELSE true
-            END
-        `),
-  check("document_metadata_check", sql4`
-            CASE 
-                WHEN metadata->>'type' = 'document' THEN
-                    metadata ? 'timestamp'
-                ELSE true
-            END
-        `)
-]);
-var memoryRelations = relations(memoryTable, ({ one }) => ({
-  embedding: one(embeddingTable)
-}));
-
-// src/schema/embedding.ts
-var DIMENSION_MAP = {
-  [VECTOR_DIMS.SMALL]: "dim384",
-  [VECTOR_DIMS.MEDIUM]: "dim512",
-  [VECTOR_DIMS.LARGE]: "dim768",
-  [VECTOR_DIMS.XL]: "dim1024",
-  [VECTOR_DIMS.XXL]: "dim1536",
-  [VECTOR_DIMS.XXXL]: "dim3072"
-};
-var embeddingTable = pgTable5("embeddings", {
-  id: uuid5("id").primaryKey().defaultRandom().notNull(),
-  memoryId: uuid5("memory_id").references(() => memoryTable.id, { onDelete: "cascade" }),
-  createdAt: timestamp5("created_at").default(sql5`now()`).notNull(),
-  dim384: vector("dim_384", { dimensions: VECTOR_DIMS.SMALL }),
-  dim512: vector("dim_512", { dimensions: VECTOR_DIMS.MEDIUM }),
-  dim768: vector("dim_768", { dimensions: VECTOR_DIMS.LARGE }),
-  dim1024: vector("dim_1024", { dimensions: VECTOR_DIMS.XL }),
-  dim1536: vector("dim_1536", { dimensions: VECTOR_DIMS.XXL }),
-  dim3072: vector("dim_3072", { dimensions: VECTOR_DIMS.XXXL })
-}, (table) => [
-  check2("embedding_source_check", sql5`"memory_id" IS NOT NULL`),
-  index2("idx_embedding_memory").on(table.memoryId),
-  foreignKey2({
-    name: "fk_embedding_memory",
-    columns: [table.memoryId],
-    foreignColumns: [memoryTable.id]
-  }).onDelete("cascade")
-]);
-
-// src/schema/index.ts
-init_agent();
-var exports_schema = {};
-__export(exports_schema, {
-  worldTable: () => worldTable,
-  taskTable: () => taskTable,
-  serverTable: () => serverTable,
-  roomTable: () => roomTable,
-  relationshipTable: () => relationshipTable,
-  participantTable: () => participantTable,
-  messageTable: () => messageTable,
-  messageServerTable: () => messageServerTable,
-  messageServerAgentsTable: () => messageServerAgentsTable,
-  memoryTable: () => memoryTable,
-  logTable: () => logTable,
-  entityTable: () => entityTable,
-  embeddingTable: () => embeddingTable,
-  componentTable: () => componentTable,
-  channelTable: () => channelTable,
-  channelParticipantsTable: () => channelParticipantsTable,
-  cacheTable: () => cacheTable,
-  agentTable: () => agentTable
-});
+import { and as and11, eq as eq14, inArray as inArray5, sql as sql32 } from "drizzle-orm";
 
-// src/schema/cache.ts
-init_agent();
-import { sql as sql6 } from "drizzle-orm";
-import { jsonb as jsonb5, pgTable as pgTable6, text as text5, primaryKey, timestamp as timestamp6, uuid as uuid6 } from "drizzle-orm/pg-core";
-var cacheTable = pgTable6("cache", {
-  key: text5("key").notNull(),
-  agentId: uuid6("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
-  value: jsonb5("value").notNull(),
-  createdAt: timestamp6("created_at", { withTimezone: true }).default(sql6`now()`).notNull(),
-  expiresAt: timestamp6("expires_at", { withTimezone: true })
-}, (table) => [primaryKey({ columns: [table.key, table.agentId] })]);
-// src/schema/component.ts
-init_agent();
-import { sql as sql8 } from "drizzle-orm";
-import { jsonb as jsonb7, pgTable as pgTable8, text as text7, timestamp as timestamp8, uuid as uuid8 } from "drizzle-orm/pg-core";
-
-// src/schema/world.ts
-init_agent();
-import { sql as sql7 } from "drizzle-orm";
-import { jsonb as jsonb6, pgTable as pgTable7, text as text6, timestamp as timestamp7, uuid as uuid7 } from "drizzle-orm/pg-core";
-var worldTable = pgTable7("worlds", {
-  id: uuid7("id").notNull().primaryKey().default(sql7`gen_random_uuid()`),
-  agentId: uuid7("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
-  name: text6("name").notNull(),
-  metadata: jsonb6("metadata").$type(),
-  messageServerId: uuid7("message_server_id"),
-  createdAt: timestamp7("created_at").default(sql7`now()`).notNull()
-});
-
-// src/schema/component.ts
-var componentTable = pgTable8("components", {
-  id: uuid8("id").primaryKey().default(sql8`gen_random_uuid()`).notNull(),
-  entityId: uuid8("entity_id").references(() => entityTable.id, { onDelete: "cascade" }).notNull(),
-  agentId: uuid8("agent_id").references(() => agentTable.id, { onDelete: "cascade" }).notNull(),
-  roomId: uuid8("room_id").references(() => roomTable.id, { onDelete: "cascade" }).notNull(),
-  worldId: uuid8("world_id").references(() => worldTable.id, { onDelete: "cascade" }),
-  sourceEntityId: uuid8("source_entity_id").references(() => entityTable.id, {
-    onDelete: "cascade"
-  }),
-  type: text7("type").notNull(),
-  data: jsonb7("data").default(sql8`'{}'::jsonb`),
-  createdAt: timestamp8("created_at").default(sql8`now()`).notNull()
-});
-// src/schema/log.ts
-import { sql as sql9 } from "drizzle-orm";
-import { foreignKey as foreignKey3, jsonb as jsonb8, pgTable as pgTable9, text as text8, timestamp as timestamp9, uuid as uuid9 } from "drizzle-orm/pg-core";
-var logTable = pgTable9("logs", {
-  id: uuid9("id").defaultRandom().notNull(),
-  createdAt: timestamp9("created_at", { withTimezone: true }).default(sql9`now()`).notNull(),
-  entityId: uuid9("entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
-  body: jsonb8("body").notNull(),
-  type: text8("type").notNull(),
-  roomId: uuid9("room_id").notNull().references(() => roomTable.id, { onDelete: "cascade" })
-}, (table) => [
-  foreignKey3({
-    name: "fk_room",
-    columns: [table.roomId],
-    foreignColumns: [roomTable.id]
-  }).onDelete("cascade"),
-  foreignKey3({
-    name: "fk_user",
-    columns: [table.entityId],
-    foreignColumns: [entityTable.id]
-  }).onDelete("cascade")
-]);
-
-// src/schema/index.ts
-init_server();
-
-// src/schema/participant.ts
-init_agent();
-import { sql as sql11 } from "drizzle-orm";
-import { foreignKey as foreignKey4, index as index3, pgTable as pgTable11, text as text9, timestamp as timestamp11, uuid as uuid11 } from "drizzle-orm/pg-core";
-var participantTable = pgTable11("participants", {
-  id: uuid11("id").notNull().primaryKey().default(sql11`gen_random_uuid()`),
-  createdAt: timestamp11("created_at", { withTimezone: true }).default(sql11`now()`).notNull(),
-  entityId: uuid11("entity_id").references(() => entityTable.id, {
-    onDelete: "cascade"
-  }),
-  roomId: uuid11("room_id").references(() => roomTable.id, {
-    onDelete: "cascade"
-  }),
-  agentId: uuid11("agent_id").references(() => agentTable.id, {
-    onDelete: "cascade"
-  }),
-  roomState: text9("room_state")
-}, (table) => [
-  index3("idx_participants_user").on(table.entityId),
-  index3("idx_participants_room").on(table.roomId),
-  foreignKey4({
-    name: "fk_room",
-    columns: [table.roomId],
-    foreignColumns: [roomTable.id]
-  }).onDelete("cascade"),
-  foreignKey4({
-    name: "fk_user",
-    columns: [table.entityId],
-    foreignColumns: [entityTable.id]
-  }).onDelete("cascade")
-]);
-// src/schema/relationship.ts
-init_agent();
-import { sql as sql12 } from "drizzle-orm";
-import {
-  foreignKey as foreignKey5,
-  index as index4,
-  jsonb as jsonb9,
-  pgTable as pgTable12,
-  text as text10,
-  timestamp as timestamp12,
-  unique as unique2,
-  uuid as uuid12
-} from "drizzle-orm/pg-core";
-var relationshipTable = pgTable12("relationships", {
-  id: uuid12("id").notNull().primaryKey().default(sql12`gen_random_uuid()`),
-  createdAt: timestamp12("created_at", { withTimezone: true }).default(sql12`now()`).notNull(),
-  sourceEntityId: uuid12("source_entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
-  targetEntityId: uuid12("target_entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
-  agentId: uuid12("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
-  tags: text10("tags").array(),
-  metadata: jsonb9("metadata").$type()
-}, (table) => [
-  index4("idx_relationships_users").on(table.sourceEntityId, table.targetEntityId),
-  unique2("unique_relationship").on(table.sourceEntityId, table.targetEntityId, table.agentId),
-  foreignKey5({
-    name: "fk_user_a",
-    columns: [table.sourceEntityId],
-    foreignColumns: [entityTable.id]
-  }).onDelete("cascade"),
-  foreignKey5({
-    name: "fk_user_b",
-    columns: [table.targetEntityId],
-    foreignColumns: [entityTable.id]
-  }).onDelete("cascade")
-]);
-// src/schema/tasks.ts
-init_agent();
-import { jsonb as jsonb10, pgTable as pgTable13, text as text11, timestamp as timestamp13, uuid as uuid13 } from "drizzle-orm/pg-core";
-import { sql as sql13 } from "drizzle-orm";
-var taskTable = pgTable13("tasks", {
-  id: uuid13("id").primaryKey().defaultRandom(),
-  name: text11("name").notNull(),
-  description: text11("description"),
-  roomId: uuid13("room_id"),
-  worldId: uuid13("world_id"),
-  entityId: uuid13("entity_id"),
-  agentId: uuid13("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
-  tags: text11("tags").array().default(sql13`'{}'::text[]`),
-  metadata: jsonb10("metadata").$type().default(sql13`'{}'::jsonb`),
-  createdAt: timestamp13("created_at", { withTimezone: true }).defaultNow(),
-  updatedAt: timestamp13("updated_at", { withTimezone: true }).defaultNow()
-});
-// src/schema/messageServer.ts
-import { pgTable as pgTable14, text as text12, jsonb as jsonb11, timestamp as timestamp14, uuid as uuid14 } from "drizzle-orm/pg-core";
-import { sql as sql14 } from "drizzle-orm";
-var messageServerTable = pgTable14("message_servers", {
-  id: uuid14("id").primaryKey(),
-  name: text12("name").notNull(),
-  sourceType: text12("source_type").notNull(),
-  sourceId: text12("source_id"),
-  metadata: jsonb11("metadata").$type(),
-  createdAt: timestamp14("created_at", { mode: "date" }).default(sql14`CURRENT_TIMESTAMP`).notNull(),
-  updatedAt: timestamp14("updated_at", { mode: "date" }).default(sql14`CURRENT_TIMESTAMP`).notNull()
-});
-// src/schema/channel.ts
-import { pgTable as pgTable15, text as text13, jsonb as jsonb12, timestamp as timestamp15, uuid as uuid15 } from "drizzle-orm/pg-core";
-import { sql as sql15 } from "drizzle-orm";
-var channelTable = pgTable15("channels", {
-  id: text13("id").primaryKey(),
-  messageServerId: uuid15("message_server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
-  name: text13("name").notNull(),
-  type: text13("type").notNull(),
-  sourceType: text13("source_type"),
-  sourceId: text13("source_id"),
-  topic: text13("topic"),
-  metadata: jsonb12("metadata").$type(),
-  createdAt: timestamp15("created_at", { mode: "date" }).default(sql15`CURRENT_TIMESTAMP`).notNull(),
-  updatedAt: timestamp15("updated_at", { mode: "date" }).default(sql15`CURRENT_TIMESTAMP`).notNull()
-});
-// src/schema/message.ts
-import { pgTable as pgTable16, text as text14, jsonb as jsonb13, timestamp as timestamp16 } from "drizzle-orm/pg-core";
-import { sql as sql16 } from "drizzle-orm";
-var messageTable = pgTable16("central_messages", {
-  id: text14("id").primaryKey(),
-  channelId: text14("channel_id").notNull().references(() => channelTable.id, { onDelete: "cascade" }),
-  authorId: text14("author_id").notNull(),
-  content: text14("content").notNull(),
-  rawMessage: jsonb13("raw_message"),
-  inReplyToRootMessageId: text14("in_reply_to_root_message_id").references(() => messageTable.id, {
-    onDelete: "set null"
-  }),
-  sourceType: text14("source_type"),
-  sourceId: text14("source_id"),
-  metadata: jsonb13("metadata").$type(),
-  createdAt: timestamp16("created_at", { mode: "date" }).default(sql16`CURRENT_TIMESTAMP`).notNull(),
-  updatedAt: timestamp16("updated_at", { mode: "date" }).default(sql16`CURRENT_TIMESTAMP`).notNull()
-});
-// src/schema/channelParticipant.ts
-import { pgTable as pgTable17, text as text15, primaryKey as primaryKey2 } from "drizzle-orm/pg-core";
-var channelParticipantsTable = pgTable17("channel_participants", {
-  channelId: text15("channel_id").notNull().references(() => channelTable.id, { onDelete: "cascade" }),
-  entityId: text15("entity_id").notNull()
-}, (table) => [primaryKey2({ columns: [table.channelId, table.entityId] })]);
-// src/schema/messageServerAgent.ts
-import { pgTable as pgTable18, uuid as uuid16, primaryKey as primaryKey3 } from "drizzle-orm/pg-core";
-init_agent();
-var messageServerAgentsTable = pgTable18("message_server_agents", {
-  messageServerId: uuid16("message_server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
-  agentId: uuid16("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" })
-}, (table) => [primaryKey3({ columns: [table.messageServerId, table.agentId] })]);
 // src/utils.ts
 function sanitizeJsonObject(value, seen = new WeakSet) {
   if (value === null || value === undefined) {
@@ -21647,8 +21754,10 @@ function sanitizeJsonObject(value, seen = new WeakSet) {
 }
 
 // src/stores/agent.store.ts
+init_schema();
 import { logger } from "@elizaos/core";
 import { count, eq } from "drizzle-orm";
+
 class AgentStore {
   ctx;
   constructor(ctx) {
@@ -21835,7 +21944,7 @@ class AgentStore {
 
 // src/stores/memory.store.ts
 import { logger as logger2 } from "@elizaos/core";
-import { and, cosineDistance, desc, eq as eq2, gte, inArray, lte, sql as sql17 } from "drizzle-orm";
+import { and, cosineDistance, desc, eq as eq2, gte, inArray, lte, sql as sql18 } from "drizzle-orm";
 
 // ../../node_modules/uuid/dist/stringify.js
 var byteToHex = [];
@@ -21892,6 +22001,8 @@ function v4(options, buf, offset) {
 }
 var v4_default = v4;
 // src/stores/memory.store.ts
+init_schema();
+
 class MemoryStore {
   ctx;
   constructor(ctx) {
@@ -22046,7 +22157,7 @@ class MemoryStore {
   async searchByEmbedding(embedding, params) {
     return this.ctx.withRetry(async () => {
       const cleanVector = embedding.map((n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0);
-      const similarity = sql17`1 - (${cosineDistance(embeddingTable[this.ctx.getEmbeddingDimension()], cleanVector)})`;
+      const similarity = sql18`1 - (${cosineDistance(embeddingTable[this.ctx.getEmbeddingDimension()], cleanVector)})`;
       const conditions = [
         eq2(memoryTable.type, params.tableName),
         eq2(memoryTable.agentId, this.ctx.agentId)
@@ -22105,8 +22216,8 @@ class MemoryStore {
         {
           id: memoryId,
           type: tableName,
-          content: sql17`${contentToInsert}::jsonb`,
-          metadata: sql17`${metadataToInsert}::jsonb`,
+          content: sql18`${contentToInsert}::jsonb`,
+          metadata: sql18`${metadataToInsert}::jsonb`,
           entityId: memory.entityId,
           roomId: memory.roomId,
           worldId: memory.worldId,
@@ -22129,12 +22240,12 @@ class MemoryStore {
             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: sql17`${contentToUpdate}::jsonb`,
-              ...memory.metadata && { metadata: sql17`${metadataToUpdate}::jsonb` }
+              content: sql18`${contentToUpdate}::jsonb`,
+              ...memory.metadata && { metadata: sql18`${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: sql17`${metadataToUpdate}::jsonb` }).where(eq2(memoryTable.id, memory.id));
+            await tx.update(memoryTable).set({ metadata: sql18`${metadataToUpdate}::jsonb` }).where(eq2(memoryTable.id, memory.id));
           }
           if (memory.embedding && Array.isArray(memory.embedding)) {
             await this.upsertEmbedding(tx, memory.id, memory.embedding);
@@ -22197,7 +22308,7 @@ class MemoryStore {
       const conditions = [eq2(memoryTable.roomId, roomId), eq2(memoryTable.type, tableName)];
       if (unique3)
         conditions.push(eq2(memoryTable.unique, true));
-      const result = await this.db.select({ count: sql17`count(*)` }).from(memoryTable).where(and(...conditions));
+      const result = await this.db.select({ count: sql18`count(*)` }).from(memoryTable).where(and(...conditions));
       return Number(result[0]?.count ?? 0);
     }, "MemoryStore.count");
   }
@@ -22215,7 +22326,7 @@ class MemoryStore {
     }
   }
   async deleteFragments(tx, documentId) {
-    const fragments = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq2(memoryTable.agentId, this.ctx.agentId), sql17`${memoryTable.metadata}->>'documentId' = ${documentId}`));
+    const fragments = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq2(memoryTable.agentId, this.ctx.agentId), sql18`${memoryTable.metadata}->>'documentId' = ${documentId}`));
     if (fragments.length > 0) {
       const fragmentIds = fragments.map((f) => f.id);
       await tx.delete(embeddingTable).where(inArray(embeddingTable.memoryId, fragmentIds));
@@ -22226,6 +22337,8 @@ class MemoryStore {
 
 // src/stores/room.store.ts
 import { and as and2, eq as eq3, inArray as inArray2 } from "drizzle-orm";
+init_schema();
+
 class RoomStore {
   ctx;
   constructor(ctx) {
@@ -22311,8 +22424,10 @@ class RoomStore {
 }
 
 // src/stores/participant.store.ts
+init_schema();
 import { logger as logger3 } from "@elizaos/core";
 import { and as and3, eq as eq4, inArray as inArray3 } from "drizzle-orm";
+
 class ParticipantStore {
   ctx;
   constructor(ctx) {
@@ -22446,8 +22561,10 @@ class ParticipantStore {
 }
 
 // src/stores/entity.store.ts
+init_schema();
 import { logger as logger4 } from "@elizaos/core";
-import { and as and4, eq as eq5, inArray as inArray4, or, sql as sql18 } from "drizzle-orm";
+import { and as and4, eq as eq5, inArray as inArray4, or, sql as sql19 } from "drizzle-orm";
+
 class EntityStore {
   ctx;
   constructor(ctx) {
@@ -22584,11 +22701,11 @@ class EntityStore {
   async getByNames(params) {
     return this.ctx.withRetry(async () => {
       const { names, agentId } = params;
-      const nameConditions = names.map((name) => sql18`${name} = ANY(${entityTable.names})`);
-      const query = sql18`
+      const nameConditions = names.map((name) => sql19`${name} = ANY(${entityTable.names})`);
+      const query = sql19`
         SELECT * FROM ${entityTable}
         WHERE ${entityTable.agentId} = ${agentId}
-        AND (${sql18.join(nameConditions, sql18` OR `)})
+        AND (${sql19.join(nameConditions, sql19` OR `)})
       `;
       const result = await this.db.execute(query);
       return result.rows.map((row) => ({
@@ -22611,7 +22728,7 @@ class EntityStore {
           metadata: row.metadata || {}
         }));
       }
-      const searchQuery = sql18`
+      const searchQuery = sql19`
         SELECT * FROM ${entityTable}
         WHERE ${entityTable.agentId} = ${agentId}
         AND EXISTS (
@@ -22646,7 +22763,9 @@ class EntityStore {
 }
 
 // src/stores/component.store.ts
+init_schema();
 import { and as and5, eq as eq6 } from "drizzle-orm";
+
 class ComponentStore {
   ctx;
   constructor(ctx) {
@@ -22736,7 +22855,9 @@ class ComponentStore {
 
 // src/stores/relationship.store.ts
 import { logger as logger5 } from "@elizaos/core";
-import { and as and6, eq as eq7, sql as sql19 } from "drizzle-orm";
+import { and as and6, eq as eq7, sql as sql20 } from "drizzle-orm";
+init_schema();
+
 class RelationshipStore {
   ctx;
   constructor(ctx) {
@@ -22812,13 +22933,13 @@ class RelationshipStore {
       const { entityId, tags } = params;
       let query;
       if (tags && tags.length > 0) {
-        query = sql19`
+        query = sql20`
           SELECT * FROM ${relationshipTable}
           WHERE (${relationshipTable.sourceEntityId} = ${entityId} OR ${relationshipTable.targetEntityId} = ${entityId})
-          AND ${relationshipTable.tags} && CAST(ARRAY[${sql19.join(tags, sql19`, `)}] AS text[])
+          AND ${relationshipTable.tags} && CAST(ARRAY[${sql20.join(tags, sql20`, `)}] AS text[])
         `;
       } else {
-        query = sql19`
+        query = sql20`
           SELECT * FROM ${relationshipTable}
           WHERE ${relationshipTable.sourceEntityId} = ${entityId} OR ${relationshipTable.targetEntityId} = ${entityId}
         `;
@@ -22839,8 +22960,10 @@ class RelationshipStore {
 }
 
 // src/stores/cache.store.ts
+init_schema();
 import { logger as logger6 } from "@elizaos/core";
 import { and as and7, eq as eq8 } from "drizzle-orm";
+
 class CacheStore {
   ctx;
   constructor(ctx) {
@@ -22913,6 +23036,8 @@ class CacheStore {
 
 // src/stores/world.store.ts
 import { eq as eq9 } from "drizzle-orm";
+init_schema();
+
 class WorldStore {
   ctx;
   constructor(ctx) {
@@ -22957,7 +23082,9 @@ class WorldStore {
 }
 
 // src/stores/task.store.ts
-import { and as and8, eq as eq10, sql as sql20 } from "drizzle-orm";
+init_schema();
+import { and as and8, eq as eq10, sql as sql21 } from "drizzle-orm";
+
 class TaskStore {
   ctx;
   constructor(ctx) {
@@ -22991,7 +23118,7 @@ class TaskStore {
   async getAll(params) {
     return this.ctx.withRetry(async () => {
       const result = await this.db.select().from(taskTable).where(and8(eq10(taskTable.agentId, this.ctx.agentId), ...params.roomId ? [eq10(taskTable.roomId, params.roomId)] : [], ...params.tags && params.tags.length > 0 ? [
-        sql20`${taskTable.tags} @> ARRAY[${sql20.join(params.tags.map((t) => sql20`${t}`), sql20`, `)}]::text[]`
+        sql21`${taskTable.tags} @> ARRAY[${sql21.join(params.tags.map((t) => sql21`${t}`), sql21`, `)}]::text[]`
       ] : []));
       return result.map((row) => ({
         id: row.id,
@@ -23066,7 +23193,8 @@ class TaskStore {
 }
 
 // src/stores/log.store.ts
-import { and as and9, desc as desc2, eq as eq11, gte as gte2, lte as lte2, sql as sql21 } from "drizzle-orm";
+init_schema();
+import { and as and9, desc as desc2, eq as eq11, gte as gte2, lte as lte2, sql as sql22 } from "drizzle-orm";
 import { logger as logger7 } from "@elizaos/core";
 class LogStore {
   ctx;
@@ -23079,7 +23207,7 @@ class LogStore {
       const jsonString = JSON.stringify(sanitizedBody);
       await this.ctx.withIsolationContext(params.entityId, async (tx) => {
         await tx.insert(logTable).values({
-          body: sql21`${jsonString}::jsonb`,
+          body: sql22`${jsonString}::jsonb`,
           entityId: params.entityId,
           roomId: params.roomId,
           type: params.type
@@ -23119,7 +23247,7 @@ class LogStore {
       const runMap = new Map;
       const conditions = [
         eq11(logTable.type, "run_event"),
-        sql21`${logTable.body} ? 'runId'`,
+        sql22`${logTable.body} ? 'runId'`,
         eq11(roomTable.agentId, agentId)
       ];
       if (params.roomId) {
@@ -23134,9 +23262,9 @@ class LogStore {
       const whereClause = and9(...conditions);
       const eventLimit = Math.max(limit * 20, 200);
       const runEventRows = await tx.select({
-        runId: sql21`(${logTable.body} ->> 'runId')`,
-        status: sql21`(${logTable.body} ->> 'status')`,
-        messageId: sql21`(${logTable.body} ->> 'messageId')`,
+        runId: sql22`(${logTable.body} ->> 'runId')`,
+        status: sql22`(${logTable.body} ->> 'status')`,
+        messageId: sql22`(${logTable.body} ->> 'messageId')`,
         rawBody: logTable.body,
         createdAt: logTable.createdAt,
         roomId: logTable.roomId,
@@ -23183,15 +23311,15 @@ class LogStore {
           }
         }
         const createdAt = row.createdAt instanceof Date ? row.createdAt : new Date(row.createdAt);
-        const timestamp17 = createdAt.getTime();
+        const timestamp18 = createdAt.getTime();
         const eventStatus = row.status ?? body?.status;
         if (eventStatus === "started") {
-          summary.startedAt = summary.startedAt === null ? timestamp17 : Math.min(summary.startedAt, timestamp17);
+          summary.startedAt = summary.startedAt === null ? timestamp18 : Math.min(summary.startedAt, timestamp18);
         } else if (eventStatus === "completed" || eventStatus === "timeout" || eventStatus === "error") {
           summary.status = eventStatus;
-          summary.endedAt = timestamp17;
+          summary.endedAt = timestamp18;
           if (summary.startedAt !== null) {
-            summary.durationMs = Math.max(timestamp17 - summary.startedAt, 0);
+            summary.durationMs = Math.max(timestamp18 - summary.startedAt, 0);
           }
         }
         runMap.set(runId, summary);
@@ -23211,8 +23339,8 @@ class LogStore {
       const runIds = limitedRuns.map((run) => run.runId).filter(Boolean);
       if (runIds.length > 0) {
         const db = this.ctx.getDb();
-        const runIdArray = sql21`array[${sql21.join(runIds.map((id) => sql21`${id}`), sql21`, `)}]::text[]`;
-        const actionSummary = await db.execute(sql21`
+        const runIdArray = sql22`array[${sql22.join(runIds.map((id) => sql22`${id}`), sql22`, `)}]::text[]`;
+        const actionSummary = await db.execute(sql22`
           SELECT
             body->>'runId' as "runId",
             COUNT(*)::int as "actions",
@@ -23232,7 +23360,7 @@ class LogStore {
           counts.errors += Number(row.errors ?? 0);
           counts.modelCalls += Number(row.modelCalls ?? 0);
         }
-        const evaluatorSummary = await db.execute(sql21`
+        const evaluatorSummary = await db.execute(sql22`
           SELECT
             body->>'runId' as "runId",
             COUNT(*)::int as "evaluators"
@@ -23248,7 +23376,7 @@ class LogStore {
             continue;
           counts.evaluators += Number(row.evaluators ?? 0);
         }
-        const genericSummary = await db.execute(sql21`
+        const genericSummary = await db.execute(sql22`
           SELECT
             body->>'runId' as "runId",
             COUNT(*) FILTER (WHERE type LIKE 'useModel:%')::int as "modelLogs",
@@ -23291,7 +23419,9 @@ class LogStore {
 
 // src/stores/messaging.store.ts
 import { ChannelType } from "@elizaos/core";
-import { and as and10, desc as desc3, eq as eq12, lt, sql as sql22 } from "drizzle-orm";
+import { and as and10, desc as desc3, eq as eq12, lt, sql as sql23 } from "drizzle-orm";
+init_schema();
+
 class MessagingStore {
   ctx;
   constructor(ctx) {
@@ -23362,7 +23492,7 @@ class MessagingStore {
   }
   async getMessageServerByRlsServerId(rlsServerId) {
     return this.ctx.withRetry(async () => {
-      const results = await this.db.execute(sql22`
+      const results = await this.db.execute(sql23`
         SELECT id, name, source_type, source_id, metadata, created_at, updated_at
         FROM message_servers
         WHERE server_id = ${rlsServerId}
@@ -23827,7 +23957,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async getCachedEmbeddings(opts) {
     return this.withDatabase(async () => {
       try {
-        const results = await this.db.execute(sql31`
+        const results = await this.db.execute(sql32`
                     WITH content_text AS (
                         SELECT
                             m.id,
@@ -23887,7 +24017,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         const jsonString = JSON.stringify(sanitizedBody);
         await this.withIsolationContext(params.entityId, async (tx) => {
           await tx.insert(logTable).values({
-            body: sql31`${jsonString}::jsonb`,
+            body: sql32`${jsonString}::jsonb`,
             entityId: params.entityId,
             roomId: params.roomId,
             type: params.type
@@ -24159,9 +24289,45 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async deleteMessage(messageId) {
     return this.messagingStore.deleteMessage(messageId);
   }
+  async getUserByEmail(email) {
+    return this.withDatabase(async () => {
+      const { userTable: userTable2 } = await Promise.resolve().then(() => (init_schema(), exports_schema));
+      const rows = await this.db.select().from(userTable2).where(eq14(userTable2.email, email.toLowerCase())).limit(1);
+      return rows.length > 0 ? rows[0] : null;
+    });
+  }
+  async getUserByUsername(username) {
+    return this.withDatabase(async () => {
+      const { userTable: userTable2 } = await Promise.resolve().then(() => (init_schema(), exports_schema));
+      const rows = await this.db.select().from(userTable2).where(eq14(userTable2.username, username)).limit(1);
+      return rows.length > 0 ? rows[0] : null;
+    });
+  }
+  async getUserById(id) {
+    return this.withDatabase(async () => {
+      const { userTable: userTable2 } = await Promise.resolve().then(() => (init_schema(), exports_schema));
+      const rows = await this.db.select().from(userTable2).where(eq14(userTable2.id, id)).limit(1);
+      return rows.length > 0 ? rows[0] : null;
+    });
+  }
+  async createUser(user) {
+    return this.withDatabase(async () => {
+      const { userTable: userTable2 } = await Promise.resolve().then(() => (init_schema(), exports_schema));
+      await this.db.insert(userTable2).values(user);
+      return user;
+    });
+  }
+  async updateUserLastLogin(userId) {
+    return this.withDatabase(async () => {
+      const { userTable: userTable2 } = await Promise.resolve().then(() => (init_schema(), exports_schema));
+      await this.db.update(userTable2).set({ lastLoginAt: new Date }).where(eq14(userTable2.id, userId));
+    });
+  }
 }
 
 // src/pglite/adapter.ts
+init_embedding();
+
 class PgliteDatabaseAdapter extends BaseDrizzleAdapter {
   manager;
   embeddingDimension = DIMENSION_MAP[384];
@@ -24260,6 +24426,7 @@ class PGliteClientManager {
 }
 
 // src/index.browser.ts
+init_schema();
 init_migration_service();
 var GLOBAL_SINGLETONS = Symbol.for("@elizaos/plugin-sql/global-singletons");
 var globalSymbols = globalThis;
@@ -24300,5 +24467,5 @@ export {
   DatabaseMigrationService
 };
 
-//# debugId=0A9AA0ECC3C837CD64756E2164756E21
+//# debugId=D001744F84EC701864756E2164756E21
 //# sourceMappingURL=index.browser.js.map