@elizaos/server 1.3.0 → 1.3.2

package/dist/index.js

@@ -385,10 +385,10 @@ var require_lib = __commonJS({
 // src/index.ts
 var import_cors2 = __toESM(require_lib(), 1);
 import {
-  logger as logger29,
+  logger as logger30,
   parseBooleanFromText
 } from "@elizaos/core";
-import express31 from "express";
+import express32 from "express";
 import helmet2 from "helmet";
 import * as fs9 from "fs";
 import http from "http";
@@ -398,8 +398,8 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/api/index.ts
 var import_cors = __toESM(require_lib(), 1);
-import { logger as logger25, validateUuid as validateUuid21 } from "@elizaos/core";
-import express30 from "express";
+import { logger as logger26, validateUuid as validateUuid22 } from "@elizaos/core";
+import express31 from "express";
 import helmet from "helmet";
 import { match } from "path-to-regexp";
 import { Server as SocketIOServer } from "socket.io";
@@ -1149,9 +1149,9 @@ function createAgentMemoryRouter(agents) {
       if (!runtime) {
         return sendError(res, 404, "NOT_FOUND", "Agent not found");
       }
-      const deletedCount = (await runtime.getAllMemories()).length;
+      const deleted = (await runtime.getAllMemories()).length;
       await runtime.clearAllAgentMemories();
-      sendSuccess(res, { deletedCount, message: "All agent memories cleared successfully" });
+      sendSuccess(res, { deleted, message: "All agent memories cleared successfully" });
     } catch (error) {
       logger6.error("[DELETE ALL AGENT MEMORIES] Error deleting all agent memories:", error);
       sendError(
@@ -1377,7 +1377,7 @@ function agentsRouter(agents, serverInstance) {
 }
 
 // src/api/messaging/index.ts
-import express12 from "express";
+import express13 from "express";
 
 // src/api/messaging/core.ts
 import { logger as logger8, validateUuid as validateUuid8 } from "@elizaos/core";
@@ -2800,24 +2800,384 @@ Respond with just the title, nothing else.
   return router;
 }
 
+// src/api/messaging/sessions.ts
+import { logger as logger13, validateUuid as validateUuid13, ChannelType as ChannelType3 } from "@elizaos/core";
+import express12 from "express";
+
+// ../../node_modules/uuid/dist/esm/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+// ../../node_modules/uuid/dist/esm/rng.js
+import { randomFillSync } from "crypto";
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// ../../node_modules/uuid/dist/esm/native.js
+import { randomUUID } from "crypto";
+var native_default = { randomUUID };
+
+// ../../node_modules/uuid/dist/esm/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// src/api/messaging/sessions.ts
+var SESSION_TIMEOUT_MS = parseInt(process.env.SESSION_TIMEOUT_MINUTES || "30") * 60 * 1e3;
+var sessions = /* @__PURE__ */ new Map();
+var DEFAULT_SERVER_ID4 = "00000000-0000-0000-0000-000000000000";
+var MAX_CONTENT_LENGTH = 4e3;
+var MAX_METADATA_SIZE = 1024 * 10;
+var MAX_LIMIT = 100;
+var DEFAULT_LIMIT = 50;
+function validateMetadata(metadata) {
+  if (!metadata || typeof metadata !== "object") {
+    return true;
+  }
+  const metadataStr = JSON.stringify(metadata);
+  if (metadataStr.length > MAX_METADATA_SIZE) {
+    throw new Error(`Metadata exceeds maximum size of ${MAX_METADATA_SIZE} bytes`);
+  }
+  return true;
+}
+function validateContent(content) {
+  if (typeof content !== "string") {
+    throw new Error("Content must be a string");
+  }
+  if (content.length === 0) {
+    throw new Error("Content cannot be empty");
+  }
+  if (content.length > MAX_CONTENT_LENGTH) {
+    throw new Error(`Content exceeds maximum length of ${MAX_CONTENT_LENGTH} characters`);
+  }
+  return true;
+}
+function errorResponse(res, status, message, details) {
+  logger13.error(`[Sessions API] Error: ${message}`, details);
+  return res.status(status).json({
+    error: message,
+    details: process.env.NODE_ENV === "development" ? details : void 0
+  });
+}
+function createSessionsRouter(agents, serverInstance) {
+  const router = express12.Router();
+  router.get("/sessions/health", (_req, res) => {
+    const response = {
+      status: "healthy",
+      activeSessions: sessions.size,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    res.json(response);
+  });
+  router.post("/sessions", async (req, res) => {
+    try {
+      const body = req.body;
+      if (!body.agentId || !body.userId) {
+        return errorResponse(res, 400, "Missing required fields: agentId and userId");
+      }
+      if (!validateUuid13(body.agentId) || !validateUuid13(body.userId)) {
+        return errorResponse(res, 400, "Invalid UUID format for agentId or userId");
+      }
+      const agent = agents.get(body.agentId);
+      if (!agent) {
+        return errorResponse(res, 404, "Agent not found");
+      }
+      if (body.metadata && !validateMetadata(body.metadata)) {
+        return errorResponse(res, 400, "Invalid metadata");
+      }
+      const sessionId = v4_default();
+      const channelId = v4_default();
+      await serverInstance.createChannel({
+        id: channelId,
+        name: `session-${sessionId}`,
+        type: ChannelType3.DM,
+        messageServerId: DEFAULT_SERVER_ID4,
+        metadata: {
+          sessionId,
+          agentId: body.agentId,
+          userId: body.userId,
+          ...body.metadata || {}
+        }
+      });
+      await serverInstance.addParticipantsToChannel(channelId, [body.agentId]);
+      const session = {
+        id: sessionId,
+        agentId: body.agentId,
+        channelId,
+        userId: body.userId,
+        metadata: body.metadata || {},
+        createdAt: /* @__PURE__ */ new Date(),
+        lastActivity: /* @__PURE__ */ new Date()
+      };
+      sessions.set(sessionId, session);
+      const response = {
+        sessionId,
+        agentId: session.agentId,
+        userId: session.userId,
+        createdAt: session.createdAt,
+        metadata: session.metadata
+      };
+      res.status(201).json(response);
+    } catch (error) {
+      errorResponse(
+        res,
+        500,
+        "Failed to create session",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  });
+  router.get("/sessions/:sessionId", async (req, res) => {
+    const { sessionId } = req.params;
+    const session = sessions.get(sessionId);
+    if (!session) {
+      return errorResponse(res, 404, "Session not found");
+    }
+    const response = {
+      sessionId: session.id,
+      agentId: session.agentId,
+      userId: session.userId,
+      createdAt: session.createdAt,
+      lastActivity: session.lastActivity,
+      metadata: session.metadata
+    };
+    res.json(response);
+  });
+  router.post("/sessions/:sessionId/messages", async (req, res) => {
+    try {
+      const { sessionId } = req.params;
+      const body = req.body;
+      const session = sessions.get(sessionId);
+      if (!session) {
+        return errorResponse(res, 404, "Session not found");
+      }
+      try {
+        validateContent(body.content);
+      } catch (error) {
+        return errorResponse(res, 400, error instanceof Error ? error.message : String(error));
+      }
+      if (body.metadata && !validateMetadata(body.metadata)) {
+        return errorResponse(res, 400, "Invalid metadata");
+      }
+      session.lastActivity = /* @__PURE__ */ new Date();
+      const message = await serverInstance.createMessage({
+        channelId: session.channelId,
+        authorId: session.userId,
+        content: body.content,
+        rawMessage: {
+          content: body.content,
+          attachments: body.attachments
+        },
+        sourceType: "user",
+        metadata: {
+          sessionId,
+          ...body.metadata || {}
+        }
+      });
+      res.status(201).json({
+        id: message.id,
+        content: message.content,
+        authorId: message.authorId,
+        createdAt: message.createdAt,
+        metadata: message.metadata
+      });
+    } catch (error) {
+      errorResponse(
+        res,
+        500,
+        "Failed to send message",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  });
+  router.get("/sessions/:sessionId/messages", async (req, res) => {
+    try {
+      const { sessionId } = req.params;
+      const query = req.query;
+      const session = sessions.get(sessionId);
+      if (!session) {
+        return errorResponse(res, 404, "Session not found");
+      }
+      let messageLimit = DEFAULT_LIMIT;
+      if (query.limit) {
+        const parsedLimit = parseInt(query.limit, 10);
+        if (isNaN(parsedLimit) || parsedLimit < 1) {
+          return errorResponse(res, 400, "Invalid limit parameter");
+        }
+        messageLimit = Math.min(parsedLimit, MAX_LIMIT);
+      }
+      let beforeDate;
+      let afterDate;
+      if (query.before) {
+        const beforeTimestamp = parseInt(query.before, 10);
+        if (isNaN(beforeTimestamp)) {
+          return errorResponse(res, 400, "Invalid before parameter");
+        }
+        beforeDate = new Date(beforeTimestamp);
+      }
+      if (query.after) {
+        const afterTimestamp = parseInt(query.after, 10);
+        if (isNaN(afterTimestamp)) {
+          return errorResponse(res, 400, "Invalid after parameter");
+        }
+        afterDate = new Date(afterTimestamp);
+      }
+      let messages;
+      if (afterDate) {
+        messages = await serverInstance.getMessagesForChannel(
+          session.channelId,
+          messageLimit * 2,
+          // Get extra to ensure we have enough after filtering
+          void 0
+          // Don't use beforeDate for initial query
+        );
+        messages = messages.filter((msg) => msg.createdAt > afterDate).slice(0, messageLimit);
+      } else {
+        messages = await serverInstance.getMessagesForChannel(
+          session.channelId,
+          messageLimit,
+          beforeDate
+        );
+      }
+      const simplifiedMessages = messages.map((msg) => {
+        let rawMessage = {};
+        try {
+          rawMessage = typeof msg.rawMessage === "string" ? JSON.parse(msg.rawMessage) : msg.rawMessage || {};
+        } catch (error) {
+          logger13.warn(
+            `[Sessions API] Failed to parse rawMessage for message ${msg.id}`,
+            error instanceof Error ? error.message : String(error)
+          );
+        }
+        return {
+          id: msg.id,
+          content: msg.content,
+          authorId: msg.authorId,
+          isAgent: msg.sourceType === "agent_response",
+          createdAt: msg.createdAt,
+          metadata: {
+            ...msg.metadata,
+            thought: rawMessage.thought,
+            actions: rawMessage.actions
+          }
+        };
+      });
+      const response = {
+        messages: simplifiedMessages,
+        hasMore: messages.length === messageLimit
+      };
+      res.json(response);
+    } catch (error) {
+      errorResponse(
+        res,
+        500,
+        "Failed to fetch messages",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  });
+  router.delete("/sessions/:sessionId", async (req, res) => {
+    try {
+      const { sessionId } = req.params;
+      const session = sessions.get(sessionId);
+      if (!session) {
+        return errorResponse(res, 404, "Session not found");
+      }
+      sessions.delete(sessionId);
+      res.json({ success: true });
+    } catch (error) {
+      errorResponse(
+        res,
+        500,
+        "Failed to delete session",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  });
+  router.get("/sessions", async (_req, res) => {
+    const activeSessions = Array.from(sessions.values()).map((session) => ({
+      sessionId: session.id,
+      agentId: session.agentId,
+      userId: session.userId,
+      createdAt: session.createdAt,
+      lastActivity: session.lastActivity,
+      metadata: session.metadata
+    }));
+    res.json({
+      sessions: activeSessions,
+      total: activeSessions.length
+    });
+  });
+  const cleanupInterval = setInterval(
+    () => {
+      const now = /* @__PURE__ */ new Date();
+      for (const [sessionId, session] of sessions.entries()) {
+        if (now.getTime() - session.lastActivity.getTime() > SESSION_TIMEOUT_MS) {
+          sessions.delete(sessionId);
+          logger13.info(`[Sessions API] Cleaned up inactive session: ${sessionId}`);
+        }
+      }
+    },
+    5 * 60 * 1e3
+  );
+  process.on("SIGTERM", () => {
+    clearInterval(cleanupInterval);
+  });
+  return router;
+}
+
 // src/api/messaging/index.ts
 function messagingRouter(agents, serverInstance) {
-  const router = express12.Router();
+  const router = express13.Router();
   if (!serverInstance) {
     throw new Error("ServerInstance is required for messaging router");
   }
   router.use("/", createMessagingCoreRouter(serverInstance));
   router.use("/", createServersRouter(serverInstance));
   router.use("/", createChannelsRouter(agents, serverInstance));
+  router.use("/", createSessionsRouter(agents, serverInstance));
   return router;
 }
 
 // src/api/media/index.ts
-import express15 from "express";
+import express16 from "express";
 
 // src/api/media/agents.ts
-import { validateUuid as validateUuid13, logger as logger13, getContentTypeFromMimeType } from "@elizaos/core";
-import express13 from "express";
+import { validateUuid as validateUuid14, logger as logger14, getContentTypeFromMimeType } from "@elizaos/core";
+import express14 from "express";
 import multer2 from "multer";
 import fs2 from "fs";
 import path2 from "path";
@@ -2851,10 +3211,10 @@ async function saveUploadedFile(file, agentId) {
   return { filename, url };
 }
 function createAgentMediaRouter() {
-  const router = express13.Router();
+  const router = express14.Router();
   router.post("/:agentId/upload-media", upload.single("file"), async (req, res) => {
-    logger13.debug("[MEDIA UPLOAD] Processing media upload with multer");
-    const agentId = validateUuid13(req.params.agentId);
+    logger14.debug("[MEDIA UPLOAD] Processing media upload with multer");
+    const agentId = validateUuid14(req.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
@@ -2872,7 +3232,7 @@ function createAgentMediaRouter() {
     }
     try {
       const result = await saveUploadedFile(req.file, agentId);
-      logger13.info(
+      logger14.info(
         `[MEDIA UPLOAD] Successfully uploaded ${mediaType}: ${result.filename}. URL: ${result.url}`
       );
       sendSuccess(res, {
@@ -2883,7 +3243,7 @@ function createAgentMediaRouter() {
         size: req.file.size
       });
     } catch (error) {
-      logger13.error(`[MEDIA UPLOAD] Error processing upload: ${error}`);
+      logger14.error(`[MEDIA UPLOAD] Error processing upload: ${error}`);
       sendError(
         res,
         500,
@@ -2897,8 +3257,8 @@ function createAgentMediaRouter() {
 }
 
 // src/api/media/channels.ts
-import { validateUuid as validateUuid14, logger as logger14 } from "@elizaos/core";
-import express14 from "express";
+import { validateUuid as validateUuid15, logger as logger15 } from "@elizaos/core";
+import express15 from "express";
 import rateLimit2 from "express-rate-limit";
 import multer3 from "multer";
 import fs3 from "fs";
@@ -2933,7 +3293,7 @@ async function saveUploadedFile2(file, channelId) {
   return { filename, url };
 }
 function createChannelMediaRouter() {
-  const router = express14.Router();
+  const router = express15.Router();
   const uploadMediaRateLimiter = rateLimit2({
     windowMs: 15 * 60 * 1e3,
     // 15 minutes
@@ -2947,7 +3307,7 @@ function createChannelMediaRouter() {
     // Apply rate limiter
     upload2.single("file"),
     async (req, res) => {
-      const channelId = validateUuid14(req.params.channelId);
+      const channelId = validateUuid15(req.params.channelId);
       if (!channelId) {
         res.status(400).json({ success: false, error: "Invalid channelId format" });
         return;
@@ -2958,7 +3318,7 @@ function createChannelMediaRouter() {
       }
       try {
         const result = await saveUploadedFile2(req.file, channelId);
-        logger14.info(
+        logger15.info(
           `[Channel Media Upload] File uploaded for channel ${channelId}: ${result.filename}. URL: ${result.url}`
         );
         res.json({
@@ -2973,7 +3333,7 @@ function createChannelMediaRouter() {
           }
         });
       } catch (error) {
-        logger14.error(
+        logger15.error(
           `[Channel Media Upload] Error processing upload for channel ${channelId}: ${error.message}`,
           error
         );
@@ -2986,32 +3346,32 @@ function createChannelMediaRouter() {
 
 // src/api/media/index.ts
 function mediaRouter() {
-  const router = express15.Router();
+  const router = express16.Router();
   router.use("/agents", createAgentMediaRouter());
   router.use("/channels", createChannelMediaRouter());
   return router;
 }
 
 // src/api/memory/index.ts
-import express17 from "express";
+import express18 from "express";
 
 // src/api/memory/groups.ts
-import { validateUuid as validateUuid16, logger as logger17, createUniqueUuid as createUniqueUuid4, ChannelType as ChannelType3 } from "@elizaos/core";
-import express16 from "express";
+import { validateUuid as validateUuid17, logger as logger18, createUniqueUuid as createUniqueUuid4, ChannelType as ChannelType4 } from "@elizaos/core";
+import express17 from "express";
 
 // src/api/shared/file-utils.ts
 import fs4 from "fs";
 import path4 from "path";
-import { logger as logger15 } from "@elizaos/core";
+import { logger as logger16 } from "@elizaos/core";
 var cleanupUploadedFile = (file) => {
-  logger15.debug(`[FILE] Multer file ${file.originalname} in memory, no cleanup needed`);
+  logger16.debug(`[FILE] Multer file ${file.originalname} in memory, no cleanup needed`);
 };
 
 // src/upload.ts
 import fs5 from "fs";
 import path5 from "path";
 import multer4 from "multer";
-import { validateUuid as validateUuid15, logger as logger16 } from "@elizaos/core";
+import { validateUuid as validateUuid16, logger as logger17 } from "@elizaos/core";
 var storage3 = multer4.memoryStorage();
 var agentAudioUpload = () => multer4({
   storage: storage3,
@@ -3033,10 +3393,10 @@ function validateAudioFile(file) {
 
 // src/api/memory/groups.ts
 function createGroupMemoryRouter(agents, serverInstance) {
-  const router = express16.Router();
+  const router = express17.Router();
   const db = serverInstance?.database;
   router.post("/groups/:serverId", async (req, res) => {
-    const serverId = validateUuid16(req.params.serverId);
+    const serverId = validateUuid17(req.params.serverId);
     const { name, worldId, source, metadata, agentIds = [] } = req.body;
     if (!Array.isArray(agentIds) || agentIds.length === 0) {
       return sendError(res, 400, "BAD_REQUEST", "agentIds must be a non-empty array");
@@ -3058,7 +3418,7 @@ function createGroupMemoryRouter(agents, serverInstance) {
           id: roomId,
           name: roomName,
           source,
-          type: ChannelType3.API,
+          type: ChannelType4.API,
           worldId,
           serverId,
           metadata,
@@ -3072,10 +3432,10 @@ function createGroupMemoryRouter(agents, serverInstance) {
           name: roomName,
           source: "client",
           worldId,
-          type: ChannelType3.API
+          type: ChannelType4.API
         });
       } catch (error) {
-        logger17.error(`[ROOM CREATE] Error creating room for agent ${agentId}:`, error);
+        logger18.error(`[ROOM CREATE] Error creating room for agent ${agentId}:`, error);
         errors.push({
           agentId,
           code: error instanceof Error && error.message === "Agent not found" ? "NOT_FOUND" : "CREATE_ERROR",
@@ -3098,7 +3458,7 @@ function createGroupMemoryRouter(agents, serverInstance) {
     });
   });
   router.delete("/groups/:serverId", async (req, res) => {
-    const worldId = validateUuid16(req.params.serverId);
+    const worldId = validateUuid17(req.params.serverId);
     if (!worldId) {
       return sendError(res, 400, "INVALID_ID", "Invalid serverId (worldId) format");
     }
@@ -3109,7 +3469,7 @@ function createGroupMemoryRouter(agents, serverInstance) {
       await db.deleteRoomsByWorldId(worldId);
       res.status(204).send();
     } catch (error) {
-      logger17.error("[GROUP DELETE] Error deleting group:", error);
+      logger18.error("[GROUP DELETE] Error deleting group:", error);
       sendError(
         res,
         500,
@@ -3120,7 +3480,7 @@ function createGroupMemoryRouter(agents, serverInstance) {
     }
   });
   router.delete("/groups/:serverId/memories", async (req, res) => {
-    const worldId = validateUuid16(req.params.serverId);
+    const worldId = validateUuid17(req.params.serverId);
     if (!worldId) {
       return sendError(res, 400, "INVALID_ID", "Invalid serverId (worldId) format");
     }
@@ -3135,7 +3495,7 @@ function createGroupMemoryRouter(agents, serverInstance) {
       }
       res.status(204).send();
     } catch (error) {
-      logger17.error("[GROUP MEMORIES DELETE] Error clearing memories:", error);
+      logger18.error("[GROUP MEMORIES DELETE] Error clearing memories:", error);
       sendError(
         res,
         500,
@@ -3150,7 +3510,7 @@ function createGroupMemoryRouter(agents, serverInstance) {
 
 // src/api/memory/index.ts
 function memoryRouter(agents, serverInstance) {
-  const router = express17.Router();
+  const router = express18.Router();
   router.use("/", createAgentMemoryRouter(agents));
   router.use("/", createGroupMemoryRouter(agents, serverInstance));
   router.use("/", createRoomManagementRouter(agents));
@@ -3158,22 +3518,22 @@ function memoryRouter(agents, serverInstance) {
 }
 
 // src/api/audio/index.ts
-import express21 from "express";
+import express22 from "express";
 
 // src/api/audio/processing.ts
-import { logger as logger18, ModelType as ModelType2, validateUuid as validateUuid17 } from "@elizaos/core";
-import express18 from "express";
+import { logger as logger19, ModelType as ModelType2, validateUuid as validateUuid18 } from "@elizaos/core";
+import express19 from "express";
 import fs6 from "fs";
 import os from "os";
 import path6 from "path";
 function createAudioProcessingRouter(agents) {
-  const router = express18.Router();
+  const router = express19.Router();
   router.use(createUploadRateLimit());
   router.use(createFileSystemRateLimit());
   router.post("/:agentId/audio-messages", agentAudioUpload().single("file"), async (req, res) => {
     const audioReq = req;
-    logger18.debug("[AUDIO MESSAGE] Processing audio message");
-    const agentId = validateUuid17(req.params.agentId);
+    logger19.debug("[AUDIO MESSAGE] Processing audio message");
+    const agentId = validateUuid18(req.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
@@ -3201,11 +3561,11 @@ function createAudioProcessingRouter(agents) {
         );
       }
       const transcription = await runtime.useModel(ModelType2.TRANSCRIPTION, audioFile.buffer);
-      logger18.info(`[AUDIO MESSAGE] Transcription for agent ${agentId}: ${transcription}`);
+      logger19.info(`[AUDIO MESSAGE] Transcription for agent ${agentId}: ${transcription}`);
       cleanupUploadedFile(audioFile);
       sendSuccess(res, { transcription, message: "Audio transcribed, further processing TBD." });
     } catch (error) {
-      logger18.error("[AUDIO MESSAGE] Error processing audio:", error);
+      logger19.error("[AUDIO MESSAGE] Error processing audio:", error);
       cleanupUploadedFile(audioFile);
       sendError(
         res,
@@ -3218,8 +3578,8 @@ function createAudioProcessingRouter(agents) {
   });
   router.post("/:agentId/transcriptions", agentAudioUpload().single("file"), async (req, res) => {
     const audioReq = req;
-    logger18.debug("[TRANSCRIPTION] Request to transcribe audio");
-    const agentId = validateUuid17(req.params.agentId);
+    logger19.debug("[TRANSCRIPTION] Request to transcribe audio");
+    const agentId = validateUuid18(req.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
@@ -3233,7 +3593,7 @@ function createAudioProcessingRouter(agents) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
     try {
-      logger18.debug("[TRANSCRIPTION] Reading audio file");
+      logger19.debug("[TRANSCRIPTION] Reading audio file");
       if (!validateAudioFile(audioFile)) {
         cleanupUploadedFile(audioFile);
         return sendError(res, 400, "INVALID_FILE_TYPE", "Invalid audio file type");
@@ -3247,16 +3607,16 @@ function createAudioProcessingRouter(agents) {
           `Audio file too large (max ${MAX_FILE_SIZE_DISPLAY})`
         );
       }
-      logger18.debug("[TRANSCRIPTION] Transcribing audio");
+      logger19.debug("[TRANSCRIPTION] Transcribing audio");
       const transcription = await runtime.useModel(ModelType2.TRANSCRIPTION, audioFile.buffer);
       cleanupUploadedFile(audioFile);
       if (!transcription) {
         return sendError(res, 500, "PROCESSING_ERROR", "Failed to transcribe audio");
       }
-      logger18.success("[TRANSCRIPTION] Successfully transcribed audio");
+      logger19.success("[TRANSCRIPTION] Successfully transcribed audio");
       sendSuccess(res, { text: transcription });
     } catch (error) {
-      logger18.error("[TRANSCRIPTION] Error transcribing audio:", error);
+      logger19.error("[TRANSCRIPTION] Error transcribing audio:", error);
       cleanupUploadedFile(audioFile);
       sendError(
         res,
@@ -3271,8 +3631,8 @@ function createAudioProcessingRouter(agents) {
 }
 
 // src/api/audio/synthesis.ts
-import { validateUuid as validateUuid18, logger as logger19, ModelType as ModelType3 } from "@elizaos/core";
-import express19 from "express";
+import { validateUuid as validateUuid19, logger as logger20, ModelType as ModelType3 } from "@elizaos/core";
+import express20 from "express";
 
 // src/api/audio/audioBuffer.ts
 import { Readable } from "stream";
@@ -3329,9 +3689,9 @@ async function convertToAudioBuffer(speechResponse, detectMimeType) {
 
 // src/api/audio/synthesis.ts
 function createSynthesisRouter(agents) {
-  const router = express19.Router();
+  const router = express20.Router();
   router.post("/:agentId/audio-messages/synthesize", async (req, res) => {
-    const agentId = validateUuid18(req.params.agentId);
+    const agentId = validateUuid19(req.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
@@ -3346,14 +3706,14 @@ function createSynthesisRouter(agents) {
     try {
       const speechResponse = await runtime.useModel(ModelType3.TEXT_TO_SPEECH, text);
       const audioResult = await convertToAudioBuffer(speechResponse, true);
-      logger19.debug("[TTS] Setting response headers");
+      logger20.debug("[TTS] Setting response headers");
       res.set({
         "Content-Type": audioResult.mimeType,
         "Content-Length": audioResult.buffer.length.toString()
       });
       res.send(audioResult.buffer);
     } catch (error) {
-      logger19.error("[TTS] Error generating speech:", error);
+      logger20.error("[TTS] Error generating speech:", error);
       sendError(
         res,
         500,
@@ -3364,8 +3724,8 @@ function createSynthesisRouter(agents) {
     }
   });
   router.post("/:agentId/speech/generate", async (req, res) => {
-    logger19.debug("[SPEECH GENERATE] Request to generate speech from text");
-    const agentId = validateUuid18(req.params.agentId);
+    logger20.debug("[SPEECH GENERATE] Request to generate speech from text");
+    const agentId = validateUuid19(req.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
@@ -3378,21 +3738,21 @@ function createSynthesisRouter(agents) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
     try {
-      logger19.debug("[SPEECH GENERATE] Using text-to-speech model");
+      logger20.debug("[SPEECH GENERATE] Using text-to-speech model");
       const speechResponse = await runtime.useModel(ModelType3.TEXT_TO_SPEECH, text);
       const audioResult = await convertToAudioBuffer(speechResponse, true);
-      logger19.debug("[SPEECH GENERATE] Detected audio MIME type:", audioResult.mimeType);
-      logger19.debug("[SPEECH GENERATE] Setting response headers");
+      logger20.debug("[SPEECH GENERATE] Detected audio MIME type:", audioResult.mimeType);
+      logger20.debug("[SPEECH GENERATE] Setting response headers");
       res.set({
         "Content-Type": audioResult.mimeType,
         "Content-Length": audioResult.buffer.length.toString()
       });
       res.send(audioResult.buffer);
-      logger19.success(
+      logger20.success(
         `[SPEECH GENERATE] Successfully generated speech for: ${runtime.character.name}`
       );
     } catch (error) {
-      logger19.error("[SPEECH GENERATE] Error generating speech:", error);
+      logger20.error("[SPEECH GENERATE] Error generating speech:", error);
       sendError(
         res,
         500,
@@ -3407,19 +3767,19 @@ function createSynthesisRouter(agents) {
 
 // src/api/audio/conversation.ts
 import {
-  validateUuid as validateUuid19,
-  logger as logger20,
+  validateUuid as validateUuid20,
+  logger as logger21,
   ModelType as ModelType4,
-  ChannelType as ChannelType4,
+  ChannelType as ChannelType5,
   createUniqueUuid as createUniqueUuid5,
   composePrompt,
   messageHandlerTemplate
 } from "@elizaos/core";
-import express20 from "express";
+import express21 from "express";
 function createConversationRouter(agents) {
-  const router = express20.Router();
+  const router = express21.Router();
   router.post("/:agentId/speech/conversation", async (req, res) => {
-    const agentId = validateUuid19(req.params.agentId);
+    const agentId = validateUuid20(req.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
@@ -3435,14 +3795,14 @@ function createConversationRouter(agents) {
       const roomId = createUniqueUuid5(runtime, rawRoomId ?? `default-room-${agentId}`);
       const entityId = createUniqueUuid5(runtime, rawUserId ?? "Anon");
       const worldId = rawWorldId ?? createUniqueUuid5(runtime, "direct");
-      logger20.debug("[SPEECH CONVERSATION] Ensuring connection");
+      logger21.debug("[SPEECH CONVERSATION] Ensuring connection");
       await runtime.ensureConnection({
         entityId,
         roomId,
         userName: req.body.userName,
         name: req.body.name,
         source: "direct",
-        type: ChannelType4.API,
+        type: ChannelType5.API,
         worldId,
         worldName: "Direct"
       });
@@ -3452,7 +3812,7 @@ function createConversationRouter(agents) {
         attachments: [],
         source: "direct",
         inReplyTo: void 0,
-        channelType: ChannelType4.API
+        channelType: ChannelType5.API
       };
       const userMessageMemory = {
         id: messageId,
@@ -3463,16 +3823,16 @@ function createConversationRouter(agents) {
         content,
         createdAt: Date.now()
       };
-      logger20.debug("[SPEECH CONVERSATION] Creating memory");
+      logger21.debug("[SPEECH CONVERSATION] Creating memory");
       await runtime.createMemory(userMessageMemory, "messages");
-      logger20.debug("[SPEECH CONVERSATION] Composing state");
+      logger21.debug("[SPEECH CONVERSATION] Composing state");
       const state = await runtime.composeState(userMessageMemory);
-      logger20.debug("[SPEECH CONVERSATION] Creating context");
+      logger21.debug("[SPEECH CONVERSATION] Creating context");
       const prompt = composePrompt({
         state,
         template: messageHandlerTemplate
       });
-      logger20.debug("[SPEECH CONVERSATION] Using LLM for response");
+      logger21.debug("[SPEECH CONVERSATION] Using LLM for response");
       const llmResponse = await runtime.useModel(ModelType4.TEXT_LARGE, {
         // Renamed to llmResponse
         messages: [
@@ -3489,7 +3849,7 @@ function createConversationRouter(agents) {
       if (!llmResponse) {
         return sendError(res, 500, "MODEL_ERROR", "No response from model");
       }
-      logger20.debug("[SPEECH CONVERSATION] Creating response memory");
+      logger21.debug("[SPEECH CONVERSATION] Creating response memory");
       const responseMessage = {
         // Explicitly type as Memory
         id: createUniqueUuid5(runtime, `resp-${messageId}`),
@@ -3512,20 +3872,20 @@ function createConversationRouter(agents) {
         async () => [userMessageMemory]
         // Callback should return relevant memories
       );
-      logger20.debug("[SPEECH CONVERSATION] Generating speech response from LLM output");
+      logger21.debug("[SPEECH CONVERSATION] Generating speech response from LLM output");
       const speechAudioResponse = await runtime.useModel(ModelType4.TEXT_TO_SPEECH, llmResponse);
       const audioResult = await convertToAudioBuffer(speechAudioResponse, true);
-      logger20.debug("[SPEECH CONVERSATION] Setting response headers");
+      logger21.debug("[SPEECH CONVERSATION] Setting response headers");
       res.set({
         "Content-Type": audioResult.mimeType,
         "Content-Length": audioResult.buffer.length.toString()
       });
       res.send(audioResult.buffer);
-      logger20.success(
+      logger21.success(
         `[SPEECH CONVERSATION] Successfully processed conversation for: ${runtime.character.name}`
       );
     } catch (error) {
-      logger20.error("[SPEECH CONVERSATION] Error processing conversation:", error);
+      logger21.error("[SPEECH CONVERSATION] Error processing conversation:", error);
       sendError(
         res,
         500,
@@ -3540,7 +3900,7 @@ function createConversationRouter(agents) {
 
 // src/api/audio/index.ts
 function audioRouter(agents) {
-  const router = express21.Router();
+  const router = express22.Router();
   router.use("/", createAudioProcessingRouter(agents));
   router.use("/", createSynthesisRouter(agents));
   router.use("/", createConversationRouter(agents));
@@ -3548,23 +3908,23 @@ function audioRouter(agents) {
 }
 
 // src/api/runtime/index.ts
-import express25 from "express";
+import express26 from "express";
 
 // src/api/runtime/health.ts
-import { logger as logger21 } from "@elizaos/core";
-import express22 from "express";
+import { logger as logger22 } from "@elizaos/core";
+import express23 from "express";
 function createHealthRouter(agents, serverInstance) {
-  const router = express22.Router();
+  const router = express23.Router();
   router.get("/ping", (_req, res) => {
     res.json({ pong: true, timestamp: Date.now() });
   });
   router.get("/hello", (_req, res) => {
-    logger21.info("Hello endpoint hit");
+    logger22.info("Hello endpoint hit");
     res.setHeader("Content-Type", "application/json");
     res.send(JSON.stringify({ message: "Hello World!" }));
   });
   router.get("/status", (_req, res) => {
-    logger21.info("Status endpoint hit");
+    logger22.info("Status endpoint hit");
     res.setHeader("Content-Type", "application/json");
     res.send(
       JSON.stringify({
@@ -3575,7 +3935,7 @@ function createHealthRouter(agents, serverInstance) {
     );
   });
   router.get("/health", (_req, res) => {
-    logger21.log({ apiRoute: "/health" }, "Health check route hit");
+    logger22.log({ apiRoute: "/health" }, "Health check route hit");
     const healthcheck = {
       status: "OK",
       version: process.env.APP_VERSION || "unknown",
@@ -3588,7 +3948,7 @@ function createHealthRouter(agents, serverInstance) {
     res.status(statusCode).json(healthcheck);
   });
   router.post("/stop", (_req, res) => {
-    logger21.log({ apiRoute: "/stop" }, "Server stopping...");
+    logger22.log({ apiRoute: "/stop" }, "Server stopping...");
     serverInstance?.stop();
     res.json({ message: "Server stopping..." });
   });
@@ -3596,8 +3956,8 @@ function createHealthRouter(agents, serverInstance) {
 }
 
 // src/api/runtime/logging.ts
-import { logger as logger22 } from "@elizaos/core";
-import express23 from "express";
+import { logger as logger23 } from "@elizaos/core";
+import express24 from "express";
 var LOG_LEVELS = {
   fatal: 60,
   error: 50,
@@ -3610,14 +3970,14 @@ var LOG_LEVELS = {
   trace: 10
 };
 function createLoggingRouter() {
-  const router = express23.Router();
+  const router = express24.Router();
   const logsHandler = async (req, res) => {
     const since = req.query.since ? Number(req.query.since) : Date.now() - 36e5;
     const requestedLevel = req.query.level?.toString().toLowerCase() || "all";
     const requestedAgentName = req.query.agentName?.toString() || "all";
     const requestedAgentId = req.query.agentId?.toString() || "all";
     const limit = Math.min(Number(req.query.limit) || 100, 1e3);
-    const destination = logger22[Symbol.for("pino-destination")];
+    const destination = logger23[Symbol.for("pino-destination")];
     if (!destination?.recentLogs) {
       return res.status(500).json({
         error: "Logger destination not available",
@@ -3658,7 +4018,7 @@ function createLoggingRouter() {
         }
         return timeMatch && levelMatch && agentNameMatch && agentIdMatch;
       }).slice(-limit);
-      logger22.debug("Logs request processed", {
+      logger23.debug("Logs request processed", {
         requestedLevel,
         requestedLevelValue,
         requestedAgentName,
@@ -3697,7 +4057,7 @@ function createLoggingRouter() {
   router.post("/logs", logsHandler);
   const logsClearHandler = (_req, res) => {
     try {
-      const destination = logger22[Symbol.for("pino-destination")];
+      const destination = logger23[Symbol.for("pino-destination")];
       if (!destination?.clear) {
         return res.status(500).json({
           error: "Logger clear method not available",
@@ -3705,7 +4065,7 @@ function createLoggingRouter() {
         });
       }
       destination.clear();
-      logger22.debug("Logs cleared via API endpoint");
+      logger23.debug("Logs cleared via API endpoint");
       res.json({ status: "success", message: "Logs cleared successfully" });
     } catch (error) {
       res.status(500).json({
@@ -3719,9 +4079,9 @@ function createLoggingRouter() {
 }
 
 // src/api/runtime/debug.ts
-import express24 from "express";
+import express25 from "express";
 function createDebugRouter(serverInstance) {
-  const router = express24.Router();
+  const router = express25.Router();
   router.get("/servers", async (_req, res) => {
     try {
       const servers = await serverInstance?.getServers();
@@ -3742,7 +4102,7 @@ function createDebugRouter(serverInstance) {
 
 // src/api/runtime/index.ts
 function runtimeRouter(agents, serverInstance) {
-  const router = express25.Router();
+  const router = express26.Router();
   router.use("/", createHealthRouter(agents, serverInstance));
   router.use("/", createLoggingRouter(agents, serverInstance));
   router.use("/debug", createDebugRouter(serverInstance));
@@ -3750,18 +4110,18 @@ function runtimeRouter(agents, serverInstance) {
 }
 
 // src/api/tee/index.ts
-import express26 from "express";
+import express27 from "express";
 function teeRouter() {
-  const router = express26.Router();
+  const router = express27.Router();
   return router;
 }
 
 // src/api/system/index.ts
-import express29 from "express";
+import express30 from "express";
 
 // src/api/system/environment.ts
-import { logger as logger23 } from "@elizaos/core";
-import express27 from "express";
+import { logger as logger24 } from "@elizaos/core";
+import express28 from "express";
 import { existsSync, writeFileSync } from "fs";
 import path7 from "path";
 import dotenv from "dotenv";
@@ -3804,7 +4164,7 @@ function resolveEnvFile(startDir = process.cwd()) {
   return path7.join(startDir, ".env");
 }
 function createEnvironmentRouter() {
-  const router = express27.Router();
+  const router = express28.Router();
   router.get("/local", async (_req, res) => {
     try {
       const localEnvPath = getLocalEnvPath();
@@ -3820,7 +4180,7 @@ function createEnvironmentRouter() {
         data: localEnvs
       });
     } catch (error) {
-      logger23.error(`[ENVS GET] Error retrieving local envs`, error);
+      logger24.error(`[ENVS GET] Error retrieving local envs`, error);
       res.status(500).json({
         success: false,
         error: {
@@ -3852,7 +4212,7 @@ function createEnvironmentRouter() {
         message: "Local env updated"
       });
     } catch (error) {
-      logger23.error(`[ENVS POST] Error updating local envs`, error);
+      logger24.error(`[ENVS POST] Error updating local envs`, error);
       res.status(500).json({
         success: false,
         error: {
@@ -3867,12 +4227,12 @@ function createEnvironmentRouter() {
 }
 
 // src/api/system/version.ts
-import express28 from "express";
+import express29 from "express";
 
 // package.json
 var package_default = {
   name: "@elizaos/server",
-  version: "1.3.0",
+  version: "1.3.2",
   description: "ElizaOS Server - Core server infrastructure for ElizaOS agents",
   publishConfig: {
     access: "public",
@@ -3923,10 +4283,10 @@ var package_default = {
     which: "^4.0.0",
     ws: "^8.18.0"
   },
-  gitHead: "991b811b95d08df421efc4f516d0cfb52c4a83b3",
+  gitHead: "48d0b08182b5fd5b17dd58198b1fee15b0815775",
   dependencies: {
-    "@elizaos/core": "1.3.0",
-    "@elizaos/plugin-sql": "1.3.0",
+    "@elizaos/core": "workspace:*",
+    "@elizaos/plugin-sql": "workspace:*",
     "@types/express": "^5.0.2",
     "@types/helmet": "^4.0.0",
     "@types/multer": "^1.4.13",
@@ -3964,7 +4324,7 @@ function getVersionInfo() {
   }
 }
 function createVersionRouter() {
-  const router = express28.Router();
+  const router = express29.Router();
   router.get("/", (_, res) => {
     const versionInfo = getVersionInfo();
     const statusCode = versionInfo.error ? 500 : 200;
@@ -3975,7 +4335,7 @@ function createVersionRouter() {
 
 // src/api/system/index.ts
 function systemRouter() {
-  const router = express29.Router();
+  const router = express30.Router();
   router.use("/env", createEnvironmentRouter());
   router.use("/version", createVersionRouter());
   return router;
@@ -3983,13 +4343,13 @@ function systemRouter() {
 
 // src/socketio/index.ts
 import {
-  logger as logger24,
+  logger as logger25,
   SOCKET_MESSAGE_TYPE,
-  validateUuid as validateUuid20,
-  ChannelType as ChannelType5,
+  validateUuid as validateUuid21,
+  ChannelType as ChannelType6,
   EventType
 } from "@elizaos/core";
-var DEFAULT_SERVER_ID4 = "00000000-0000-0000-0000-000000000000";
+var DEFAULT_SERVER_ID5 = "00000000-0000-0000-0000-000000000000";
 var SocketIORouter = class {
   agents;
   connections;
@@ -4001,22 +4361,22 @@ var SocketIORouter = class {
     this.connections = /* @__PURE__ */ new Map();
     this.logStreamConnections = /* @__PURE__ */ new Map();
     this.serverInstance = serverInstance;
-    logger24.info(`[SocketIO] Router initialized with ${this.agents.size} agents`);
+    logger25.info(`[SocketIO] Router initialized with ${this.agents.size} agents`);
   }
   setupListeners(io) {
-    logger24.info(`[SocketIO] Setting up Socket.IO event listeners`);
+    logger25.info(`[SocketIO] Setting up Socket.IO event listeners`);
     const messageTypes = Object.keys(SOCKET_MESSAGE_TYPE).map(
       (key) => `${key}: ${SOCKET_MESSAGE_TYPE[key]}`
     );
-    logger24.info(`[SocketIO] Registered message types: ${messageTypes.join(", ")}`);
+    logger25.info(`[SocketIO] Registered message types: ${messageTypes.join(", ")}`);
     io.on("connection", (socket) => {
       this.handleNewConnection(socket, io);
     });
   }
   handleNewConnection(socket, _io) {
-    logger24.info(`[SocketIO] New connection: ${socket.id}`);
+    logger25.info(`[SocketIO] New connection: ${socket.id}`);
     socket.on(String(SOCKET_MESSAGE_TYPE.ROOM_JOINING), (payload) => {
-      logger24.debug(
+      logger25.debug(
         `[SocketIO] Channel joining event received directly: ${JSON.stringify(payload)}`
       );
       this.handleChannelJoining(socket, payload);
@@ -4024,7 +4384,7 @@ var SocketIORouter = class {
     socket.on(String(SOCKET_MESSAGE_TYPE.SEND_MESSAGE), (payload) => {
       const messagePreview = payload.message?.substring(0, 50) + (payload.message?.length > 50 ? "..." : "");
       const channelId = payload.channelId || payload.roomId;
-      logger24.info(
+      logger25.info(
         `[SocketIO] SEND_MESSAGE event received directly: ${JSON.stringify({
           senderId: payload.senderId,
           channelId,
@@ -4034,7 +4394,7 @@ var SocketIORouter = class {
       this.handleMessageSubmission(socket, payload);
     });
     socket.on("message", (data) => {
-      logger24.info(
+      logger25.info(
         `[SocketIO] Generic 'message' event received: ${JSON.stringify(data)} (SocketID: ${socket.id})`
       );
       this.handleGenericMessage(socket, data);
@@ -4044,11 +4404,11 @@ var SocketIORouter = class {
     socket.on("update_log_filters", (filters) => this.handleLogFilterUpdate(socket, filters));
     socket.on("disconnect", () => this.handleDisconnect(socket));
     socket.on("error", (error) => {
-      logger24.error(`[SocketIO] Socket error for ${socket.id}: ${error.message}`, error);
+      logger25.error(`[SocketIO] Socket error for ${socket.id}: ${error.message}`, error);
     });
     if (process.env.NODE_ENV === "development") {
       socket.onAny((event, ...args) => {
-        logger24.info(`[SocketIO DEBUG ${socket.id}] Event '${event}': ${JSON.stringify(args)}`);
+        logger25.info(`[SocketIO DEBUG ${socket.id}] Event '${event}': ${JSON.stringify(args)}`);
       });
     }
     socket.emit("connection_established", {
@@ -4059,7 +4419,7 @@ var SocketIORouter = class {
   handleGenericMessage(socket, data) {
     try {
       if (!(data && typeof data === "object" && "type" in data && "payload" in data)) {
-        logger24.warn(
+        logger25.warn(
           `[SocketIO ${socket.id}] Malformed 'message' event data: ${JSON.stringify(data)}`
         );
         return;
@@ -4067,21 +4427,21 @@ var SocketIORouter = class {
       const { type, payload } = data;
       switch (type) {
         case SOCKET_MESSAGE_TYPE.ROOM_JOINING:
-          logger24.info(`[SocketIO ${socket.id}] Handling channel joining via 'message' event`);
+          logger25.info(`[SocketIO ${socket.id}] Handling channel joining via 'message' event`);
           this.handleChannelJoining(socket, payload);
           break;
         case SOCKET_MESSAGE_TYPE.SEND_MESSAGE:
-          logger24.info(`[SocketIO ${socket.id}] Handling message sending via 'message' event`);
+          logger25.info(`[SocketIO ${socket.id}] Handling message sending via 'message' event`);
           this.handleMessageSubmission(socket, payload);
           break;
         default:
-          logger24.warn(
+          logger25.warn(
             `[SocketIO ${socket.id}] Unknown message type received in 'message' event: ${type}`
           );
           break;
       }
     } catch (error) {
-      logger24.error(
+      logger25.error(
         `[SocketIO ${socket.id}] Error processing 'message' event: ${error.message}`,
         error
       );
@@ -4090,7 +4450,7 @@ var SocketIORouter = class {
   handleChannelJoining(socket, payload) {
     const channelId = payload.channelId || payload.roomId;
     const { agentId, entityId, serverId, metadata } = payload;
-    logger24.debug(
+    logger25.debug(
       `[SocketIO] handleChannelJoining called with payload:`,
       JSON.stringify(payload, null, 2)
     );
@@ -4099,18 +4459,18 @@ var SocketIORouter = class {
       return;
     }
     if (agentId) {
-      const agentUuid = validateUuid20(agentId);
+      const agentUuid = validateUuid21(agentId);
       if (agentUuid) {
         this.connections.set(socket.id, agentUuid);
-        logger24.info(`[SocketIO] Socket ${socket.id} associated with agent ${agentUuid}`);
+        logger25.info(`[SocketIO] Socket ${socket.id} associated with agent ${agentUuid}`);
       }
     }
     socket.join(channelId);
-    logger24.info(`[SocketIO] Socket ${socket.id} joined Socket.IO channel: ${channelId}`);
-    if (entityId && (serverId || DEFAULT_SERVER_ID4)) {
-      const finalServerId = serverId || DEFAULT_SERVER_ID4;
-      const isDm = metadata?.isDm || metadata?.channelType === ChannelType5.DM;
-      logger24.info(
+    logger25.info(`[SocketIO] Socket ${socket.id} joined Socket.IO channel: ${channelId}`);
+    if (entityId && (serverId || DEFAULT_SERVER_ID5)) {
+      const finalServerId = serverId || DEFAULT_SERVER_ID5;
+      const isDm = metadata?.isDm || metadata?.channelType === ChannelType6.DM;
+      logger25.info(
         `[SocketIO] Emitting ENTITY_JOINED event for entityId: ${entityId}, serverId: ${finalServerId}, isDm: ${isDm}`
       );
       const runtime = Array.from(this.agents.values())[0];
@@ -4122,19 +4482,19 @@ var SocketIORouter = class {
           // Use serverId as worldId identifier
           roomId: channelId,
           metadata: {
-            type: isDm ? ChannelType5.DM : ChannelType5.GROUP,
+            type: isDm ? ChannelType6.DM : ChannelType6.GROUP,
             isDm,
             ...metadata
           },
           source: "socketio"
         });
-        logger24.info(`[SocketIO] ENTITY_JOINED event emitted successfully for ${entityId}`);
+        logger25.info(`[SocketIO] ENTITY_JOINED event emitted successfully for ${entityId}`);
       } else {
-        logger24.warn(`[SocketIO] No runtime available to emit ENTITY_JOINED event`);
+        logger25.warn(`[SocketIO] No runtime available to emit ENTITY_JOINED event`);
       }
     } else {
-      logger24.debug(
-        `[SocketIO] Missing entityId (${entityId}) or serverId (${serverId || DEFAULT_SERVER_ID4}) - not emitting ENTITY_JOINED event`
+      logger25.debug(
+        `[SocketIO] Missing entityId (${entityId}) or serverId (${serverId || DEFAULT_SERVER_ID5}) - not emitting ENTITY_JOINED event`
       );
     }
     const successMessage = `Socket ${socket.id} successfully joined channel ${channelId}.`;
@@ -4143,24 +4503,24 @@ var SocketIORouter = class {
       channelId,
       roomId: channelId,
       // Keep for backward compatibility
-      ...agentId && { agentId: validateUuid20(agentId) || agentId }
+      ...agentId && { agentId: validateUuid21(agentId) || agentId }
     };
     socket.emit("channel_joined", responsePayload);
     socket.emit("room_joined", responsePayload);
-    logger24.info(`[SocketIO] ${successMessage}`);
+    logger25.info(`[SocketIO] ${successMessage}`);
   }
   async handleMessageSubmission(socket, payload) {
     const channelId = payload.channelId || payload.roomId;
     const { senderId, senderName, message, serverId, source, metadata, attachments } = payload;
-    logger24.info(
+    logger25.info(
       `[SocketIO ${socket.id}] Received SEND_MESSAGE for central submission: channel ${channelId} from ${senderName || senderId}`
     );
-    logger24.info(
+    logger25.info(
       `[SocketIO ${socket.id}] Full payload for debugging:`,
       JSON.stringify(payload, null, 2)
     );
-    const isValidServerId = serverId === DEFAULT_SERVER_ID4 || validateUuid20(serverId);
-    if (!validateUuid20(channelId) || !isValidServerId || !validateUuid20(senderId) || !message) {
+    const isValidServerId = serverId === DEFAULT_SERVER_ID5 || validateUuid21(serverId);
+    if (!validateUuid21(channelId) || !isValidServerId || !validateUuid21(senderId) || !message) {
       this.sendErrorResponse(
         socket,
         `For SEND_MESSAGE: channelId, serverId (server_id), senderId (author_id), and message are required.`
@@ -4168,9 +4528,9 @@ var SocketIORouter = class {
       return;
     }
     try {
-      const isDmForWorldSetup = metadata?.isDm || metadata?.channelType === ChannelType5.DM;
+      const isDmForWorldSetup = metadata?.isDm || metadata?.channelType === ChannelType6.DM;
       if (isDmForWorldSetup && senderId) {
-        logger24.info(
+        logger25.info(
           `[SocketIO] Detected DM channel during message submission, emitting ENTITY_JOINED for proper world setup`
         );
         const runtime = Array.from(this.agents.values())[0];
@@ -4182,85 +4542,85 @@ var SocketIORouter = class {
             // Use serverId as worldId identifier
             roomId: channelId,
             metadata: {
-              type: ChannelType5.DM,
+              type: ChannelType6.DM,
               isDm: true,
               ...metadata
             },
             source: "socketio_message"
           });
-          logger24.info(`[SocketIO] ENTITY_JOINED event emitted for DM channel setup: ${senderId}`);
+          logger25.info(`[SocketIO] ENTITY_JOINED event emitted for DM channel setup: ${senderId}`);
         }
       }
-      logger24.info(
+      logger25.info(
         `[SocketIO ${socket.id}] Checking if channel ${channelId} exists before creating message`
       );
       let channelExists = false;
       try {
         const existingChannel = await this.serverInstance.getChannelDetails(channelId);
         channelExists = !!existingChannel;
-        logger24.info(`[SocketIO ${socket.id}] Channel ${channelId} exists: ${channelExists}`);
+        logger25.info(`[SocketIO ${socket.id}] Channel ${channelId} exists: ${channelExists}`);
       } catch (error) {
-        logger24.info(
+        logger25.info(
           `[SocketIO ${socket.id}] Channel ${channelId} does not exist, will create it. Error: ${error.message}`
         );
       }
       if (!channelExists) {
-        logger24.info(
+        logger25.info(
           `[SocketIO ${socket.id}] Auto-creating channel ${channelId} with serverId ${serverId}`
         );
         try {
           const servers = await this.serverInstance.getServers();
           const serverExists = servers.some((s) => s.id === serverId);
-          logger24.info(
+          logger25.info(
             `[SocketIO ${socket.id}] Server ${serverId} exists: ${serverExists}. Available servers: ${servers.map((s) => s.id).join(", ")}`
           );
           if (!serverExists) {
-            logger24.error(
+            logger25.error(
               `[SocketIO ${socket.id}] Server ${serverId} does not exist, cannot create channel`
             );
             this.sendErrorResponse(socket, `Server ${serverId} does not exist`);
             return;
           }
-          const isDmChannel = metadata?.isDm || metadata?.channelType === ChannelType5.DM;
+          const isDmChannel = metadata?.isDm || metadata?.channelType === ChannelType6.DM;
           const channelData = {
             id: channelId,
             // Use the specific channel ID from the client
             messageServerId: serverId,
             name: isDmChannel ? `DM ${channelId.substring(0, 8)}` : `Chat ${channelId.substring(0, 8)}`,
-            type: isDmChannel ? ChannelType5.DM : ChannelType5.GROUP,
+            type: isDmChannel ? ChannelType6.DM : ChannelType6.GROUP,
             sourceType: "auto_created",
             metadata: {
               created_by: "socketio_auto_creation",
               created_for_user: senderId,
               created_at: (/* @__PURE__ */ new Date()).toISOString(),
-              channel_type: isDmChannel ? ChannelType5.DM : ChannelType5.GROUP,
+              channel_type: isDmChannel ? ChannelType6.DM : ChannelType6.GROUP,
               ...metadata
             }
           };
-          logger24.info(
+          logger25.info(
             `[SocketIO ${socket.id}] Creating channel with data:`,
             JSON.stringify(channelData, null, 2)
           );
           let participants = [senderId];
           if (isDmChannel) {
             const otherParticipant = metadata?.targetUserId || metadata?.recipientId || payload.targetUserId;
-            if (otherParticipant && validateUuid20(otherParticipant)) {
+            if (otherParticipant && validateUuid21(otherParticipant)) {
               participants.push(otherParticipant);
-              logger24.info(
+              logger25.info(
                 `[SocketIO ${socket.id}] DM channel will include participants: ${participants.join(", ")}`
               );
             } else {
-              logger24.warn(
+              logger25.warn(
                 `[SocketIO ${socket.id}] DM channel missing second participant, only adding sender: ${senderId}`
               );
             }
           }
           await this.serverInstance.createChannel(channelData, participants);
-          logger24.info(
-            `[SocketIO ${socket.id}] Auto-created ${isDmChannel ? ChannelType5.DM : ChannelType5.GROUP} channel ${channelId} for message submission with ${participants.length} participants`
+          logger25.info(
+            `[SocketIO ${socket.id}] Auto-created ${isDmChannel ? ChannelType6.DM : ChannelType6.GROUP} channel ${channelId} for message submission with ${participants.length} participants`
           );
         } catch (createError) {
-          logger24.error(
+          logger25.error(
             `[SocketIO ${socket.id}] Failed to auto-create channel ${channelId}:`,
             createError
           );
@@ -4268,7 +4628,7 @@ var SocketIORouter = class {
           return;
         }
       } else {
-        logger24.info(
+        logger25.info(
           `[SocketIO ${socket.id}] Channel ${channelId} already exists, proceeding with message creation`
         );
       }
@@ -4287,7 +4647,7 @@ var SocketIORouter = class {
         sourceType: source || "socketio_client"
       };
       const createdRootMessage = await this.serverInstance.createMessage(newRootMessageData);
-      logger24.info(
+      logger25.info(
         `[SocketIO ${socket.id}] Message from ${senderId} (msgId: ${payload.messageId || "N/A"}) submitted to central store (central ID: ${createdRootMessage.id}). It will be processed by agents and broadcasted upon their reply.`
       );
       const messageBroadcast = {
@@ -4318,7 +4678,7 @@ var SocketIORouter = class {
         // Keep for backward compatibility
       });
     } catch (error) {
-      logger24.error(
+      logger25.error(
         `[SocketIO ${socket.id}] Error during central submission for message: ${error.message}`,
         error
       );
@@ -4326,14 +4686,14 @@ var SocketIORouter = class {
     }
   }
   sendErrorResponse(socket, errorMessage) {
-    logger24.error(`[SocketIO ${socket.id}] Sending error to client: ${errorMessage}`);
+    logger25.error(`[SocketIO ${socket.id}] Sending error to client: ${errorMessage}`);
     socket.emit("messageError", {
       error: errorMessage
     });
   }
   handleLogSubscription(socket) {
     this.logStreamConnections.set(socket.id, {});
-    logger24.info(`[SocketIO ${socket.id}] Client subscribed to log stream`);
+    logger25.info(`[SocketIO ${socket.id}] Client subscribed to log stream`);
     socket.emit("log_subscription_confirmed", {
       subscribed: true,
       message: "Successfully subscribed to log stream"
@@ -4341,7 +4701,7 @@ var SocketIORouter = class {
   }
   handleLogUnsubscription(socket) {
     this.logStreamConnections.delete(socket.id);
-    logger24.info(`[SocketIO ${socket.id}] Client unsubscribed from log stream`);
+    logger25.info(`[SocketIO ${socket.id}] Client unsubscribed from log stream`);
     socket.emit("log_subscription_confirmed", {
       subscribed: false,
       message: "Successfully unsubscribed from log stream"
@@ -4351,13 +4711,13 @@ var SocketIORouter = class {
     const existingFilters = this.logStreamConnections.get(socket.id);
     if (existingFilters !== void 0) {
       this.logStreamConnections.set(socket.id, { ...existingFilters, ...filters });
-      logger24.info(`[SocketIO ${socket.id}] Updated log filters:`, filters);
+      logger25.info(`[SocketIO ${socket.id}] Updated log filters:`, filters);
       socket.emit("log_filters_updated", {
         success: true,
         filters: this.logStreamConnections.get(socket.id)
       });
     } else {
-      logger24.warn(`[SocketIO ${socket.id}] Cannot update filters: not subscribed to log stream`);
+      logger25.warn(`[SocketIO ${socket.id}] Cannot update filters: not subscribed to log stream`);
       socket.emit("log_filters_updated", {
         success: false,
         error: "Not subscribed to log stream"
@@ -4375,7 +4735,7 @@ var SocketIORouter = class {
           shouldBroadcast = shouldBroadcast && logEntry.agentName === filters.agentName;
         }
         if (filters.level && filters.level !== "all") {
-          const numericLevel = typeof filters.level === "string" ? logger24.levels.values[filters.level.toLowerCase()] || 70 : filters.level;
+          const numericLevel = typeof filters.level === "string" ? logger25.levels.values[filters.level.toLowerCase()] || 70 : filters.level;
           shouldBroadcast = shouldBroadcast && logEntry.level >= numericLevel;
         }
         if (shouldBroadcast) {
@@ -4389,11 +4749,11 @@ var SocketIORouter = class {
     this.connections.delete(socket.id);
     this.logStreamConnections.delete(socket.id);
     if (agentIdAssociated) {
-      logger24.info(
+      logger25.info(
         `[SocketIO] Client ${socket.id} (associated with agent ${agentIdAssociated}) disconnected.`
       );
     } else {
-      logger24.info(`[SocketIO] Client ${socket.id} disconnected.`);
+      logger25.info(`[SocketIO] Client ${socket.id} disconnected.`);
     }
   }
 };
@@ -4412,7 +4772,7 @@ function setupSocketIO(server, agents, serverInstance) {
   return io;
 }
 function setupLogStreaming(io, router) {
-  const loggerInstance = logger25;
+  const loggerInstance = logger26;
   const destination = loggerInstance[Symbol.for("pino-destination")];
   if (destination && typeof destination.write === "function") {
     const originalWrite = destination.write.bind(destination);
@@ -4436,14 +4796,14 @@ function setupLogStreaming(io, router) {
 }
 function createPluginRouteHandler(agents) {
   return (req, res, next) => {
-    logger25.debug("Handling plugin request in the plugin route handler", {
+    logger26.debug("Handling plugin request in the plugin route handler", {
       path: req.path,
       method: req.method,
       query: req.query
     });
     const agentApiRoutePattern = /^\/agents\/[a-f0-9-]{36}\/(?!plugins\/)/i;
     if (agentApiRoutePattern.test(req.path)) {
-      logger25.debug(`Skipping agent API route in plugin handler: ${req.path}`);
+      logger26.debug(`Skipping agent API route in plugin handler: ${req.path}`);
       return next();
     }
     if (req.path.startsWith("/api/messages/")) {
@@ -4451,24 +4811,24 @@ function createPluginRouteHandler(agents) {
     }
     const clientRoutePattern = /^\/(chat|settings|agents|profile|dashboard|login|register|admin|home|about)\b/i;
     if (clientRoutePattern.test(req.path)) {
-      logger25.debug(`Skipping client-side route in plugin handler: ${req.path}`);
+      logger26.debug(`Skipping client-side route in plugin handler: ${req.path}`);
       return next();
     }
     if (req.path.endsWith(".js") || req.path.includes(".js?") || req.path.match(/index-[A-Za-z0-9]{8}\.js/)) {
-      logger25.debug(`JavaScript request in plugin handler: ${req.method} ${req.path}`);
+      logger26.debug(`JavaScript request in plugin handler: ${req.method} ${req.path}`);
       res.setHeader("Content-Type", "application/javascript");
     }
     if (agents.size === 0) {
-      logger25.debug("No agents available, skipping plugin route handling.");
+      logger26.debug("No agents available, skipping plugin route handling.");
       return next();
     }
     let handled = false;
     const agentIdFromQuery = req.query.agentId;
     const reqPath = req.path;
-    if (agentIdFromQuery && validateUuid21(agentIdFromQuery)) {
+    if (agentIdFromQuery && validateUuid22(agentIdFromQuery)) {
       const runtime = agents.get(agentIdFromQuery);
       if (runtime) {
-        logger25.debug(
+        logger26.debug(
           `Agent-scoped request for Agent ID: ${agentIdFromQuery} from query. Path: ${reqPath}`
         );
         for (const route of runtime.routes) {
@@ -4479,7 +4839,7 @@ function createPluginRouteHandler(agents) {
           if (routePath.endsWith("/*")) {
             const baseRoute = routePath.slice(0, -1);
             if (reqPath.startsWith(baseRoute)) {
-              logger25.debug(
+              logger26.debug(
                 `Agent ${agentIdFromQuery} plugin wildcard route: [${route.type.toUpperCase()}] ${routePath} for request: ${reqPath}`
               );
               try {
@@ -4488,7 +4848,7 @@ function createPluginRouteHandler(agents) {
                   handled = true;
                 }
               } catch (error) {
-                logger25.error(
+                logger26.error(
                   `Error handling plugin wildcard route for agent ${agentIdFromQuery}: ${routePath}`,
                   {
                     error,
@@ -4506,14 +4866,14 @@ function createPluginRouteHandler(agents) {
               }
             }
           } else {
-            logger25.debug(
+            logger26.debug(
               `Agent ${agentIdFromQuery} attempting plugin route match: [${route.type.toUpperCase()}] ${routePath} vs request path: ${reqPath}`
             );
             let matcher;
             try {
               matcher = match(routePath, { decode: decodeURIComponent });
             } catch (err) {
-              logger25.error(
+              logger26.error(
                 `Invalid plugin route path syntax for agent ${agentIdFromQuery}: "${routePath}"`,
                 err
               );
@@ -4521,7 +4881,7 @@ function createPluginRouteHandler(agents) {
             }
             const matched = matcher(reqPath);
             if (matched) {
-              logger25.debug(
+              logger26.debug(
                 `Agent ${agentIdFromQuery} plugin route matched: [${route.type.toUpperCase()}] ${routePath} vs request path: ${reqPath}`
               );
               req.params = { ...matched.params || {} };
@@ -4531,7 +4891,7 @@ function createPluginRouteHandler(agents) {
                   handled = true;
                 }
               } catch (error) {
-                logger25.error(
+                logger26.error(
                   `Error handling plugin route for agent ${agentIdFromQuery}: ${routePath}`,
                   {
                     error,
@@ -4552,7 +4912,7 @@ function createPluginRouteHandler(agents) {
           }
         }
       } else {
-        logger25.warn(
+        logger26.warn(
           `Agent ID ${agentIdFromQuery} provided in query, but agent runtime not found. Path: ${reqPath}.`
         );
         if (reqPath.startsWith("/api/")) {
@@ -4568,8 +4928,8 @@ function createPluginRouteHandler(agents) {
           return next();
         }
       }
-    } else if (agentIdFromQuery && !validateUuid21(agentIdFromQuery)) {
-      logger25.warn(`Invalid Agent ID format in query: ${agentIdFromQuery}. Path: ${reqPath}.`);
+    } else if (agentIdFromQuery && !validateUuid22(agentIdFromQuery)) {
+      logger26.warn(`Invalid Agent ID format in query: ${agentIdFromQuery}. Path: ${reqPath}.`);
       if (reqPath.startsWith("/api/")) {
         res.status(400).json({
           success: false,
@@ -4583,7 +4943,7 @@ function createPluginRouteHandler(agents) {
         return next();
       }
     } else {
-      logger25.debug(`No valid agentId in query. Trying global match for path: ${reqPath}`);
+      logger26.debug(`No valid agentId in query. Trying global match for path: ${reqPath}`);
       for (const [_, runtime] of agents) {
         if (handled) break;
         for (const route of runtime.routes) {
@@ -4597,14 +4957,14 @@ function createPluginRouteHandler(agents) {
           if (routePath.endsWith("/*")) {
             const baseRoute = routePath.slice(0, -1);
             if (reqPath.startsWith(baseRoute)) {
-              logger25.debug(
+              logger26.debug(
                 `Global plugin wildcard route: [${route.type.toUpperCase()}] ${routePath} (Agent: ${runtime.agentId}) for request: ${reqPath}`
               );
               try {
                 route?.handler?.(req, res, runtime);
                 handled = true;
               } catch (error) {
-                logger25.error(
+                logger26.error(
                   `Error handling global plugin wildcard route ${routePath} (Agent: ${runtime.agentId})`,
                   { error, path: reqPath }
                 );
@@ -4618,14 +4978,14 @@ function createPluginRouteHandler(agents) {
               }
             }
           } else if (reqPath === routePath) {
-            logger25.debug(
+            logger26.debug(
               `Global plugin route matched: [${route.type.toUpperCase()}] ${routePath} (Agent: ${runtime.agentId}) for request: ${reqPath}`
             );
             try {
               route?.handler?.(req, res, runtime);
               handled = true;
             } catch (error) {
-              logger25.error(
+              logger26.error(
                 `Error handling global plugin route ${routePath} (Agent: ${runtime.agentId})`,
                 { error, path: reqPath }
               );
@@ -4644,12 +5004,12 @@ function createPluginRouteHandler(agents) {
     if (handled) {
       return;
     }
-    logger25.debug(`No plugin route handled ${req.method} ${req.path}, passing to next middleware.`);
+    logger26.debug(`No plugin route handled ${req.method} ${req.path}, passing to next middleware.`);
     next();
   };
 }
 function createApiRouter(agents, serverInstance) {
-  const router = express30.Router();
+  const router = express31.Router();
   router.use(
     helmet({
       // Disable CSP here - let main app handle it with environment awareness
@@ -4687,7 +5047,7 @@ function createApiRouter(agents, serverInstance) {
 }
 
 // src/authMiddleware.ts
-import { logger as logger26 } from "@elizaos/core";
+import { logger as logger27 } from "@elizaos/core";
 function apiKeyAuthMiddleware(req, res, next) {
   const serverAuthToken = process.env.ELIZA_SERVER_AUTH_TOKEN;
   if (!serverAuthToken) {
@@ -4698,7 +5058,7 @@ function apiKeyAuthMiddleware(req, res, next) {
   }
   const apiKey = req.headers?.["x-api-key"];
   if (!apiKey || apiKey !== serverAuthToken) {
-    logger26.warn(`Unauthorized access attempt: Missing or invalid X-API-KEY from ${req.ip}`);
+    logger27.warn(`Unauthorized access attempt: Missing or invalid X-API-KEY from ${req.ip}`);
     return res.status(401).send("Unauthorized: Invalid or missing X-API-KEY");
   }
   next();
@@ -4706,12 +5066,12 @@ function apiKeyAuthMiddleware(req, res, next) {
 
 // src/services/message.ts
 import {
-  ChannelType as ChannelType6,
+  ChannelType as ChannelType7,
   EventType as EventType2,
   Service,
   createUniqueUuid as createUniqueUuid6,
-  logger as logger27,
-  validateUuid as validateUuid22
+  logger as logger28,
+  validateUuid as validateUuid23
 } from "@elizaos/core";
 var MessageBusService = class _MessageBusService extends Service {
   static serviceType = "message-bus-service";
@@ -4723,7 +5083,11 @@ var MessageBusService = class _MessageBusService extends Service {
   subscribedServers = /* @__PURE__ */ new Set();
   constructor(runtime) {
     super(runtime);
-    this.boundHandleIncomingMessage = this.handleIncomingMessage.bind(this);
+    this.boundHandleIncomingMessage = (data) => {
+      this.handleIncomingMessage(data).catch((error) => {
+        logger28.error(`[${this.runtime.character.name}] Error handling incoming message:`, error);
+      });
+    };
     this.boundHandleServerAgentUpdate = this.handleServerAgentUpdate.bind(this);
     this.boundHandleMessageDeleted = this.handleMessageDeleted.bind(this);
     this.boundHandleChannelCleared = this.handleChannelCleared.bind(this);
@@ -4738,7 +5102,7 @@ var MessageBusService = class _MessageBusService extends Service {
     await service.stop();
   }
   async connectToMessageBus() {
-    logger27.info(
+    logger28.info(
       `[${this.runtime.character.name}] MessageBusService: Subscribing to internal message bus for 'new_message', 'message_deleted', and 'channel_cleared' events.`
     );
     bus_default.on("new_message", this.boundHandleIncomingMessage);
@@ -4753,9 +5117,9 @@ var MessageBusService = class _MessageBusService extends Service {
     try {
       const serverApiUrl = this.getCentralMessageServerUrl();
       this.validChannelIds.clear();
-      const DEFAULT_SERVER_ID6 = "00000000-0000-0000-0000-000000000000";
+      const DEFAULT_SERVER_ID7 = "00000000-0000-0000-0000-000000000000";
       const serversToCheck = new Set(this.subscribedServers);
-      serversToCheck.add(DEFAULT_SERVER_ID6);
+      serversToCheck.add(DEFAULT_SERVER_ID7);
       for (const serverId of serversToCheck) {
         try {
           const channelsUrl = new URL(
@@ -4769,31 +5133,31 @@ var MessageBusService = class _MessageBusService extends Service {
             const data = await response.json();
             if (data.success && data.data?.channels && Array.isArray(data.data.channels)) {
               data.data.channels.forEach((channel) => {
-                if (channel.id && validateUuid22(channel.id)) {
+                if (channel.id && validateUuid23(channel.id)) {
                   this.validChannelIds.add(channel.id);
                 }
               });
-              logger27.info(
+              logger28.info(
                 `[${this.runtime.character.name}] MessageBusService: Fetched ${data.data.channels.length} channels from server ${serverId}`
               );
             }
           } else {
-            logger27.warn(
+            logger28.warn(
               `[${this.runtime.character.name}] MessageBusService: Failed to fetch channels for server ${serverId}: ${response.status} ${response.statusText}`
             );
           }
         } catch (serverError) {
-          logger27.error(
+          logger28.error(
             `[${this.runtime.character.name}] MessageBusService: Error fetching channels for server ${serverId}:`,
             serverError
           );
         }
       }
-      logger27.info(
+      logger28.info(
         `[${this.runtime.character.name}] MessageBusService: Loaded ${this.validChannelIds.size} valid channel IDs from ${serversToCheck.size} servers (including default server)`
       );
     } catch (error) {
-      logger27.error(
+      logger28.error(
         `[${this.runtime.character.name}] MessageBusService: Error in fetchValidChannelIds:`,
         error
       );
@@ -4802,8 +5166,8 @@ var MessageBusService = class _MessageBusService extends Service {
   async getChannelParticipants(channelId) {
     try {
       const serverApiUrl = this.getCentralMessageServerUrl();
-      if (!validateUuid22(channelId)) {
-        logger27.warn(
+      if (!validateUuid23(channelId)) {
+        logger28.warn(
           `[${this.runtime.character.name}] MessageBusService: Invalid channel ID format: ${channelId}`
         );
         return [];
@@ -4818,11 +5182,11 @@ var MessageBusService = class _MessageBusService extends Service {
         });
         if (detailsResponse.ok) {
           this.validChannelIds.add(channelId);
-          logger27.info(
+          logger28.info(
             `[${this.runtime.character.name}] MessageBusService: Discovered new channel ${channelId}, added to valid channels`
           );
         } else {
-          logger27.warn(
+          logger28.warn(
             `[${this.runtime.character.name}] MessageBusService: Channel ${channelId} does not exist or is not accessible`
           );
           return [];
@@ -4843,7 +5207,7 @@ var MessageBusService = class _MessageBusService extends Service {
       }
       return [];
     } catch (error) {
-      logger27.error(
+      logger28.error(
         `[${this.runtime.character.name}] MessageBusService: Error fetching participants for channel ${channelId}:`,
         error
       );
@@ -4864,27 +5228,27 @@ var MessageBusService = 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_ID6 = "00000000-0000-0000-0000-000000000000";
-          this.subscribedServers.add(DEFAULT_SERVER_ID6);
-          logger27.info(
+          const DEFAULT_SERVER_ID7 = "00000000-0000-0000-0000-000000000000";
+          this.subscribedServers.add(DEFAULT_SERVER_ID7);
+          logger28.info(
             `[${this.runtime.character.name}] MessageBusService: Agent is subscribed to ${this.subscribedServers.size} servers (including default server)`
           );
         }
       } else {
-        const DEFAULT_SERVER_ID6 = "00000000-0000-0000-0000-000000000000";
-        this.subscribedServers.add(DEFAULT_SERVER_ID6);
-        logger27.warn(
+        const DEFAULT_SERVER_ID7 = "00000000-0000-0000-0000-000000000000";
+        this.subscribedServers.add(DEFAULT_SERVER_ID7);
+        logger28.warn(
           `[${this.runtime.character.name}] MessageBusService: Failed to fetch agent servers, but added default server`
         );
       }
     } catch (error) {
-      logger27.error(
+      logger28.error(
         `[${this.runtime.character.name}] MessageBusService: Error fetching agent servers:`,
         error
       );
-      const DEFAULT_SERVER_ID6 = "00000000-0000-0000-0000-000000000000";
-      this.subscribedServers.add(DEFAULT_SERVER_ID6);
-      logger27.info(
+      const DEFAULT_SERVER_ID7 = "00000000-0000-0000-0000-000000000000";
+      this.subscribedServers.add(DEFAULT_SERVER_ID7);
+      logger28.info(
         `[${this.runtime.character.name}] MessageBusService: Added default server after error`
       );
     }
@@ -4895,13 +5259,13 @@ var MessageBusService = class _MessageBusService extends Service {
     }
     if (data.type === "agent_added_to_server") {
       this.subscribedServers.add(data.serverId);
-      logger27.info(
+      logger28.info(
         `[${this.runtime.character.name}] MessageBusService: Agent added to server ${data.serverId}`
       );
       await this.fetchValidChannelIds();
     } else if (data.type === "agent_removed_from_server") {
       this.subscribedServers.delete(data.serverId);
-      logger27.info(
+      logger28.info(
         `[${this.runtime.character.name}] MessageBusService: Agent removed from server ${data.serverId}`
       );
       await this.fetchValidChannelIds();
@@ -4909,19 +5273,19 @@ var MessageBusService = class _MessageBusService extends Service {
   }
   async validateServerSubscription(message) {
     if (!this.subscribedServers.has(message.server_id)) {
-      logger27.debug(
+      logger28.debug(
         `[${this.runtime.character.name}] MessageBusService: Agent not subscribed to server ${message.server_id}, ignoring message`
       );
       return false;
     }
-    logger27.info(
+    logger28.info(
       `[${this.runtime.character.name}] MessageBusService: Passed server subscription check for ${message.server_id}`
     );
     return true;
   }
   async validateNotSelfMessage(message) {
     if (message.author_id === this.runtime.agentId) {
-      logger27.debug(
+      logger28.debug(
         `[${this.runtime.character.name}] MessageBusService: Agent is the author of the message, ignoring message`
       );
       return false;
@@ -4943,7 +5307,7 @@ var MessageBusService = class _MessageBusService extends Service {
       });
     } catch (error) {
       if (error.message && error.message.includes("worlds_pkey")) {
-        logger27.debug(
+        logger28.debug(
           `[${this.runtime.character.name}] MessageBusService: World ${agentWorldId} already exists, continuing with message processing`
         );
       } else {
@@ -4959,14 +5323,14 @@ var MessageBusService = class _MessageBusService extends Service {
         channelId: message.channel_id,
         serverId: message.server_id,
         source: message.source_type || "central-bus",
-        type: message.metadata?.channelType || ChannelType6.GROUP,
+        type: message.metadata?.channelType || ChannelType7.GROUP,
         metadata: {
           ...message.metadata?.channelMetadata || {}
         }
       });
     } catch (error) {
       if (error.message && error.message.includes("rooms_pkey")) {
-        logger27.debug(
+        logger28.debug(
           `[${this.runtime.character.name}] MessageBusService: Room ${agentRoomId} already exists, continuing with message processing`
         );
       } else {
@@ -4998,8 +5362,9 @@ var MessageBusService = class _MessageBusService extends Service {
       attachments: message.metadata?.attachments,
       inReplyTo: message.in_reply_to_message_id ? createUniqueUuid6(this.runtime, message.in_reply_to_message_id) : void 0
     };
+    const uniqueMemoryId = createUniqueUuid6(this.runtime, `${message.id}-${this.runtime.agentId}`);
     return {
-      id: createUniqueUuid6(this.runtime, message.id),
+      id: uniqueMemoryId,
       entityId: agentAuthorEntityId,
       agentId: this.runtime.agentId,
       roomId: agentRoomId,
@@ -5018,25 +5383,45 @@ var MessageBusService = class _MessageBusService extends Service {
       }
     };
   }
-  async handleIncomingMessage(message) {
-    logger27.info(
+  async handleIncomingMessage(data) {
+    if (!data || typeof data !== "object") {
+      logger28.error(
+        `[${this.runtime.character.name}] MessageBusService: Invalid message data received`
+      );
+      return;
+    }
+    const messageData = data;
+    if (!messageData.id || !messageData.channel_id || !messageData.author_id || !messageData.content) {
+      logger28.error(
+        `[${this.runtime.character.name}] MessageBusService: Message missing required fields`,
+        {
+          hasId: !!messageData.id,
+          hasChannelId: !!messageData.channel_id,
+          hasAuthorId: !!messageData.author_id,
+          hasContent: !!messageData.content
+        }
+      );
+      return;
+    }
+    const message = messageData;
+    logger28.info(
       `[${this.runtime.character.name}] MessageBusService: Received message from central bus`,
       { messageId: message.id }
     );
     const participants = await this.getChannelParticipants(message.channel_id);
     if (!participants.includes(this.runtime.agentId)) {
-      logger27.info(
+      logger28.info(
         `[${this.runtime.character.name}] MessageBusService: Agent not a participant in channel ${message.channel_id}, ignoring message`
       );
       return;
     }
-    logger27.info(
+    logger28.info(
       `[${this.runtime.character.name} - ${this.runtime.agentId}] MessageBusService: Agent is a participant in channel ${message.channel_id}, proceeding with message processing`
     );
     try {
       if (!await this.validateServerSubscription(message)) return;
       if (!await this.validateNotSelfMessage(message)) return;
-      logger27.info(
+      logger28.info(
         `[${this.runtime.character.name}] MessageBusService: All checks passed, proceeding to create agent memory and emit MESSAGE_RECEIVED event`
       );
       const { agentWorldId, agentRoomId } = await this.ensureWorldAndRoomExist(message);
@@ -5049,13 +5434,13 @@ var MessageBusService = class _MessageBusService extends Service {
       );
       const existingMemory = await this.runtime.getMemoryById(agentMemory.id);
       if (existingMemory) {
-        logger27.debug(
+        logger28.debug(
           `[${this.runtime.character.name}] MessageBusService: Memory ${agentMemory.id} already exists, skipping duplicate processing`
         );
         return;
       }
       const callbackForCentralBus = async (responseContent) => {
-        logger27.info(
+        logger28.info(
           `[${this.runtime.character.name}] Agent generated response for message. Preparing to send back to bus.`
         );
         await this.runtime.createMemory(
@@ -5090,7 +5475,7 @@ var MessageBusService = class _MessageBusService extends Service {
         }
       });
     } catch (error) {
-      logger27.error(
+      logger28.error(
         `[${this.runtime.character.name}] MessageBusService: Error processing incoming message:`,
         error
       );
@@ -5098,7 +5483,7 @@ var MessageBusService = class _MessageBusService extends Service {
   }
   async handleMessageDeleted(data) {
     try {
-      logger27.info(
+      logger28.info(
         `[${this.runtime.character.name}] MessageBusService: Received message_deleted event for message ${data.messageId}`
       );
       const agentMemoryId = createUniqueUuid6(this.runtime, data.messageId);
@@ -5109,16 +5494,16 @@ var MessageBusService = class _MessageBusService extends Service {
           message: existingMemory,
           source: "message-bus-service"
         });
-        logger27.debug(
+        logger28.debug(
           `[${this.runtime.character.name}] MessageBusService: Successfully processed message deletion for ${data.messageId}`
         );
       } else {
-        logger27.warn(
+        logger28.warn(
           `[${this.runtime.character.name}] MessageBusService: No memory found for deleted message ${data.messageId}`
         );
       }
     } catch (error) {
-      logger27.error(
+      logger28.error(
         `[${this.runtime.character.name}] MessageBusService: Error handling message deletion:`,
         error
       );
@@ -5126,7 +5511,7 @@ var MessageBusService = class _MessageBusService extends Service {
   }
   async handleChannelCleared(data) {
     try {
-      logger27.info(
+      logger28.info(
         `[${this.runtime.character.name}] MessageBusService: Received channel_cleared event for channel ${data.channelId}`
       );
       const agentRoomId = createUniqueUuid6(this.runtime, data.channelId);
@@ -5134,7 +5519,7 @@ var MessageBusService = class _MessageBusService extends Service {
         tableName: "messages",
         roomIds: [agentRoomId]
       });
-      logger27.info(
+      logger28.info(
         `[${this.runtime.character.name}] MessageBusService: Found ${memories.length} memories to delete for channel ${data.channelId}`
       );
       await this.runtime.emitEvent(EventType2.CHANNEL_CLEARED, {
@@ -5144,11 +5529,11 @@ var MessageBusService = class _MessageBusService extends Service {
         channelId: data.channelId,
         memoryCount: memories.length
       });
-      logger27.info(
+      logger28.info(
         `[${this.runtime.character.name}] MessageBusService: Successfully processed channel clear for ${data.channelId} -> room ${agentRoomId}`
       );
     } catch (error) {
-      logger27.error(
+      logger28.error(
         `[${this.runtime.character.name}] MessageBusService: Error handling channel clear:`,
         error
       );
@@ -5161,14 +5546,14 @@ var MessageBusService = class _MessageBusService extends Service {
       const channelId = room?.channelId;
       const serverId = world?.serverId;
       if (!channelId || !serverId) {
-        logger27.error(
+        logger28.error(
           `[${this.runtime.character.name}] MessageBusService: Cannot map agent room/world to central IDs for response. AgentRoomID: ${agentRoomId}, AgentWorldID: ${agentWorldId}. Room or World object missing, or channelId/serverId not found on them.`
         );
         return;
       }
       const shouldSkip = content.actions?.includes("IGNORE") || !content.text || content.text.trim() === "";
       if (shouldSkip) {
-        logger27.info(
+        logger28.info(
           `[${this.runtime.character.name}] MessageBusService: Skipping response (reason: ${content.actions?.includes("IGNORE") ? "IGNORE action" : "No text"})`
         );
         return;
@@ -5198,10 +5583,10 @@ var MessageBusService = class _MessageBusService extends Service {
           agentName: this.runtime.character.name,
           attachments: content.attachments,
           channelType: originalMessage?.metadata?.channelType || room?.type,
-          isDm: originalMessage?.metadata?.isDm || (originalMessage?.metadata?.channelType || room?.type) === ChannelType6.DM
+          isDm: originalMessage?.metadata?.isDm || (originalMessage?.metadata?.channelType || room?.type) === ChannelType7.DM
         }
       };
-      logger27.info(
+      logger28.info(
         `[${this.runtime.character.name}] MessageBusService: Sending payload to central server API endpoint (/api/messaging/submit):`,
         payloadToServer
       );
@@ -5214,12 +5599,12 @@ var MessageBusService = class _MessageBusService extends Service {
         body: JSON.stringify(payloadToServer)
       });
       if (!response.ok) {
-        logger27.error(
+        logger28.error(
           `[${this.runtime.character.name}] MessageBusService: Error sending response to central server: ${response.status} ${await response.text()}`
         );
       }
     } catch (error) {
-      logger27.error(
+      logger28.error(
         `[${this.runtime.character.name}] MessageBusService: Error sending agent response to bus:`,
         error
       );
@@ -5235,7 +5620,7 @@ var MessageBusService = class _MessageBusService extends Service {
         body: JSON.stringify({ channel_id: channelId, server_id: serverId })
       });
     } catch (error) {
-      logger27.warn(
+      logger28.warn(
         `[${this.runtime.character.name}] MessageBusService: Failed to notify completion`,
         error
       );
@@ -5260,7 +5645,7 @@ var MessageBusService = class _MessageBusService extends Service {
       if (!isNaN(portNum) && portNum > 0 && portNum <= 65535) {
         validatedPort = portNum;
       } else {
-        logger27.warn(`[MessageBusService] Invalid SERVER_PORT value: ${serverPort}`);
+        logger28.warn(`[MessageBusService] Invalid SERVER_PORT value: ${serverPort}`);
       }
     }
     const host = process.platform === "win32" ? "127.0.0.1" : "localhost";
@@ -5269,14 +5654,14 @@ var MessageBusService = class _MessageBusService extends Service {
     try {
       const url = new URL(baseUrl);
       if (!["http:", "https:"].includes(url.protocol)) {
-        logger27.warn(
+        logger28.warn(
           `[MessageBusService] Unsafe protocol in CENTRAL_MESSAGE_SERVER_URL: ${url.protocol}`
         );
         return defaultUrl;
       }
       const allowedHosts = ["localhost", "127.0.0.1", "::1"];
       if (!allowedHosts.includes(url.hostname)) {
-        logger27.warn(
+        logger28.warn(
           `[MessageBusService] Unsafe hostname in CENTRAL_MESSAGE_SERVER_URL: ${url.hostname}`
         );
         return defaultUrl;
@@ -5284,7 +5669,7 @@ var MessageBusService = class _MessageBusService extends Service {
       if (url.port) {
         const portNum = parseInt(url.port, 10);
         if (isNaN(portNum) || portNum <= 0 || portNum > 65535) {
-          logger27.warn(
+          logger28.warn(
             `[MessageBusService] Invalid port in CENTRAL_MESSAGE_SERVER_URL: ${url.port}`
           );
           return defaultUrl;
@@ -5295,14 +5680,14 @@ var MessageBusService = class _MessageBusService extends Service {
       url.hash = "";
       return url.toString().replace(/\/$/, "");
     } catch (error) {
-      logger27.error(
+      logger28.error(
         `[MessageBusService] Invalid URL format in CENTRAL_MESSAGE_SERVER_URL: ${baseUrl}`
       );
       return defaultUrl;
     }
   }
   async stop() {
-    logger27.info(`[${this.runtime.character.name}] MessageBusService stopping...`);
+    logger28.info(`[${this.runtime.character.name}] MessageBusService stopping...`);
     bus_default.off("new_message", this.boundHandleIncomingMessage);
     bus_default.off("server_agent_update", this.boundHandleServerAgentUpdate);
     bus_default.off("message_deleted", this.boundHandleMessageDeleted);
@@ -5320,7 +5705,7 @@ import fs8 from "fs";
 import path8 from "path";
 import { fileURLToPath } from "url";
 import {
-  logger as logger28,
+  logger as logger29,
   parseAndValidateCharacter,
   validateCharacter
 } from "@elizaos/core";
@@ -5350,7 +5735,7 @@ async function loadCharactersFromUrl(url) {
     return characters;
   } catch (e) {
     const errorMsg = e instanceof Error ? e.message : String(e);
-    logger28.error(`Error loading character(s) from ${url}: ${errorMsg}`);
+    logger29.error(`Error loading character(s) from ${url}: ${errorMsg}`);
     if (errorMsg.includes("Character validation failed") || errorMsg.includes("validation")) {
       throw new Error(
         `Invalid character data from URL '${url}'. The character data does not match the required schema: ${errorMsg}`
@@ -5401,13 +5786,13 @@ async function jsonToCharacter(character) {
     }
     const revalidationResult = validateCharacter(updatedCharacter);
     if (!revalidationResult.success) {
-      logger28.warn(
+      logger29.warn(
         "Character became invalid after adding environment settings, using original validated character"
       );
       return validatedCharacter;
     }
     if (!revalidationResult.data) {
-      logger28.warn("Revalidation succeeded but no data returned, using original character");
+      logger29.warn("Revalidation succeeded but no data returned, using original character");
       return validatedCharacter;
     }
     return revalidationResult.data;
@@ -5428,30 +5813,30 @@ async function loadCharacter(filePath) {
 function handleCharacterLoadError(path10, error) {
   const errorMsg = error instanceof Error ? error.message : String(error);
   if (errorMsg.includes("ENOENT") || errorMsg.includes("no such file")) {
-    logger28.error(`Character file not found: ${path10}`);
+    logger29.error(`Character file not found: ${path10}`);
     throw new Error(
       `Character '${path10}' not found. Please check if the file exists and the path is correct.`
     );
   } else if (errorMsg.includes("Character validation failed")) {
-    logger28.error(`Character validation failed for: ${path10}`);
+    logger29.error(`Character validation failed for: ${path10}`);
     throw new Error(`Character file '${path10}' contains invalid character data. ${errorMsg}`);
   } else if (errorMsg.includes("JSON")) {
-    logger28.error(`JSON parsing error in character file: ${path10}`);
+    logger29.error(`JSON parsing error in character file: ${path10}`);
     throw new Error(`Character file '${path10}' has malformed JSON. Please check the file content.`);
   } else if (errorMsg.includes("Invalid JSON")) {
-    logger28.error(`Invalid JSON in character file: ${path10}`);
+    logger29.error(`Invalid JSON in character file: ${path10}`);
     throw new Error(
       `Character file '${path10}' has invalid JSON format. Please check the file content.`
     );
   } else {
-    logger28.error(`Error loading character from ${path10}: ${errorMsg}`);
+    logger29.error(`Error loading character from ${path10}: ${errorMsg}`);
     throw new Error(`Failed to load character '${path10}': ${errorMsg}`);
   }
 }
 async function safeLoadCharacter(path10) {
   try {
     const character = await loadCharacter(path10);
-    logger28.info(`Successfully loaded character from: ${path10}`);
+    logger29.info(`Successfully loaded character from: ${path10}`);
     return character;
   } catch (e) {
     return handleCharacterLoadError(path10, e);
@@ -5526,7 +5911,7 @@ async function readCharactersFromStorage(characterPaths) {
       characterPaths.push(path8.join(uploadDir, fileName));
     }
   } catch (err) {
-    logger28.error(`Error reading directory: ${err.message}`);
+    logger29.error(`Error reading directory: ${err.message}`);
   }
   return characterPaths;
 }
@@ -5544,12 +5929,12 @@ async function loadCharacters(charactersArg) {
         loadedCharacters.push(character);
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        logger28.error(`Failed to load character from '${characterPath}': ${errorMsg}`);
+        logger29.error(`Failed to load character from '${characterPath}': ${errorMsg}`);
       }
     }
   }
   if (hasValidRemoteUrls()) {
-    logger28.info("Loading characters from remote URLs");
+    logger29.info("Loading characters from remote URLs");
     const characterUrls = commaSeparatedStringToArray(process.env.REMOTE_CHARACTER_URLS || "");
     for (const characterUrl of characterUrls) {
       const characters = await loadCharactersFromUrl(characterUrl);
@@ -5557,8 +5942,8 @@ async function loadCharacters(charactersArg) {
     }
   }
   if (loadedCharacters.length === 0) {
-    logger28.info("No characters found, using default character");
-    logger28.warn("Server package does not include a default character. Please provide one.");
+    logger29.info("No characters found, using default character");
+    logger29.warn("Server package does not include a default character. Please provide one.");
   }
   return loadedCharacters;
 }
@@ -5604,7 +5989,7 @@ function resolvePgliteDir(dir, fallbackDir) {
   return resolved;
 }
 var __dirname2 = dirname(fileURLToPath2(import.meta.url));
-var DEFAULT_SERVER_ID5 = "00000000-0000-0000-0000-000000000000";
+var DEFAULT_SERVER_ID6 = "00000000-0000-0000-0000-000000000000";
 function isWebUIEnabled() {
   const isProduction = process.env.NODE_ENV === "production";
   const uiEnabledEnv = process.env.ELIZA_UI_ENABLE;
@@ -5636,13 +6021,13 @@ var AgentServer = class {
    */
   constructor() {
     try {
-      logger29.debug("Initializing AgentServer (constructor)...");
+      logger30.debug("Initializing AgentServer (constructor)...");
       this.agents = /* @__PURE__ */ new Map();
       this.loadCharacterTryPath = loadCharacterTryPath;
       this.jsonToCharacter = jsonToCharacter;
       this.registerSignalHandlers();
     } catch (error) {
-      logger29.error("Failed to initialize AgentServer (constructor):", error);
+      logger30.error("Failed to initialize AgentServer (constructor):", error);
       throw error;
     }
   }
@@ -5654,13 +6039,13 @@ var AgentServer = class {
    */
   async initialize(options) {
     if (this.isInitialized) {
-      logger29.warn("AgentServer is already initialized, skipping initialization");
+      logger30.warn("AgentServer is already initialized, skipping initialization");
       return;
     }
     try {
-      logger29.debug("Initializing AgentServer (async operations)...");
+      logger30.debug("Initializing AgentServer (async operations)...");
       const agentDataDir = resolvePgliteDir(options?.dataDir);
-      logger29.info(`[INIT] Database Dir for SQL plugin: ${agentDataDir}`);
+      logger30.info(`[INIT] Database Dir for SQL plugin: ${agentDataDir}`);
       this.database = createDatabaseAdapter(
         {
           dataDir: agentDataDir,
@@ -5669,47 +6054,47 @@ var AgentServer = class {
         "00000000-0000-0000-0000-000000000002"
       );
       await this.database.init();
-      logger29.success("Consolidated database initialized successfully");
-      logger29.info("[INIT] Running database migrations for messaging tables...");
+      logger30.success("Consolidated database initialized successfully");
+      logger30.info("[INIT] Running database migrations for messaging tables...");
       try {
         const migrationService = new DatabaseMigrationService();
         const db = this.database.getDatabase();
         await migrationService.initializeWithDatabase(db);
         migrationService.discoverAndRegisterPluginSchemas([sqlPlugin]);
         await migrationService.runAllPluginMigrations();
-        logger29.success("[INIT] Database migrations completed successfully");
+        logger30.success("[INIT] Database migrations completed successfully");
       } catch (migrationError) {
-        logger29.error("[INIT] Failed to run database migrations:", migrationError);
+        logger30.error("[INIT] Failed to run database migrations:", migrationError);
         throw new Error(
           `Database migration failed: ${migrationError instanceof Error ? migrationError.message : String(migrationError)}`
         );
       }
       await new Promise((resolve) => setTimeout(resolve, 500));
-      logger29.info("[INIT] Ensuring default server exists...");
+      logger30.info("[INIT] Ensuring default server exists...");
       await this.ensureDefaultServer();
-      logger29.success("[INIT] Default server setup complete");
+      logger30.success("[INIT] Default server setup complete");
       await this.initializeServer(options);
       await new Promise((resolve) => setTimeout(resolve, 250));
       this.isInitialized = true;
     } catch (error) {
-      logger29.error("Failed to initialize AgentServer (async operations):", error);
+      logger30.error("Failed to initialize AgentServer (async operations):", error);
       console.trace(error);
       throw error;
     }
   }
   async ensureDefaultServer() {
     try {
-      logger29.info("[AgentServer] Checking for default server...");
+      logger30.info("[AgentServer] Checking for default server...");
       const servers = await this.database.getMessageServers();
-      logger29.debug(`[AgentServer] Found ${servers.length} existing servers`);
+      logger30.debug(`[AgentServer] Found ${servers.length} existing servers`);
       servers.forEach((s) => {
-        logger29.debug(`[AgentServer] Existing server: ID=${s.id}, Name=${s.name}`);
+        logger30.debug(`[AgentServer] Existing server: ID=${s.id}, Name=${s.name}`);
       });
       const defaultServer = servers.find(
         (s) => s.id === "00000000-0000-0000-0000-000000000000"
       );
       if (!defaultServer) {
-        logger29.info(
+        logger30.info(
           "[AgentServer] Creating default server with UUID 00000000-0000-0000-0000-000000000000..."
         );
         try {
@@ -5718,43 +6103,43 @@ var AgentServer = class {
             VALUES ('00000000-0000-0000-0000-000000000000', 'Default Server', 'eliza_default', NOW(), NOW())
             ON CONFLICT (id) DO NOTHING
           `);
-          logger29.success("[AgentServer] Default server created via raw SQL");
+          logger30.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'"
           );
-          logger29.debug("[AgentServer] Raw SQL check result:", checkResult);
+          logger30.debug("[AgentServer] Raw SQL check result:", checkResult);
         } catch (sqlError) {
-          logger29.error("[AgentServer] Raw SQL insert failed:", sqlError);
+          logger30.error("[AgentServer] Raw SQL insert failed:", sqlError);
           try {
             const server = await this.database.createMessageServer({
               id: "00000000-0000-0000-0000-000000000000",
               name: "Default Server",
               sourceType: "eliza_default"
             });
-            logger29.success("[AgentServer] Default server created via ORM with ID:", server.id);
+            logger30.success("[AgentServer] Default server created via ORM with ID:", server.id);
           } catch (ormError) {
-            logger29.error("[AgentServer] Both SQL and ORM creation failed:", ormError);
+            logger30.error("[AgentServer] Both SQL and ORM creation failed:", ormError);
             throw new Error(`Failed to create default server: ${ormError.message}`);
           }
         }
         const verifyServers = await this.database.getMessageServers();
-        logger29.debug(`[AgentServer] After creation attempt, found ${verifyServers.length} servers`);
+        logger30.debug(`[AgentServer] After creation attempt, found ${verifyServers.length} servers`);
         verifyServers.forEach((s) => {
-          logger29.debug(`[AgentServer] Server after creation: ID=${s.id}, Name=${s.name}`);
+          logger30.debug(`[AgentServer] Server after creation: ID=${s.id}, Name=${s.name}`);
         });
         const verifyDefault = verifyServers.find(
           (s) => s.id === "00000000-0000-0000-0000-000000000000"
         );
         if (!verifyDefault) {
-          throw new Error(`Failed to create or verify default server with ID ${DEFAULT_SERVER_ID5}`);
+          throw new Error(`Failed to create or verify default server with ID ${DEFAULT_SERVER_ID6}`);
         } else {
-          logger29.success("[AgentServer] Default server creation verified successfully");
+          logger30.success("[AgentServer] Default server creation verified successfully");
         }
       } else {
-        logger29.info("[AgentServer] Default server already exists with ID:", defaultServer.id);
+        logger30.info("[AgentServer] Default server already exists with ID:", defaultServer.id);
       }
     } catch (error) {
-      logger29.error("[AgentServer] Error ensuring default server:", error);
+      logger30.error("[AgentServer] Error ensuring default server:", error);
       throw error;
     }
   }
@@ -5769,12 +6154,12 @@ var AgentServer = class {
       if (options?.clientPath) {
         this.clientPath = options.clientPath;
       }
-      this.app = express31();
+      this.app = express32();
       const isProd = process.env.NODE_ENV === "production";
-      logger29.debug("Setting up security headers...");
+      logger30.debug("Setting up security headers...");
       if (!isProd) {
-        logger29.debug(`NODE_ENV: ${process.env.NODE_ENV}`);
-        logger29.debug(`CSP will be: ${isProd ? "ENABLED" : "MINIMAL_DEV"}`);
+        logger30.debug(`NODE_ENV: ${process.env.NODE_ENV}`);
+        logger30.debug(`CSP will be: ${isProd ? "ENABLED" : "MINIMAL_DEV"}`);
       }
       this.app.use(
         helmet2({
@@ -5838,12 +6223,12 @@ var AgentServer = class {
         })
       );
       if (options?.middlewares) {
-        logger29.debug("Applying custom middlewares...");
+        logger30.debug("Applying custom middlewares...");
         for (const middleware of options.middlewares) {
           this.app.use(middleware);
         }
       }
-      logger29.debug("Setting up standard middlewares...");
+      logger30.debug("Setting up standard middlewares...");
       this.app.use(
         (0, import_cors2.default)({
           origin: process.env.CORS_ORIGIN || true,
@@ -5853,30 +6238,30 @@ var AgentServer = class {
         })
       );
       this.app.use(
-        express31.json({
+        express32.json({
           limit: process.env.EXPRESS_MAX_PAYLOAD || "2mb"
         })
       );
       const serverAuthToken = process.env.ELIZA_SERVER_AUTH_TOKEN;
       if (serverAuthToken) {
-        logger29.info("Server authentication enabled. Requires X-API-KEY header for /api routes.");
+        logger30.info("Server authentication enabled. Requires X-API-KEY header for /api routes.");
         this.app.use("/api", (req, res, next) => {
           apiKeyAuthMiddleware(req, res, next);
         });
       } else {
-        logger29.warn(
+        logger30.warn(
           "Server authentication is disabled. Set ELIZA_SERVER_AUTH_TOKEN environment variable to enable."
         );
       }
       this.isWebUIEnabled = isWebUIEnabled();
       if (this.isWebUIEnabled) {
-        logger29.info("Web UI enabled");
+        logger30.info("Web UI enabled");
       } else {
         const uiEnabledEnv = process.env.ELIZA_UI_ENABLE;
         if (uiEnabledEnv !== void 0 && uiEnabledEnv.trim() !== "") {
-          logger29.info(`Web UI disabled by environment variable (ELIZA_UI_ENABLE=${uiEnabledEnv})`);
+          logger30.info(`Web UI disabled by environment variable (ELIZA_UI_ENABLE=${uiEnabledEnv})`);
         } else {
-          logger29.info("Web UI disabled for security (production mode)");
+          logger30.info("Web UI disabled for security (production mode)");
         }
       }
       const uploadsBasePath = path9.join(process.cwd(), ".eliza", "data", "uploads", "agents");
@@ -5907,13 +6292,13 @@ var AgentServer = class {
           res.sendFile(sanitizedFilename, { root: agentUploadsPath }, (err) => {
             if (err) {
               if (err.message === "Request aborted") {
-                logger29.warn(`[MEDIA] Download aborted: ${req.originalUrl}`);
+                logger30.warn(`[MEDIA] Download aborted: ${req.originalUrl}`);
               } else if (!res.headersSent) {
-                logger29.warn(`[MEDIA] File not found: ${agentUploadsPath}/${sanitizedFilename}`);
+                logger30.warn(`[MEDIA] File not found: ${agentUploadsPath}/${sanitizedFilename}`);
                 res.status(404).json({ error: "File not found" });
               }
             } else {
-              logger29.debug(`[MEDIA] Successfully served: ${sanitizedFilename}`);
+              logger30.debug(`[MEDIA] Successfully served: ${sanitizedFilename}`);
             }
           });
         }
@@ -5961,12 +6346,12 @@ var AgentServer = class {
           }
           res.sendFile(filePath, (err) => {
             if (err) {
-              logger29.warn(`[STATIC] Channel media file not found: ${filePath}`, err);
+              logger30.warn(`[STATIC] Channel media file not found: ${filePath}`, err);
               if (!res.headersSent) {
                 res.status(404).json({ error: "File not found" });
               }
             } else {
-              logger29.debug(`[STATIC] Served channel media file: ${filePath}`);
+              logger30.debug(`[STATIC] Served channel media file: ${filePath}`);
             }
           });
         }
@@ -6101,30 +6486,30 @@ var AgentServer = class {
             })()
           ].filter(Boolean)
         ].filter(Boolean);
-        logger29.debug(`[STATIC] process.argv[0]: ${process.argv[0]}`);
-        logger29.debug(`[STATIC] process.argv[1]: ${process.argv[1]}`);
-        logger29.debug(`[STATIC] __dirname: ${__dirname2}`);
+        logger30.debug(`[STATIC] process.argv[0]: ${process.argv[0]}`);
+        logger30.debug(`[STATIC] process.argv[1]: ${process.argv[1]}`);
+        logger30.debug(`[STATIC] __dirname: ${__dirname2}`);
         for (const possiblePath of possiblePaths) {
           if (possiblePath && existsSync3(path9.join(possiblePath, "index.html"))) {
             clientPath = possiblePath;
-            logger29.info(`[STATIC] Found client files at: ${clientPath}`);
+            logger30.info(`[STATIC] Found client files at: ${clientPath}`);
             break;
           }
         }
         if (clientPath) {
           this.clientPath = clientPath;
-          this.app.use(express31.static(clientPath, staticOptions));
-          logger29.info(`[STATIC] Serving static files from: ${clientPath}`);
+          this.app.use(express32.static(clientPath, staticOptions));
+          logger30.info(`[STATIC] Serving static files from: ${clientPath}`);
         } else {
-          logger29.warn("[STATIC] Client dist path not found. Searched locations:");
+          logger30.warn("[STATIC] Client dist path not found. Searched locations:");
           possiblePaths.forEach((p) => {
-            if (p) logger29.warn(`[STATIC]   - ${p}`);
+            if (p) logger30.warn(`[STATIC]   - ${p}`);
           });
-          logger29.warn("[STATIC] The web UI will not be available.");
-          logger29.warn(
+          logger30.warn("[STATIC] The web UI will not be available.");
+          logger30.warn(
             "[STATIC] To fix this, ensure the client is built: cd packages/client && bun run build"
           );
-          logger29.warn("[STATIC] Then rebuild the server: cd packages/server && bun run build");
+          logger30.warn("[STATIC] Then rebuild the server: cd packages/server && bun run build");
         }
       }
       const pluginRouteHandler = createPluginRouteHandler(this.agents);
@@ -6134,13 +6519,13 @@ var AgentServer = class {
         "/api",
         (req, _res, next) => {
           if (req.path !== "/ping") {
-            logger29.debug(`API request: ${req.method} ${req.path}`);
+            logger30.debug(`API request: ${req.method} ${req.path}`);
           }
           next();
         },
         apiRouter,
         (err, req, res, _next) => {
-          logger29.error(`API error: ${req.method} ${req.path}`, err);
+          logger30.error(`API error: ${req.method} ${req.path}`, err);
           res.status(500).json({
             success: false,
             error: {
@@ -6173,27 +6558,27 @@ var AgentServer = class {
           if (resolvedClientPath) {
             const indexFilePath = path9.join(resolvedClientPath, "index.html");
             if (!existsSync3(indexFilePath)) {
-              logger29.error(`[STATIC] index.html not found at expected path: ${indexFilePath}`);
-              logger29.error(`[STATIC] Client path was: ${resolvedClientPath}`);
+              logger30.error(`[STATIC] index.html not found at expected path: ${indexFilePath}`);
+              logger30.error(`[STATIC] Client path was: ${resolvedClientPath}`);
               res.status(404).send("Client application not found");
               return;
             }
             res.sendFile("index.html", { root: resolvedClientPath }, (err) => {
               if (err) {
-                logger29.warn(`[STATIC] Failed to serve index.html: ${err.message}`);
-                logger29.warn(`[STATIC] Attempted root: ${resolvedClientPath}`);
-                logger29.warn(`[STATIC] Full path was: ${indexFilePath}`);
-                logger29.warn(`[STATIC] Error code: ${err.code || "unknown"}`);
+                logger30.warn(`[STATIC] Failed to serve index.html: ${err.message}`);
+                logger30.warn(`[STATIC] Attempted root: ${resolvedClientPath}`);
+                logger30.warn(`[STATIC] Full path was: ${indexFilePath}`);
+                logger30.warn(`[STATIC] Error code: ${err.code || "unknown"}`);
                 if (!res.headersSent) {
                   res.status(404).send("Client application not found");
                 }
               } else {
-                logger29.debug(`[STATIC] Successfully served index.html for route: ${req.path}`);
+                logger30.debug(`[STATIC] Successfully served index.html for route: ${req.path}`);
               }
             });
           } else {
-            logger29.warn("[STATIC] Client dist path not found in SPA fallback");
-            logger29.warn("[STATIC] Neither local nor instance clientPath variables are set");
+            logger30.warn("[STATIC] Client dist path not found in SPA fallback");
+            logger30.warn("[STATIC] Neither local nor instance clientPath variables are set");
             res.status(404).send("Client application not found");
           }
         });
@@ -6204,9 +6589,9 @@ var AgentServer = class {
       }
       this.server = http.createServer(this.app);
       this.socketIO = setupSocketIO(this.server, this.agents, this);
-      logger29.success("AgentServer HTTP server and Socket.IO initialized");
+      logger30.success("AgentServer HTTP server and Socket.IO initialized");
     } catch (error) {
-      logger29.error("Failed to complete server initialization:", error);
+      logger30.error("Failed to complete server initialization:", error);
       throw error;
     }
   }
@@ -6229,47 +6614,47 @@ var AgentServer = class {
         throw new Error("Runtime missing character configuration");
       }
       this.agents.set(runtime.agentId, runtime);
-      logger29.debug(`Agent ${runtime.character.name} (${runtime.agentId}) added to agents map`);
+      logger30.debug(`Agent ${runtime.character.name} (${runtime.agentId}) added to agents map`);
       try {
         if (messageBusConnectorPlugin) {
           await runtime.registerPlugin(messageBusConnectorPlugin);
-          logger29.info(
+          logger30.info(
             `[AgentServer] Automatically registered MessageBusConnector for agent ${runtime.character.name}`
           );
         } else {
-          logger29.error(`[AgentServer] CRITICAL: MessageBusConnector plugin definition not found.`);
+          logger30.error(`[AgentServer] CRITICAL: MessageBusConnector plugin definition not found.`);
         }
       } catch (e) {
-        logger29.error(
+        logger30.error(
           `[AgentServer] CRITICAL: Failed to register MessageBusConnector for agent ${runtime.character.name}`,
           e
         );
       }
       const teePlugin = runtime.plugins.find((p) => p.name === "phala-tee-plugin");
       if (teePlugin) {
-        logger29.debug(`Found TEE plugin for agent ${runtime.agentId}`);
+        logger30.debug(`Found TEE plugin for agent ${runtime.agentId}`);
         if (teePlugin.providers) {
           for (const provider of teePlugin.providers) {
             runtime.registerProvider(provider);
-            logger29.debug(`Registered TEE provider: ${provider.name}`);
+            logger30.debug(`Registered TEE provider: ${provider.name}`);
           }
         }
         if (teePlugin.actions) {
           for (const action of teePlugin.actions) {
             runtime.registerAction(action);
-            logger29.debug(`Registered TEE action: ${action.name}`);
+            logger30.debug(`Registered TEE action: ${action.name}`);
           }
         }
       }
-      logger29.success(
+      logger30.success(
         `Successfully registered agent ${runtime.character.name} (${runtime.agentId}) with core services.`
       );
-      await this.addAgentToServer(DEFAULT_SERVER_ID5, runtime.agentId);
-      logger29.info(
-        `[AgentServer] Auto-associated agent ${runtime.character.name} with server ID: ${DEFAULT_SERVER_ID5}`
+      await this.addAgentToServer(DEFAULT_SERVER_ID6, runtime.agentId);
+      logger30.info(
+        `[AgentServer] Auto-associated agent ${runtime.character.name} with server ID: ${DEFAULT_SERVER_ID6}`
       );
     } catch (error) {
-      logger29.error("Failed to register agent:", error);
+      logger30.error("Failed to register agent:", error);
       throw error;
     }
   }
@@ -6281,7 +6666,7 @@ var AgentServer = class {
    */
   unregisterAgent(agentId) {
     if (!agentId) {
-      logger29.warn("[AGENT UNREGISTER] Attempted to unregister undefined or invalid agent runtime");
+      logger30.warn("[AGENT UNREGISTER] Attempted to unregister undefined or invalid agent runtime");
       return;
     }
     try {
@@ -6289,20 +6674,20 @@ var AgentServer = class {
       if (agent) {
         try {
           agent.stop().catch((stopError) => {
-            logger29.error(
+            logger30.error(
               `[AGENT UNREGISTER] Error stopping agent services for ${agentId}:`,
               stopError
             );
           });
-          logger29.debug(`[AGENT UNREGISTER] Stopping services for agent ${agentId}`);
+          logger30.debug(`[AGENT UNREGISTER] Stopping services for agent ${agentId}`);
         } catch (stopError) {
-          logger29.error(`[AGENT UNREGISTER] Error initiating stop for agent ${agentId}:`, stopError);
+          logger30.error(`[AGENT UNREGISTER] Error initiating stop for agent ${agentId}:`, stopError);
         }
       }
       this.agents.delete(agentId);
-      logger29.debug(`Agent ${agentId} removed from agents map`);
+      logger30.debug(`Agent ${agentId} removed from agents map`);
     } catch (error) {
-      logger29.error(`Error removing agent ${agentId}:`, error);
+      logger30.error(`Error removing agent ${agentId}:`, error);
     }
   }
   /**
@@ -6325,9 +6710,9 @@ var AgentServer = class {
         if (!port || typeof port !== "number") {
           throw new Error(`Invalid port number: ${port}`);
         }
-        logger29.debug(`Starting server on port ${port}...`);
-        logger29.debug(`Current agents count: ${this.agents.size}`);
-        logger29.debug(`Environment: ${process.env.NODE_ENV}`);
+        logger30.debug(`Starting server on port ${port}...`);
+        logger30.debug(`Current agents count: ${this.agents.size}`);
+        logger30.debug(`Environment: ${process.env.NODE_ENV}`);
         const host = process.env.SERVER_HOST || "0.0.0.0";
         this.server.listen(port, host, () => {
           if (this.isWebUIEnabled && process.env.NODE_ENV !== "development") {
@@ -6347,33 +6732,33 @@ Go to the dashboard at \x1B[1mhttp://localhost:${port}\x1B[22m\x1B[0m`
             );
           }
           console.log(`AgentServer is listening on port ${port}`);
-          logger29.success(
+          logger30.success(
             `REST API bound to ${host}:${port}. If running locally, access it at http://localhost:${port}.`
           );
-          logger29.debug(`Active agents: ${this.agents.size}`);
+          logger30.debug(`Active agents: ${this.agents.size}`);
           this.agents.forEach((agent, id) => {
-            logger29.debug(`- Agent ${id}: ${agent.character.name}`);
+            logger30.debug(`- Agent ${id}: ${agent.character.name}`);
           });
           resolve();
         }).on("error", (error) => {
-          logger29.error(`Failed to bind server to ${host}:${port}:`, error);
+          logger30.error(`Failed to bind server to ${host}:${port}:`, error);
           if (error.code === "EADDRINUSE") {
-            logger29.error(
+            logger30.error(
               `Port ${port} is already in use. Please try a different port or stop the process using that port.`
             );
           } else if (error.code === "EACCES") {
-            logger29.error(
+            logger30.error(
               `Permission denied to bind to port ${port}. Try using a port above 1024 or running with appropriate permissions.`
             );
           } else if (error.code === "EADDRNOTAVAIL") {
-            logger29.error(
+            logger30.error(
               `Cannot bind to ${host}:${port} - address not available. Check if the host address is correct.`
             );
           }
           reject(error);
         });
       } catch (error) {
-        logger29.error("Failed to start server:", error);
+        logger30.error("Failed to start server:", error);
         reject(error);
       }
     });
@@ -6385,7 +6770,7 @@ Go to the dashboard at \x1B[1mhttp://localhost:${port}\x1B[22m\x1B[0m`
   async stop() {
     if (this.server) {
       this.server.close(() => {
-        logger29.success("Server stopped");
+        logger30.success("Server stopped");
       });
     }
   }
@@ -6433,7 +6818,7 @@ Go to the dashboard at \x1B[1mhttp://localhost:${port}\x1B[22m\x1B[0m`
     for (const message of messages) {
       await this.database.deleteMessage(message.id);
     }
-    logger29.info(`[AgentServer] Cleared all messages for central channel: ${channelId}`);
+    logger30.info(`[AgentServer] Cleared all messages for central channel: ${channelId}`);
   }
   async findOrCreateCentralDmChannel(user1Id, user2Id, messageServerId) {
     return this.database.findOrCreateDmChannel(user1Id, user2Id, messageServerId);
@@ -6456,7 +6841,7 @@ Go to the dashboard at \x1B[1mhttp://localhost:${port}\x1B[22m\x1B[0m`
         metadata: createdMessage.metadata
       };
       bus_default.emit("new_message", messageForBus);
-      logger29.info(`[AgentServer] Published message ${createdMessage.id} to internal message bus`);
+      logger30.info(`[AgentServer] Published message ${createdMessage.id} to internal message bus`);
     }
     return createdMessage;
   }
@@ -6465,7 +6850,7 @@ Go to the dashboard at \x1B[1mhttp://localhost:${port}\x1B[22m\x1B[0m`
   }
   // Optional: Method to remove a participant
   async removeParticipantFromChannel() {
-    logger29.warn(
+    logger30.warn(
       `[AgentServer] Remove participant operation not directly supported in database adapter`
     );
   }
@@ -6522,31 +6907,31 @@ Go to the dashboard at \x1B[1mhttp://localhost:${port}\x1B[22m\x1B[0m`
    */
   registerSignalHandlers() {
     const gracefulShutdown = async () => {
-      logger29.info("Received shutdown signal, initiating graceful shutdown...");
-      logger29.debug("Stopping all agents...");
+      logger30.info("Received shutdown signal, initiating graceful shutdown...");
+      logger30.debug("Stopping all agents...");
       for (const [id, agent] of this.agents.entries()) {
         try {
           await agent.stop();
-          logger29.debug(`Stopped agent ${id}`);
+          logger30.debug(`Stopped agent ${id}`);
         } catch (error) {
-          logger29.error(`Error stopping agent ${id}:`, error);
+          logger30.error(`Error stopping agent ${id}:`, error);
         }
       }
       if (this.database) {
         try {
           await this.database.close();
-          logger29.info("Database closed.");
+          logger30.info("Database closed.");
         } catch (error) {
-          logger29.error("Error closing database:", error);
+          logger30.error("Error closing database:", error);
         }
       }
       if (this.server) {
         this.server.close(() => {
-          logger29.success("Server closed successfully");
+          logger30.success("Server closed successfully");
           process.exit(0);
         });
         setTimeout(() => {
-          logger29.error("Could not close connections in time, forcing shutdown");
+          logger30.error("Could not close connections in time, forcing shutdown");
           process.exit(1);
         }, 5e3);
       } else {
@@ -6555,7 +6940,7 @@ Go to the dashboard at \x1B[1mhttp://localhost:${port}\x1B[22m\x1B[0m`
     };
     process.on("SIGTERM", gracefulShutdown);
     process.on("SIGINT", gracefulShutdown);
-    logger29.debug("Shutdown handlers registered");
+    logger30.debug("Shutdown handlers registered");
   }
 };
 export {