@elizaos/plugin-sql 1.6.4-alpha.9 → 1.6.4-beta.0

package/dist/browser/index.browser.js

@@ -36,7 +36,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/runtime-migrator/storage/migration-tracker.ts
-import { sql as sql16 } from "drizzle-orm";
+import { sql as sql17 } from "drizzle-orm";
 
 class MigrationTracker {
   db;
@@ -44,11 +44,11 @@ class MigrationTracker {
     this.db = db;
   }
   async ensureSchema() {
-    await this.db.execute(sql16`CREATE SCHEMA IF NOT EXISTS migrations`);
+    await this.db.execute(sql17`CREATE SCHEMA IF NOT EXISTS migrations`);
   }
   async ensureTables() {
     await this.ensureSchema();
-    await this.db.execute(sql16`
+    await this.db.execute(sql17`
       CREATE TABLE IF NOT EXISTS migrations._migrations (
         id SERIAL PRIMARY KEY,
         plugin_name TEXT NOT NULL,
@@ -56,7 +56,7 @@ class MigrationTracker {
         created_at BIGINT NOT NULL
       )
     `);
-    await this.db.execute(sql16`
+    await this.db.execute(sql17`
       CREATE TABLE IF NOT EXISTS migrations._journal (
         plugin_name TEXT PRIMARY KEY,
         version TEXT NOT NULL,
@@ -64,7 +64,7 @@ class MigrationTracker {
         entries JSONB NOT NULL DEFAULT '[]'
       )
     `);
-    await this.db.execute(sql16`
+    await this.db.execute(sql17`
       CREATE TABLE IF NOT EXISTS migrations._snapshots (
         id SERIAL PRIMARY KEY,
         plugin_name TEXT NOT NULL,
@@ -76,7 +76,7 @@ class MigrationTracker {
     `);
   }
   async getLastMigration(pluginName) {
-    const result = await this.db.execute(sql16`SELECT id, hash, created_at 
+    const result = await this.db.execute(sql17`SELECT id, hash, created_at 
           FROM migrations._migrations 
           WHERE plugin_name = ${pluginName} 
           ORDER BY created_at DESC 
@@ -84,14 +84,14 @@ class MigrationTracker {
     return result.rows[0] || null;
   }
   async recordMigration(pluginName, hash, createdAt) {
-    await this.db.execute(sql16`INSERT INTO migrations._migrations (plugin_name, hash, created_at) 
+    await this.db.execute(sql17`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 sql17 } from "drizzle-orm";
+import { sql as sql18 } from "drizzle-orm";
 
 class JournalStorage {
   db;
@@ -99,7 +99,7 @@ class JournalStorage {
     this.db = db;
   }
   async loadJournal(pluginName) {
-    const result = await this.db.execute(sql17`SELECT version, dialect, entries 
+    const result = await this.db.execute(sql18`SELECT version, dialect, entries 
           FROM migrations._journal 
           WHERE plugin_name = ${pluginName}`);
     if (result.rows.length === 0) {
@@ -113,7 +113,7 @@ class JournalStorage {
     };
   }
   async saveJournal(pluginName, journal) {
-    await this.db.execute(sql17`INSERT INTO migrations._journal (plugin_name, version, dialect, entries)
+    await this.db.execute(sql18`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 
@@ -155,7 +155,7 @@ class JournalStorage {
 var init_journal_storage = () => {};
 
 // src/runtime-migrator/storage/snapshot-storage.ts
-import { sql as sql18 } from "drizzle-orm";
+import { sql as sql19 } from "drizzle-orm";
 
 class SnapshotStorage {
   db;
@@ -163,7 +163,7 @@ class SnapshotStorage {
     this.db = db;
   }
   async saveSnapshot(pluginName, idx, snapshot) {
-    await this.db.execute(sql18`INSERT INTO migrations._snapshots (plugin_name, idx, snapshot)
+    await this.db.execute(sql19`INSERT INTO migrations._snapshots (plugin_name, idx, snapshot)
           VALUES (${pluginName}, ${idx}, ${JSON.stringify(snapshot)}::jsonb)
           ON CONFLICT (plugin_name, idx) 
           DO UPDATE SET 
@@ -171,7 +171,7 @@ class SnapshotStorage {
             created_at = NOW()`);
   }
   async loadSnapshot(pluginName, idx) {
-    const result = await this.db.execute(sql18`SELECT snapshot 
+    const result = await this.db.execute(sql19`SELECT snapshot 
           FROM migrations._snapshots 
           WHERE plugin_name = ${pluginName} AND idx = ${idx}`);
     if (result.rows.length === 0) {
@@ -180,7 +180,7 @@ class SnapshotStorage {
     return result.rows[0].snapshot;
   }
   async getLatestSnapshot(pluginName) {
-    const result = await this.db.execute(sql18`SELECT snapshot 
+    const result = await this.db.execute(sql19`SELECT snapshot 
           FROM migrations._snapshots 
           WHERE plugin_name = ${pluginName}
           ORDER BY idx DESC
@@ -191,7 +191,7 @@ class SnapshotStorage {
     return result.rows[0].snapshot;
   }
   async getAllSnapshots(pluginName) {
-    const result = await this.db.execute(sql18`SELECT snapshot 
+    const result = await this.db.execute(sql19`SELECT snapshot 
           FROM migrations._snapshots 
           WHERE plugin_name = ${pluginName}
           ORDER BY idx ASC`);
@@ -201,7 +201,7 @@ class SnapshotStorage {
 var init_snapshot_storage = () => {};
 
 // src/runtime-migrator/extension-manager.ts
-import { sql as sql19 } from "drizzle-orm";
+import { sql as sql20 } from "drizzle-orm";
 import { logger } from "@elizaos/core";
 
 class ExtensionManager {
@@ -216,7 +216,7 @@ class ExtensionManager {
           logger.warn(`[RuntimeMigrator] Invalid extension name "${extension}" - contains invalid characters`);
           continue;
         }
-        await this.db.execute(sql19`CREATE EXTENSION IF NOT EXISTS ${sql19.identifier(extension)}`);
+        await this.db.execute(sql20`CREATE EXTENSION IF NOT EXISTS ${sql20.identifier(extension)}`);
         logger.debug(`[RuntimeMigrator] Extension installed: ${extension}`);
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -1858,12 +1858,12 @@ function objectToString(o) {
 function pad(n) {
   return n < 10 ? "0" + n.toString(10) : n.toString(10);
 }
-function timestamp16() {
+function timestamp17() {
   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", timestamp16(), format.apply(null, args));
+  console.log("%s - %s", timestamp17(), format.apply(null, args));
 }
 function inherits(ctor, superCtor) {
   if (superCtor)
@@ -17863,8 +17863,8 @@ function hasChanges(previousSnapshot, currentSnapshot) {
   const currHash = hashSnapshot(currentSnapshot);
   return prevHash !== currHash;
 }
-var sqlToStr = (sql20, casing) => {
-  return sql20.toQuery({
+var sqlToStr = (sql21, casing) => {
+  return sql21.toQuery({
     escapeName: () => {
       throw new Error("we don't support params for `sql` default values");
     },
@@ -18502,18 +18502,18 @@ function generateCreateTableSQL(fullTableName, table) {
   return { tableSQL, fkSQLs };
 }
 function generateColumnDefinition(name, def) {
-  let sql20 = `"${name}" ${def.type}`;
+  let sql21 = `"${name}" ${def.type}`;
   if (def.primaryKey && !def.type.includes("SERIAL")) {
-    sql20 += " PRIMARY KEY";
+    sql21 += " PRIMARY KEY";
   }
   if (def.notNull) {
-    sql20 += " NOT NULL";
+    sql21 += " NOT NULL";
   }
   if (def.default !== undefined) {
     const defaultValue = formatDefaultValue(def.default, def.type);
-    sql20 += ` DEFAULT ${defaultValue}`;
+    sql21 += ` DEFAULT ${defaultValue}`;
   }
-  return sql20;
+  return sql21;
 }
 function generateAddColumnSQL(table, column, definition) {
   const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
@@ -18669,14 +18669,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 sql20 = `ALTER TABLE "${schemaFrom}"."${tableFrom}" ADD CONSTRAINT "${fk.name}" FOREIGN KEY (${columnsFrom}) REFERENCES "${schemaTo}"."${fk.tableTo}" (${columnsTo})`;
+  let sql21 = `ALTER TABLE "${schemaFrom}"."${tableFrom}" ADD CONSTRAINT "${fk.name}" FOREIGN KEY (${columnsFrom}) REFERENCES "${schemaTo}"."${fk.tableTo}" (${columnsTo})`;
   if (fk.onDelete) {
-    sql20 += ` ON DELETE ${fk.onDelete}`;
+    sql21 += ` ON DELETE ${fk.onDelete}`;
   }
   if (fk.onUpdate) {
-    sql20 += ` ON UPDATE ${fk.onUpdate}`;
+    sql21 += ` ON UPDATE ${fk.onUpdate}`;
   }
-  return sql20 + ";";
+  return sql21 + ";";
 }
 function generateDropForeignKeySQL(fk) {
   const [schema, tableName] = fk.tableFrom ? fk.tableFrom.includes(".") ? fk.tableFrom.split(".") : ["public", fk.tableFrom] : ["public", ""];
@@ -18687,12 +18687,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 sql20 = `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${name}" UNIQUE`;
+  let sql21 = `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${name}" UNIQUE`;
   if (constraint.nullsNotDistinct) {
-    sql20 += ` NULLS NOT DISTINCT`;
+    sql21 += ` NULLS NOT DISTINCT`;
   }
-  sql20 += ` (${columns});`;
-  return sql20;
+  sql21 += ` (${columns});`;
+  return sql21;
 }
 function generateDropUniqueConstraintSQL(constraint) {
   const table = constraint.table || "";
@@ -18759,7 +18759,7 @@ function normalizeSchemaName(input) {
 var init_schema_transformer = () => {};
 
 // src/runtime-migrator/drizzle-adapters/database-introspector.ts
-import { sql as sql20 } from "drizzle-orm";
+import { sql as sql21 } from "drizzle-orm";
 import { logger as logger4 } from "@elizaos/core";
 
 class DatabaseIntrospector {
@@ -18884,7 +18884,7 @@ class DatabaseIntrospector {
     };
   }
   async getTables(schemaName) {
-    const result = await this.db.execute(sql20`SELECT 
+    const result = await this.db.execute(sql21`SELECT 
             table_schema,
             table_name
           FROM information_schema.tables
@@ -18894,7 +18894,7 @@ class DatabaseIntrospector {
     return result.rows;
   }
   async getColumns(schemaName, tableName) {
-    const result = await this.db.execute(sql20`SELECT 
+    const result = await this.db.execute(sql21`SELECT 
             a.attname AS column_name,
             CASE 
               WHEN a.attnotnull THEN 'NO'
@@ -18937,7 +18937,7 @@ class DatabaseIntrospector {
     return result.rows;
   }
   async getIndexes(schemaName, tableName) {
-    const result = await this.db.execute(sql20`SELECT 
+    const result = await this.db.execute(sql21`SELECT 
             i.relname AS name,
             idx.indisunique AS is_unique,
             idx.indisprimary AS is_primary,
@@ -18961,7 +18961,7 @@ class DatabaseIntrospector {
     return result.rows;
   }
   async getForeignKeys(schemaName, tableName) {
-    const result = await this.db.execute(sql20`SELECT
+    const result = await this.db.execute(sql21`SELECT
             con.conname AS name,
             att.attname AS column_name,
             fnsp.nspname AS foreign_table_schema,
@@ -18996,7 +18996,7 @@ class DatabaseIntrospector {
     return result.rows;
   }
   async getPrimaryKeys(schemaName, tableName) {
-    const result = await this.db.execute(sql20`SELECT 
+    const result = await this.db.execute(sql21`SELECT 
             con.conname AS name,
             ARRAY(
               SELECT a.attname
@@ -19014,7 +19014,7 @@ class DatabaseIntrospector {
     return result.rows;
   }
   async getUniqueConstraints(schemaName, tableName) {
-    const result = await this.db.execute(sql20`SELECT 
+    const result = await this.db.execute(sql21`SELECT 
             con.conname AS name,
             ARRAY(
               SELECT a.attname
@@ -19032,7 +19032,7 @@ class DatabaseIntrospector {
     return result.rows;
   }
   async getCheckConstraints(schemaName, tableName) {
-    const result = await this.db.execute(sql20`SELECT 
+    const result = await this.db.execute(sql21`SELECT 
             con.conname AS name,
             pg_get_constraintdef(con.oid) AS definition
           FROM pg_constraint con
@@ -19044,7 +19044,7 @@ class DatabaseIntrospector {
     return result.rows;
   }
   async getEnums(schemaName) {
-    const result = await this.db.execute(sql20`SELECT 
+    const result = await this.db.execute(sql21`SELECT 
             n.nspname AS schema,
             t.typname AS name,
             e.enumlabel AS value,
@@ -19076,7 +19076,7 @@ class DatabaseIntrospector {
   }
   async hasExistingTables(pluginName) {
     const schemaName = pluginName === "@elizaos/plugin-sql" ? "public" : this.deriveSchemaName(pluginName);
-    const result = await this.db.execute(sql20`SELECT COUNT(*) AS count
+    const result = await this.db.execute(sql21`SELECT COUNT(*) AS count
           FROM information_schema.tables
           WHERE table_schema = ${schemaName}
             AND table_type = 'BASE TABLE'`);
@@ -19090,7 +19090,7 @@ class DatabaseIntrospector {
 var init_database_introspector = () => {};
 
 // src/runtime-migrator/runtime-migrator.ts
-import { sql as sql21 } from "drizzle-orm";
+import { sql as sql22 } from "drizzle-orm";
 import { logger as logger5 } from "@elizaos/core";
 
 class RuntimeMigrator {
@@ -19130,7 +19130,7 @@ class RuntimeMigrator {
     }
     for (const schemaName of schemasToCreate) {
       logger5.debug(`[RuntimeMigrator] Ensuring schema '${schemaName}' exists`);
-      await this.db.execute(sql21.raw(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`));
+      await this.db.execute(sql22.raw(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`));
     }
   }
   validateSchemaUsage(pluginName, snapshot) {
@@ -19377,11 +19377,11 @@ class RuntimeMigrator {
         try {
           logger5.debug(`[RuntimeMigrator] Using PostgreSQL advisory locks for ${pluginName}`);
           const lockIdStr = lockId.toString();
-          const lockResult = await this.db.execute(sql21`SELECT pg_try_advisory_lock(CAST(${lockIdStr} AS bigint)) as acquired`);
+          const lockResult = await this.db.execute(sql22`SELECT pg_try_advisory_lock(CAST(${lockIdStr} AS bigint)) as acquired`);
           lockAcquired = lockResult.rows[0]?.acquired === true;
           if (!lockAcquired) {
             logger5.info(`[RuntimeMigrator] Migration already in progress for ${pluginName}, waiting for lock...`);
-            await this.db.execute(sql21`SELECT pg_advisory_lock(CAST(${lockIdStr} AS bigint))`);
+            await this.db.execute(sql22`SELECT pg_advisory_lock(CAST(${lockIdStr} AS bigint))`);
             lockAcquired = true;
             logger5.info(`[RuntimeMigrator] Lock acquired for ${pluginName}`);
           } else {
@@ -19499,7 +19499,7 @@ class RuntimeMigrator {
       if (lockAcquired && isRealPostgres) {
         try {
           const lockIdStr = lockId.toString();
-          await this.db.execute(sql21`SELECT pg_advisory_unlock(CAST(${lockIdStr} AS bigint))`);
+          await this.db.execute(sql22`SELECT pg_advisory_unlock(CAST(${lockIdStr} AS bigint))`);
           logger5.debug(`[RuntimeMigrator] Advisory lock released for ${pluginName}`);
         } catch (unlockError) {
           logger5.warn(`[RuntimeMigrator] Failed to release advisory lock for ${pluginName}:`, JSON.stringify(unlockError));
@@ -19510,23 +19510,23 @@ class RuntimeMigrator {
   async executeMigration(pluginName, snapshot, hash, sqlStatements) {
     let transactionStarted = false;
     try {
-      await this.db.execute(sql21`BEGIN`);
+      await this.db.execute(sql22`BEGIN`);
       transactionStarted = true;
       for (const stmt of sqlStatements) {
         logger5.debug(`[RuntimeMigrator] Executing: ${stmt}`);
-        await this.db.execute(sql21.raw(stmt));
+        await this.db.execute(sql22.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(sql21`COMMIT`);
+      await this.db.execute(sql22`COMMIT`);
       logger5.info(`[RuntimeMigrator] Recorded migration ${tag} for ${pluginName}`);
     } catch (error) {
       if (transactionStarted) {
         try {
-          await this.db.execute(sql21`ROLLBACK`);
+          await this.db.execute(sql22`ROLLBACK`);
           logger5.error("[RuntimeMigrator] Migration failed, rolled back:", JSON.stringify(error));
         } catch (rollbackError) {
           logger5.error("[RuntimeMigrator] Failed to rollback transaction:", JSON.stringify(rollbackError));
@@ -19537,8 +19537,8 @@ class RuntimeMigrator {
   }
   generateMigrationTag(idx, pluginName) {
     const prefix = idx.toString().padStart(4, "0");
-    const timestamp17 = Date.now().toString(36);
-    return `${prefix}_${pluginName}_${timestamp17}`;
+    const timestamp18 = Date.now().toString(36);
+    return `${prefix}_${pluginName}_${timestamp18}`;
   }
   async getStatus(pluginName) {
     const lastMigration = await this.migrationTracker.getLastMigration(pluginName);
@@ -19553,9 +19553,9 @@ class RuntimeMigrator {
   }
   async reset(pluginName) {
     logger5.warn(`[RuntimeMigrator] Resetting migrations for ${pluginName}`);
-    await this.db.execute(sql21`DELETE FROM migrations._migrations WHERE plugin_name = ${pluginName}`);
-    await this.db.execute(sql21`DELETE FROM migrations._journal WHERE plugin_name = ${pluginName}`);
-    await this.db.execute(sql21`DELETE FROM migrations._snapshots WHERE plugin_name = ${pluginName}`);
+    await this.db.execute(sql22`DELETE FROM migrations._migrations WHERE plugin_name = ${pluginName}`);
+    await this.db.execute(sql22`DELETE FROM migrations._journal WHERE plugin_name = ${pluginName}`);
+    await this.db.execute(sql22`DELETE FROM migrations._snapshots WHERE plugin_name = ${pluginName}`);
     logger5.warn(`[RuntimeMigrator] Reset complete for ${pluginName}`);
   }
   async checkMigration(pluginName, schema) {
@@ -19713,7 +19713,7 @@ import {
   lt,
   lte,
   or,
-  sql as sql22
+  sql as sql23
 } from "drizzle-orm";
 
 // node_modules/uuid/dist/esm-browser/stringify.js
@@ -19792,6 +19792,7 @@ import { boolean, jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-c
 var agentTable = pgTable("agents", {
   id: uuid("id").primaryKey().defaultRandom(),
   enabled: boolean("enabled").default(true).notNull(),
+  owner_id: uuid("owner_id"),
   createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
   updatedAt: timestamp("updated_at", { withTimezone: true }).default(sql`now()`).notNull(),
   name: text("name").notNull(),
@@ -19940,6 +19941,7 @@ __export(exports_schema, {
   roomTable: () => roomTable,
   relationshipTable: () => relationshipTable,
   participantTable: () => participantTable,
+  ownersTable: () => ownersTable,
   messageTable: () => messageTable,
   messageServerTable: () => messageServerTable,
   memoryTable: () => memoryTable,
@@ -20015,19 +20017,27 @@ var logTable = pgTable9("logs", {
     foreignColumns: [entityTable.id]
   }).onDelete("cascade")
 ]);
-// src/schema/participant.ts
+// src/schema/owners.ts
 import { sql as sql10 } from "drizzle-orm";
-import { foreignKey as foreignKey4, index as index3, pgTable as pgTable10, text as text9, timestamp as timestamp10, uuid as uuid10 } from "drizzle-orm/pg-core";
-var participantTable = pgTable10("participants", {
-  id: uuid10("id").notNull().primaryKey().default(sql10`gen_random_uuid()`),
+import { pgTable as pgTable10, timestamp as timestamp10, uuid as uuid10 } from "drizzle-orm/pg-core";
+var ownersTable = pgTable10("owners", {
+  id: uuid10("id").primaryKey(),
   createdAt: timestamp10("created_at", { withTimezone: true }).default(sql10`now()`).notNull(),
-  entityId: uuid10("entityId").references(() => entityTable.id, {
+  updatedAt: timestamp10("updated_at", { withTimezone: true }).default(sql10`now()`).notNull()
+});
+// 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 = pgTable11("participants", {
+  id: uuid11("id").notNull().primaryKey().default(sql11`gen_random_uuid()`),
+  createdAt: timestamp11("created_at", { withTimezone: true }).default(sql11`now()`).notNull(),
+  entityId: uuid11("entityId").references(() => entityTable.id, {
     onDelete: "cascade"
   }),
-  roomId: uuid10("roomId").references(() => roomTable.id, {
+  roomId: uuid11("roomId").references(() => roomTable.id, {
     onDelete: "cascade"
   }),
-  agentId: uuid10("agentId").references(() => agentTable.id, {
+  agentId: uuid11("agentId").references(() => agentTable.id, {
     onDelete: "cascade"
   }),
   roomState: text9("roomState")
@@ -20046,23 +20056,23 @@ var participantTable = pgTable10("participants", {
   }).onDelete("cascade")
 ]);
 // src/schema/relationship.ts
-import { sql as sql11 } from "drizzle-orm";
+import { sql as sql12 } from "drizzle-orm";
 import {
   foreignKey as foreignKey5,
   index as index4,
   jsonb as jsonb9,
-  pgTable as pgTable11,
+  pgTable as pgTable12,
   text as text10,
-  timestamp as timestamp11,
+  timestamp as timestamp12,
   unique as unique2,
-  uuid as uuid11
+  uuid as uuid12
 } from "drizzle-orm/pg-core";
-var relationshipTable = pgTable11("relationships", {
-  id: uuid11("id").notNull().primaryKey().default(sql11`gen_random_uuid()`),
-  createdAt: timestamp11("created_at", { withTimezone: true }).default(sql11`now()`).notNull(),
-  sourceEntityId: uuid11("sourceEntityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
-  targetEntityId: uuid11("targetEntityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
-  agentId: uuid11("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+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("sourceEntityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  targetEntityId: uuid12("targetEntityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  agentId: uuid12("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
   tags: text10("tags").array(),
   metadata: jsonb9("metadata")
 }, (table) => [
@@ -20080,52 +20090,52 @@ var relationshipTable = pgTable11("relationships", {
   }).onDelete("cascade")
 ]);
 // src/schema/tasks.ts
-import { jsonb as jsonb10, pgTable as pgTable12, text as text11, timestamp as timestamp12, uuid as uuid12 } from "drizzle-orm/pg-core";
-import { sql as sql12 } from "drizzle-orm";
-var taskTable = pgTable12("tasks", {
-  id: uuid12("id").primaryKey().defaultRandom(),
+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: uuid12("roomId"),
-  worldId: uuid12("worldId"),
-  entityId: uuid12("entityId"),
-  agentId: uuid12("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
-  tags: text11("tags").array().default(sql12`'{}'::text[]`),
-  metadata: jsonb10("metadata").default(sql12`'{}'::jsonb`),
-  createdAt: timestamp12("created_at", { withTimezone: true }).defaultNow(),
-  updatedAt: timestamp12("updated_at", { withTimezone: true }).defaultNow()
+  roomId: uuid13("roomId"),
+  worldId: uuid13("worldId"),
+  entityId: uuid13("entityId"),
+  agentId: uuid13("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  tags: text11("tags").array().default(sql13`'{}'::text[]`),
+  metadata: jsonb10("metadata").default(sql13`'{}'::jsonb`),
+  createdAt: timestamp13("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp13("updated_at", { withTimezone: true }).defaultNow()
 });
 // src/schema/messageServer.ts
-import { pgTable as pgTable13, text as text12, jsonb as jsonb11, timestamp as timestamp13, uuid as uuid13 } from "drizzle-orm/pg-core";
-import { sql as sql13 } from "drizzle-orm";
-var messageServerTable = pgTable13("message_servers", {
-  id: uuid13("id").primaryKey(),
+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"),
-  createdAt: timestamp13("created_at", { mode: "date" }).default(sql13`CURRENT_TIMESTAMP`).notNull(),
-  updatedAt: timestamp13("updated_at", { mode: "date" }).default(sql13`CURRENT_TIMESTAMP`).notNull()
+  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 pgTable14, text as text13, jsonb as jsonb12, timestamp as timestamp14, uuid as uuid14 } from "drizzle-orm/pg-core";
-import { sql as sql14 } from "drizzle-orm";
-var channelTable = pgTable14("channels", {
+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: uuid14("server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
+  messageServerId: uuid15("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"),
-  createdAt: timestamp14("created_at", { mode: "date" }).default(sql14`CURRENT_TIMESTAMP`).notNull(),
-  updatedAt: timestamp14("updated_at", { mode: "date" }).default(sql14`CURRENT_TIMESTAMP`).notNull()
+  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 pgTable15, text as text14, jsonb as jsonb13, timestamp as timestamp15 } from "drizzle-orm/pg-core";
-import { sql as sql15 } from "drizzle-orm";
-var messageTable = pgTable15("central_messages", {
+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(),
@@ -20137,22 +20147,22 @@ var messageTable = pgTable15("central_messages", {
   sourceType: text14("source_type"),
   sourceId: text14("source_id"),
   metadata: jsonb13("metadata"),
-  createdAt: timestamp15("created_at", { mode: "date" }).default(sql15`CURRENT_TIMESTAMP`).notNull(),
-  updatedAt: timestamp15("updated_at", { mode: "date" }).default(sql15`CURRENT_TIMESTAMP`).notNull()
+  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 pgTable16, text as text15, primaryKey as primaryKey2 } from "drizzle-orm/pg-core";
-var channelParticipantsTable = pgTable16("channel_participants", {
+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" }),
   userId: text15("user_id").notNull()
 }, (table) => ({
   pk: primaryKey2({ columns: [table.channelId, table.userId] })
 }));
 // src/schema/serverAgent.ts
-import { pgTable as pgTable17, uuid as uuid15, primaryKey as primaryKey3 } from "drizzle-orm/pg-core";
-var serverAgentsTable = pgTable17("server_agents", {
-  serverId: uuid15("server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
-  agentId: uuid15("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" })
+import { pgTable as pgTable18, uuid as uuid16, primaryKey as primaryKey3 } from "drizzle-orm/pg-core";
+var serverAgentsTable = pgTable18("server_agents", {
+  serverId: uuid16("server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
+  agentId: uuid16("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" })
 }, (table) => ({
   pk: primaryKey3({ columns: [table.serverId, table.agentId] })
 }));
@@ -20188,6 +20198,24 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     super();
     this.agentId = agentId;
   }
+  normalizeEntityNames(names) {
+    if (names == null) {
+      return [];
+    }
+    if (typeof names === "string") {
+      return [names];
+    }
+    if (Array.isArray(names)) {
+      return names.map(String);
+    }
+    if (names instanceof Set) {
+      return Array.from(names).map(String);
+    }
+    if (typeof names === "object" && typeof names[Symbol.iterator] === "function") {
+      return Array.from(names).map(String);
+    }
+    return [String(names)];
+  }
   async withRetry(operation) {
     let lastError = new Error("Unknown error");
     for (let attempt = 1;attempt <= this.maxRetries; attempt++) {
@@ -20459,7 +20487,12 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withDatabase(async () => {
       try {
         return await this.db.transaction(async (tx) => {
-          await tx.insert(entityTable).values(entities);
+          const normalizedEntities = entities.map((entity) => ({
+            ...entity,
+            names: this.normalizeEntityNames(entity.names),
+            metadata: entity.metadata || {}
+          }));
+          await tx.insert(entityTable).values(normalizedEntities);
           logger7.debug(`${entities.length} Entities created successfully`);
           return true;
         });
@@ -20493,7 +20526,12 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       throw new Error("Entity ID is required for update");
     }
     return this.withDatabase(async () => {
-      await this.db.update(entityTable).set(entity).where(eq(entityTable.id, entity.id));
+      const normalizedEntity = {
+        ...entity,
+        names: this.normalizeEntityNames(entity.names),
+        metadata: entity.metadata || {}
+      };
+      await this.db.update(entityTable).set(normalizedEntity).where(eq(entityTable.id, entity.id));
     });
   }
   async deleteEntity(entityId) {
@@ -20507,11 +20545,11 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async getEntitiesByNames(params) {
     return this.withDatabase(async () => {
       const { names, agentId } = params;
-      const nameConditions = names.map((name) => sql22`${name} = ANY(${entityTable.names})`);
-      const query = sql22`
+      const nameConditions = names.map((name) => sql23`${name} = ANY(${entityTable.names})`);
+      const query = sql23`
         SELECT * FROM ${entityTable}
         WHERE ${entityTable.agentId} = ${agentId}
-        AND (${sql22.join(nameConditions, sql22` OR `)})
+        AND (${sql23.join(nameConditions, sql23` OR `)})
       `;
       const result = await this.db.execute(query);
       return result.rows.map((row) => ({
@@ -20534,7 +20572,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           metadata: row.metadata || {}
         }));
       }
-      const searchQuery = sql22`
+      const searchQuery = sql23`
         SELECT * FROM ${entityTable}
         WHERE ${entityTable.agentId} = ${agentId}
         AND EXISTS (
@@ -20792,7 +20830,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async getCachedEmbeddings(opts) {
     return this.withDatabase(async () => {
       try {
-        const results = await this.db.execute(sql22`
+        const results = await this.db.execute(sql23`
                     WITH content_text AS (
                         SELECT
                             m.id,
@@ -20847,7 +20885,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         const jsonString = JSON.stringify(sanitizedBody);
         await this.db.transaction(async (tx) => {
           await tx.insert(logTable).values({
-            body: sql22`${jsonString}::jsonb`,
+            body: sql23`${jsonString}::jsonb`,
             entityId: params.entityId,
             roomId: params.roomId,
             type: params.type
@@ -20910,7 +20948,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       const runMap = new Map;
       const conditions = [
         eq(logTable.type, "run_event"),
-        sql22`${logTable.body} ? 'runId'`,
+        sql23`${logTable.body} ? 'runId'`,
         eq(roomTable.agentId, this.agentId)
       ];
       if (params.roomId) {
@@ -20925,9 +20963,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       const whereClause = and(...conditions);
       const eventLimit = Math.max(limit * 20, 200);
       const runEventRows = await this.db.select({
-        runId: sql22`(${logTable.body} ->> 'runId')`,
-        status: sql22`(${logTable.body} ->> 'status')`,
-        messageId: sql22`(${logTable.body} ->> 'messageId')`,
+        runId: sql23`(${logTable.body} ->> 'runId')`,
+        status: sql23`(${logTable.body} ->> 'status')`,
+        messageId: sql23`(${logTable.body} ->> 'messageId')`,
         rawBody: logTable.body,
         createdAt: logTable.createdAt,
         roomId: logTable.roomId,
@@ -20974,15 +21012,15 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           }
         }
         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);
@@ -21001,8 +21039,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       }
       const runIds = limitedRuns.map((run) => run.runId).filter(Boolean);
       if (runIds.length > 0) {
-        const runIdArray = sql22`array[${sql22.join(runIds.map((id) => sql22`${id}`), sql22`, `)}]::text[]`;
-        const actionSummary = await this.db.execute(sql22`
+        const runIdArray = sql23`array[${sql23.join(runIds.map((id) => sql23`${id}`), sql23`, `)}]::text[]`;
+        const actionSummary = await this.db.execute(sql23`
           SELECT
             body->>'runId' as "runId",
             COUNT(*)::int as "actions",
@@ -21022,7 +21060,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           counts.errors += Number(row.errors ?? 0);
           counts.modelCalls += Number(row.modelCalls ?? 0);
         }
-        const evaluatorSummary = await this.db.execute(sql22`
+        const evaluatorSummary = await this.db.execute(sql23`
           SELECT
             body->>'runId' as "runId",
             COUNT(*)::int as "evaluators"
@@ -21038,7 +21076,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
             continue;
           counts.evaluators += Number(row.evaluators ?? 0);
         }
-        const genericSummary = await this.db.execute(sql22`
+        const genericSummary = await this.db.execute(sql23`
           SELECT
             body->>'runId' as "runId",
             COUNT(*) FILTER (WHERE type LIKE 'useModel:%')::int as "modelLogs",
@@ -21091,7 +21129,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async searchMemoriesByEmbedding(embedding, params) {
     return this.withDatabase(async () => {
       const cleanVector = embedding.map((n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0);
-      const similarity = sql22`1 - (${cosineDistance(embeddingTable[this.embeddingDimension], cleanVector)})`;
+      const similarity = sql23`1 - (${cosineDistance(embeddingTable[this.embeddingDimension], cleanVector)})`;
       const conditions = [eq(memoryTable.type, params.tableName)];
       if (params.unique) {
         conditions.push(eq(memoryTable.unique, true));
@@ -21159,8 +21197,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         {
           id: memoryId,
           type: tableName,
-          content: sql22`${contentToInsert}::jsonb`,
-          metadata: sql22`${metadataToInsert}::jsonb`,
+          content: sql23`${contentToInsert}::jsonb`,
+          metadata: sql23`${metadataToInsert}::jsonb`,
           entityId: memory.entityId,
           roomId: memory.roomId,
           worldId: memory.worldId,
@@ -21191,13 +21229,13 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
             const contentToUpdate = typeof memory.content === "string" ? memory.content : JSON.stringify(memory.content ?? {});
             const metadataToUpdate = typeof memory.metadata === "string" ? memory.metadata : JSON.stringify(memory.metadata ?? {});
             await tx.update(memoryTable).set({
-              content: sql22`${contentToUpdate}::jsonb`,
-              ...memory.metadata && { metadata: sql22`${metadataToUpdate}::jsonb` }
+              content: sql23`${contentToUpdate}::jsonb`,
+              ...memory.metadata && { metadata: sql23`${metadataToUpdate}::jsonb` }
             }).where(eq(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: sql22`${metadataToUpdate}::jsonb`
+              metadata: sql23`${metadataToUpdate}::jsonb`
             }).where(eq(memoryTable.id, memory.id));
           }
           if (memory.embedding && Array.isArray(memory.embedding)) {
@@ -21264,7 +21302,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     }
   }
   async getMemoryFragments(tx, documentId) {
-    const fragments = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq(memoryTable.agentId, this.agentId), sql22`${memoryTable.metadata}->>'documentId' = ${documentId}`));
+    const fragments = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq(memoryTable.agentId, this.agentId), sql23`${memoryTable.metadata}->>'documentId' = ${documentId}`));
     return fragments.map((f) => ({ id: f.id }));
   }
   async deleteAllMemories(roomId, tableName) {
@@ -21293,7 +21331,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       if (unique3) {
         conditions.push(eq(memoryTable.unique, true));
       }
-      const result = await this.db.select({ count: sql22`count(*)` }).from(memoryTable).where(and(...conditions));
+      const result = await this.db.select({ count: sql23`count(*)` }).from(memoryTable).where(and(...conditions));
       return Number(result[0]?.count ?? 0);
     });
   }
@@ -21524,13 +21562,13 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       const { entityId, tags } = params;
       let query;
       if (tags && tags.length > 0) {
-        query = sql22`
+        query = sql23`
           SELECT * FROM ${relationshipTable}
           WHERE (${relationshipTable.sourceEntityId} = ${entityId} OR ${relationshipTable.targetEntityId} = ${entityId})
-          AND ${relationshipTable.tags} && CAST(ARRAY[${sql22.join(tags, sql22`, `)}] AS text[])
+          AND ${relationshipTable.tags} && CAST(ARRAY[${sql23.join(tags, sql23`, `)}] AS text[])
         `;
       } else {
-        query = sql22`
+        query = sql23`
           SELECT * FROM ${relationshipTable}
           WHERE ${relationshipTable.sourceEntityId} = ${entityId} OR ${relationshipTable.targetEntityId} = ${entityId}
         `;
@@ -21657,7 +21695,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withRetry(async () => {
       return this.withDatabase(async () => {
         const result = await this.db.select().from(taskTable).where(and(eq(taskTable.agentId, this.agentId), ...params.roomId ? [eq(taskTable.roomId, params.roomId)] : [], ...params.tags && params.tags.length > 0 ? [
-          sql22`${taskTable.tags} @> ARRAY[${sql22.raw(params.tags.map((t) => `'${t.replace(/'/g, "''")}'`).join(", "))}]::text[]`
+          sql23`${taskTable.tags} @> ARRAY[${sql23.raw(params.tags.map((t) => `'${t.replace(/'/g, "''")}'`).join(", "))}]::text[]`
         ] : []));
         return result.map((row) => ({
           id: row.id,
@@ -22206,5 +22244,5 @@ export {
   DatabaseMigrationService
 };
 
-//# debugId=2E7587FF28B8361264756E2164756E21
+//# debugId=1883B6786029AB3864756E2164756E21
 //# sourceMappingURL=index.browser.js.map