@elizaos/plugin-sql 1.0.4 → 1.0.6

package/dist/{chunk-QOV7MUNF.js → chunk-74FVWTXP.js}

@@ -106,7 +106,9 @@ var PGliteClientManager = class {
   async initialize() {
     try {
       await this.client.waitReady;
-      logger.info("PGlite client initialized successfully");
+      await this.client.query("CREATE EXTENSION IF NOT EXISTS vector;");
+      await this.client.query("CREATE EXTENSION IF NOT EXISTS fuzzystrmatch;");
+      logger.info("PGlite client initialized and extensions ensured successfully");
     } catch (error) {
       logger.error("Failed to initialize PGlite client:", error);
       throw error;
@@ -342,6 +344,12 @@ var PostgresConnectionManager = class {
         migrationsSchema: "public"
       });
     } catch (error) {
+      if (error instanceof Error && error.message.includes("already exists")) {
+        logger2.info(
+          "Database migrations already applied - if you need to upgrade, you will need to manually migrate or reset your database"
+        );
+        return;
+      }
       logger2.error("Failed to run database migrations (pg):", error);
     }
   }
@@ -390,4 +398,4 @@ export {
   PostgresConnectionManager,
   resolvePgliteDir
 };
-//# sourceMappingURL=chunk-QOV7MUNF.js.map
+//# sourceMappingURL=chunk-74FVWTXP.js.map

