@elizaos/plugin-sql 1.6.5-alpha.15 → 1.6.5-alpha.16

package/dist/node/index.node.js

@@ -5909,14 +5909,14 @@ class ExtensionManager {
     for (const extension of extensions) {
       try {
         if (!/^[a-zA-Z0-9_-]+$/.test(extension)) {
-          logger2.warn(`[RuntimeMigrator] Invalid extension name "${extension}" - contains invalid characters`);
+          logger2.warn({ src: "plugin:sql", extension }, "Invalid extension name - contains invalid characters");
           continue;
         }
         await this.db.execute(sql`CREATE EXTENSION IF NOT EXISTS ${sql.identifier(extension)}`);
-        logger2.debug(`[RuntimeMigrator] Extension installed: ${extension}`);
+        logger2.debug({ src: "plugin:sql", extension }, "Extension installed");
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        logger2.warn(`[RuntimeMigrator] Could not install extension ${extension}: ${errorMessage}`);
+        logger2.warn({ src: "plugin:sql", extension, error: errorMessage }, "Could not install extension");
       }
     }
   }
@@ -6628,10 +6628,7 @@ async function generateMigrationSQL(previousSnapshot, currentSnapshot, diff) {
   }
   const dataLossCheck = checkForDataLoss(diff);
   if (dataLossCheck.warnings.length > 0) {
-    logger3.warn("[RuntimeMigrator] Schema changes may cause data loss:");
-    for (const warning of dataLossCheck.warnings) {
-      logger3.warn(`  - ${warning}`);
-    }
+    logger3.warn({ src: "plugin:sql", warnings: dataLossCheck.warnings }, "Schema changes may cause data loss");
   }
   const schemasToCreate = new Set;
   for (const tableName of diff.tables.created) {
@@ -7053,7 +7050,7 @@ class DatabaseIntrospector {
     this.db = db2;
   }
   async introspectSchema(schemaName = "public") {
-    logger5.info(`[DatabaseIntrospector] Starting introspection for schema: ${schemaName}`);
+    logger5.info({ src: "plugin:sql", schemaName }, "Starting database introspection");
     const tables = {};
     const schemas = {};
     const enums = {};
@@ -7061,7 +7058,7 @@ class DatabaseIntrospector {
     for (const tableInfo of allTables) {
       const tableName = tableInfo.table_name;
       const tableSchema = tableInfo.table_schema || "public";
-      logger5.debug(`[DatabaseIntrospector] Introspecting table: ${tableSchema}.${tableName}`);
+      logger5.debug({ src: "plugin:sql", tableSchema, tableName }, "Introspecting table");
       const columns2 = await this.getColumns(tableSchema, tableName);
       const columnsObject = {};
       const uniqueConstraintObject = {};
@@ -7156,7 +7153,7 @@ class DatabaseIntrospector {
       }
       enums[key].values.push(enumInfo.value);
     }
-    logger5.info(`[DatabaseIntrospector] Introspection complete. Found ${Object.keys(tables).length} tables`);
+    logger5.info({ src: "plugin:sql", tableCount: Object.keys(tables).length }, "Database introspection complete");
     return {
       version: "7",
       dialect: "postgresql",
@@ -7418,7 +7415,7 @@ class RuntimeMigrator {
       }
     }
     for (const schemaName of schemasToCreate) {
-      logger6.debug(`[RuntimeMigrator] Ensuring schema '${schemaName}' exists`);
+      logger6.debug({ src: "plugin:sql", schemaName }, "Ensuring schema exists");
       await this.db.execute(sql.raw(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`));
     }
   }
@@ -7429,10 +7426,10 @@ class RuntimeMigrator {
       const tableData = table3;
       const actualSchema = tableData.schema || "public";
       if (!isCorePLugin && actualSchema === "public") {
-        logger6.warn(`[RuntimeMigrator] WARNING: Plugin '${pluginName}' table '${tableData.name}' is using public schema. ` + `Consider using pgSchema('${expectedSchema}').table(...) for better isolation.`);
+        logger6.warn({ src: "plugin:sql", pluginName, tableName: tableData.name, expectedSchema }, "Plugin table is using public schema - consider using pgSchema for better isolation");
       }
       if (isCorePLugin && actualSchema !== "public") {
-        logger6.warn(`[RuntimeMigrator] WARNING: Core plugin '@elizaos/plugin-sql' table '${tableData.name}' is using schema '${actualSchema}'. ` + `Core tables should use public schema.`);
+        logger6.warn({ src: "plugin:sql", pluginName: "@elizaos/plugin-sql", tableName: tableData.name, actualSchema }, "Core plugin table should use public schema");
       }
     }
   }
@@ -7643,13 +7640,13 @@ class RuntimeMigrator {
         }
       }
     }
-    logger6.debug(`[RuntimeMigrator] Connection string did not match any PostgreSQL patterns: ${url.substring(0, 50)}...`);
+    logger6.debug({ src: "plugin:sql", urlPreview: url.substring(0, 50) }, "Connection string did not match any PostgreSQL patterns");
     return false;
   }
   async initialize() {
-    logger6.info("[RuntimeMigrator] Initializing migration system...");
+    logger6.info({ src: "plugin:sql" }, "Initializing migration system");
     await this.migrationTracker.ensureTables();
-    logger6.info("[RuntimeMigrator] Migration system initialized");
+    logger6.info({ src: "plugin:sql" }, "Migration system initialized");
   }
   async migrate(pluginName, schema2, options = {}) {
     const lockId = this.getAdvisoryLockId(pluginName);
@@ -7658,30 +7655,30 @@ class RuntimeMigrator {
     }
     let lockAcquired = false;
     try {
-      logger6.info(`[RuntimeMigrator] Starting migration for plugin: ${pluginName}`);
+      logger6.info({ src: "plugin:sql", pluginName }, "Starting migration for plugin");
       await this.initialize();
       const postgresUrl = process.env.POSTGRES_URL || process.env.DATABASE_URL || "";
       const isRealPostgres = this.isRealPostgresDatabase(postgresUrl);
       if (isRealPostgres) {
         try {
-          logger6.debug(`[RuntimeMigrator] Using PostgreSQL advisory locks for ${pluginName}`);
+          logger6.debug({ src: "plugin:sql", pluginName }, "Using PostgreSQL advisory locks");
           const lockIdStr = lockId.toString();
           const lockResult = await this.db.execute(sql`SELECT pg_try_advisory_lock(CAST(${lockIdStr} AS bigint)) as acquired`);
           lockAcquired = lockResult.rows[0]?.acquired === true;
           if (!lockAcquired) {
-            logger6.info(`[RuntimeMigrator] Migration already in progress for ${pluginName}, waiting for lock...`);
+            logger6.info({ src: "plugin:sql", pluginName }, "Migration already in progress, waiting for lock");
             await this.db.execute(sql`SELECT pg_advisory_lock(CAST(${lockIdStr} AS bigint))`);
             lockAcquired = true;
-            logger6.info(`[RuntimeMigrator] Lock acquired for ${pluginName}`);
+            logger6.info({ src: "plugin:sql", pluginName }, "Lock acquired");
           } else {
-            logger6.debug(`[RuntimeMigrator] Advisory lock acquired for ${pluginName} (lock ID: ${lockIdStr})`);
+            logger6.debug({ src: "plugin:sql", pluginName, lockId: lockIdStr }, "Advisory lock acquired");
           }
         } catch (lockError) {
-          logger6.warn(`[RuntimeMigrator] Failed to acquire advisory lock, continuing without lock: ${lockError}`);
+          logger6.warn({ src: "plugin:sql", pluginName, error: lockError instanceof Error ? lockError.message : String(lockError) }, "Failed to acquire advisory lock, continuing without lock");
           lockAcquired = false;
         }
       } else {
-        logger6.debug(`[RuntimeMigrator] Development database detected (PGLite or non-PostgreSQL), skipping advisory locks`);
+        logger6.debug({ src: "plugin:sql" }, "Development database detected, skipping advisory locks");
       }
       await this.extensionManager.installRequiredExtensions(["vector", "fuzzystrmatch", "pgcrypto"]);
       const currentSnapshot = await generateSnapshot(schema2);
@@ -7690,14 +7687,14 @@ class RuntimeMigrator {
       const currentHash = hashSnapshot(currentSnapshot);
       const lastMigration = await this.migrationTracker.getLastMigration(pluginName);
       if (lastMigration && lastMigration.hash === currentHash) {
-        logger6.info(`[RuntimeMigrator] No changes detected for ${pluginName}, skipping migration (hash: ${currentHash})`);
+        logger6.info({ src: "plugin:sql", pluginName, hash: currentHash }, "No changes detected, skipping migration");
         return;
       }
       let previousSnapshot = await this.snapshotStorage.getLatestSnapshot(pluginName);
       if (!previousSnapshot && Object.keys(currentSnapshot.tables).length > 0) {
         const hasExistingTables = await this.introspector.hasExistingTables(pluginName);
         if (hasExistingTables) {
-          logger6.info(`[RuntimeMigrator] No snapshot found for ${pluginName} but tables exist in database. Introspecting...`);
+          logger6.info({ src: "plugin:sql", pluginName }, "No snapshot found but tables exist in database, introspecting");
           const schemaName = this.getExpectedSchemaName(pluginName);
           const introspectedSnapshot = await this.introspector.introspectSchema(schemaName);
           if (Object.keys(introspectedSnapshot.tables).length > 0) {
@@ -7705,15 +7702,15 @@ class RuntimeMigrator {
             await this.journalStorage.updateJournal(pluginName, 0, `introspected_${Date.now()}`, true);
             const introspectedHash = hashSnapshot(introspectedSnapshot);
             await this.migrationTracker.recordMigration(pluginName, introspectedHash, Date.now());
-            logger6.info(`[RuntimeMigrator] Created initial snapshot from existing database for ${pluginName}`);
+            logger6.info({ src: "plugin:sql", pluginName }, "Created initial snapshot from existing database");
             previousSnapshot = introspectedSnapshot;
           }
         }
       }
       if (!hasChanges(previousSnapshot, currentSnapshot)) {
-        logger6.info(`[RuntimeMigrator] No schema changes for ${pluginName}`);
+        logger6.info({ src: "plugin:sql", pluginName }, "No schema changes");
         if (!previousSnapshot && Object.keys(currentSnapshot.tables).length === 0) {
-          logger6.info(`[RuntimeMigrator] Recording empty schema for ${pluginName}`);
+          logger6.info({ src: "plugin:sql", pluginName }, "Recording empty schema");
           await this.migrationTracker.recordMigration(pluginName, currentHash, Date.now());
           const idx = await this.journalStorage.getNextIdx(pluginName);
           const tag = this.generateMigrationTag(idx, pluginName);
@@ -7724,7 +7721,7 @@ class RuntimeMigrator {
       }
       const diff = await calculateDiff(previousSnapshot, currentSnapshot);
       if (!hasDiffChanges(diff)) {
-        logger6.info(`[RuntimeMigrator] No actionable changes for ${pluginName}`);
+        logger6.info({ src: "plugin:sql", pluginName }, "No actionable changes");
         return;
       }
       const dataLossCheck = checkForDataLoss(diff);
@@ -7732,55 +7729,34 @@ class RuntimeMigrator {
         const isProduction = false;
         const allowDestructive = options.force || options.allowDataLoss || process.env.ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS === "true";
         if (!allowDestructive) {
-          logger6.error("[RuntimeMigrator] Destructive migration blocked");
-          logger6.error(`[RuntimeMigrator] Plugin: ${pluginName}`);
-          logger6.error(`[RuntimeMigrator] Environment: ${isProduction ? "PRODUCTION" : "DEVELOPMENT"}`);
-          logger6.error("[RuntimeMigrator] Destructive operations detected:");
-          for (const warning of dataLossCheck.warnings) {
-            logger6.error(`[RuntimeMigrator]   - ${warning}`);
-          }
-          logger6.error("[RuntimeMigrator] To proceed with destructive migrations:");
-          logger6.error("[RuntimeMigrator]   1. Set environment variable: export ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true");
-          logger6.error("[RuntimeMigrator]   2. Or use option: migrate(plugin, schema, { force: true })");
-          if (isProduction) {
-            logger6.error("[RuntimeMigrator]   3. For production, consider using drizzle-kit for manual migration");
-          }
+          logger6.error({ src: "plugin:sql", pluginName, environment: isProduction ? "PRODUCTION" : "DEVELOPMENT", warnings: dataLossCheck.warnings }, "Destructive migration blocked - set ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true or use force option");
           const errorMessage = isProduction ? `Destructive migration blocked in production for ${pluginName}. Set ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true or use drizzle-kit.` : `Destructive migration blocked for ${pluginName}. Set ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true to proceed.`;
           throw new Error(errorMessage);
         }
         if (dataLossCheck.requiresConfirmation) {
-          logger6.warn("[RuntimeMigrator] Proceeding with destructive migration");
-          logger6.warn(`[RuntimeMigrator] Plugin: ${pluginName}`);
-          logger6.warn("[RuntimeMigrator] The following operations will be performed:");
-          for (const warning of dataLossCheck.warnings) {
-            logger6.warn(`[RuntimeMigrator]   ⚠️ ${warning}`);
-          }
+          logger6.warn({ src: "plugin:sql", pluginName, warnings: dataLossCheck.warnings }, "Proceeding with destructive migration");
         }
       }
       const sqlStatements = await generateMigrationSQL(previousSnapshot, currentSnapshot, diff);
       if (sqlStatements.length === 0) {
-        logger6.info(`[RuntimeMigrator] No SQL statements to execute for ${pluginName}`);
+        logger6.info({ src: "plugin:sql", pluginName }, "No SQL statements to execute");
         return;
       }
-      logger6.info(`[RuntimeMigrator] Executing ${sqlStatements.length} SQL statements for ${pluginName}`);
+      logger6.info({ src: "plugin:sql", pluginName, statementCount: sqlStatements.length }, "Executing SQL statements");
       if (options.verbose) {
         sqlStatements.forEach((stmt, i) => {
-          logger6.debug(`[RuntimeMigrator] Statement ${i + 1}: ${stmt}`);
+          logger6.debug({ src: "plugin:sql", statementIndex: i + 1, statement: stmt }, "SQL statement");
         });
       }
       if (options.dryRun) {
-        logger6.info("[RuntimeMigrator] DRY RUN mode - not executing statements");
-        logger6.info("[RuntimeMigrator] Would execute:");
-        sqlStatements.forEach((stmt, i) => {
-          logger6.info(`  ${i + 1}. ${stmt}`);
-        });
+        logger6.info({ src: "plugin:sql", pluginName, statements: sqlStatements }, "DRY RUN mode - not executing statements");
         return;
       }
       await this.executeMigration(pluginName, currentSnapshot, currentHash, sqlStatements);
-      logger6.info(`[RuntimeMigrator] Migration completed successfully for ${pluginName}`);
+      logger6.info({ src: "plugin:sql", pluginName }, "Migration completed successfully");
       return;
     } catch (error) {
-      logger6.error(`[RuntimeMigrator] Migration failed for ${pluginName}:`, JSON.stringify(error));
+      logger6.error({ src: "plugin:sql", pluginName, error: error instanceof Error ? error.message : String(error) }, "Migration failed");
       throw error;
     } finally {
       const postgresUrl = process.env.POSTGRES_URL || process.env.DATABASE_URL || "";
@@ -7789,9 +7765,9 @@ class RuntimeMigrator {
         try {
           const lockIdStr = lockId.toString();
           await this.db.execute(sql`SELECT pg_advisory_unlock(CAST(${lockIdStr} AS bigint))`);
-          logger6.debug(`[RuntimeMigrator] Advisory lock released for ${pluginName}`);
+          logger6.debug({ src: "plugin:sql", pluginName }, "Advisory lock released");
         } catch (unlockError) {
-          logger6.warn(`[RuntimeMigrator] Failed to release advisory lock for ${pluginName}:`, JSON.stringify(unlockError));
+          logger6.warn({ src: "plugin:sql", pluginName, error: unlockError instanceof Error ? unlockError.message : String(unlockError) }, "Failed to release advisory lock");
         }
       }
     }
@@ -7802,7 +7778,7 @@ class RuntimeMigrator {
       await this.db.execute(sql`BEGIN`);
       transactionStarted = true;
       for (const stmt of sqlStatements) {
-        logger6.debug(`[RuntimeMigrator] Executing: ${stmt}`);
+        logger6.debug({ src: "plugin:sql", statement: stmt }, "Executing SQL statement");
         await this.db.execute(sql.raw(stmt));
       }
       const idx = await this.journalStorage.getNextIdx(pluginName);
@@ -7811,14 +7787,14 @@ class RuntimeMigrator {
       await this.journalStorage.updateJournal(pluginName, idx, tag, true);
       await this.snapshotStorage.saveSnapshot(pluginName, idx, snapshot);
       await this.db.execute(sql`COMMIT`);
-      logger6.info(`[RuntimeMigrator] Recorded migration ${tag} for ${pluginName}`);
+      logger6.info({ src: "plugin:sql", pluginName, tag }, "Recorded migration");
     } catch (error) {
       if (transactionStarted) {
         try {
           await this.db.execute(sql`ROLLBACK`);
-          logger6.error("[RuntimeMigrator] Migration failed, rolled back:", JSON.stringify(error));
+          logger6.error({ src: "plugin:sql", error: error instanceof Error ? error.message : String(error) }, "Migration failed, rolled back");
         } catch (rollbackError) {
-          logger6.error("[RuntimeMigrator] Failed to rollback transaction:", JSON.stringify(rollbackError));
+          logger6.error({ src: "plugin:sql", error: rollbackError instanceof Error ? rollbackError.message : String(rollbackError) }, "Failed to rollback transaction");
         }
       }
       throw error;
@@ -7841,31 +7817,31 @@ class RuntimeMigrator {
     };
   }
   async reset(pluginName) {
-    logger6.warn(`[RuntimeMigrator] Resetting migrations for ${pluginName}`);
+    logger6.warn({ src: "plugin:sql", pluginName }, "Resetting migrations");
     await this.db.execute(sql`DELETE FROM migrations._migrations WHERE plugin_name = ${pluginName}`);
     await this.db.execute(sql`DELETE FROM migrations._journal WHERE plugin_name = ${pluginName}`);
     await this.db.execute(sql`DELETE FROM migrations._snapshots WHERE plugin_name = ${pluginName}`);
-    logger6.warn(`[RuntimeMigrator] Reset complete for ${pluginName}`);
+    logger6.warn({ src: "plugin:sql", pluginName }, "Reset complete");
   }
   async checkMigration(pluginName, schema2) {
     try {
-      logger6.info(`[RuntimeMigrator] Checking migration for ${pluginName}...`);
+      logger6.info({ src: "plugin:sql", pluginName }, "Checking migration");
       const currentSnapshot = await generateSnapshot(schema2);
       const previousSnapshot = await this.snapshotStorage.getLatestSnapshot(pluginName);
       if (!hasChanges(previousSnapshot, currentSnapshot)) {
-        logger6.info(`[RuntimeMigrator] No changes detected for ${pluginName}`);
+        logger6.info({ src: "plugin:sql", pluginName }, "No changes detected");
         return null;
       }
       const diff = await calculateDiff(previousSnapshot, currentSnapshot);
       const dataLossCheck = checkForDataLoss(diff);
       if (dataLossCheck.hasDataLoss) {
-        logger6.warn(`[RuntimeMigrator] Migration for ${pluginName} would cause data loss`);
+        logger6.warn({ src: "plugin:sql", pluginName }, "Migration would cause data loss");
       } else {
-        logger6.info(`[RuntimeMigrator] Migration for ${pluginName} is safe (no data loss)`);
+        logger6.info({ src: "plugin:sql", pluginName }, "Migration is safe (no data loss)");
       }
       return dataLossCheck;
     } catch (error) {
-      logger6.error(`[RuntimeMigrator] Failed to check migration for ${pluginName}:`, JSON.stringify(error));
+      logger6.error({ src: "plugin:sql", pluginName, error: error instanceof Error ? error.message : String(error) }, "Failed to check migration");
       throw error;
     }
   }
@@ -8264,7 +8240,7 @@ async function installRLSFunctions(adapter) {
     END;
     $$ LANGUAGE plpgsql;
   `);
-  logger8.info("[Data Isolation] PostgreSQL functions installed");
+  logger8.info({ src: "plugin:sql" }, "RLS PostgreSQL functions installed");
   await installEntityRLS(adapter);
 }
 async function getOrCreateRlsServer(adapter, serverId) {
@@ -8272,7 +8248,7 @@ async function getOrCreateRlsServer(adapter, serverId) {
   await db2.insert(serverTable).values({
     id: serverId
   }).onConflictDoNothing();
-  logger8.info(`[Data Isolation] Server: ${serverId.slice(0, 8)}…`);
+  logger8.info({ src: "plugin:sql", serverId: serverId.slice(0, 8) }, "RLS server registered");
   return serverId;
 }
 async function setServerContext(adapter, serverId) {
@@ -8284,8 +8260,7 @@ async function setServerContext(adapter, serverId) {
   if (servers.length === 0) {
     throw new Error(`Server ${serverId} does not exist`);
   }
-  logger8.info(`[Data Isolation] Server: ${serverId.slice(0, 8)}…`);
-  logger8.info("[Data Isolation] Context configured successfully (using application_name)");
+  logger8.info({ src: "plugin:sql", serverId: serverId.slice(0, 8) }, "RLS context configured");
 }
 async function assignAgentToServer(adapter, agentId, serverId) {
   if (!agentId || !serverId) {
@@ -8298,26 +8273,26 @@ async function assignAgentToServer(adapter, agentId, serverId) {
     const agent = agents[0];
     const currentServerId = agent.server_id;
     if (currentServerId === serverId) {
-      logger8.debug(`[Data Isolation] Agent ${agent.name} already assigned to correct server`);
+      logger8.debug({ src: "plugin:sql", agentName: agent.name }, "Agent already assigned to correct server");
     } else {
       await db2.update(agentTable).set({ server_id: serverId }).where(eq(agentTable.id, agentId));
       if (currentServerId === null) {
-        logger8.info(`[Data Isolation] Agent ${agent.name} assigned to server`);
+        logger8.info({ src: "plugin:sql", agentName: agent.name }, "Agent assigned to server");
       } else {
-        logger8.warn(`[Data Isolation] Agent ${agent.name} server changed`);
+        logger8.warn({ src: "plugin:sql", agentName: agent.name }, "Agent server changed");
       }
     }
   } else {
-    logger8.debug(`[Data Isolation] Agent ${agentId} doesn't exist yet`);
+    logger8.debug({ src: "plugin:sql", agentId }, "Agent does not exist yet");
   }
 }
 async function applyRLSToNewTables(adapter) {
   const db2 = adapter.db;
   try {
     await db2.execute(sql`SELECT apply_rls_to_all_tables()`);
-    logger8.info("[Data Isolation] Applied to all tables");
+    logger8.info({ src: "plugin:sql" }, "RLS applied to all tables");
   } catch (error) {
-    logger8.warn("[Data Isolation] Failed to apply to some tables:", String(error));
+    logger8.warn({ src: "plugin:sql", error: String(error) }, "Failed to apply RLS to some tables");
   }
 }
 async function uninstallRLS(adapter) {
@@ -8331,14 +8306,14 @@ async function uninstallRLS(adapter) {
     `);
     const rlsEnabled = checkResult.rows?.[0]?.rls_enabled;
     if (!rlsEnabled) {
-      logger8.debug("[Data Isolation] RLS not installed, skipping cleanup");
+      logger8.debug({ src: "plugin:sql" }, "RLS not installed, skipping cleanup");
       return;
     }
-    logger8.info("[Data Isolation] Disabling RLS globally (keeping server_id columns for schema compatibility)...");
+    logger8.info({ src: "plugin:sql" }, "Disabling RLS globally (keeping server_id columns for schema compatibility)...");
     try {
       await uninstallEntityRLS(adapter);
     } catch (entityRlsError) {
-      logger8.debug("[Data Isolation] Entity RLS cleanup skipped (not installed or already cleaned)");
+      logger8.debug({ src: "plugin:sql" }, "Entity RLS cleanup skipped (not installed or already cleaned)");
     }
     await db2.execute(sql`
       CREATE OR REPLACE FUNCTION _temp_disable_rls_on_table(
@@ -8375,22 +8350,22 @@ async function uninstallRLS(adapter) {
       const tableName = row.tablename;
       try {
         await db2.execute(sql`SELECT _temp_disable_rls_on_table(${schemaName}, ${tableName})`);
-        logger8.debug(`[Data Isolation] Disabled RLS on table: ${schemaName}.${tableName}`);
+        logger8.debug({ src: "plugin:sql", schemaName, tableName }, "Disabled RLS on table");
       } catch (error) {
-        logger8.warn(`[Data Isolation] Failed to disable RLS on table ${schemaName}.${tableName}:`, String(error));
+        logger8.warn({ src: "plugin:sql", schemaName, tableName, error: String(error) }, "Failed to disable RLS on table");
       }
     }
     await db2.execute(sql`DROP FUNCTION IF EXISTS _temp_disable_rls_on_table(text, text)`);
-    logger8.info("[Data Isolation] Keeping server_id values intact (prevents data theft on re-enable)");
-    logger8.info("[Data Isolation] Clearing servers table...");
+    logger8.info({ src: "plugin:sql" }, "Keeping server_id values intact (prevents data theft on re-enable)");
+    logger8.info({ src: "plugin:sql" }, "Clearing servers table...");
     await db2.execute(sql`TRUNCATE TABLE servers`);
     await db2.execute(sql`DROP FUNCTION IF EXISTS apply_rls_to_all_tables() CASCADE`);
     await db2.execute(sql`DROP FUNCTION IF EXISTS add_server_isolation(text, text) CASCADE`);
     await db2.execute(sql`DROP FUNCTION IF EXISTS current_server_id() CASCADE`);
-    logger8.info("[Data Isolation] Dropped all RLS functions");
-    logger8.success("[Data Isolation] RLS disabled successfully (server_id columns preserved)");
+    logger8.info({ src: "plugin:sql" }, "Dropped all RLS functions");
+    logger8.info({ src: "plugin:sql" }, "RLS disabled successfully (server_id columns preserved)");
   } catch (error) {
-    logger8.error("[Data Isolation] Failed to disable RLS:", String(error));
+    logger8.error({ src: "plugin:sql", error: String(error) }, "Failed to disable RLS");
     throw error;
   }
 }
@@ -8703,20 +8678,19 @@ class DatabaseMigrationService {
     await migrateToEntityRLS({ db: db2 });
     this.migrator = new RuntimeMigrator(db2);
     await this.migrator.initialize();
-    logger9.info("DatabaseMigrationService initialized with database and runtime migrator");
+    logger9.info({ src: "plugin:sql" }, "DatabaseMigrationService initialized");
   }
   discoverAndRegisterPluginSchemas(plugins) {
     for (const plugin of plugins) {
       if (plugin.schema) {
         this.registeredSchemas.set(plugin.name, plugin.schema);
-        logger9.info(`Registered schema for plugin: ${plugin.name}`);
       }
     }
-    logger9.info(`Discovered ${this.registeredSchemas.size} plugin schemas out of ${plugins.length} plugins`);
+    logger9.info({ src: "plugin:sql", schemasDiscovered: this.registeredSchemas.size, totalPlugins: plugins.length }, "Plugin schemas discovered");
   }
   registerSchema(pluginName, schema2) {
     this.registeredSchemas.set(pluginName, schema2);
-    logger9.info(`Registered schema for plugin: ${pluginName}`);
+    logger9.debug({ src: "plugin:sql", pluginName }, "Schema registered");
   }
   async runAllPluginMigrations(options) {
     if (!this.db || !this.migrator) {
@@ -8728,12 +8702,7 @@ class DatabaseMigrationService {
       force: options?.force ?? false,
       dryRun: options?.dryRun ?? false
     };
-    logger9.info("[DatabaseMigrationService] Starting migrations");
-    logger9.info(`[DatabaseMigrationService] Environment: ${isProduction ? "PRODUCTION" : "DEVELOPMENT"}`);
-    logger9.info(`[DatabaseMigrationService] Plugins to migrate: ${this.registeredSchemas.size}`);
-    if (migrationOptions.dryRun) {
-      logger9.info("[DatabaseMigrationService] DRY RUN mode - no changes will be applied");
-    }
+    logger9.info({ src: "plugin:sql", environment: isProduction ? "PRODUCTION" : "DEVELOPMENT", pluginCount: this.registeredSchemas.size, dryRun: migrationOptions.dryRun }, "Starting migrations");
     let successCount = 0;
     let failureCount = 0;
     const errors2 = [];
@@ -8741,43 +8710,37 @@ class DatabaseMigrationService {
       try {
         await this.migrator.migrate(pluginName, schema2, migrationOptions);
         successCount++;
-        logger9.info(`[DatabaseMigrationService] ✅ Completed: ${pluginName}`);
+        logger9.info({ src: "plugin:sql", pluginName }, "Migration completed");
       } catch (error) {
         failureCount++;
         const errorMessage = error.message;
         errors2.push({ pluginName, error });
         if (errorMessage.includes("Destructive migration blocked")) {
-          logger9.error(`[DatabaseMigrationService] ❌ Blocked: ${pluginName} (destructive changes detected)`);
-          if (!migrationOptions.force && process.env.ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS !== "true") {
-            logger9.error("[DatabaseMigrationService] To allow destructive migrations:");
-            logger9.error("[DatabaseMigrationService]   - Set ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true");
-            logger9.error("[DatabaseMigrationService]   - Or pass { force: true } to this method");
-          }
+          logger9.error({ src: "plugin:sql", pluginName }, "Migration blocked - destructive changes detected. Set ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true or use force option");
         } else {
-          logger9.error(`[DatabaseMigrationService] ❌ Failed: ${pluginName}`, JSON.stringify(error));
+          logger9.error({ src: "plugin:sql", pluginName, error: errorMessage }, "Migration failed");
         }
       }
     }
     if (failureCount === 0) {
-      logger9.info(`[DatabaseMigrationService] All ${successCount} migrations completed successfully`);
+      logger9.info({ src: "plugin:sql", successCount }, "All migrations completed successfully");
       const dataIsolationEnabled = process.env.ENABLE_DATA_ISOLATION === "true";
       if (dataIsolationEnabled) {
         try {
-          logger9.info("[DatabaseMigrationService] Re-applying Row Level Security...");
+          logger9.info({ src: "plugin:sql" }, "Re-applying Row Level Security...");
           await installRLSFunctions({ db: this.db });
           await applyRLSToNewTables({ db: this.db });
           await applyEntityRLSToAllTables({ db: this.db });
-          logger9.info("[DatabaseMigrationService] ✅ RLS re-applied successfully");
+          logger9.info({ src: "plugin:sql" }, "RLS re-applied successfully");
         } catch (rlsError) {
           const errorMsg = rlsError instanceof Error ? rlsError.message : String(rlsError);
-          logger9.warn("[DatabaseMigrationService] ⚠️ Failed to re-apply RLS:", errorMsg);
-          logger9.warn("[DatabaseMigrationService] This is OK if server_id columns are not yet in schemas");
+          logger9.warn({ src: "plugin:sql", error: errorMsg }, "Failed to re-apply RLS (this is OK if server_id columns are not yet in schemas)");
         }
       } else {
-        logger9.info("[DatabaseMigrationService] Skipping RLS re-application (ENABLE_DATA_ISOLATION is not true)");
+        logger9.info({ src: "plugin:sql" }, "Skipping RLS re-application (ENABLE_DATA_ISOLATION is not true)");
       }
     } else {
-      logger9.error(`[DatabaseMigrationService] Migrations failed: ${failureCount} failed, ${successCount} succeeded`);
+      logger9.error({ src: "plugin:sql", failureCount, successCount }, "Some migrations failed");
       const errorSummary = errors2.map((e) => `${e.pluginName}: ${e.error.message}`).join(`
   `);
       throw new Error(`${failureCount} migration(s) failed:
@@ -9441,10 +9404,10 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           const backoffDelay = Math.min(this.baseDelay * 2 ** (attempt - 1), this.maxDelay);
           const jitter = Math.random() * this.jitterMax;
           const delay = backoffDelay + jitter;
-          logger10.warn(`Database operation failed (attempt ${attempt}/${this.maxRetries}): ${error instanceof Error ? error.message : String(error)}, nextRetryIn: ${(delay / 1000).toFixed(1)}s`);
+          logger10.warn({ src: "plugin:sql", attempt, maxRetries: this.maxRetries, error: error instanceof Error ? error.message : String(error) }, "Database operation failed, retrying");
           await new Promise((resolve) => setTimeout(resolve, delay));
         } else {
-          logger10.error(`Max retry attempts reached: ${error instanceof Error ? error.message : String(error)}, totalAttempts: ${attempt}`);
+          logger10.error({ src: "plugin:sql", totalAttempts: attempt, error: error instanceof Error ? error.message : String(error) }, "Max retry attempts reached");
           throw error instanceof Error ? error : new Error(String(error));
         }
       }
@@ -9498,7 +9461,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         if (agent.id) {
           const existing = await this.db.select({ id: agentTable.id }).from(agentTable).where(eq(agentTable.id, agent.id)).limit(1);
           if (existing.length > 0) {
-            logger10.warn(`Attempted to create an agent with a duplicate ID. ID: ${agent.id}`);
+            logger10.warn({ src: "plugin:sql", agentId: agent.id }, "Attempted to create agent with duplicate ID");
             return false;
           }
         }
@@ -9509,10 +9472,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
             updatedAt: new Date(agent.updatedAt || Date.now())
           });
         });
-        logger10.debug(`Agent created successfully: ${agent.id}`);
         return true;
       } catch (error) {
-        logger10.error(`Error creating agent: ${error instanceof Error ? error.message : String(error)}, agentId: ${agent.id}`);
+        logger10.error({ src: "plugin:sql", agentId: agent.id, error: error instanceof Error ? error.message : String(error) }, "Failed to create agent");
         return false;
       }
     });
@@ -9546,10 +9508,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           }
           await tx.update(agentTable).set(updateData).where(eq(agentTable.id, agentId));
         });
-        logger10.debug(`Agent updated successfully: ${agentId}`);
         return true;
       } catch (error) {
-        logger10.error(`Error updating agent: ${error instanceof Error ? error.message : String(error)}, agentId: ${agentId}`);
+        logger10.error({ src: "plugin:sql", agentId, error: error instanceof Error ? error.message : String(error) }, "Failed to update agent");
         return false;
       }
     });
@@ -9591,22 +9552,16 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return finalSettings === undefined ? {} : finalSettings;
   }
   async deleteAgent(agentId) {
-    logger10.debug(`[DB] Deleting agent with ID: ${agentId}`);
     return this.withDatabase(async () => {
       try {
         const result = await this.db.delete(agentTable).where(eq(agentTable.id, agentId)).returning();
         if (result.length === 0) {
-          logger10.warn(`[DB] Agent ${agentId} not found`);
+          logger10.warn({ src: "plugin:sql", agentId }, "Agent not found for deletion");
           return false;
         }
-        logger10.success(`[DB] Agent ${agentId} and all related data successfully deleted via cascade`);
         return true;
       } catch (error) {
-        logger10.error(`[DB] Failed to delete agent ${agentId}: ${error instanceof Error ? error.message : String(error)}`);
-        if (error instanceof Error) {
-          logger10.error(`[DB] Error details: ${error.name} - ${error.message}`);
-          logger10.error(`[DB] Stack trace: ${error.stack}`);
-        }
+        logger10.error({ src: "plugin:sql", agentId, error: error instanceof Error ? error.message : String(error) }, "Failed to delete agent");
         throw error;
       }
     });
@@ -9617,7 +9572,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         const result = await this.db.select({ count: count() }).from(agentTable);
         return result[0]?.count || 0;
       } catch (error) {
-        logger10.error(`Error counting agents: ${error instanceof Error ? error.message : String(error)}`);
+        logger10.error({ src: "plugin:sql", error: error instanceof Error ? error.message : String(error) }, "Failed to count agents");
         return 0;
       }
     });
@@ -9626,9 +9581,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withDatabase(async () => {
       try {
         await this.db.delete(agentTable);
-        logger10.success("Successfully cleaned up agent table");
       } catch (error) {
-        logger10.error(`Error cleaning up agent table: ${error instanceof Error ? error.message : String(error)}`);
+        logger10.error({ src: "plugin:sql", error: error instanceof Error ? error.message : String(error) }, "Failed to clean up agent table");
         throw error;
       }
     });
@@ -9707,21 +9661,17 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
             metadata: entity2.metadata || {}
           }));
           await tx.insert(entityTable).values(normalizedEntities);
-          logger10.debug(`${entities.length} Entities created successfully`);
           return true;
         });
       } catch (error) {
-        logger10.error(`Error creating entities, entityId: ${entities[0].id}, (metadata?.)name: ${entities[0].metadata?.name}`, error instanceof Error ? error.message : String(error));
-        if (error instanceof Error && error.stack) {
-          logger10.trace("Stack trace:", error.stack);
-        }
+        logger10.error({ src: "plugin:sql", entityId: entities[0]?.id, error: error instanceof Error ? error.message : String(error) }, "Failed to create entities");
         return false;
       }
     });
   }
   async ensureEntityExists(entity2) {
     if (!entity2.id) {
-      logger10.error("Entity ID is required for ensureEntityExists");
+      logger10.error({ src: "plugin:sql" }, "Entity ID is required for ensureEntityExists");
       return false;
     }
     try {
@@ -9731,7 +9681,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       }
       return true;
     } catch (error) {
-      logger10.error(`Error ensuring entity exists: ${error instanceof Error ? error.message : String(error)}, entityId: ${entity2.id}`);
+      logger10.error({ src: "plugin:sql", entityId: entity2.id, error: error instanceof Error ? error.message : String(error) }, "Failed to ensure entity exists");
       return false;
     }
   }
@@ -10081,7 +10031,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           levenshtein_score: Number(row.levenshtein_score)
         })).filter((row) => Array.isArray(row.embedding));
       } catch (error) {
-        logger10.error(`Error in getCachedEmbeddings: ${error instanceof Error ? error.message : String(error)}, tableName: ${opts.query_table_name}, fieldName: ${opts.query_field_name}`);
+        logger10.error({ src: "plugin:sql", tableName: opts.query_table_name, fieldName: opts.query_field_name, error: error instanceof Error ? error.message : String(error) }, "Failed to get cached embeddings");
         if (error instanceof Error && error.message === "levenshtein argument exceeds maximum length of 255 characters") {
           return [];
         }
@@ -10103,7 +10053,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           });
         });
       } catch (error) {
-        logger10.error(`Failed to create log entry: ${error instanceof Error ? error.message : String(error)}, type: ${params.type}, roomId: ${params.roomId}, entityId: ${params.entityId}`);
+        logger10.error({ src: "plugin:sql", type: params.type, roomId: params.roomId, entityId: params.entityId, error: error instanceof Error ? error.message : String(error) }, "Failed to create log entry");
         throw error;
       }
     });
@@ -10380,11 +10330,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     });
   }
   async createMemory(memory, tableName) {
-    logger10.debug(`DrizzleAdapter createMemory: memoryId: ${memory.id}, embeddingLength: ${memory.embedding?.length}, contentLength: ${memory.content?.text?.length}`);
     const memoryId = memory.id ?? v4();
     const existing = await this.getMemoryById(memoryId);
     if (existing) {
-      logger10.debug(`Memory already exists, skipping creation: ${memoryId}`);
       return memoryId;
     }
     if (memory.unique === undefined) {
@@ -10434,7 +10382,6 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async updateMemory(memory) {
     return this.withDatabase(async () => {
       try {
-        logger10.debug(`Updating memory: memoryId: ${memory.id}, hasEmbedding: ${!!memory.embedding}`);
         await this.db.transaction(async (tx) => {
           if (memory.content) {
             const contentToUpdate = typeof memory.content === "string" ? memory.content : JSON.stringify(memory.content ?? {});
@@ -10466,10 +10413,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
             }
           }
         });
-        logger10.debug(`Memory updated successfully: ${memory.id}`);
         return true;
       } catch (error) {
-        logger10.error(`Error updating memory: ${error instanceof Error ? error.message : String(error)}, memoryId: ${memory.id}`);
+        logger10.error({ src: "plugin:sql", memoryId: memory.id, error: error instanceof Error ? error.message : String(error) }, "Failed to update memory");
         return false;
       }
     });
@@ -10481,7 +10427,6 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         await tx.delete(embeddingTable).where(eq(embeddingTable.memoryId, memoryId));
         await tx.delete(memoryTable).where(eq(memoryTable.id, memoryId));
       });
-      logger10.debug(`Memory and related fragments removed successfully: ${memoryId}`);
     });
   }
   async deleteManyMemories(memoryIds) {
@@ -10500,7 +10445,6 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           await tx.delete(memoryTable).where(inArray(memoryTable.id, batch));
         }
       });
-      logger10.debug(`Batch memory deletion completed successfully: ${memoryIds.length}`);
     });
   }
   async deleteMemoryFragments(tx, documentId) {
@@ -10509,7 +10453,6 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       const fragmentIds = fragmentsToDelete.map((f) => f.id);
       await tx.delete(embeddingTable).where(inArray(embeddingTable.memoryId, fragmentIds));
       await tx.delete(memoryTable).where(inArray(memoryTable.id, fragmentIds));
-      logger10.debug(`Deleted related fragments: documentId: ${documentId}, fragmentCount: ${fragmentsToDelete.length}`);
     }
   }
   async getMemoryFragments(tx, documentId) {
@@ -10521,7 +10464,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       await this.db.transaction(async (tx) => {
         const rows = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)));
         const ids = rows.map((r) => r.id);
-        logger10.debug(`[deleteAllMemories] memory IDs to delete: roomId: ${roomId}, tableName: ${tableName}, ids: ${JSON.stringify(ids)}`);
+        logger10.debug({ src: "plugin:sql", roomId, tableName, memoryCount: ids.length }, "Deleting all memories");
         if (ids.length === 0) {
           return;
         }
@@ -10531,7 +10474,6 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         }));
         await tx.delete(memoryTable).where(and(eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)));
       });
-      logger10.debug(`All memories removed successfully: roomId: ${roomId}, tableName: ${tableName}`);
     });
   }
   async countMemories(roomId, unique2 = true, tableName = "") {
@@ -10640,7 +10582,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         }).onConflictDoNothing();
         return true;
       } catch (error) {
-        logger10.error(`Error adding participant to room: ${error instanceof Error ? error.message : String(error)}, entityId: ${entityId}, roomId: ${roomId}, agentId: ${this.agentId}`);
+        logger10.error({ src: "plugin:sql", entityId, roomId, agentId: this.agentId, error: error instanceof Error ? error.message : String(error) }, "Failed to add participant to room");
         return false;
       }
     });
@@ -10654,10 +10596,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           agentId: this.agentId
         }));
         await this.db.insert(participantTable).values(values).onConflictDoNothing().execute();
-        logger10.debug(`${entityIds.length} Entities linked successfully`);
         return true;
       } catch (error) {
-        logger10.error(`Error adding participants to room: ${error instanceof Error ? error.message : String(error)}, entityIdSample: ${entityIds[0]}, roomId: ${roomId}, agentId: ${this.agentId}`);
+        logger10.error({ src: "plugin:sql", roomId, agentId: this.agentId, error: error instanceof Error ? error.message : String(error) }, "Failed to add participants to room");
         return false;
       }
     });
@@ -10669,10 +10610,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           return await tx.delete(participantTable).where(and(eq(participantTable.entityId, entityId), eq(participantTable.roomId, roomId))).returning();
         });
         const removed = result.length > 0;
-        logger10.debug(`Participant ${removed ? "removed" : "not found"}: entityId: ${entityId}, roomId: ${roomId}, removed: ${removed}`);
         return removed;
       } catch (error) {
-        logger10.error(`Error removing participant from room: ${error instanceof Error ? error.message : String(error)}, entityId: ${entityId}, roomId: ${roomId}`);
+        logger10.error({ src: "plugin:sql", entityId, roomId, error: error instanceof Error ? error.message : String(error) }, "Failed to remove participant from room");
         return false;
       }
     });
@@ -10719,7 +10659,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           await tx.update(participantTable).set({ roomState: state }).where(and(eq(participantTable.roomId, roomId), eq(participantTable.entityId, entityId), eq(participantTable.agentId, this.agentId)));
         });
       } catch (error) {
-        logger10.error(`Error setting participant follow state: roomId: ${roomId}, entityId: ${entityId}, state: ${state}, error: ${error instanceof Error ? error.message : String(error)}`);
+        logger10.error({ src: "plugin:sql", roomId, entityId, state, error: error instanceof Error ? error.message : String(error) }, "Failed to set participant follow state");
         throw error;
       }
     });
@@ -10739,7 +10679,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         await this.db.insert(relationshipTable).values(saveParams);
         return true;
       } catch (error) {
-        logger10.error(`Error creating relationship: ${error instanceof Error ? error.message : String(error)}, saveParams: ${JSON.stringify(saveParams)}`);
+        logger10.error({ src: "plugin:sql", agentId: this.agentId, error: error instanceof Error ? error.message : String(error), saveParams }, "Error creating relationship");
         return false;
       }
     });
@@ -10752,7 +10692,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           metadata: relationship.metadata || {}
         }).where(eq(relationshipTable.id, relationship.id));
       } catch (error) {
-        logger10.error(`Error updating relationship: ${error instanceof Error ? error.message : String(error)}, relationship: ${JSON.stringify(relationship)}`);
+        logger10.error({ src: "plugin:sql", agentId: this.agentId, error: error instanceof Error ? error.message : String(error), relationshipId: relationship.id }, "Error updating relationship");
         throw error;
       }
     });
@@ -10814,7 +10754,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         }
         return;
       } catch (error) {
-        logger10.error(`Error fetching cache: ${error instanceof Error ? error.message : String(error)}, key: ${key}, agentId: ${this.agentId}`);
+        logger10.error({ src: "plugin:sql", agentId: this.agentId, error: error instanceof Error ? error.message : String(error), key }, "Error fetching cache");
         return;
       }
     });
@@ -10834,7 +10774,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         });
         return true;
       } catch (error) {
-        logger10.error(`Error setting cache: ${error instanceof Error ? error.message : String(error)}, key: ${key}, agentId: ${this.agentId}`);
+        logger10.error({ src: "plugin:sql", agentId: this.agentId, error: error instanceof Error ? error.message : String(error), key }, "Error setting cache");
         return false;
       }
     });
@@ -10847,7 +10787,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         });
         return true;
       } catch (error) {
-        logger10.error(`Error deleting cache: ${error instanceof Error ? error.message : String(error)}, key: ${key}, agentId: ${this.agentId}`);
+        logger10.error({ src: "plugin:sql", agentId: this.agentId, error: error instanceof Error ? error.message : String(error), key }, "Error deleting cache");
         return false;
       }
     });
@@ -11010,25 +10950,20 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withDatabase(async () => {
       const rooms = await this.db.select({ id: roomTable.id }).from(roomTable).where(and(eq(roomTable.worldId, worldId), eq(roomTable.agentId, this.agentId)));
       if (rooms.length === 0) {
-        logger10.debug(`No rooms found for worldId ${worldId} and agentId ${this.agentId} to delete.`);
         return;
       }
       const roomIds = rooms.map((room) => room.id);
       if (roomIds.length > 0) {
         await this.db.delete(logTable).where(inArray(logTable.roomId, roomIds));
-        logger10.debug(`Deleted logs for ${roomIds.length} rooms in world ${worldId}.`);
         await this.db.delete(participantTable).where(inArray(participantTable.roomId, roomIds));
-        logger10.debug(`Deleted participants for ${roomIds.length} rooms in world ${worldId}.`);
         const memoriesInRooms = await this.db.select({ id: memoryTable.id }).from(memoryTable).where(inArray(memoryTable.roomId, roomIds));
         const memoryIdsInRooms = memoriesInRooms.map((m) => m.id);
         if (memoryIdsInRooms.length > 0) {
           await this.db.delete(embeddingTable).where(inArray(embeddingTable.memoryId, memoryIdsInRooms));
-          logger10.debug(`Deleted embeddings for ${memoryIdsInRooms.length} memories in world ${worldId}.`);
           await this.db.delete(memoryTable).where(inArray(memoryTable.id, memoryIdsInRooms));
-          logger10.debug(`Deleted ${memoryIdsInRooms.length} memories in world ${worldId}.`);
         }
         await this.db.delete(roomTable).where(inArray(roomTable.id, roomIds));
-        logger10.debug(`Deleted ${roomIds.length} rooms for worldId ${worldId}.`);
+        logger10.debug({ src: "plugin:sql", worldId, roomsDeleted: roomIds.length, memoriesDeleted: memoryIdsInRooms.length }, "World cleanup completed");
       }
     });
   }
@@ -11376,7 +11311,7 @@ class PgliteDatabaseAdapter extends BaseDrizzleAdapter {
     return this.getEntitiesByIds(entityIds);
   }
   async getMemoriesByServerId(_params) {
-    logger11.warn("getMemoriesByServerId called but not implemented - returning empty array");
+    logger11.warn({ src: "plugin:sql" }, "getMemoriesByServerId called but not implemented");
     return [];
   }
   async ensureAgentExists(agent) {
@@ -11401,13 +11336,13 @@ class PgliteDatabaseAdapter extends BaseDrizzleAdapter {
   }
   async withDatabase(operation) {
     if (this.manager.isShuttingDown()) {
-      logger11.warn("Database is shutting down");
+      logger11.warn({ src: "plugin:sql" }, "Database is shutting down");
       return null;
     }
     return operation();
   }
   async init() {
-    logger11.debug("PGliteDatabaseAdapter initialized, skipping automatic migrations.");
+    logger11.debug({ src: "plugin:sql" }, "PGliteDatabaseAdapter initialized");
   }
   async isReady() {
     return !this.manager.isShuttingDown();
@@ -11759,7 +11694,7 @@ class PgDatabaseAdapter extends BaseDrizzleAdapter {
     return this.getEntitiesByIds(entityIds);
   }
   async getMemoriesByServerId(_params) {
-    logger12.warn("getMemoriesByServerId called but not implemented - returning empty array");
+    logger12.warn({ src: "plugin:sql" }, "getMemoriesByServerId called but not implemented");
     return [];
   }
   async ensureAgentExists(agent) {
@@ -11795,7 +11730,7 @@ class PgDatabaseAdapter extends BaseDrizzleAdapter {
     });
   }
   async init() {
-    logger12.debug("PgDatabaseAdapter initialized, skipping automatic migrations.");
+    logger12.debug({ src: "plugin:sql" }, "PgDatabaseAdapter initialized");
   }
   async isReady() {
     return this.manager.testConnection();
@@ -11868,7 +11803,7 @@ class PostgresConnectionManager {
     const poolConfig = { connectionString };
     if (rlsServerId) {
       poolConfig.application_name = rlsServerId;
-      logger13.debug(`[RLS] Pool configured with application_name: ${rlsServerId.substring(0, 8)}...`);
+      logger13.debug({ src: "plugin:sql", rlsServerId: rlsServerId.substring(0, 8) }, "Pool configured with RLS server");
     }
     this.pool = new Pool2(poolConfig);
     this.db = drizzle2(this.pool, { casing: "snake_case" });
@@ -11889,7 +11824,7 @@ class PostgresConnectionManager {
       await client.query("SELECT 1");
       return true;
     } catch (error) {
-      logger13.error(`Failed to connect to the database: ${error instanceof Error ? error.message : String(error)}`);
+      logger13.error({ src: "plugin:sql", error: error instanceof Error ? error.message : String(error) }, "Failed to connect to the database");
       return false;
     } finally {
       if (client) {
@@ -11994,14 +11929,14 @@ function createDatabaseAdapter(config, agentId) {
       }
       rlsServerId = stringToUuid(rlsServerIdString);
       managerKey = rlsServerId;
-      logger14.debug(`[Data Isolation] Using connection pool for server_id: ${rlsServerId.slice(0, 8)}… (from ELIZA_SERVER_ID="${rlsServerIdString}")`);
+      logger14.debug({ src: "plugin:sql", rlsServerId: rlsServerId.slice(0, 8), serverIdString: rlsServerIdString }, "Using connection pool for RLS server");
     }
     if (!globalSingletons.postgresConnectionManagers) {
       globalSingletons.postgresConnectionManagers = new Map;
     }
     let manager = globalSingletons.postgresConnectionManagers.get(managerKey);
     if (!manager) {
-      logger14.debug(`[Data Isolation] Creating new connection pool for key: ${managerKey.slice(0, 8)}…`);
+      logger14.debug({ src: "plugin:sql", managerKey: managerKey.slice(0, 8) }, "Creating new connection pool");
       manager = new PostgresConnectionManager(config.postgresUrl, rlsServerId);
       globalSingletons.postgresConnectionManagers.set(managerKey, manager);
     }
@@ -12019,18 +11954,18 @@ var plugin = {
   priority: 0,
   schema: exports_schema,
   init: async (_config, runtime) => {
-    logger14.info("plugin-sql (node) init starting...");
+    runtime.logger.info({ src: "plugin:sql", agentId: runtime.agentId }, "plugin-sql (node) init starting");
     const adapterRegistered = await runtime.isReady().then(() => true).catch((error) => {
       const message = error instanceof Error ? error.message : String(error);
       if (message.includes("Database adapter not registered")) {
-        logger14.info("No pre-registered database adapter detected; registering adapter");
+        runtime.logger.info({ src: "plugin:sql", agentId: runtime.agentId }, "No pre-registered database adapter detected; registering adapter");
       } else {
-        logger14.warn({ error }, "Database adapter readiness check error; proceeding to register adapter");
+        runtime.logger.warn({ src: "plugin:sql", agentId: runtime.agentId, error: message }, "Database adapter readiness check error; proceeding to register adapter");
       }
       return false;
     });
     if (adapterRegistered) {
-      logger14.info("Database adapter already registered, skipping creation");
+      runtime.logger.info({ src: "plugin:sql", agentId: runtime.agentId }, "Database adapter already registered, skipping creation");
       return;
     }
     const postgresUrl = runtime.getSetting("POSTGRES_URL");
@@ -12040,7 +11975,7 @@ var plugin = {
       postgresUrl
     }, runtime.agentId);
     runtime.registerDatabaseAdapter(dbAdapter);
-    logger14.info("Database adapter created and registered");
+    runtime.logger.info({ src: "plugin:sql", agentId: runtime.agentId }, "Database adapter created and registered");
   }
 };
 var index_node_default = plugin;
@@ -12057,5 +11992,5 @@ export {
   DatabaseMigrationService
 };
 
-//# debugId=3F2BC9AFD4703ECD64756E2164756E21
+//# debugId=A90408A8FE4E3FF564756E2164756E21
 //# sourceMappingURL=index.node.js.map