@elizaos/server 1.6.4-alpha.14 → 1.6.4-alpha.16

package/dist/index.d.ts

@@ -57,6 +57,8 @@ export declare class AgentServer {
     private clientPath?;
     elizaOS?: ElizaOS;
     database: DatabaseAdapter;
+    private rlsOwnerId?;
+    serverId: UUID;
     loadCharacterTryPath: (characterPath: string) => Promise<Character>;
     jsonToCharacter: (character: unknown) => Promise<Character>;
     /**

package/dist/index.js

@@ -26420,7 +26420,6 @@ function transformMessageAttachments(message) {
 }
 
 // src/api/messaging/core.ts
-var DEFAULT_SERVER_ID = "00000000-0000-0000-0000-000000000000";
 function createMessagingCoreRouter(serverInstance) {
   const router = express10.Router();
   router.post("/submit", async (req, res) => {
@@ -26434,7 +26433,7 @@ function createMessagingCoreRouter(serverInstance) {
       raw_message,
       metadata
     } = req.body;
-    const isValidServerId = server_id === DEFAULT_SERVER_ID || validateUuid9(server_id);
+    const isValidServerId = server_id === serverInstance.serverId;
     if (!validateUuid9(channel_id) || !validateUuid9(author_id) || !content || !isValidServerId || !source_type || !raw_message) {
       return res.status(400).json({
         success: false,
@@ -26492,7 +26491,7 @@ function createMessagingCoreRouter(serverInstance) {
       raw_message,
       metadata
     } = req.body;
-    const isValidServerId = server_id === DEFAULT_SERVER_ID || validateUuid9(server_id);
+    const isValidServerId = server_id === serverInstance.serverId;
     if (!validateUuid9(channel_id) || !validateUuid9(author_id) || !content || !isValidServerId || !source_type || !raw_message) {
       return res.status(400).json({
         success: false,
@@ -26561,8 +26560,8 @@ function createMessagingCoreRouter(serverInstance) {
     if (author_id && !validateUuid9(author_id)) {
       return res.status(400).json({ success: false, error: "Invalid author_id format" });
     }
-    if (server_id && !(server_id === DEFAULT_SERVER_ID || validateUuid9(server_id))) {
-      return res.status(400).json({ success: false, error: "Invalid server_id format" });
+    if (server_id && server_id !== serverInstance.serverId) {
+      return res.status(403).json({ success: false, error: "Forbidden: server_id does not match current server" });
     }
     try {
       const updated = await serverInstance.updateMessage(id, {
@@ -26660,7 +26659,6 @@ function createMessagingCoreRouter(serverInstance) {
 // src/api/messaging/servers.ts
 import { logger as logger9, validateUuid as validateUuid10 } from "@elizaos/core";
 import express11 from "express";
-var DEFAULT_SERVER_ID2 = "00000000-0000-0000-0000-000000000000";
 function createServersRouter(serverInstance) {
   const router = express11.Router();
   router.get("/central-servers", async (_req, res) => {
@@ -26694,7 +26692,7 @@ function createServersRouter(serverInstance) {
     }
   });
   router.post("/servers/:serverId/agents", async (req, res) => {
-    const serverId = req.params.serverId === DEFAULT_SERVER_ID2 ? DEFAULT_SERVER_ID2 : validateUuid10(req.params.serverId);
+    const serverId = validateUuid10(req.params.serverId);
     const { agentId } = req.body;
     if (!serverId || !validateUuid10(agentId)) {
       return res.status(400).json({
@@ -26702,6 +26700,12 @@ function createServersRouter(serverInstance) {
         error: "Invalid serverId or agentId format"
       });
     }
+    if (serverId !== serverInstance.serverId) {
+      return res.status(403).json({
+        success: false,
+        error: "Cannot modify agents for a different server"
+      });
+    }
     try {
       await serverInstance.addAgentToServer(serverId, agentId);
       const messageForBus = {
@@ -26724,7 +26728,7 @@ function createServersRouter(serverInstance) {
     }
   });
   router.delete("/servers/:serverId/agents/:agentId", async (req, res) => {
-    const serverId = req.params.serverId === DEFAULT_SERVER_ID2 ? DEFAULT_SERVER_ID2 : validateUuid10(req.params.serverId);
+    const serverId = validateUuid10(req.params.serverId);
     const agentId = validateUuid10(req.params.agentId);
     if (!serverId || !agentId) {
       return res.status(400).json({
@@ -26732,6 +26736,12 @@ function createServersRouter(serverInstance) {
         error: "Invalid serverId or agentId format"
       });
     }
+    if (serverId !== serverInstance.serverId) {
+      return res.status(403).json({
+        success: false,
+        error: "Cannot modify agents for a different server"
+      });
+    }
     try {
       await serverInstance.removeAgentFromServer(serverId, agentId);
       const messageForBus = {
@@ -26754,13 +26764,19 @@ function createServersRouter(serverInstance) {
     }
   });
   router.get("/servers/:serverId/agents", async (req, res) => {
-    const serverId = req.params.serverId === DEFAULT_SERVER_ID2 ? DEFAULT_SERVER_ID2 : validateUuid10(req.params.serverId);
+    const serverId = validateUuid10(req.params.serverId);
     if (!serverId) {
       return res.status(400).json({
         success: false,
         error: "Invalid serverId format"
       });
     }
+    if (serverId !== serverInstance.serverId) {
+      return res.status(403).json({
+        success: false,
+        error: "Cannot access agents for a different server"
+      });
+    }
     try {
       const agents = await serverInstance.getAgentsForServer(serverId);
       res.json({
@@ -27603,7 +27619,6 @@ var ALLOWED_MEDIA_MIME_TYPES = [
 import multer from "multer";
 import fs from "fs";
 import path2 from "path";
-var DEFAULT_SERVER_ID3 = "00000000-0000-0000-0000-000000000000";
 var channelStorage = multer.memoryStorage();
 var channelUploadMiddleware = multer({
   storage: channelStorage,
@@ -27647,13 +27662,19 @@ function createChannelsRouter(elizaOS, serverInstance) {
       metadata,
       source_type
     } = req.body;
-    const isValidServerId = server_id === DEFAULT_SERVER_ID3 || validateUuid13(server_id);
-    if (!channelIdParam || !validateUuid13(author_id) || !content || !isValidServerId) {
+    const isValidServerId = server_id === serverInstance.serverId;
+    if (!channelIdParam || !validateUuid13(author_id) || !content || !validateUuid13(server_id)) {
       return res.status(400).json({
         success: false,
         error: "Missing required fields: channelId, server_id, author_id, content"
       });
     }
+    if (!isValidServerId) {
+      return res.status(403).json({
+        success: false,
+        error: "Forbidden: server_id does not match current server"
+      });
+    }
     try {
       logger15.info(`[Messages Router] Checking if channel ${channelIdParam} exists before creating message`);
       let channelExists = false;
@@ -27799,7 +27820,7 @@ function createChannelsRouter(elizaOS, serverInstance) {
     }
   });
   router.get("/central-servers/:serverId/channels", async (req, res) => {
-    const serverId = req.params.serverId === DEFAULT_SERVER_ID3 ? DEFAULT_SERVER_ID3 : validateUuid13(req.params.serverId);
+    const serverId = validateUuid13(req.params.serverId);
     if (!serverId) {
       return res.status(400).json({ success: false, error: "Invalid serverId" });
     }
@@ -27858,7 +27879,7 @@ function createChannelsRouter(elizaOS, serverInstance) {
   router.get("/dm-channel", async (req, res) => {
     const targetUserId = validateUuid13(req.query.targetUserId);
     const currentUserId = validateUuid13(req.query.currentUserId);
-    const providedDmServerId = req.query.dmServerId === DEFAULT_SERVER_ID3 ? DEFAULT_SERVER_ID3 : validateUuid13(req.query.dmServerId);
+    const providedDmServerId = validateUuid13(req.query.dmServerId);
     if (!targetUserId || !currentUserId) {
       res.status(400).json({ success: false, error: "Missing targetUserId or currentUserId" });
       return;
@@ -27867,15 +27888,15 @@ function createChannelsRouter(elizaOS, serverInstance) {
       res.status(400).json({ success: false, error: "Cannot create DM channel with oneself" });
       return;
     }
-    let dmServerIdToUse = DEFAULT_SERVER_ID3;
+    let dmServerIdToUse = serverInstance.serverId;
     try {
       if (providedDmServerId) {
         const existingServer = await serverInstance.getServerById(providedDmServerId);
         if (existingServer) {
           dmServerIdToUse = providedDmServerId;
         } else {
-          logger15.warn(`Provided dmServerId ${providedDmServerId} not found, using default DM server logic.`);
-          dmServerIdToUse = DEFAULT_SERVER_ID3;
+          logger15.warn(`Provided dmServerId ${providedDmServerId} not found, using current server ID.`);
+          dmServerIdToUse = serverInstance.serverId;
         }
       }
       const channel = await serverInstance.findOrCreateCentralDmChannel(currentUserId, targetUserId, dmServerIdToUse);
@@ -27898,13 +27919,25 @@ function createChannelsRouter(elizaOS, serverInstance) {
       server_id,
       metadata
     } = req.body;
-    const isValidServerId = server_id === DEFAULT_SERVER_ID3 || validateUuid13(server_id);
-    if (!name || !isValidServerId || !Array.isArray(participantCentralUserIds) || participantCentralUserIds.some((id) => !validateUuid13(id))) {
+    if (!validateUuid13(server_id)) {
+      return res.status(400).json({
+        success: false,
+        error: "Invalid server_id format"
+      });
+    }
+    const isValidServerId = server_id === serverInstance.serverId;
+    if (!name || !Array.isArray(participantCentralUserIds) || participantCentralUserIds.some((id) => !validateUuid13(id))) {
       return res.status(400).json({
         success: false,
         error: 'Invalid payload. Required: name, server_id (UUID or "0"), participantCentralUserIds (array of UUIDs). Optional: type, metadata.'
       });
     }
+    if (!isValidServerId) {
+      return res.status(403).json({
+        success: false,
+        error: "Forbidden: server_id does not match current server"
+      });
+    }
     try {
       const channelData = {
         messageServerId: server_id,
@@ -28542,7 +28575,6 @@ var DEFAULT_MAX_DURATION_MINUTES = safeParseInt(process.env.SESSION_MAX_DURATION
 var DEFAULT_WARNING_THRESHOLD_MINUTES = safeParseInt(process.env.SESSION_WARNING_THRESHOLD_MINUTES, 5, 1, 60);
 var CLEANUP_INTERVAL_MS = safeParseInt(process.env.SESSION_CLEANUP_INTERVAL_MINUTES, 5, 1, 60) * 60 * 1000;
 var sessions = new Map;
-var DEFAULT_SERVER_ID4 = "00000000-0000-0000-0000-000000000000";
 var agentTimeoutConfigs = new Map;
 var activeCleanupIntervals = new Set;
 var processHandlersRegistered = false;
@@ -28778,7 +28810,7 @@ function createSessionsRouter(elizaOS, serverInstance) {
         id: channelId,
         name: `session-${sessionId}`,
         type: ChannelType3.DM,
-        messageServerId: DEFAULT_SERVER_ID4,
+        messageServerId: serverInstance.serverId,
         metadata: {
           sessionId,
           agentId: body.agentId,
@@ -29208,7 +29240,7 @@ var JobValidation = {
 };
 
 // src/api/messaging/jobs.ts
-var DEFAULT_SERVER_ID5 = "00000000-0000-0000-0000-000000000000";
+var DEFAULT_SERVER_ID = "00000000-0000-0000-0000-000000000000";
 var JOB_CLEANUP_INTERVAL_MS = 60000;
 var ABSOLUTE_MAX_LISTENER_TIMEOUT_MS = 5 * 60 * 1000;
 var MAX_JOBS_IN_MEMORY = 1e4;
@@ -29411,7 +29443,7 @@ function createJobsRouter(elizaOS, serverInstance) {
           id: channelId,
           name: `job-${jobId}`,
           type: ChannelType4.DM,
-          messageServerId: DEFAULT_SERVER_ID5,
+          messageServerId: DEFAULT_SERVER_ID,
           metadata: {
             jobId,
             agentId,
@@ -29448,7 +29480,7 @@ function createJobsRouter(elizaOS, serverInstance) {
         bus_default.emit("new_message", {
           id: userMessage.id,
           channel_id: channelId,
-          server_id: DEFAULT_SERVER_ID5,
+          server_id: DEFAULT_SERVER_ID,
           author_id: userId,
           content: body.content,
           created_at: new Date(userMessage.createdAt).getTime(),
@@ -30624,7 +30656,7 @@ import express31 from "express";
 // package.json
 var package_default = {
   name: "@elizaos/server",
-  version: "1.6.4-alpha.14",
+  version: "1.6.4-alpha.16",
   description: "ElizaOS Server - Core server infrastructure for ElizaOS agents",
   publishConfig: {
     access: "public",
@@ -30744,8 +30776,6 @@ import {
   ChannelType as ChannelType7,
   EventType
 } from "@elizaos/core";
-var DEFAULT_SERVER_ID6 = "00000000-0000-0000-0000-000000000000";
-
 class SocketIORouter {
   elizaOS;
   connections;
@@ -30844,8 +30874,8 @@ class SocketIORouter {
     }
     socket.join(channelId);
     logger29.info(`[SocketIO] Socket ${socket.id} joined Socket.IO channel: ${channelId}`);
-    if (entityId && (serverId || DEFAULT_SERVER_ID6)) {
-      const finalServerId = serverId || DEFAULT_SERVER_ID6;
+    if (entityId && (serverId || this.serverInstance.serverId)) {
+      const finalServerId = serverId || this.serverInstance.serverId;
       const isDm = metadata?.isDm || metadata?.channelType === ChannelType7.DM;
       logger29.info(`[SocketIO] Emitting ENTITY_JOINED event for entityId: ${entityId}, serverId: ${finalServerId}, isDm: ${isDm}`);
       const runtime = this.elizaOS.getAgents()[0];
@@ -30867,7 +30897,7 @@ class SocketIORouter {
         logger29.warn(`[SocketIO] No runtime available to emit ENTITY_JOINED event`);
       }
     } else {
-      logger29.debug(`[SocketIO] Missing entityId (${entityId}) or serverId (${serverId || DEFAULT_SERVER_ID6}) - not emitting ENTITY_JOINED event`);
+      logger29.debug(`[SocketIO] Missing entityId (${entityId}) or serverId (${serverId || this.serverInstance.serverId}) - not emitting ENTITY_JOINED event`);
     }
     const successMessage = `Socket ${socket.id} successfully joined channel ${channelId}.`;
     const responsePayload = {
@@ -30885,7 +30915,7 @@ class SocketIORouter {
     const { senderId, senderName, message, serverId, source, metadata, attachments } = payload;
     logger29.info(`[SocketIO ${socket.id}] Received SEND_MESSAGE for central submission: channel ${channelId} from ${senderName || senderId}`);
     logger29.info(`[SocketIO ${socket.id}] Full payload for debugging:`, JSON.stringify(payload, null, 2));
-    const isValidServerId = serverId === DEFAULT_SERVER_ID6 || validateUuid23(serverId);
+    const isValidServerId = serverId === this.serverInstance.serverId || validateUuid23(serverId);
     if (!validateUuid23(channelId) || !isValidServerId || !validateUuid23(senderId) || !message) {
       this.sendErrorResponse(socket, `For SEND_MESSAGE: channelId, serverId (server_id), senderId (author_id), and message are required.`);
       return;
@@ -31313,16 +31343,27 @@ import {
   validateUuid as validateUuid25
 } from "@elizaos/core";
 var globalElizaOS = null;
+var globalAgentServer = null;
 function setGlobalElizaOS(elizaOS) {
   globalElizaOS = elizaOS;
   logger31.info("[MessageBusService] Global ElizaOS instance set");
 }
+function setGlobalAgentServer(agentServer) {
+  globalAgentServer = agentServer;
+  logger31.info("[MessageBusService] Global AgentServer instance set");
+}
 function getGlobalElizaOS() {
   if (!globalElizaOS) {
     throw new Error("ElizaOS not initialized. Call setGlobalElizaOS() before using MessageBusService.");
   }
   return globalElizaOS;
 }
+function getGlobalAgentServer() {
+  if (!globalAgentServer) {
+    throw new Error("AgentServer not initialized. Call setGlobalAgentServer() before using MessageBusService.");
+  }
+  return globalAgentServer;
+}
 
 class MessageBusService extends Service {
   static serviceType = "message-bus-service";
@@ -31332,8 +31373,10 @@ class MessageBusService extends Service {
   boundHandleMessageDeleted;
   boundHandleChannelCleared;
   subscribedServers = new Set;
+  serverInstance;
   constructor(runtime) {
     super(runtime);
+    this.serverInstance = getGlobalAgentServer();
     this.boundHandleIncomingMessage = (data) => {
       this.handleIncomingMessage(data).catch((error) => {
         logger31.error(`[${this.runtime.character.name}] Error handling incoming message:`, error instanceof Error ? error.message : String(error));
@@ -31366,9 +31409,8 @@ class MessageBusService extends Service {
     try {
       const serverApiUrl = this.getCentralMessageServerUrl();
       this.validChannelIds.clear();
-      const DEFAULT_SERVER_ID7 = "00000000-0000-0000-0000-000000000000";
       const serversToCheck = new Set(this.subscribedServers);
-      serversToCheck.add(DEFAULT_SERVER_ID7);
+      serversToCheck.add(this.serverInstance.serverId);
       for (const serverId of serversToCheck) {
         try {
           const channelsUrl = new URL(`/api/messaging/central-servers/${encodeURIComponent(serverId)}/channels`, serverApiUrl);
@@ -31444,20 +31486,17 @@ class MessageBusService extends Service {
         const data = await response.json();
         if (data.success && data.data?.servers) {
           this.subscribedServers = new Set(data.data.servers);
-          const DEFAULT_SERVER_ID7 = "00000000-0000-0000-0000-000000000000";
-          this.subscribedServers.add(DEFAULT_SERVER_ID7);
-          logger31.info(`[${this.runtime.character.name}] MessageBusService: Agent is subscribed to ${this.subscribedServers.size} servers (including default server)`);
+          this.subscribedServers.add(this.serverInstance.serverId);
+          logger31.info(`[${this.runtime.character.name}] MessageBusService: Agent is subscribed to ${this.subscribedServers.size} servers (including server ${this.serverInstance.serverId})`);
         }
       } else {
-        const DEFAULT_SERVER_ID7 = "00000000-0000-0000-0000-000000000000";
-        this.subscribedServers.add(DEFAULT_SERVER_ID7);
-        logger31.warn(`[${this.runtime.character.name}] MessageBusService: Failed to fetch agent servers, but added default server`);
+        this.subscribedServers.add(this.serverInstance.serverId);
+        logger31.warn(`[${this.runtime.character.name}] MessageBusService: Failed to fetch agent servers, but added server ${this.serverInstance.serverId}`);
       }
     } catch (error) {
       logger31.error(`[${this.runtime.character.name}] MessageBusService: Error fetching agent servers:`, error instanceof Error ? error.message : String(error));
-      const DEFAULT_SERVER_ID7 = "00000000-0000-0000-0000-000000000000";
-      this.subscribedServers.add(DEFAULT_SERVER_ID7);
-      logger31.info(`[${this.runtime.character.name}] MessageBusService: Added default server after error`);
+      this.subscribedServers.add(this.serverInstance.serverId);
+      logger31.info(`[${this.runtime.character.name}] MessageBusService: Added server ${this.serverInstance.serverId} after error`);
     }
   }
   async handleServerAgentUpdate(data) {
@@ -48493,8 +48532,632 @@ function _init2(options = {}, getDefaultIntegrationsImpl) {
   return client;
 }
 // src/index.ts
-import sqlPlugin, { createDatabaseAdapter, DatabaseMigrationService } from "@elizaos/plugin-sql";
+import sqlPlugin, {
+  createDatabaseAdapter,
+  DatabaseMigrationService,
+  installRLSFunctions,
+  getOrCreateRlsOwner,
+  setOwnerContext,
+  assignAgentToOwner,
+  applyRLSToNewTables,
+  uninstallRLS
+} from "@elizaos/plugin-sql";
 import { encryptedCharacter, stringToUuid as stringToUuid2 } from "@elizaos/core";
+
+// ../../node_modules/drizzle-orm/entity.js
+var entityKind = Symbol.for("drizzle:entityKind");
+var hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
+function is(value, type) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (value instanceof type) {
+    return true;
+  }
+  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
+    throw new Error(`Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`);
+  }
+  let cls = Object.getPrototypeOf(value).constructor;
+  if (cls) {
+    while (cls) {
+      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
+        return true;
+      }
+      cls = Object.getPrototypeOf(cls);
+    }
+  }
+  return false;
+}
+
+// ../../node_modules/drizzle-orm/column.js
+class Column {
+  constructor(table, config3) {
+    this.table = table;
+    this.config = config3;
+    this.name = config3.name;
+    this.keyAsName = config3.keyAsName;
+    this.notNull = config3.notNull;
+    this.default = config3.default;
+    this.defaultFn = config3.defaultFn;
+    this.onUpdateFn = config3.onUpdateFn;
+    this.hasDefault = config3.hasDefault;
+    this.primary = config3.primaryKey;
+    this.isUnique = config3.isUnique;
+    this.uniqueName = config3.uniqueName;
+    this.uniqueType = config3.uniqueType;
+    this.dataType = config3.dataType;
+    this.columnType = config3.columnType;
+    this.generated = config3.generated;
+    this.generatedIdentity = config3.generatedIdentity;
+  }
+  static [entityKind] = "Column";
+  name;
+  keyAsName;
+  primary;
+  notNull;
+  default;
+  defaultFn;
+  onUpdateFn;
+  hasDefault;
+  isUnique;
+  uniqueName;
+  uniqueType;
+  dataType;
+  columnType;
+  enumValues = undefined;
+  generated = undefined;
+  generatedIdentity = undefined;
+  config;
+  mapFromDriverValue(value) {
+    return value;
+  }
+  mapToDriverValue(value) {
+    return value;
+  }
+  shouldDisableInsert() {
+    return this.config.generated !== undefined && this.config.generated.type !== "byDefault";
+  }
+}
+
+// ../../node_modules/drizzle-orm/table.utils.js
+var TableName = Symbol.for("drizzle:Name");
+
+// ../../node_modules/drizzle-orm/tracing-utils.js
+function iife(fn, ...args) {
+  return fn(...args);
+}
+
+// ../../node_modules/drizzle-orm/pg-core/unique-constraint.js
+function uniqueKeyName(table, columns) {
+  return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+
+// ../../node_modules/drizzle-orm/pg-core/columns/common.js
+class PgColumn extends Column {
+  constructor(table, config3) {
+    if (!config3.uniqueName) {
+      config3.uniqueName = uniqueKeyName(table, [config3.name]);
+    }
+    super(table, config3);
+    this.table = table;
+  }
+  static [entityKind] = "PgColumn";
+}
+
+class ExtraConfigColumn extends PgColumn {
+  static [entityKind] = "ExtraConfigColumn";
+  getSQLType() {
+    return this.getSQLType();
+  }
+  indexConfig = {
+    order: this.config.order ?? "asc",
+    nulls: this.config.nulls ?? "last",
+    opClass: this.config.opClass
+  };
+  defaultConfig = {
+    order: "asc",
+    nulls: "last",
+    opClass: undefined
+  };
+  asc() {
+    this.indexConfig.order = "asc";
+    return this;
+  }
+  desc() {
+    this.indexConfig.order = "desc";
+    return this;
+  }
+  nullsFirst() {
+    this.indexConfig.nulls = "first";
+    return this;
+  }
+  nullsLast() {
+    this.indexConfig.nulls = "last";
+    return this;
+  }
+  op(opClass) {
+    this.indexConfig.opClass = opClass;
+    return this;
+  }
+}
+
+// ../../node_modules/drizzle-orm/pg-core/columns/enum.js
+class PgEnumObjectColumn extends PgColumn {
+  static [entityKind] = "PgEnumObjectColumn";
+  enum;
+  enumValues = this.config.enum.enumValues;
+  constructor(table, config3) {
+    super(table, config3);
+    this.enum = config3.enum;
+  }
+  getSQLType() {
+    return this.enum.enumName;
+  }
+}
+var isPgEnumSym = Symbol.for("drizzle:isPgEnum");
+function isPgEnum(obj) {
+  return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
+}
+class PgEnumColumn extends PgColumn {
+  static [entityKind] = "PgEnumColumn";
+  enum = this.config.enum;
+  enumValues = this.config.enum.enumValues;
+  constructor(table, config3) {
+    super(table, config3);
+    this.enum = config3.enum;
+  }
+  getSQLType() {
+    return this.enum.enumName;
+  }
+}
+
+// ../../node_modules/drizzle-orm/subquery.js
+class Subquery {
+  static [entityKind] = "Subquery";
+  constructor(sql, fields, alias, isWith = false, usedTables = []) {
+    this._ = {
+      brand: "Subquery",
+      sql,
+      selectedFields: fields,
+      alias,
+      isWith,
+      usedTables
+    };
+  }
+}
+
+// ../../node_modules/drizzle-orm/version.js
+var version = "0.44.7";
+
+// ../../node_modules/drizzle-orm/tracing.js
+var otel;
+var rawTracer;
+var tracer = {
+  startActiveSpan(name, fn) {
+    if (!otel) {
+      return fn();
+    }
+    if (!rawTracer) {
+      rawTracer = otel.trace.getTracer("drizzle-orm", version);
+    }
+    return iife((otel2, rawTracer2) => rawTracer2.startActiveSpan(name, (span) => {
+      try {
+        return fn(span);
+      } catch (e) {
+        span.setStatus({
+          code: otel2.SpanStatusCode.ERROR,
+          message: e instanceof Error ? e.message : "Unknown error"
+        });
+        throw e;
+      } finally {
+        span.end();
+      }
+    }), otel, rawTracer);
+  }
+};
+
+// ../../node_modules/drizzle-orm/view-common.js
+var ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
+
+// ../../node_modules/drizzle-orm/table.js
+var Schema = Symbol.for("drizzle:Schema");
+var Columns = Symbol.for("drizzle:Columns");
+var ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
+var OriginalName = Symbol.for("drizzle:OriginalName");
+var BaseName = Symbol.for("drizzle:BaseName");
+var IsAlias = Symbol.for("drizzle:IsAlias");
+var ExtraConfigBuilder = Symbol.for("drizzle:ExtraConfigBuilder");
+var IsDrizzleTable = Symbol.for("drizzle:IsDrizzleTable");
+
+class Table {
+  static [entityKind] = "Table";
+  static Symbol = {
+    Name: TableName,
+    Schema,
+    OriginalName,
+    Columns,
+    ExtraConfigColumns,
+    BaseName,
+    IsAlias,
+    ExtraConfigBuilder
+  };
+  [TableName];
+  [OriginalName];
+  [Schema];
+  [Columns];
+  [ExtraConfigColumns];
+  [BaseName];
+  [IsAlias] = false;
+  [IsDrizzleTable] = true;
+  [ExtraConfigBuilder] = undefined;
+  constructor(name, schema, baseName) {
+    this[TableName] = this[OriginalName] = name;
+    this[Schema] = schema;
+    this[BaseName] = baseName;
+  }
+}
+
+// ../../node_modules/drizzle-orm/sql/sql.js
+function isSQLWrapper(value) {
+  return value !== null && value !== undefined && typeof value.getSQL === "function";
+}
+function mergeQueries(queries) {
+  const result = { sql: "", params: [] };
+  for (const query of queries) {
+    result.sql += query.sql;
+    result.params.push(...query.params);
+    if (query.typings?.length) {
+      if (!result.typings) {
+        result.typings = [];
+      }
+      result.typings.push(...query.typings);
+    }
+  }
+  return result;
+}
+
+class StringChunk {
+  static [entityKind] = "StringChunk";
+  value;
+  constructor(value) {
+    this.value = Array.isArray(value) ? value : [value];
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+
+class SQL {
+  constructor(queryChunks) {
+    this.queryChunks = queryChunks;
+    for (const chunk of queryChunks) {
+      if (is(chunk, Table)) {
+        const schemaName = chunk[Table.Symbol.Schema];
+        this.usedTables.push(schemaName === undefined ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]);
+      }
+    }
+  }
+  static [entityKind] = "SQL";
+  decoder = noopDecoder;
+  shouldInlineParams = false;
+  usedTables = [];
+  append(query) {
+    this.queryChunks.push(...query.queryChunks);
+    return this;
+  }
+  toQuery(config3) {
+    return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
+      const query = this.buildQueryFromSourceParams(this.queryChunks, config3);
+      span?.setAttributes({
+        "drizzle.query.text": query.sql,
+        "drizzle.query.params": JSON.stringify(query.params)
+      });
+      return query;
+    });
+  }
+  buildQueryFromSourceParams(chunks, _config) {
+    const config3 = Object.assign({}, _config, {
+      inlineParams: _config.inlineParams || this.shouldInlineParams,
+      paramStartIndex: _config.paramStartIndex || { value: 0 }
+    });
+    const {
+      casing,
+      escapeName,
+      escapeParam,
+      prepareTyping,
+      inlineParams,
+      paramStartIndex
+    } = config3;
+    return mergeQueries(chunks.map((chunk) => {
+      if (is(chunk, StringChunk)) {
+        return { sql: chunk.value.join(""), params: [] };
+      }
+      if (is(chunk, Name)) {
+        return { sql: escapeName(chunk.value), params: [] };
+      }
+      if (chunk === undefined) {
+        return { sql: "", params: [] };
+      }
+      if (Array.isArray(chunk)) {
+        const result = [new StringChunk("(")];
+        for (const [i, p] of chunk.entries()) {
+          result.push(p);
+          if (i < chunk.length - 1) {
+            result.push(new StringChunk(", "));
+          }
+        }
+        result.push(new StringChunk(")"));
+        return this.buildQueryFromSourceParams(result, config3);
+      }
+      if (is(chunk, SQL)) {
+        return this.buildQueryFromSourceParams(chunk.queryChunks, {
+          ...config3,
+          inlineParams: inlineParams || chunk.shouldInlineParams
+        });
+      }
+      if (is(chunk, Table)) {
+        const schemaName = chunk[Table.Symbol.Schema];
+        const tableName = chunk[Table.Symbol.Name];
+        return {
+          sql: schemaName === undefined || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
+          params: []
+        };
+      }
+      if (is(chunk, Column)) {
+        const columnName = casing.getColumnCasing(chunk);
+        if (_config.invokeSource === "indexes") {
+          return { sql: escapeName(columnName), params: [] };
+        }
+        const schemaName = chunk.table[Table.Symbol.Schema];
+        return {
+          sql: chunk.table[IsAlias] || schemaName === undefined ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
+          params: []
+        };
+      }
+      if (is(chunk, View)) {
+        const schemaName = chunk[ViewBaseConfig].schema;
+        const viewName = chunk[ViewBaseConfig].name;
+        return {
+          sql: schemaName === undefined || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
+          params: []
+        };
+      }
+      if (is(chunk, Param)) {
+        if (is(chunk.value, Placeholder)) {
+          return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+        }
+        const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
+        if (is(mappedValue, SQL)) {
+          return this.buildQueryFromSourceParams([mappedValue], config3);
+        }
+        if (inlineParams) {
+          return { sql: this.mapInlineParam(mappedValue, config3), params: [] };
+        }
+        let typings = ["none"];
+        if (prepareTyping) {
+          typings = [prepareTyping(chunk.encoder)];
+        }
+        return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
+      }
+      if (is(chunk, Placeholder)) {
+        return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+      }
+      if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== undefined) {
+        return { sql: escapeName(chunk.fieldAlias), params: [] };
+      }
+      if (is(chunk, Subquery)) {
+        if (chunk._.isWith) {
+          return { sql: escapeName(chunk._.alias), params: [] };
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk._.sql,
+          new StringChunk(") "),
+          new Name(chunk._.alias)
+        ], config3);
+      }
+      if (isPgEnum(chunk)) {
+        if (chunk.schema) {
+          return { sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName), params: [] };
+        }
+        return { sql: escapeName(chunk.enumName), params: [] };
+      }
+      if (isSQLWrapper(chunk)) {
+        if (chunk.shouldOmitSQLParens?.()) {
+          return this.buildQueryFromSourceParams([chunk.getSQL()], config3);
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk.getSQL(),
+          new StringChunk(")")
+        ], config3);
+      }
+      if (inlineParams) {
+        return { sql: this.mapInlineParam(chunk, config3), params: [] };
+      }
+      return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+    }));
+  }
+  mapInlineParam(chunk, { escapeString }) {
+    if (chunk === null) {
+      return "null";
+    }
+    if (typeof chunk === "number" || typeof chunk === "boolean") {
+      return chunk.toString();
+    }
+    if (typeof chunk === "string") {
+      return escapeString(chunk);
+    }
+    if (typeof chunk === "object") {
+      const mappedValueAsString = chunk.toString();
+      if (mappedValueAsString === "[object Object]") {
+        return escapeString(JSON.stringify(chunk));
+      }
+      return escapeString(mappedValueAsString);
+    }
+    throw new Error("Unexpected param value: " + chunk);
+  }
+  getSQL() {
+    return this;
+  }
+  as(alias) {
+    if (alias === undefined) {
+      return this;
+    }
+    return new SQL.Aliased(this, alias);
+  }
+  mapWith(decoder) {
+    this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
+    return this;
+  }
+  inlineParams() {
+    this.shouldInlineParams = true;
+    return this;
+  }
+  if(condition) {
+    return condition ? this : undefined;
+  }
+}
+
+class Name {
+  constructor(value) {
+    this.value = value;
+  }
+  static [entityKind] = "Name";
+  brand;
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+var noopDecoder = {
+  mapFromDriverValue: (value) => value
+};
+var noopEncoder = {
+  mapToDriverValue: (value) => value
+};
+var noopMapper = {
+  ...noopDecoder,
+  ...noopEncoder
+};
+
+class Param {
+  constructor(value, encoder = noopEncoder) {
+    this.value = value;
+    this.encoder = encoder;
+  }
+  static [entityKind] = "Param";
+  brand;
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+function sql(strings, ...params) {
+  const queryChunks = [];
+  if (params.length > 0 || strings.length > 0 && strings[0] !== "") {
+    queryChunks.push(new StringChunk(strings[0]));
+  }
+  for (const [paramIndex, param2] of params.entries()) {
+    queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
+  }
+  return new SQL(queryChunks);
+}
+((sql2) => {
+  function empty() {
+    return new SQL([]);
+  }
+  sql2.empty = empty;
+  function fromList(list) {
+    return new SQL(list);
+  }
+  sql2.fromList = fromList;
+  function raw(str) {
+    return new SQL([new StringChunk(str)]);
+  }
+  sql2.raw = raw;
+  function join4(chunks, separator) {
+    const result = [];
+    for (const [i, chunk] of chunks.entries()) {
+      if (i > 0 && separator !== undefined) {
+        result.push(separator);
+      }
+      result.push(chunk);
+    }
+    return new SQL(result);
+  }
+  sql2.join = join4;
+  function identifier(value) {
+    return new Name(value);
+  }
+  sql2.identifier = identifier;
+  function placeholder2(name2) {
+    return new Placeholder(name2);
+  }
+  sql2.placeholder = placeholder2;
+  function param2(value, encoder) {
+    return new Param(value, encoder);
+  }
+  sql2.param = param2;
+})(sql || (sql = {}));
+((SQL2) => {
+
+  class Aliased {
+    constructor(sql2, fieldAlias) {
+      this.sql = sql2;
+      this.fieldAlias = fieldAlias;
+    }
+    static [entityKind] = "SQL.Aliased";
+    isSelectionField = false;
+    getSQL() {
+      return this.sql;
+    }
+    clone() {
+      return new Aliased(this.sql, this.fieldAlias);
+    }
+  }
+  SQL2.Aliased = Aliased;
+})(SQL || (SQL = {}));
+
+class Placeholder {
+  constructor(name2) {
+    this.name = name2;
+  }
+  static [entityKind] = "Placeholder";
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+var IsDrizzleView = Symbol.for("drizzle:IsDrizzleView");
+
+class View {
+  static [entityKind] = "View";
+  [ViewBaseConfig];
+  [IsDrizzleView] = true;
+  constructor({ name: name2, schema, selectedFields, query }) {
+    this[ViewBaseConfig] = {
+      name: name2,
+      originalName: name2,
+      schema,
+      selectedFields,
+      query,
+      isExisting: !query,
+      isAlias: false
+    };
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+Column.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Table.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Subquery.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+
+// src/index.ts
 import { existsSync as existsSync4 } from "node:fs";
 var import_dotenv2 = __toESM(require_main(), 1);
 import { ElizaOS as ElizaOS4 } from "@elizaos/core";
@@ -48535,7 +49198,7 @@ function resolvePgliteDir(dir, fallbackDir) {
   return resolved;
 }
 var __dirname3 = dirname3(fileURLToPath2(import.meta.url));
-var DEFAULT_SERVER_ID7 = "00000000-0000-0000-0000-000000000000";
+var DEFAULT_SERVER_ID2 = "00000000-0000-0000-0000-000000000000";
 function isWebUIEnabled() {
   const isProduction = false;
   const uiEnabledEnv = process.env.ELIZA_UI_ENABLE;
@@ -48554,6 +49217,8 @@ class AgentServer {
   clientPath;
   elizaOS;
   database;
+  rlsOwnerId;
+  serverId = DEFAULT_SERVER_ID2;
   loadCharacterTryPath;
   jsonToCharacter;
   async startAgents(agents, options) {
@@ -48585,6 +49250,9 @@ class AgentServer {
               });
               logger33.info(`Persisted agent ${runtime.character.name} (${runtime.agentId}) to database`);
             }
+            if (this.rlsOwnerId) {
+              await assignAgentToOwner(this.database, runtime.agentId, this.rlsOwnerId);
+            }
           } catch (error2) {
             logger33.error({ error: error2 }, `Failed to persist agent ${runtime.agentId} to database`);
           }
@@ -48657,6 +49325,43 @@ class AgentServer {
         logger33.error({ error: migrationError }, "[INIT] Failed to run database migrations:");
         throw new Error(`Database migration failed: ${migrationError instanceof Error ? migrationError.message : String(migrationError)}`);
       }
+      const rlsEnabled = process.env.ENABLE_RLS_ISOLATION === "true";
+      const rlsOwnerIdString = process.env.RLS_OWNER_ID;
+      if (rlsEnabled) {
+        if (!config3?.postgresUrl) {
+          logger33.error("[RLS] ENABLE_RLS_ISOLATION requires PostgreSQL (not compatible with PGLite)");
+          throw new Error("RLS isolation requires PostgreSQL database");
+        }
+        if (!rlsOwnerIdString) {
+          logger33.error("[RLS] ENABLE_RLS_ISOLATION requires RLS_OWNER_ID environment variable");
+          throw new Error("RLS_OWNER_ID environment variable is required when RLS is enabled");
+        }
+        const owner_id = stringToUuid2(rlsOwnerIdString);
+        logger33.info("[INIT] Initializing RLS multi-tenant isolation...");
+        logger33.info(`[RLS] Tenant ID: ${owner_id.slice(0, 8)}… (from RLS_OWNER_ID="${rlsOwnerIdString}")`);
+        logger33.warn("[RLS] Ensure your PostgreSQL user is NOT a superuser!");
+        logger33.warn("[RLS] Superusers bypass ALL RLS policies, defeating isolation.");
+        try {
+          await installRLSFunctions(this.database);
+          await getOrCreateRlsOwner(this.database, owner_id);
+          this.rlsOwnerId = owner_id;
+          await setOwnerContext(this.database, owner_id);
+          await applyRLSToNewTables(this.database);
+          logger33.success("[INIT] RLS multi-tenant isolation initialized successfully");
+        } catch (rlsError) {
+          logger33.error({ error: rlsError }, "[INIT] Failed to initialize RLS:");
+          throw new Error(`RLS initialization failed: ${rlsError instanceof Error ? rlsError.message : String(rlsError)}`);
+        }
+      } else if (config3?.postgresUrl) {
+        logger33.info("[INIT] RLS multi-tenant isolation disabled (legacy mode)");
+        try {
+          logger33.info("[INIT] Cleaning up RLS policies and functions...");
+          await uninstallRLS(this.database);
+          logger33.success("[INIT] RLS cleanup completed");
+        } catch (cleanupError) {
+          logger33.debug("[INIT] RLS cleanup skipped (RLS not installed or already cleaned)");
+        }
+      }
       await new Promise((resolve2) => setTimeout(resolve2, 500));
       logger33.info("[INIT] Ensuring default server exists...");
       await this.ensureDefaultServer();
@@ -48667,6 +49372,7 @@ class AgentServer {
       this.elizaOS = new ElizaOS3;
       this.elizaOS.enableEditableMode();
       setGlobalElizaOS(this.elizaOS);
+      setGlobalAgentServer(this);
       logger33.success("[INIT] ElizaOS initialized");
       await this.initializeServer(config3);
       await new Promise((resolve2) => setTimeout(resolve2, 250));
@@ -48679,36 +49385,42 @@ class AgentServer {
   }
   async ensureDefaultServer() {
     try {
-      logger33.info("[AgentServer] Checking for default server...");
+      const rlsEnabled = process.env.ENABLE_RLS_ISOLATION === "true";
+      this.serverId = rlsEnabled && this.rlsOwnerId ? this.rlsOwnerId : "00000000-0000-0000-0000-000000000000";
+      const serverName = rlsEnabled && this.rlsOwnerId ? `Server ${this.rlsOwnerId.substring(0, 8)}` : "Default Server";
+      logger33.info(`[AgentServer] Checking for server ${this.serverId}...`);
       const servers = await this.database.getMessageServers();
       logger33.debug(`[AgentServer] Found ${servers.length} existing servers`);
       servers.forEach((s) => {
         logger33.debug(`[AgentServer] Existing server: ID=${s.id}, Name=${s.name}`);
       });
-      const defaultServer = servers.find((s) => s.id === "00000000-0000-0000-0000-000000000000");
+      const defaultServer = servers.find((s) => s.id === this.serverId);
       if (!defaultServer) {
-        logger33.info("[AgentServer] Creating default server with UUID 00000000-0000-0000-0000-000000000000...");
+        logger33.info(`[AgentServer] Creating server with UUID ${this.serverId}...`);
         try {
-          await this.database.db.execute(`
+          const db = this.database.db;
+          await db.execute(sql`
             INSERT INTO message_servers (id, name, source_type, created_at, updated_at)
-            VALUES ('00000000-0000-0000-0000-000000000000', 'Default Server', 'eliza_default', NOW(), NOW())
+            VALUES (${this.serverId}, ${serverName}, ${"eliza_default"}, NOW(), NOW())
             ON CONFLICT (id) DO NOTHING
           `);
-          logger33.success("[AgentServer] Default server created via raw SQL");
-          const checkResult = await this.database.db.execute("SELECT id, name FROM message_servers WHERE id = '00000000-0000-0000-0000-000000000000'");
-          logger33.debug("[AgentServer] Raw SQL check result:", checkResult);
+          logger33.success("[AgentServer] Server created via parameterized query");
+          const checkResult = await db.execute(sql`
+            SELECT id, name FROM message_servers WHERE id = ${this.serverId}
+          `);
+          logger33.debug("[AgentServer] Parameterized query check result:", checkResult);
         } catch (sqlError) {
           logger33.error("[AgentServer] Raw SQL insert failed:", sqlError);
           try {
             const server = await this.database.createMessageServer({
-              id: "00000000-0000-0000-0000-000000000000",
-              name: "Default Server",
+              id: this.serverId,
+              name: serverName,
               sourceType: "eliza_default"
             });
-            logger33.success("[AgentServer] Default server created via ORM with ID:", server.id);
+            logger33.success("[AgentServer] Server created via ORM with ID:", server.id);
           } catch (ormError) {
             logger33.error("[AgentServer] Both SQL and ORM creation failed:", ormError);
-            throw new Error(`Failed to create default server: ${ormError.message}`);
+            throw new Error(`Failed to create server: ${ormError.message}`);
           }
         }
         const verifyServers = await this.database.getMessageServers();
@@ -48716,14 +49428,14 @@ class AgentServer {
         verifyServers.forEach((s) => {
           logger33.debug(`[AgentServer] Server after creation: ID=${s.id}, Name=${s.name}`);
         });
-        const verifyDefault = verifyServers.find((s) => s.id === "00000000-0000-0000-0000-000000000000");
+        const verifyDefault = verifyServers.find((s) => s.id === this.serverId);
         if (!verifyDefault) {
-          throw new Error(`Failed to create or verify default server with ID ${DEFAULT_SERVER_ID7}`);
+          throw new Error(`Failed to create or verify server with ID ${this.serverId}`);
         } else {
-          logger33.success("[AgentServer] Default server creation verified successfully");
+          logger33.success("[AgentServer] Server creation verified successfully");
         }
       } else {
-        logger33.info("[AgentServer] Default server already exists with ID:", defaultServer.id);
+        logger33.info("[AgentServer] Server already exists with ID:", defaultServer.id);
       }
     } catch (error2) {
       logger33.error({ error: error2 }, "[AgentServer] Error ensuring default server:");
@@ -49030,8 +49742,8 @@ class AgentServer {
                 const nvmPath = path8.join(os3.homedir(), ".nvm/versions/node");
                 if (existsSync4(nvmPath)) {
                   const versions = fs6.readdirSync(nvmPath);
-                  for (const version of versions) {
-                    const cliPath = path8.join(nvmPath, version, "lib/node_modules/@elizaos/server/dist/client");
+                  for (const version2 of versions) {
+                    const cliPath = path8.join(nvmPath, version2, "lib/node_modules/@elizaos/server/dist/client");
                     if (existsSync4(path8.join(cliPath, "index.html"))) {
                       return cliPath;
                     }
@@ -49213,8 +49925,8 @@ class AgentServer {
         }
       }
       logger33.success(`Successfully registered agent ${runtime.character.name} (${runtime.agentId}) with core services.`);
-      await this.addAgentToServer(DEFAULT_SERVER_ID7, runtime.agentId);
-      logger33.info(`[AgentServer] Auto-associated agent ${runtime.character.name} with server ID: ${DEFAULT_SERVER_ID7}`);
+      await this.addAgentToServer(this.serverId, runtime.agentId);
+      logger33.info(`[AgentServer] Auto-associated agent ${runtime.character.name} with server ID: ${this.serverId}`);
     } catch (error2) {
       logger33.error({ error: error2 }, "Failed to register agent:");
       throw error2;

package/dist/services/message.d.ts

@@ -1,10 +1,16 @@
 import { Service, type Content, type IAgentRuntime, type Plugin, type UUID, ElizaOS } from '@elizaos/core';
 import type { MessageMetadata } from '@elizaos/api-client';
+import type { AgentServer } from '../index.js';
 /**
  * Set the global ElizaOS instance
  * Should be called by AgentServer during initialization
  */
 export declare function setGlobalElizaOS(elizaOS: ElizaOS): void;
+/**
+ * Set the global AgentServer instance
+ * Should be called by AgentServer during initialization
+ */
+export declare function setGlobalAgentServer(agentServer: AgentServer): void;
 export interface MessageServiceMessage {
     id: UUID;
     channel_id: UUID;
@@ -27,6 +33,7 @@ export declare class MessageBusService extends Service {
     private boundHandleMessageDeleted;
     private boundHandleChannelCleared;
     private subscribedServers;
+    private serverInstance;
     constructor(runtime: IAgentRuntime);
     static start(runtime: IAgentRuntime): Promise<Service>;
     static stop(runtime: IAgentRuntime): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elizaos/server",
-  "version": "1.6.4-alpha.14",
+  "version": "1.6.4-alpha.16",
   "description": "ElizaOS Server - Core server infrastructure for ElizaOS agents",
   "publishConfig": {
     "access": "public",
@@ -44,7 +44,7 @@
     "dev": "bun run build.ts --watch"
   },
   "devDependencies": {
-    "@elizaos/client": "1.6.4-alpha.14",
+    "@elizaos/client": "1.6.4-alpha.16",
     "@types/node": "^24.0.1",
     "prettier": "3.6.2",
     "tsx": "4.20.6",
@@ -52,10 +52,10 @@
     "which": "^5.0.0",
     "ws": "^8.18.0"
   },
-  "gitHead": "2008059da01bd9a89c480e28a30d4aa27dd9840f",
+  "gitHead": "23eb854811f3a84b324c0daea12adad45c5ae2b0",
   "dependencies": {
-    "@elizaos/core": "1.6.4-alpha.14",
-    "@elizaos/plugin-sql": "1.6.4-alpha.14",
+    "@elizaos/core": "1.6.4-alpha.16",
+    "@elizaos/plugin-sql": "1.6.4-alpha.16",
     "@sentry/node": "^10.16.0",
     "@types/express": "^5.0.2",
     "@types/helmet": "^4.0.0",