package/dist/chunk-74FVWTXP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/pglite/manager.ts","../src/pg/manager.ts","../src/utils.ts"],"sourceRoot":"./","sourcesContent":["import { dirname as pathDirname, resolve as pathResolve } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { PGlite, type PGliteOptions } from '@electric-sql/pglite';\nimport { fuzzystrmatch } from '@electric-sql/pglite/contrib/fuzzystrmatch';\nimport { vector } from '@electric-sql/pglite/vector';\nimport { logger } from '@elizaos/core';\nimport { drizzle } from 'drizzle-orm/pglite';\nimport { migrate } from 'drizzle-orm/pglite/migrator';\nimport type { IDatabaseClientManager } from '../types';\n\n/**\n * Class representing a database client manager for PGlite.\n * @implements { IDatabaseClientManager }\n */\nexport class PGliteClientManager implements IDatabaseClientManager<PGlite> {\n  private client: PGlite;\n  private shuttingDown = false;\n  private readonly shutdownTimeout = 500;\n\n  /**\n   * Constructor for creating a new instance of PGlite with the provided options.\n   * Initializes the PGlite client with additional extensions.\n   * @param {PGliteOptions} options - The options to configure the PGlite client.\n   */\n  constructor(options: PGliteOptions) {\n    this.client = new PGlite({\n      ...options,\n      extensions: {\n        vector,\n        fuzzystrmatch,\n      },\n    });\n    this.setupShutdownHandlers();\n  }\n\n  /**\n   * Retrieves the PostgreSQL lite connection.\n   *\n   * @returns {PGlite} The PostgreSQL lite connection.\n   * @throws {Error} If the client manager is currently shutting down.\n   */\n  public getConnection(): PGlite {\n    if (this.shuttingDown) {\n      throw new Error('Client manager is shutting down');\n    }\n    return this.client;\n  }\n\n  /**\n   * Initiates a graceful shutdown of the PGlite client.\n   * Checks if the client is already in the process of shutting down.\n   * Logs the start of shutdown process and sets shuttingDown flag to true.\n   * Sets a timeout for the shutdown process and forces closure of database connection if timeout is reached.\n   * Handles the shutdown process, closes the client connection, clears the timeout, and logs the completion of shutdown.\n   * Logs any errors that occur during the shutdown process.\n   */\n  private async gracefulShutdown() {\n    if (this.shuttingDown) {\n      return;\n    }\n\n    this.shuttingDown = true;\n    logger.info('Starting graceful shutdown of PGlite client...');\n\n    const timeout = setTimeout(() => {\n      logger.warn('Shutdown timeout reached, forcing database connection closure...');\n      this.client.close().finally(() => {\n        logger.warn('Forced database connection closure complete.');\n        if (process.env.NODE_ENV !== 'test') {\n          process.exit(1);\n        }\n      });\n    }, this.shutdownTimeout);\n\n    try {\n      await this.client.close();\n      clearTimeout(timeout);\n      logger.info('PGlite client shutdown completed successfully');\n      if (process.env.NODE_ENV !== 'test') {\n        process.exit(0);\n      }\n    } catch (error) {\n      logger.error('Error during graceful shutdown:', error);\n      if (process.env.NODE_ENV !== 'test') {\n        process.exit(1);\n      } else {\n        throw error;\n      }\n    }\n  }\n\n  /**\n   * Sets up shutdown handlers for SIGINT, SIGTERM, and beforeExit events to gracefully shutdown the application.\n   * @private\n   */\n  private setupShutdownHandlers() {\n    process.on('SIGINT', async () => {\n      await this.gracefulShutdown();\n    });\n\n    process.on('SIGTERM', async () => {\n      await this.gracefulShutdown();\n    });\n\n    process.on('beforeExit', async () => {\n      await this.gracefulShutdown();\n    });\n  }\n\n  /**\n   * Initializes the client for PGlite.\n   *\n   * @returns {Promise<void>} A Promise that resolves when the client is initialized successfully\n   */\n  public async initialize(): Promise<void> {\n    try {\n      await this.client.waitReady;\n      // Explicitly create extensions\n      await this.client.query('CREATE EXTENSION IF NOT EXISTS vector;');\n      await this.client.query('CREATE EXTENSION IF NOT EXISTS fuzzystrmatch;');\n      logger.info('PGlite client initialized and extensions ensured successfully');\n    } catch (error) {\n      logger.error('Failed to initialize PGlite client:', error);\n      throw error;\n    }\n  }\n\n  /**\n   * Asynchronously closes the resource. If the resource is not already shutting down,\n   * it performs a graceful shutdown before closing.\n   *\n   * @returns A promise that resolves once the resource has been closed.\n   */\n  public async close(): Promise<void> {\n    if (!this.shuttingDown) {\n      await this.gracefulShutdown();\n    }\n  }\n\n  /**\n   * Check if the system is currently shutting down.\n   *\n   * @returns {boolean} True if the system is shutting down, false otherwise.\n   */\n  public isShuttingDown(): boolean {\n    return this.shuttingDown;\n  }\n\n  /**\n   * Asynchronously runs database migrations using Drizzle.\n   *\n   * Drizzle will first check if the migrations are already applied.\n   * If there is a diff between database schema and migrations, it will apply the migrations.\n   * If they are already applied, it will skip them.\n   *\n   * @returns {Promise<void>} A Promise that resolves once the migrations are completed successfully.\n   */\n  async runMigrations(): Promise<void> {\n    try {\n      const db = drizzle(this.client);\n\n      const packageJsonUrl = await import.meta.resolve('@elizaos/plugin-sql/package.json');\n      const packageJsonPath = fileURLToPath(packageJsonUrl);\n      const packageRoot = pathDirname(packageJsonPath);\n      const migrationsPath = pathResolve(packageRoot, 'drizzle/migrations');\n      logger.debug(\n        `Resolved migrations path (pglite) using import.meta.resolve: ${migrationsPath}`\n      );\n\n      await migrate(db, {\n        migrationsFolder: migrationsPath,\n        migrationsSchema: 'public',\n      });\n    } catch (error) {\n      logger.error('Failed to run database migrations (pglite):', error);\n    }\n  }\n}\n","import path from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { logger } from '@elizaos/core';\nimport { drizzle } from 'drizzle-orm/node-postgres';\nimport { migrate } from 'drizzle-orm/node-postgres/migrator';\nimport pkg, { type Pool as PgPool } from 'pg';\nimport type { IDatabaseClientManager } from '../types';\n\nconst { Pool } = pkg;\n\n/**\n * Manages connections to a PostgreSQL database using a connection pool.\n * Implements IDatabaseClientManager interface.\n */\n\nexport class PostgresConnectionManager implements IDatabaseClientManager<PgPool> {\n  private pool: PgPool;\n  private isShuttingDown = false;\n  private readonly connectionTimeout: number = 5000;\n\n  /**\n   * Constructor for creating a connection pool.\n   * @param {string} connectionString - The connection string used to connect to the database.\n   */\n  constructor(connectionString: string) {\n    const defaultConfig = {\n      max: 20,\n      idleTimeoutMillis: 30000,\n      connectionTimeoutMillis: this.connectionTimeout,\n    };\n\n    this.pool = new Pool({\n      ...defaultConfig,\n      connectionString,\n    });\n\n    this.pool.on('error', (err) => {\n      logger.error('Unexpected pool error', err);\n      this.handlePoolError(err);\n    });\n\n    this.setupPoolErrorHandling();\n    this.testConnection();\n  }\n\n  /**\n   * Handles a pool error by attempting to reconnect the pool.\n   *\n   * @param {Error} error The error that occurred in the pool.\n   * @throws {Error} If failed to reconnect the pool.\n   */\n  private async handlePoolError(error: Error) {\n    logger.error('Pool error occurred, attempting to reconnect', {\n      error: error.message,\n    });\n\n    try {\n      await this.pool.end();\n\n      this.pool = new Pool({\n        ...this.pool.options,\n        connectionTimeoutMillis: this.connectionTimeout,\n      });\n\n      await this.testConnection();\n      logger.success('Pool reconnection successful');\n    } catch (reconnectError) {\n      logger.error('Failed to reconnect pool', {\n        error: reconnectError instanceof Error ? reconnectError.message : String(reconnectError),\n      });\n      throw reconnectError;\n    }\n  }\n\n  /**\n   * Asynchronously tests the database connection by executing a query to get the current timestamp.\n   *\n   * @returns {Promise<boolean>} - A Promise that resolves to true if the database connection test is successful.\n   */\n  async testConnection(): Promise<boolean> {\n    let client: pkg.PoolClient | null = null;\n    try {\n      client = await this.pool.connect();\n      const result = await client.query('SELECT NOW()');\n      logger.success('Database connection test successful:', result.rows[0]);\n      return true;\n    } catch (error) {\n      logger.error('Database connection test failed:', error);\n      throw new Error(`Failed to connect to database: ${(error as Error).message}`);\n    } finally {\n      if (client) client.release();\n    }\n  }\n\n  /**\n   * Sets up event listeners to handle pool cleanup on SIGINT, SIGTERM, and beforeExit events.\n   */\n  private setupPoolErrorHandling() {\n    process.on('SIGINT', async () => {\n      await this.cleanup();\n      process.exit(0);\n    });\n\n    process.on('SIGTERM', async () => {\n      await this.cleanup();\n      process.exit(0);\n    });\n\n    process.on('beforeExit', async () => {\n      await this.cleanup();\n    });\n  }\n\n  /**\n   * Get the connection pool.\n   * @returns {PgPool} The connection pool\n   * @throws {Error} If the connection manager is shutting down or an error occurs when trying to get the connection from the pool\n   */\n  public getConnection(): PgPool {\n    if (this.isShuttingDown) {\n      throw new Error('Connection manager is shutting down');\n    }\n\n    try {\n      return this.pool;\n    } catch (error) {\n      logger.error('Failed to get connection from pool:', error);\n      throw error;\n    }\n  }\n\n  /**\n   * Asynchronously acquires a database client from the connection pool.\n   *\n   * @returns {Promise<pkg.PoolClient>} A Promise that resolves with the acquired database client.\n   * @throws {Error} If an error occurs while acquiring the database client.\n   */\n  public async getClient(): Promise<pkg.PoolClient> {\n    try {\n      return await this.pool.connect();\n    } catch (error) {\n      logger.error('Failed to acquire a database client:', error);\n      throw error;\n    }\n  }\n\n  /**\n   * Initializes the PostgreSQL connection manager by testing the connection and logging the result.\n   *\n   * @returns {Promise<void>} A Promise that resolves once the manager is successfully initialized\n   * @throws {Error} If there is an error initializing the connection manager\n   */\n  public async initialize(): Promise<void> {\n    try {\n      await this.testConnection();\n      logger.debug('PostgreSQL connection manager initialized successfully');\n    } catch (error) {\n      logger.error('Failed to initialize connection manager:', error);\n      throw error;\n    }\n  }\n\n  /**\n   * Asynchronously close the current process by executing a cleanup function.\n   * @returns A promise that resolves once the cleanup is complete.\n   */\n  public async close(): Promise<void> {\n    await this.cleanup();\n  }\n\n  /**\n   * Cleans up and closes the database pool.\n   * @returns {Promise<void>} A Promise that resolves when the database pool is closed.\n   */\n  async cleanup(): Promise<void> {\n    try {\n      await this.pool.end();\n      logger.info('Database pool closed');\n    } catch (error) {\n      logger.error('Error closing database pool:', error);\n    }\n  }\n\n  /**\n   * Asynchronously runs database migrations using the Drizzle library.\n   *\n   * Drizzle will first check if the migrations are already applied.\n   * If there is a diff between database schema and migrations, it will apply the migrations.\n   * If they are already applied, it will skip them.\n   *\n   * @returns {Promise<void>} A Promise that resolves once the migrations are completed successfully.\n   */\n  async runMigrations(): Promise<void> {\n    try {\n      const db = drizzle(this.pool);\n\n      const packageJsonUrl = await import.meta.resolve('@elizaos/plugin-sql/package.json');\n      const packageJsonPath = fileURLToPath(packageJsonUrl);\n      const packageRoot = path.dirname(packageJsonPath);\n      const migrationsPath = path.resolve(packageRoot, 'drizzle/migrations');\n      logger.debug(`Resolved migrations path (pg) using import.meta.resolve: ${migrationsPath}`);\n\n      await migrate(db, {\n        migrationsFolder: migrationsPath,\n        migrationsSchema: 'public',\n      });\n    } catch (error) {\n      if (error instanceof Error && error.message.includes('already exists')) {\n        logger.info(\n          'Database migrations already applied - if you need to upgrade, you will need to manually migrate or reset your database'\n        );\n        return;\n      }\n      logger.error('Failed to run database migrations (pg):', error);\n    }\n  }\n}\n","import dotenv from 'dotenv';\nimport { existsSync } from 'node:fs';\nimport path from 'node:path';\n\n/**\n * Expands a file path starting with `~` to the project directory.\n *\n * @param filepath - The path to expand.\n * @returns The expanded path.\n */\nexport function expandTildePath(filepath: string): string {\n  if (filepath && filepath.startsWith('~')) {\n    return path.join(process.cwd(), filepath.slice(1));\n  }\n  return filepath;\n}\n\n/**\n * Resolves the path to the nearest `.env` file.\n *\n * If no `.env` file is found when traversing up from the starting directory,\n * a path to `.env` in the starting directory is returned.\n *\n * @param startDir - The directory to start searching from. Defaults to the\n *   current working directory.\n * @returns The resolved path to the `.env` file.\n */\nexport function resolveEnvFile(startDir: string = process.cwd()): string {\n  let currentDir = startDir;\n\n  while (true) {\n    const candidate = path.join(currentDir, '.env');\n    if (existsSync(candidate)) {\n      return candidate;\n    }\n\n    const parentDir = path.dirname(currentDir);\n    if (parentDir === currentDir) {\n      break;\n    }\n    currentDir = parentDir;\n  }\n\n  return path.join(startDir, '.env');\n}\n\n/**\n * Resolves the directory used for PGlite database storage.\n *\n * Resolution order:\n * 1. The `dir` argument if provided.\n * 2. The `PGLITE_DATA_DIR` environment variable.\n * 3. The `fallbackDir` argument if provided.\n * 4. `./.elizadb` relative to the current working directory.\n *\n * @param dir - Optional directory preference.\n * @param fallbackDir - Optional fallback directory when env var is not set.\n * @returns The resolved data directory with any tilde expanded.\n */\nexport function resolvePgliteDir(dir?: string, fallbackDir?: string): string {\n  const envPath = resolveEnvFile();\n  if (existsSync(envPath)) {\n    dotenv.config({ path: envPath });\n  }\n\n  const base =\n    dir ?? process.env.PGLITE_DATA_DIR ?? fallbackDir ?? path.join(process.cwd(), '.elizadb');\n  return expandTildePath(base);\n}\n"],"mappings":"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","names":["fileURLToPath","logger","drizzle","migrate","logger","drizzle","fileURLToPath","migrate","path","path"]}

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   PostgresConnectionManager,
   __name,
   resolvePgliteDir
-} from "./chunk-QOV7MUNF.js";
+} from "./chunk-74FVWTXP.js";
 
 // src/index.ts
 import { logger as logger4 } from "@elizaos/core";
@@ -16,9 +16,22 @@ import { drizzle } from "drizzle-orm/pglite";
 import {
   DatabaseAdapter,
   logger,
-  stringToUuid
+  stringToUuid,
+  ChannelType
 } from "@elizaos/core";
-import { and, cosineDistance, count, desc, eq, gte, inArray, lte, or, sql as sql13 } from "drizzle-orm";
+import {
+  and,
+  cosineDistance,
+  count,
+  desc,
+  eq,
+  gte,
+  inArray,
+  lte,
+  lt,
+  or,
+  sql as sql16
+} from "drizzle-orm";
 import { v4 } from "uuid";
 
 // src/schema/embedding.ts
@@ -412,6 +425,86 @@ var taskTable = pgTable12("tasks", {
   updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow()
 });
 
+// src/schema/messageServer.ts
+import { pgTable as pgTable13, text as text12, jsonb as jsonb11, timestamp as timestamp2 } from "drizzle-orm/pg-core";
+import { sql as sql13 } from "drizzle-orm";
+var messageServerTable = pgTable13("message_servers", {
+  id: text12("id").primaryKey(),
+  // UUID stored as text
+  name: text12("name").notNull(),
+  sourceType: text12("source_type").notNull(),
+  sourceId: text12("source_id"),
+  metadata: jsonb11("metadata"),
+  createdAt: timestamp2("created_at", { mode: "date" }).default(sql13`CURRENT_TIMESTAMP`).notNull(),
+  updatedAt: timestamp2("updated_at", { mode: "date" }).default(sql13`CURRENT_TIMESTAMP`).notNull()
+});
+
+// src/schema/channel.ts
+import { pgTable as pgTable14, text as text13, jsonb as jsonb12, timestamp as timestamp3 } from "drizzle-orm/pg-core";
+import { sql as sql14 } from "drizzle-orm";
+var channelTable = pgTable14("channels", {
+  id: text13("id").primaryKey(),
+  // UUID stored as text
+  messageServerId: text13("server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
+  name: text13("name").notNull(),
+  type: text13("type").notNull(),
+  // Store ChannelType enum values as text
+  sourceType: text13("source_type"),
+  sourceId: text13("source_id"),
+  topic: text13("topic"),
+  metadata: jsonb12("metadata"),
+  createdAt: timestamp3("created_at", { mode: "date" }).default(sql14`CURRENT_TIMESTAMP`).notNull(),
+  updatedAt: timestamp3("updated_at", { mode: "date" }).default(sql14`CURRENT_TIMESTAMP`).notNull()
+});
+
+// src/schema/message.ts
+import { pgTable as pgTable15, text as text14, jsonb as jsonb13, timestamp as timestamp4 } from "drizzle-orm/pg-core";
+import { sql as sql15 } from "drizzle-orm";
+var messageTable = pgTable15("central_messages", {
+  id: text14("id").primaryKey(),
+  // UUID stored as text
+  channelId: text14("channel_id").notNull().references(() => channelTable.id, { onDelete: "cascade" }),
+  authorId: text14("author_id").notNull(),
+  content: text14("content").notNull(),
+  rawMessage: jsonb13("raw_message"),
+  inReplyToRootMessageId: text14("in_reply_to_root_message_id").references(() => messageTable.id, {
+    onDelete: "set null"
+  }),
+  sourceType: text14("source_type"),
+  sourceId: text14("source_id"),
+  metadata: jsonb13("metadata"),
+  createdAt: timestamp4("created_at", { mode: "date" }).default(sql15`CURRENT_TIMESTAMP`).notNull(),
+  updatedAt: timestamp4("updated_at", { mode: "date" }).default(sql15`CURRENT_TIMESTAMP`).notNull()
+});
+
+// src/schema/channelParticipant.ts
+import { pgTable as pgTable16, text as text15, primaryKey } from "drizzle-orm/pg-core";
+var channelParticipantsTable = pgTable16(
+  "channel_participants",
+  {
+    channelId: text15("channel_id").notNull().references(() => channelTable.id, { onDelete: "cascade" }),
+    userId: text15("user_id").notNull()
+    // This is a central UUID (can be an agentId or a dedicated central user ID)
+  },
+  (table) => ({
+    pk: primaryKey({ columns: [table.channelId, table.userId] })
+  })
+);
+
+// src/schema/serverAgent.ts
+import { pgTable as pgTable17, text as text16, primaryKey as primaryKey2 } from "drizzle-orm/pg-core";
+var serverAgentsTable = pgTable17(
+  "server_agents",
+  {
+    serverId: text16("server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
+    agentId: text16("agent_id").notNull()
+    // This is the agent's UUID
+  },
+  (table) => ({
+    pk: primaryKey2({ columns: [table.serverId, table.agentId] })
+  })
+);
+
 // src/base.ts
 var BaseDrizzleAdapter = class extends DatabaseAdapter {
   static {
@@ -1267,7 +1360,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async getCachedEmbeddings(opts) {
     return this.withDatabase(async () => {
       try {
-        const results = await this.db.execute(sql13`
+        const results = await this.db.execute(sql16`
                     WITH content_text AS (
                         SELECT
                             m.id,
@@ -1335,7 +1428,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         const jsonString = JSON.stringify(sanitizedBody);
         await this.db.transaction(async (tx) => {
           await tx.insert(logTable).values({
-            body: sql13`${jsonString}::jsonb`,
+            body: sql16`${jsonString}::jsonb`,
             entityId: params.entityId,
             roomId: params.roomId,
             type: params.type
@@ -1464,7 +1557,7 @@ var BaseDrizzleAdapter = class 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 = sql13`1 - (${cosineDistance(
+      const similarity = sql16`1 - (${cosineDistance(
         embeddingTable[this.embeddingDimension],
         cleanVector
       )})`;
@@ -1546,8 +1639,8 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         {
           id: memoryId,
           type: tableName,
-          content: sql13`${contentToInsert}::jsonb`,
-          metadata: sql13`${memory.metadata || {}}::jsonb`,
+          content: sql16`${contentToInsert}::jsonb`,
+          metadata: sql16`${memory.metadata || {}}::jsonb`,
           entityId: memory.entityId,
           roomId: memory.roomId,
           worldId: memory.worldId,
@@ -1588,12 +1681,12 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
           if (memory.content) {
             const contentToUpdate = typeof memory.content === "string" ? JSON.parse(memory.content) : memory.content;
             await tx.update(memoryTable).set({
-              content: sql13`${contentToUpdate}::jsonb`,
-              ...memory.metadata && { metadata: sql13`${memory.metadata}::jsonb` }
+              content: sql16`${contentToUpdate}::jsonb`,
+              ...memory.metadata && { metadata: sql16`${memory.metadata}::jsonb` }
             }).where(eq(memoryTable.id, memory.id));
           } else if (memory.metadata) {
             await tx.update(memoryTable).set({
-              metadata: sql13`${memory.metadata}::jsonb`
+              metadata: sql16`${memory.metadata}::jsonb`
             }).where(eq(memoryTable.id, memory.id));
           }
           if (memory.embedding && Array.isArray(memory.embedding)) {
@@ -1675,7 +1768,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     const fragments = await tx.select({ id: memoryTable.id }).from(memoryTable).where(
       and(
         eq(memoryTable.agentId, this.agentId),
-        sql13`${memoryTable.metadata}->>'documentId' = ${documentId}`
+        sql16`${memoryTable.metadata}->>'documentId' = ${documentId}`
       )
     );
     return fragments.map((f) => ({ id: f.id }));
@@ -1720,7 +1813,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       if (unique7) {
         conditions.push(eq(memoryTable.unique, true));
       }
-      const result = await this.db.select({ count: sql13`count(*)` }).from(memoryTable).where(and(...conditions));
+      const result = await this.db.select({ count: sql16`count(*)` }).from(memoryTable).where(and(...conditions));
       return Number(result[0]?.count ?? 0);
     });
   }
@@ -2113,7 +2206,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         ),
         eq(relationshipTable.agentId, this.agentId),
         ...params.tags && params.tags.length > 0 ? [
-          sql13`${relationshipTable.tags} @> ARRAY[${sql13.raw(
+          sql16`${relationshipTable.tags} @> ARRAY[${sql16.raw(
             params.tags.map((tag) => `'${tag.replace(/'/g, "''")}'`).join(", ")
           )}]::text[]`
         ] : []
@@ -2304,7 +2397,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
             eq(taskTable.agentId, this.agentId),
             ...params.roomId ? [eq(taskTable.roomId, params.roomId)] : [],
             ...params.tags && params.tags.length > 0 ? [
-              sql13`${taskTable.tags} @> ARRAY[${sql13.raw(
+              sql16`${taskTable.tags} @> ARRAY[${sql16.raw(
                 params.tags.map((t) => `'${t.replace(/'/g, "''")}'`).join(", ")
               )}]::text[]`
             ] : []
@@ -2458,6 +2551,296 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  // Message Server Database Operations
+  /**
+   * Creates a new message server in the central database
+   */
+  async createMessageServer(data) {
+    return this.withDatabase(async () => {
+      const newId = data.id || v4();
+      const now = /* @__PURE__ */ new Date();
+      const serverToInsert = {
+        id: newId,
+        name: data.name,
+        sourceType: data.sourceType,
+        sourceId: data.sourceId,
+        metadata: data.metadata,
+        createdAt: now,
+        updatedAt: now
+      };
+      await this.db.insert(messageServerTable).values(serverToInsert).onConflictDoNothing();
+      if (data.id) {
+        const existing = await this.db.select().from(messageServerTable).where(eq(messageServerTable.id, data.id)).limit(1);
+        if (existing.length > 0) {
+          return {
+            id: existing[0].id,
+            name: existing[0].name,
+            sourceType: existing[0].sourceType,
+            sourceId: existing[0].sourceId || void 0,
+            metadata: existing[0].metadata || void 0,
+            createdAt: existing[0].createdAt,
+            updatedAt: existing[0].updatedAt
+          };
+        }
+      }
+      return serverToInsert;
+    });
+  }
+  /**
+   * Gets all message servers
+   */
+  async getMessageServers() {
+    return this.withDatabase(async () => {
+      const results = await this.db.select().from(messageServerTable);
+      return results.map((r) => ({
+        id: r.id,
+        name: r.name,
+        sourceType: r.sourceType,
+        sourceId: r.sourceId || void 0,
+        metadata: r.metadata || void 0,
+        createdAt: r.createdAt,
+        updatedAt: r.updatedAt
+      }));
+    });
+  }
+  /**
+   * Gets a message server by ID
+   */
+  async getMessageServerById(serverId) {
+    return this.withDatabase(async () => {
+      const results = await this.db.select().from(messageServerTable).where(eq(messageServerTable.id, serverId)).limit(1);
+      return results.length > 0 ? {
+        id: results[0].id,
+        name: results[0].name,
+        sourceType: results[0].sourceType,
+        sourceId: results[0].sourceId || void 0,
+        metadata: results[0].metadata || void 0,
+        createdAt: results[0].createdAt,
+        updatedAt: results[0].updatedAt
+      } : null;
+    });
+  }
+  /**
+   * Creates a new channel
+   */
+  async createChannel(data, participantIds) {
+    return this.withDatabase(async () => {
+      const newId = data.id || v4();
+      const now = /* @__PURE__ */ new Date();
+      const channelToInsert = {
+        id: newId,
+        messageServerId: data.messageServerId,
+        name: data.name,
+        type: data.type,
+        sourceType: data.sourceType,
+        sourceId: data.sourceId,
+        topic: data.topic,
+        metadata: data.metadata,
+        createdAt: now,
+        updatedAt: now
+      };
+      await this.db.transaction(async (tx) => {
+        await tx.insert(channelTable).values(channelToInsert);
+        if (participantIds && participantIds.length > 0) {
+          const participantValues = participantIds.map((userId) => ({
+            channelId: newId,
+            userId
+          }));
+          await tx.insert(channelParticipantsTable).values(participantValues).onConflictDoNothing();
+        }
+      });
+      return channelToInsert;
+    });
+  }
+  /**
+   * Gets channels for a server
+   */
+  async getChannelsForServer(serverId) {
+    return this.withDatabase(async () => {
+      const results = await this.db.select().from(channelTable).where(eq(channelTable.messageServerId, serverId));
+      return results.map((r) => ({
+        id: r.id,
+        messageServerId: r.messageServerId,
+        name: r.name,
+        type: r.type,
+        sourceType: r.sourceType || void 0,
+        sourceId: r.sourceId || void 0,
+        topic: r.topic || void 0,
+        metadata: r.metadata || void 0,
+        createdAt: r.createdAt,
+        updatedAt: r.updatedAt
+      }));
+    });
+  }
+  /**
+   * Gets channel details
+   */
+  async getChannelDetails(channelId) {
+    return this.withDatabase(async () => {
+      const results = await this.db.select().from(channelTable).where(eq(channelTable.id, channelId)).limit(1);
+      return results.length > 0 ? {
+        id: results[0].id,
+        messageServerId: results[0].messageServerId,
+        name: results[0].name,
+        type: results[0].type,
+        sourceType: results[0].sourceType || void 0,
+        sourceId: results[0].sourceId || void 0,
+        topic: results[0].topic || void 0,
+        metadata: results[0].metadata || void 0,
+        createdAt: results[0].createdAt,
+        updatedAt: results[0].updatedAt
+      } : null;
+    });
+  }
+  /**
+   * Creates a message
+   */
+  async createMessage(data) {
+    return this.withDatabase(async () => {
+      const newId = v4();
+      const now = /* @__PURE__ */ new Date();
+      const messageToInsert = {
+        id: newId,
+        channelId: data.channelId,
+        authorId: data.authorId,
+        content: data.content,
+        rawMessage: data.rawMessage,
+        sourceType: data.sourceType,
+        sourceId: data.sourceId,
+        metadata: data.metadata,
+        inReplyToRootMessageId: data.inReplyToRootMessageId,
+        createdAt: now,
+        updatedAt: now
+      };
+      await this.db.insert(messageTable).values(messageToInsert);
+      return messageToInsert;
+    });
+  }
+  /**
+   * Gets messages for a channel
+   */
+  async getMessagesForChannel(channelId, limit = 50, beforeTimestamp) {
+    return this.withDatabase(async () => {
+      const conditions = [eq(messageTable.channelId, channelId)];
+      if (beforeTimestamp) {
+        conditions.push(lt(messageTable.createdAt, beforeTimestamp));
+      }
+      const query = this.db.select().from(messageTable).where(and(...conditions)).orderBy(desc(messageTable.createdAt)).limit(limit);
+      const results = await query;
+      return results.map((r) => ({
+        id: r.id,
+        channelId: r.channelId,
+        authorId: r.authorId,
+        content: r.content,
+        rawMessage: r.rawMessage || void 0,
+        sourceType: r.sourceType || void 0,
+        sourceId: r.sourceId || void 0,
+        metadata: r.metadata || void 0,
+        inReplyToRootMessageId: r.inReplyToRootMessageId,
+        createdAt: r.createdAt,
+        updatedAt: r.updatedAt
+      }));
+    });
+  }
+  /**
+   * Deletes a message
+   */
+  async deleteMessage(messageId) {
+    return this.withDatabase(async () => {
+      await this.db.delete(messageTable).where(eq(messageTable.id, messageId));
+    });
+  }
+  /**
+   * Adds participants to a channel
+   */
+  async addChannelParticipants(channelId, userIds) {
+    return this.withDatabase(async () => {
+      if (!userIds || userIds.length === 0) return;
+      const participantValues = userIds.map((userId) => ({
+        channelId,
+        userId
+      }));
+      await this.db.insert(channelParticipantsTable).values(participantValues).onConflictDoNothing();
+    });
+  }
+  /**
+   * Gets participants for a channel
+   */
+  async getChannelParticipants(channelId) {
+    return this.withDatabase(async () => {
+      const results = await this.db.select({ userId: channelParticipantsTable.userId }).from(channelParticipantsTable).where(eq(channelParticipantsTable.channelId, channelId));
+      return results.map((r) => r.userId);
+    });
+  }
+  /**
+   * Adds an agent to a server
+   */
+  async addAgentToServer(serverId, agentId) {
+    return this.withDatabase(async () => {
+      await this.db.insert(serverAgentsTable).values({
+        serverId,
+        agentId
+      }).onConflictDoNothing();
+    });
+  }
+  /**
+   * Gets agents for a server
+   */
+  async getAgentsForServer(serverId) {
+    return this.withDatabase(async () => {
+      const results = await this.db.select({ agentId: serverAgentsTable.agentId }).from(serverAgentsTable).where(eq(serverAgentsTable.serverId, serverId));
+      return results.map((r) => r.agentId);
+    });
+  }
+  /**
+   * Removes an agent from a server
+   */
+  async removeAgentFromServer(serverId, agentId) {
+    return this.withDatabase(async () => {
+      await this.db.delete(serverAgentsTable).where(
+        and(eq(serverAgentsTable.serverId, serverId), eq(serverAgentsTable.agentId, agentId))
+      );
+    });
+  }
+  /**
+   * Finds or creates a DM channel between two users
+   */
+  async findOrCreateDmChannel(user1Id, user2Id, messageServerId) {
+    return this.withDatabase(async () => {
+      const ids = [user1Id, user2Id].sort();
+      const dmChannelName = `DM-${ids[0]}-${ids[1]}`;
+      const existingChannels = await this.db.select().from(channelTable).where(
+        and(
+          eq(channelTable.type, ChannelType.DM),
+          eq(channelTable.name, dmChannelName),
+          eq(channelTable.messageServerId, messageServerId)
+        )
+      ).limit(1);
+      if (existingChannels.length > 0) {
+        return {
+          id: existingChannels[0].id,
+          messageServerId: existingChannels[0].messageServerId,
+          name: existingChannels[0].name,
+          type: existingChannels[0].type,
+          sourceType: existingChannels[0].sourceType || void 0,
+          sourceId: existingChannels[0].sourceId || void 0,
+          topic: existingChannels[0].topic || void 0,
+          metadata: existingChannels[0].metadata || void 0,
+          createdAt: existingChannels[0].createdAt,
+          updatedAt: existingChannels[0].updatedAt
+        };
+      }
+      return this.createChannel(
+        {
+          messageServerId,
+          name: dmChannelName,
+          type: ChannelType.DM,
+          metadata: { user1: ids[0], user2: ids[1] }
+        },
+        ids
+      );
+    });
+  }
 };
 
 // src/pglite/adapter.ts