@elizaos/server 1.0.11 → 1.0.12

package/dist/index.js

@@ -400,7 +400,7 @@ import { match } from "path-to-regexp";
 import { Server as SocketIOServer } from "socket.io";
 
 // src/api/agents/index.ts
-import express7 from "express";
+import express8 from "express";
 
 // src/api/agents/crud.ts
 import {
@@ -1186,24 +1186,170 @@ function createAgentMemoryRouter(agents) {
   return router;
 }
 
+// src/api/memory/rooms.ts
+import { validateUuid as validateUuid7, logger as logger7, createUniqueUuid as createUniqueUuid3, ChannelType } from "@elizaos/core";
+import express7 from "express";
+function createRoomManagementRouter(agents) {
+  const router = express7.Router();
+  router.post("/:agentId/rooms", async (req, res) => {
+    const agentId = validateUuid7(req.params.agentId);
+    if (!agentId) {
+      return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
+    }
+    const runtime = agents.get(agentId);
+    if (!runtime) {
+      return sendError(res, 404, "NOT_FOUND", "Agent not found");
+    }
+    try {
+      const { name, type = ChannelType.DM, source = "client", worldId, metadata } = req.body;
+      if (!name) {
+        return sendError(res, 400, "MISSING_PARAM", "Room name is required");
+      }
+      const roomId = createUniqueUuid3(runtime, `room-${Date.now()}`);
+      const serverId = req.body.serverId || `server-${Date.now()}`;
+      let resolvedWorldId = worldId;
+      if (!resolvedWorldId) {
+        const worldName = `World for ${name}`;
+        resolvedWorldId = createUniqueUuid3(runtime, `world-${Date.now()}`);
+        await runtime.ensureWorldExists({
+          id: resolvedWorldId,
+          name: worldName,
+          agentId: runtime.agentId,
+          serverId,
+          metadata
+        });
+      }
+      await runtime.ensureRoomExists({
+        id: roomId,
+        name,
+        source,
+        type,
+        channelId: roomId,
+        serverId,
+        worldId: resolvedWorldId,
+        metadata
+      });
+      await runtime.addParticipant(runtime.agentId, roomId);
+      await runtime.ensureParticipantInRoom(runtime.agentId, roomId);
+      await runtime.setParticipantUserState(roomId, runtime.agentId, "FOLLOWED");
+      sendSuccess(
+        res,
+        {
+          id: roomId,
+          name,
+          agentId,
+          createdAt: Date.now(),
+          source,
+          type,
+          worldId: resolvedWorldId,
+          serverId,
+          metadata
+        },
+        201
+      );
+    } catch (error) {
+      logger7.error(`[ROOM CREATE] Error creating room for agent ${agentId}:`, error);
+      sendError(
+        res,
+        500,
+        "CREATE_ERROR",
+        "Failed to create room",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  });
+  router.get("/:agentId/rooms", async (req, res) => {
+    const agentId = validateUuid7(req.params.agentId);
+    if (!agentId) {
+      return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
+    }
+    const runtime = agents.get(agentId);
+    if (!runtime) {
+      return sendError(res, 404, "NOT_FOUND", "Agent not found");
+    }
+    try {
+      const worlds = await runtime.getAllWorlds();
+      const participantRoomIds = await runtime.getRoomsForParticipant(agentId);
+      const agentRooms = [];
+      for (const world of worlds) {
+        const worldRooms = await runtime.getRooms(world.id);
+        for (const room of worldRooms) {
+          if (participantRoomIds.includes(room.id)) {
+            agentRooms.push({
+              ...room
+            });
+          }
+        }
+      }
+      sendSuccess(res, { rooms: agentRooms });
+    } catch (error) {
+      logger7.error(`[ROOMS LIST] Error retrieving rooms for agent ${agentId}:`, error);
+      sendError(
+        res,
+        500,
+        "RETRIEVAL_ERROR",
+        "Failed to retrieve agent rooms",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  });
+  router.get("/:agentId/rooms/:roomId", async (req, res) => {
+    const agentId = validateUuid7(req.params.agentId);
+    const roomId = validateUuid7(req.params.roomId);
+    if (!agentId || !roomId) {
+      return sendError(res, 400, "INVALID_ID", "Invalid agent ID or room ID format");
+    }
+    const runtime = agents.get(agentId);
+    if (!runtime) {
+      return sendError(res, 404, "NOT_FOUND", "Agent not found");
+    }
+    try {
+      const room = await runtime.getRoom(roomId);
+      if (!room) {
+        return sendError(res, 404, "NOT_FOUND", "Room not found");
+      }
+      let worldName;
+      if (room.worldId) {
+        const world = await runtime.getWorld(room.worldId);
+        worldName = world?.name;
+      }
+      sendSuccess(res, {
+        ...room,
+        ...worldName && { worldName }
+      });
+    } catch (error) {
+      logger7.error(`[ROOM DETAILS] Error retrieving room ${roomId} for agent ${agentId}:`, error);
+      sendError(
+        res,
+        500,
+        "RETRIEVAL_ERROR",
+        "Failed to retrieve room details",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  });
+  return router;
+}
+
 // src/api/agents/index.ts
 function agentsRouter(agents, serverInstance) {
-  const router = express7.Router();
+  const router = express8.Router();
   router.use("/", createAgentCrudRouter(agents, serverInstance));
   router.use("/", createAgentLifecycleRouter(agents, serverInstance));
   router.use("/", createAgentWorldsRouter(agents));
   router.use("/", createAgentPanelsRouter(agents));
   router.use("/", createAgentLogsRouter(agents));
-  router.use("/", createAgentMemoryRouter(agents, serverInstance));
+  router.use("/", createAgentMemoryRouter(agents));
+  router.use("/", createRoomManagementRouter(agents));
   return router;
 }
 
 // src/api/messaging/index.ts
-import express11 from "express";
+import express12 from "express";
 
 // src/api/messaging/core.ts
-import { logger as logger7, validateUuid as validateUuid7 } from "@elizaos/core";
-import express8 from "express";
+import { logger as logger8, validateUuid as validateUuid8 } from "@elizaos/core";
+import express9 from "express";
 
 // src/bus.ts
 import EventEmitter from "events";
@@ -1216,7 +1362,7 @@ var bus_default = internalMessageBus;
 // src/api/messaging/core.ts
 var DEFAULT_SERVER_ID = "00000000-0000-0000-0000-000000000000";
 function createMessagingCoreRouter(serverInstance) {
-  const router = express8.Router();
+  const router = express9.Router();
   router.post("/submit", async (req, res) => {
     const {
       channel_id,
@@ -1232,14 +1378,14 @@ function createMessagingCoreRouter(serverInstance) {
       metadata
       // Should include agent_name if author_id is agent's runtime.agentId
     } = req.body;
-    const isValidServerId = server_id === DEFAULT_SERVER_ID || validateUuid7(server_id);
-    if (!validateUuid7(channel_id) || !validateUuid7(author_id) || !content || !isValidServerId || !source_type || !raw_message) {
+    const isValidServerId = server_id === DEFAULT_SERVER_ID || validateUuid8(server_id);
+    if (!validateUuid8(channel_id) || !validateUuid8(author_id) || !content || !isValidServerId || !source_type || !raw_message) {
       return res.status(400).json({
         success: false,
         error: "Missing required fields: channel_id, server_id, author_id, content, source_type, raw_message"
       });
     }
-    if (in_reply_to_message_id && !validateUuid7(in_reply_to_message_id)) {
+    if (in_reply_to_message_id && !validateUuid8(in_reply_to_message_id)) {
       return res.status(400).json({
         success: false,
         error: "Invalid in_reply_to_message_id format"
@@ -1247,12 +1393,12 @@ function createMessagingCoreRouter(serverInstance) {
     }
     try {
       const newRootMessageData = {
-        channelId: validateUuid7(channel_id),
-        authorId: validateUuid7(author_id),
+        channelId: validateUuid8(channel_id),
+        authorId: validateUuid8(author_id),
         content,
         rawMessage: raw_message,
         sourceType: source_type || "agent_response",
-        inReplyToRootMessageId: in_reply_to_message_id ? validateUuid7(in_reply_to_message_id) || void 0 : void 0,
+        inReplyToRootMessageId: in_reply_to_message_id ? validateUuid8(in_reply_to_message_id) || void 0 : void 0,
         metadata
       };
       const createdMessage = await serverInstance.createMessage(newRootMessageData);
@@ -1277,13 +1423,13 @@ function createMessagingCoreRouter(serverInstance) {
       }
       res.status(201).json({ success: true, data: createdMessage });
     } catch (error) {
-      logger7.error("[Messages Router /submit] Error submitting agent message:", error);
+      logger8.error("[Messages Router /submit] Error submitting agent message:", error);
       res.status(500).json({ success: false, error: "Failed to submit agent message" });
     }
   });
   router.post("/complete", async (req, res) => {
     const { channel_id, server_id } = req.body;
-    if (!validateUuid7(channel_id) || !validateUuid7(server_id)) {
+    if (!validateUuid8(channel_id) || !validateUuid8(server_id)) {
       return res.status(400).json({
         success: false,
         error: "Missing or invalid fields: channel_id, server_id"
@@ -1298,7 +1444,7 @@ function createMessagingCoreRouter(serverInstance) {
       }
       res.status(200).json({ success: true, message: "Completion event emitted" });
     } catch (error) {
-      logger7.error("[Messages Router /notify-complete] Error notifying message complete:", error);
+      logger8.error("[Messages Router /notify-complete] Error notifying message complete:", error);
       res.status(500).json({ success: false, error: "Failed to notify message completion" });
     }
   });
@@ -1317,7 +1463,7 @@ function createMessagingCoreRouter(serverInstance) {
         sourceId: messagePayload.source_id,
         // Original platform message ID
         sourceType: messagePayload.source_type,
-        inReplyToRootMessageId: messagePayload.in_reply_to_message_id ? validateUuid7(messagePayload.in_reply_to_message_id) || void 0 : void 0,
+        inReplyToRootMessageId: messagePayload.in_reply_to_message_id ? validateUuid8(messagePayload.in_reply_to_message_id) || void 0 : void 0,
         metadata: messagePayload.metadata
       };
       const createdRootMessage = await serverInstance.createMessage(messageToCreate);
@@ -1339,7 +1485,7 @@ function createMessagingCoreRouter(serverInstance) {
         metadata: createdRootMessage.metadata
       };
       bus_default.emit("new_message", messageForBus);
-      logger7.info(
+      logger8.info(
         "[Messages Router /ingest-external] Published to internal message bus:",
         createdRootMessage.id
       );
@@ -1362,7 +1508,7 @@ function createMessagingCoreRouter(serverInstance) {
         data: { messageId: createdRootMessage.id }
       });
     } catch (error) {
-      logger7.error("[Messages Router /ingest-external] Error ingesting external message:", error);
+      logger8.error("[Messages Router /ingest-external] Error ingesting external message:", error);
       res.status(500).json({ success: false, error: "Failed to ingest message" });
     }
   });
@@ -1370,17 +1516,17 @@ function createMessagingCoreRouter(serverInstance) {
 }
 
 // src/api/messaging/servers.ts
-import { logger as logger8, validateUuid as validateUuid8 } from "@elizaos/core";
-import express9 from "express";
+import { logger as logger9, validateUuid as validateUuid9 } from "@elizaos/core";
+import express10 from "express";
 var DEFAULT_SERVER_ID2 = "00000000-0000-0000-0000-000000000000";
 function createServersRouter(serverInstance) {
-  const router = express9.Router();
+  const router = express10.Router();
   router.get("/central-servers", async (_req, res) => {
     try {
       const servers = await serverInstance.getServers();
       res.json({ success: true, data: { servers } });
     } catch (error) {
-      logger8.error("[Messages Router /central-servers] Error fetching servers:", error);
+      logger9.error("[Messages Router /central-servers] Error fetching servers:", error);
       res.status(500).json({ success: false, error: "Failed to fetch servers" });
     }
   });
@@ -1401,16 +1547,16 @@ function createServersRouter(serverInstance) {
       });
       res.status(201).json({ success: true, data: { server } });
     } catch (error) {
-      logger8.error("[Messages Router /servers] Error creating server:", error);
+      logger9.error("[Messages Router /servers] Error creating server:", error);
       res.status(500).json({ success: false, error: "Failed to create server" });
     }
   });
   router.post(
     "/servers/:serverId/agents",
     async (req, res) => {
-      const serverId = req.params.serverId === DEFAULT_SERVER_ID2 ? DEFAULT_SERVER_ID2 : validateUuid8(req.params.serverId);
+      const serverId = req.params.serverId === DEFAULT_SERVER_ID2 ? DEFAULT_SERVER_ID2 : validateUuid9(req.params.serverId);
       const { agentId } = req.body;
-      if (!serverId || !validateUuid8(agentId)) {
+      if (!serverId || !validateUuid9(agentId)) {
         return res.status(400).json({
           success: false,
           error: "Invalid serverId or agentId format"
@@ -1433,7 +1579,7 @@ function createServersRouter(serverInstance) {
           }
         });
       } catch (error) {
-        logger8.error(
+        logger9.error(
           `[MessagesRouter] Error adding agent ${agentId} to server ${serverId}:`,
           error
         );
@@ -1444,8 +1590,8 @@ function createServersRouter(serverInstance) {
   router.delete(
     "/servers/:serverId/agents/:agentId",
     async (req, res) => {
-      const serverId = req.params.serverId === DEFAULT_SERVER_ID2 ? DEFAULT_SERVER_ID2 : validateUuid8(req.params.serverId);
-      const agentId = validateUuid8(req.params.agentId);
+      const serverId = req.params.serverId === DEFAULT_SERVER_ID2 ? DEFAULT_SERVER_ID2 : validateUuid9(req.params.serverId);
+      const agentId = validateUuid9(req.params.agentId);
       if (!serverId || !agentId) {
         return res.status(400).json({
           success: false,
@@ -1469,7 +1615,7 @@ function createServersRouter(serverInstance) {
           }
         });
       } catch (error) {
-        logger8.error(
+        logger9.error(
           `[MessagesRouter] Error removing agent ${agentId} from server ${serverId}:`,
           error
         );
@@ -1480,7 +1626,7 @@ function createServersRouter(serverInstance) {
   router.get(
     "/servers/:serverId/agents",
     async (req, res) => {
-      const serverId = req.params.serverId === DEFAULT_SERVER_ID2 ? DEFAULT_SERVER_ID2 : validateUuid8(req.params.serverId);
+      const serverId = req.params.serverId === DEFAULT_SERVER_ID2 ? DEFAULT_SERVER_ID2 : validateUuid9(req.params.serverId);
       if (!serverId) {
         return res.status(400).json({
           success: false,
@@ -1498,7 +1644,7 @@ function createServersRouter(serverInstance) {
           }
         });
       } catch (error) {
-        logger8.error(`[MessagesRouter] Error fetching agents for server ${serverId}:`, error);
+        logger9.error(`[MessagesRouter] Error fetching agents for server ${serverId}:`, error);
         res.status(500).json({ success: false, error: "Failed to fetch server agents" });
       }
     }
@@ -1506,7 +1652,7 @@ function createServersRouter(serverInstance) {
   router.get(
     "/agents/:agentId/servers",
     async (req, res) => {
-      const agentId = validateUuid8(req.params.agentId);
+      const agentId = validateUuid9(req.params.agentId);
       if (!agentId) {
         return res.status(400).json({
           success: false,
@@ -1524,7 +1670,7 @@ function createServersRouter(serverInstance) {
           }
         });
       } catch (error) {
-        logger8.error(`[MessagesRouter] Error fetching servers for agent ${agentId}:`, error);
+        logger9.error(`[MessagesRouter] Error fetching servers for agent ${agentId}:`, error);
         res.status(500).json({ success: false, error: "Failed to fetch agent servers" });
       }
     }
@@ -1536,22 +1682,22 @@ function createServersRouter(serverInstance) {
 import {
   composePromptFromState,
   ModelType,
-  ChannelType,
-  logger as logger13,
-  validateUuid as validateUuid12
+  ChannelType as ChannelType2,
+  logger as logger14,
+  validateUuid as validateUuid13
 } from "@elizaos/core";
-import express10 from "express";
+import express11 from "express";
 
 // src/upload.ts
 import fs2 from "fs";
 import path2 from "path";
 import fileUpload from "express-fileupload";
-import { validateUuid as validateUuid9, logger as logger10 } from "@elizaos/core";
+import { validateUuid as validateUuid10, logger as logger11 } from "@elizaos/core";
 
 // src/api/shared/file-utils.ts
 import fs from "fs";
 import path from "path";
-import { logger as logger9 } from "@elizaos/core";
+import { logger as logger10 } from "@elizaos/core";
 function createSecureUploadDir(id, type) {
   if (id.includes("..") || id.includes("/") || id.includes("\\") || id.includes("\0")) {
     throw new Error(`Invalid ${type.slice(0, -1)} ID: contains illegal characters`);
@@ -1582,15 +1728,15 @@ var cleanupFile = (filePath) => {
     const resolvedPath = path.resolve(filePath);
     const normalizedPath = path.normalize(resolvedPath);
     if (normalizedPath.includes("..") || !normalizedPath.startsWith(process.cwd())) {
-      logger9.warn(`[SECURITY] Potentially unsafe file path blocked: ${filePath}`);
+      logger10.warn(`[SECURITY] Potentially unsafe file path blocked: ${filePath}`);
       return;
     }
     if (fs.existsSync(normalizedPath)) {
       fs.unlinkSync(normalizedPath);
-      logger9.debug(`[FILE] Successfully cleaned up file: ${normalizedPath}`);
+      logger10.debug(`[FILE] Successfully cleaned up file: ${normalizedPath}`);
     }
   } catch (error) {
-    logger9.error(`Error cleaning up file ${filePath}:`, error);
+    logger10.error(`Error cleaning up file ${filePath}:`, error);
   }
 };
 var cleanupUploadedFile = (file) => {
@@ -1633,14 +1779,14 @@ function generateSecureFilename(originalName) {
   return `${uniqueSuffix}-${sanitizedName}`;
 }
 function ensureUploadDir(id, type) {
-  if (!validateUuid9(id)) {
+  if (!validateUuid10(id)) {
     throw new Error(`Invalid ${type.slice(0, -1)} ID format`);
   }
   const uploadDir = createSecureUploadDir(id, type);
   if (!fs2.existsSync(uploadDir)) {
     fs2.mkdirSync(uploadDir, { recursive: true });
   }
-  logger10.debug(`[UPLOAD] Secure ${type.slice(0, -1)} upload directory created: ${uploadDir}`);
+  logger11.debug(`[UPLOAD] Secure ${type.slice(0, -1)} upload directory created: ${uploadDir}`);
   return uploadDir;
 }
 var agentAudioUpload = () => fileUpload({
@@ -1707,19 +1853,19 @@ async function processUploadedFile(file, targetId, type) {
     const finalPath = path2.join(uploadDir, filename);
     await file.mv(finalPath);
     const url = `/media/uploads/${type}/${targetId}/${filename}`;
-    logger10.debug(`[UPLOAD] File processed successfully: ${filename}`);
+    logger11.debug(`[UPLOAD] File processed successfully: ${filename}`);
     return { filename, path: finalPath, url };
   } catch (error) {
-    logger10.error("[UPLOAD] Error processing uploaded file:", error);
+    logger11.error("[UPLOAD] Error processing uploaded file:", error);
     throw error;
   }
 }
 
 // src/api/shared/middleware.ts
-import { validateUuid as validateUuid11, logger as logger12 } from "@elizaos/core";
+import { validateUuid as validateUuid12, logger as logger13 } from "@elizaos/core";
 
 // src/api/shared/validation.ts
-import { validateUuid as validateUuid10, logger as logger11 } from "@elizaos/core";
+import { validateUuid as validateUuid11, logger as logger12 } from "@elizaos/core";
 var getRuntime = (agents, agentId) => {
   const runtime = agents.get(agentId);
   if (!runtime) {
@@ -1743,7 +1889,7 @@ var securityMiddleware = () => {
     const realIp = req.get("X-Real-IP");
     const clientIp = forwarded || realIp || req.ip;
     if (userAgent && (userAgent.includes("..") || userAgent.includes("<script"))) {
-      logger12.warn(`[SECURITY] Suspicious User-Agent from ${clientIp}: ${userAgent}`);
+      logger13.warn(`[SECURITY] Suspicious User-Agent from ${clientIp}: ${userAgent}`);
     }
     const url = req.originalUrl || req.url;
     const queryString = JSON.stringify(req.query);
@@ -1769,12 +1915,12 @@ var securityMiddleware = () => {
     }
     for (const indicator of suspiciousIndicators) {
       if (url.includes(indicator.pattern) || queryString.includes(indicator.pattern)) {
-        logger12.warn(`[SECURITY] ${indicator.name} detected from ${clientIp}: ${url}`);
+        logger13.warn(`[SECURITY] ${indicator.name} detected from ${clientIp}: ${url}`);
         break;
       }
     }
     if (hasSqlPattern) {
-      logger12.warn(`[SECURITY] SQL injection pattern detected from ${clientIp}: ${url}`);
+      logger13.warn(`[SECURITY] SQL injection pattern detected from ${clientIp}: ${url}`);
     }
     next();
   };
@@ -1823,7 +1969,7 @@ var createApiRateLimit = () => {
     // Disable the `X-RateLimit-*` headers
     handler: (req, res) => {
       const clientIp = req.ip || "unknown";
-      logger12.warn(`[SECURITY] Rate limit exceeded for IP: ${clientIp}`);
+      logger13.warn(`[SECURITY] Rate limit exceeded for IP: ${clientIp}`);
       res.status(429).json({
         success: false,
         error: {
@@ -1851,7 +1997,7 @@ var createFileSystemRateLimit = () => {
     legacyHeaders: false,
     handler: (req, res) => {
       const clientIp = req.ip || "unknown";
-      logger12.warn(
+      logger13.warn(
         `[SECURITY] File system rate limit exceeded for IP: ${clientIp}, endpoint: ${req.path}`
       );
       res.status(429).json({
@@ -1881,7 +2027,7 @@ var createUploadRateLimit = () => {
     legacyHeaders: false,
     handler: (req, res) => {
       const clientIp = req.ip || "unknown";
-      logger12.warn(
+      logger13.warn(
         `[SECURITY] Upload rate limit exceeded for IP: ${clientIp}, endpoint: ${req.path}`
       );
       res.status(429).json({
@@ -1898,11 +2044,11 @@ var createUploadRateLimit = () => {
 // src/api/messaging/channels.ts
 var DEFAULT_SERVER_ID3 = "00000000-0000-0000-0000-000000000000";
 function createChannelsRouter(agents, serverInstance) {
-  const router = express10.Router();
+  const router = express11.Router();
   router.post(
     "/central-channels/:channelId/messages",
     async (req, res) => {
-      const channelIdParam = validateUuid12(req.params.channelId);
+      const channelIdParam = validateUuid13(req.params.channelId);
       const {
         author_id,
         // This is the GUI user's central ID
@@ -1917,92 +2063,92 @@ function createChannelsRouter(agents, serverInstance) {
         source_type
         // Should be something like 'eliza_gui'
       } = req.body;
-      const isValidServerId = server_id === DEFAULT_SERVER_ID3 || validateUuid12(server_id);
-      if (!channelIdParam || !validateUuid12(author_id) || !content || !isValidServerId) {
+      const isValidServerId = server_id === DEFAULT_SERVER_ID3 || validateUuid13(server_id);
+      if (!channelIdParam || !validateUuid13(author_id) || !content || !isValidServerId) {
         return res.status(400).json({
           success: false,
           error: "Missing required fields: channelId, server_id, author_id, content"
         });
       }
       try {
-        logger13.info(
+        logger14.info(
           `[Messages Router] Checking if channel ${channelIdParam} exists before creating message`
         );
         let channelExists = false;
         try {
           const existingChannel = await serverInstance.getChannelDetails(channelIdParam);
           channelExists = !!existingChannel;
-          logger13.info(`[Messages Router] Channel ${channelIdParam} exists: ${channelExists}`);
+          logger14.info(`[Messages Router] Channel ${channelIdParam} exists: ${channelExists}`);
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
-          logger13.info(
+          logger14.info(
             `[Messages Router] Channel ${channelIdParam} does not exist, will create it. Error: ${errorMessage}`
           );
         }
         if (!channelExists) {
-          logger13.info(
+          logger14.info(
             `[Messages Router] Auto-creating channel ${channelIdParam} with serverId ${server_id}`
           );
           try {
             const servers = await serverInstance.getServers();
             const serverExists = servers.some((s) => s.id === server_id);
-            logger13.info(
+            logger14.info(
               `[Messages Router] Server ${server_id} exists: ${serverExists}. Available servers: ${servers.map((s) => s.id).join(", ")}`
             );
             if (!serverExists) {
-              logger13.error(
+              logger14.error(
                 `[Messages Router] Server ${server_id} does not exist, cannot create channel`
               );
               return res.status(500).json({ success: false, error: `Server ${server_id} does not exist` });
             }
-            const isDmChannel = metadata?.isDm || metadata?.channelType === ChannelType.DM || metadata?.channel_type === ChannelType.DM;
+            const isDmChannel = metadata?.isDm || metadata?.channelType === ChannelType2.DM || metadata?.channel_type === ChannelType2.DM;
             const channelData = {
               id: channelIdParam,
               // Use the specific channel ID from the URL
               messageServerId: server_id,
               name: isDmChannel ? `DM ${channelIdParam.substring(0, 8)}` : `Chat ${channelIdParam.substring(0, 8)}`,
-              type: isDmChannel ? ChannelType.DM : ChannelType.GROUP,
+              type: isDmChannel ? ChannelType2.DM : ChannelType2.GROUP,
               sourceType: "auto_created",
               metadata: {
                 created_by: "gui_auto_creation",
                 created_for_user: author_id,
                 created_at: (/* @__PURE__ */ new Date()).toISOString(),
-                channel_type: isDmChannel ? ChannelType.DM : ChannelType.GROUP,
+                channel_type: isDmChannel ? ChannelType2.DM : ChannelType2.GROUP,
                 ...metadata
               }
             };
-            logger13.info(
+            logger14.info(
               "[Messages Router] Creating channel with data:",
               JSON.stringify(channelData, null, 2)
             );
             const participants = [author_id];
             if (isDmChannel) {
               const otherParticipant = metadata?.targetUserId || metadata?.recipientId;
-              if (otherParticipant && validateUuid12(otherParticipant)) {
+              if (otherParticipant && validateUuid13(otherParticipant)) {
                 participants.push(otherParticipant);
-                logger13.info(
+                logger14.info(
                   `[Messages Router] DM channel will include participants: ${participants.join(", ")}`
                 );
               } else {
-                logger13.warn(
+                logger14.warn(
                   `[Messages Router] DM channel missing second participant, only adding author: ${author_id}`
                 );
               }
             }
             await serverInstance.createChannel(channelData, participants);
-            logger13.info(
-              `[Messages Router] Auto-created ${isDmChannel ? ChannelType.DM : ChannelType.GROUP} channel ${channelIdParam} for message submission with ${participants.length} participants`
+            logger14.info(
+              `[Messages Router] Auto-created ${isDmChannel ? ChannelType2.DM : ChannelType2.GROUP} channel ${channelIdParam} for message submission with ${participants.length} participants`
             );
           } catch (createError) {
             const errorMessage = createError instanceof Error ? createError.message : String(createError);
-            logger13.error(
+            logger14.error(
               `[Messages Router] Failed to auto-create channel ${channelIdParam}:`,
               createError
             );
             return res.status(500).json({ success: false, error: `Failed to create channel: ${errorMessage}` });
           }
         } else {
-          logger13.info(
+          logger14.info(
             `[Messages Router] Channel ${channelIdParam} already exists, proceeding with message creation`
           );
         }
@@ -2010,7 +2156,7 @@ function createChannelsRouter(agents, serverInstance) {
           channelId: channelIdParam,
           authorId: author_id,
           content,
-          inReplyToRootMessageId: in_reply_to_message_id ? validateUuid12(in_reply_to_message_id) || void 0 : void 0,
+          inReplyToRootMessageId: in_reply_to_message_id ? validateUuid13(in_reply_to_message_id) || void 0 : void 0,
           rawMessage: raw_message,
           metadata,
           sourceType: source_type || "eliza_gui"
@@ -2036,7 +2182,7 @@ function createChannelsRouter(agents, serverInstance) {
           // Will be undefined here, which is fine
         };
         bus_default.emit("new_message", messageForBus);
-        logger13.info(
+        logger14.info(
           "[Messages Router /central-channels/:channelId/messages] GUI Message published to internal bus:",
           messageForBus.id
         );
@@ -2056,7 +2202,7 @@ function createChannelsRouter(agents, serverInstance) {
         }
         res.status(201).json({ success: true, data: messageForBus });
       } catch (error) {
-        logger13.error(
+        logger14.error(
           "[Messages Router /central-channels/:channelId/messages] Error processing GUI message:",
           error
         );
@@ -2067,7 +2213,7 @@ function createChannelsRouter(agents, serverInstance) {
   router.get(
     "/central-channels/:channelId/messages",
     async (req, res) => {
-      const channelId = validateUuid12(req.params.channelId);
+      const channelId = validateUuid13(req.params.channelId);
       const limit = req.query.limit ? Number.parseInt(req.query.limit, 10) : 50;
       const before = req.query.before ? Number.parseInt(req.query.before, 10) : void 0;
       const beforeDate = before ? new Date(before) : void 0;
@@ -2094,7 +2240,7 @@ function createChannelsRouter(agents, serverInstance) {
         });
         res.json({ success: true, data: { messages: messagesForGui } });
       } catch (error) {
-        logger13.error(
+        logger14.error(
           `[Messages Router /central-channels/:channelId/messages] Error fetching messages for channel ${channelId}:`,
           error
         );
@@ -2105,7 +2251,7 @@ function createChannelsRouter(agents, serverInstance) {
   router.get(
     "/central-servers/:serverId/channels",
     async (req, res) => {
-      const serverId = req.params.serverId === DEFAULT_SERVER_ID3 ? DEFAULT_SERVER_ID3 : validateUuid12(req.params.serverId);
+      const serverId = req.params.serverId === DEFAULT_SERVER_ID3 ? DEFAULT_SERVER_ID3 : validateUuid13(req.params.serverId);
       if (!serverId) {
         return res.status(400).json({ success: false, error: "Invalid serverId" });
       }
@@ -2113,7 +2259,7 @@ function createChannelsRouter(agents, serverInstance) {
         const channels = await serverInstance.getChannelsForServer(serverId);
         res.json({ success: true, data: { channels } });
       } catch (error) {
-        logger13.error(
+        logger14.error(
           `[Messages Router /central-servers/:serverId/channels] Error fetching channels for server ${serverId}:`,
           error
         );
@@ -2122,22 +2268,36 @@ function createChannelsRouter(agents, serverInstance) {
     }
   );
   router.post("/channels", async (req, res) => {
-    const { messageServerId, name, type, sourceType, sourceId, topic, metadata } = req.body;
-    if (!messageServerId || !name || !type) {
+    const serverId = req.body.serverId;
+    const { name, type, sourceType, sourceId, metadata } = req.body;
+    const topic = req.body.topic ?? req.body.description;
+    if (!serverId) {
+      return res.status(400).json({
+        success: false,
+        error: "Missing required fields: serverId."
+      });
+    }
+    if (!name) {
       return res.status(400).json({
         success: false,
-        error: "Missing required fields: messageServerId, name, type"
+        error: "Missing required fields: name."
       });
     }
-    if (!validateUuid12(messageServerId)) {
+    if (!type) {
       return res.status(400).json({
         success: false,
-        error: "Invalid messageServerId format"
+        error: "Missing required fields: type."
+      });
+    }
+    if (!validateUuid13(serverId)) {
+      return res.status(400).json({
+        success: false,
+        error: "Invalid serverId format"
       });
     }
     try {
       const channel = await serverInstance.createChannel({
-        messageServerId,
+        messageServerId: serverId,
         name,
         type,
         sourceType,
@@ -2147,14 +2307,14 @@ function createChannelsRouter(agents, serverInstance) {
       });
       res.status(201).json({ success: true, data: { channel } });
     } catch (error) {
-      logger13.error("[Messages Router /channels] Error creating channel:", error);
+      logger14.error("[Messages Router /channels] Error creating channel:", error);
       res.status(500).json({ success: false, error: "Failed to create channel" });
     }
   });
   router.get("/dm-channel", async (req, res) => {
-    const targetUserId = validateUuid12(req.query.targetUserId);
-    const currentUserId = validateUuid12(req.query.currentUserId);
-    const providedDmServerId = req.query.dmServerId === DEFAULT_SERVER_ID3 ? DEFAULT_SERVER_ID3 : validateUuid12(req.query.dmServerId);
+    const targetUserId = validateUuid13(req.query.targetUserId);
+    const currentUserId = validateUuid13(req.query.currentUserId);
+    const providedDmServerId = req.query.dmServerId === DEFAULT_SERVER_ID3 ? DEFAULT_SERVER_ID3 : validateUuid13(req.query.dmServerId);
     if (!targetUserId || !currentUserId) {
       res.status(400).json({ success: false, error: "Missing targetUserId or currentUserId" });
       return;
@@ -2170,7 +2330,7 @@ function createChannelsRouter(agents, serverInstance) {
         if (existingServer) {
           dmServerIdToUse = providedDmServerId;
         } else {
-          logger13.warn(
+          logger14.warn(
             `Provided dmServerId ${providedDmServerId} not found, using default DM server logic.`
           );
           dmServerIdToUse = DEFAULT_SERVER_ID3;
@@ -2188,7 +2348,7 @@ function createChannelsRouter(agents, serverInstance) {
         stack: error.stack,
         originalError: error
       } : { message: String(error) };
-      logger13.error("Error finding/creating DM channel:", errorDetails);
+      logger14.error("Error finding/creating DM channel:", errorDetails);
       res.status(500).json({ success: false, error: "Failed to find or create DM channel" });
     }
   });
@@ -2196,12 +2356,12 @@ function createChannelsRouter(agents, serverInstance) {
     const {
       name,
       participantCentralUserIds,
-      type = ChannelType.GROUP,
+      type = ChannelType2.GROUP,
       server_id,
       metadata
     } = req.body;
-    const isValidServerId = server_id === DEFAULT_SERVER_ID3 || validateUuid12(server_id);
-    if (!name || !isValidServerId || !Array.isArray(participantCentralUserIds) || participantCentralUserIds.some((id) => !validateUuid12(id))) {
+    const isValidServerId = server_id === DEFAULT_SERVER_ID3 || validateUuid13(server_id);
+    if (!name || !isValidServerId || !Array.isArray(participantCentralUserIds) || participantCentralUserIds.some((id) => !validateUuid13(id))) {
       return res.status(400).json({
         success: false,
         error: 'Invalid payload. Required: name, server_id (UUID or "0"), participantCentralUserIds (array of UUIDs). Optional: type, metadata.'
@@ -2224,7 +2384,7 @@ function createChannelsRouter(agents, serverInstance) {
       res.status(201).json({ success: true, data: newChannel });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger13.error(
+      logger14.error(
         "[Messages Router /central-channels] Error creating group channel:",
         errorMessage
       );
@@ -2234,7 +2394,7 @@ function createChannelsRouter(agents, serverInstance) {
   router.get(
     "/central-channels/:channelId/details",
     async (req, res) => {
-      const channelId = validateUuid12(req.params.channelId);
+      const channelId = validateUuid13(req.params.channelId);
       if (!channelId) {
         return res.status(400).json({ success: false, error: "Invalid channelId" });
       }
@@ -2245,7 +2405,7 @@ function createChannelsRouter(agents, serverInstance) {
         }
         res.json({ success: true, data: channelDetails });
       } catch (error) {
-        logger13.error(`[Messages Router] Error fetching details for channel ${channelId}:`, error);
+        logger14.error(`[Messages Router] Error fetching details for channel ${channelId}:`, error);
         res.status(500).json({ success: false, error: "Failed to fetch channel details" });
       }
     }
@@ -2253,7 +2413,7 @@ function createChannelsRouter(agents, serverInstance) {
   router.get(
     "/central-channels/:channelId/participants",
     async (req, res) => {
-      const channelId = validateUuid12(req.params.channelId);
+      const channelId = validateUuid13(req.params.channelId);
       if (!channelId) {
         return res.status(400).json({ success: false, error: "Invalid channelId" });
       }
@@ -2261,7 +2421,7 @@ function createChannelsRouter(agents, serverInstance) {
         const participants = await serverInstance.getChannelParticipants(channelId);
         res.json({ success: true, data: participants });
       } catch (error) {
-        logger13.error(
+        logger14.error(
           `[Messages Router] Error fetching participants for channel ${channelId}:`,
           error
         );
@@ -2272,9 +2432,9 @@ function createChannelsRouter(agents, serverInstance) {
   router.post(
     "/central-channels/:channelId/agents",
     async (req, res) => {
-      const channelId = validateUuid12(req.params.channelId);
+      const channelId = validateUuid13(req.params.channelId);
       const { agentId } = req.body;
-      if (!channelId || !validateUuid12(agentId)) {
+      if (!channelId || !validateUuid13(agentId)) {
         return res.status(400).json({
           success: false,
           error: "Invalid channelId or agentId format"
@@ -2289,7 +2449,7 @@ function createChannelsRouter(agents, serverInstance) {
           });
         }
         await serverInstance.addParticipantsToChannel(channelId, [agentId]);
-        logger13.info(`[Messages Router] Added agent ${agentId} to channel ${channelId}`);
+        logger14.info(`[Messages Router] Added agent ${agentId} to channel ${channelId}`);
         res.status(201).json({
           success: true,
           data: {
@@ -2299,7 +2459,7 @@ function createChannelsRouter(agents, serverInstance) {
           }
         });
       } catch (error) {
-        logger13.error(
+        logger14.error(
           `[Messages Router] Error adding agent ${agentId} to channel ${channelId}:`,
           error
         );
@@ -2314,8 +2474,8 @@ function createChannelsRouter(agents, serverInstance) {
   router.delete(
     "/central-channels/:channelId/agents/:agentId",
     async (req, res) => {
-      const channelId = validateUuid12(req.params.channelId);
-      const agentId = validateUuid12(req.params.agentId);
+      const channelId = validateUuid13(req.params.channelId);
+      const agentId = validateUuid13(req.params.agentId);
       if (!channelId || !agentId) {
         return res.status(400).json({
           success: false,
@@ -2341,7 +2501,7 @@ function createChannelsRouter(agents, serverInstance) {
         await serverInstance.updateChannel(channelId, {
           participantCentralUserIds: updatedParticipants
         });
-        logger13.info(`[Messages Router] Removed agent ${agentId} from channel ${channelId}`);
+        logger14.info(`[Messages Router] Removed agent ${agentId} from channel ${channelId}`);
         res.status(200).json({
           success: true,
           data: {
@@ -2351,7 +2511,7 @@ function createChannelsRouter(agents, serverInstance) {
           }
         });
       } catch (error) {
-        logger13.error(
+        logger14.error(
           `[Messages Router] Error removing agent ${agentId} from channel ${channelId}:`,
           error
         );
@@ -2366,7 +2526,7 @@ function createChannelsRouter(agents, serverInstance) {
   router.get(
     "/central-channels/:channelId/agents",
     async (req, res) => {
-      const channelId = validateUuid12(req.params.channelId);
+      const channelId = validateUuid13(req.params.channelId);
       if (!channelId) {
         return res.status(400).json({
           success: false,
@@ -2385,7 +2545,7 @@ function createChannelsRouter(agents, serverInstance) {
           }
         });
       } catch (error) {
-        logger13.error(`[Messages Router] Error fetching agents for channel ${channelId}:`, error);
+        logger14.error(`[Messages Router] Error fetching agents for channel ${channelId}:`, error);
         res.status(500).json({
           success: false,
           error: "Failed to fetch channel agents"
@@ -2396,20 +2556,20 @@ function createChannelsRouter(agents, serverInstance) {
   router.delete(
     "/central-channels/:channelId/messages/:messageId",
     async (req, res) => {
-      const channelId = validateUuid12(req.params.channelId);
-      const messageId = validateUuid12(req.params.messageId);
+      const channelId = validateUuid13(req.params.channelId);
+      const messageId = validateUuid13(req.params.messageId);
       if (!channelId || !messageId) {
         return res.status(400).json({ success: false, error: "Invalid channelId or messageId" });
       }
       try {
         await serverInstance.deleteMessage(messageId);
-        logger13.info(`[Messages Router] Deleted message ${messageId} from central database`);
+        logger14.info(`[Messages Router] Deleted message ${messageId} from central database`);
         const deletedMessagePayload = {
           messageId,
           channelId
         };
         bus_default.emit("message_deleted", deletedMessagePayload);
-        logger13.info(
+        logger14.info(
           `[Messages Router] Emitted message_deleted event to internal bus for message ${messageId}`
         );
         if (serverInstance.socketIO) {
@@ -2420,7 +2580,7 @@ function createChannelsRouter(agents, serverInstance) {
         }
         res.status(204).send();
       } catch (error) {
-        logger13.error(
+        logger14.error(
           `[Messages Router] Error deleting message ${messageId} from channel ${channelId}:`,
           error
         );
@@ -2431,7 +2591,7 @@ function createChannelsRouter(agents, serverInstance) {
   router.delete(
     "/central-channels/:channelId/messages",
     async (req, res) => {
-      const channelId = validateUuid12(req.params.channelId);
+      const channelId = validateUuid13(req.params.channelId);
       if (!channelId) {
         return res.status(400).json({ success: false, error: "Invalid channelId" });
       }
@@ -2441,7 +2601,7 @@ function createChannelsRouter(agents, serverInstance) {
           channelId
         };
         bus_default.emit("channel_cleared", channelClearedPayload);
-        logger13.info(
+        logger14.info(
           `[Messages Router] Emitted channel_cleared event to internal bus for channel ${channelId}`
         );
         if (serverInstance.socketIO) {
@@ -2451,7 +2611,7 @@ function createChannelsRouter(agents, serverInstance) {
         }
         res.status(204).send();
       } catch (error) {
-        logger13.error(`[Messages Router] Error clearing messages for channel ${channelId}:`, error);
+        logger14.error(`[Messages Router] Error clearing messages for channel ${channelId}:`, error);
         res.status(500).json({ success: false, error: "Failed to clear messages" });
       }
     }
@@ -2459,7 +2619,7 @@ function createChannelsRouter(agents, serverInstance) {
   router.patch(
     "/central-channels/:channelId",
     async (req, res) => {
-      const channelId = validateUuid12(req.params.channelId);
+      const channelId = validateUuid13(req.params.channelId);
       if (!channelId) {
         return res.status(400).json({ success: false, error: "Invalid channelId" });
       }
@@ -2478,7 +2638,7 @@ function createChannelsRouter(agents, serverInstance) {
         }
         res.json({ success: true, data: updatedChannel });
       } catch (error) {
-        logger13.error(`[Messages Router] Error updating channel ${channelId}:`, error);
+        logger14.error(`[Messages Router] Error updating channel ${channelId}:`, error);
         res.status(500).json({ success: false, error: "Failed to update channel" });
       }
     }
@@ -2486,7 +2646,7 @@ function createChannelsRouter(agents, serverInstance) {
   router.delete(
     "/central-channels/:channelId",
     async (req, res) => {
-      const channelId = validateUuid12(req.params.channelId);
+      const channelId = validateUuid13(req.params.channelId);
       if (!channelId) {
         return res.status(400).json({ success: false, error: "Invalid channelId" });
       }
@@ -2494,14 +2654,14 @@ function createChannelsRouter(agents, serverInstance) {
         const messages = await serverInstance.getMessagesForChannel(channelId);
         const messageCount = messages.length;
         await serverInstance.deleteChannel(channelId);
-        logger13.info(
+        logger14.info(
           `[Messages Router] Deleted channel ${channelId} with ${messageCount} messages from central database`
         );
         const channelClearedPayload = {
           channelId
         };
         bus_default.emit("channel_cleared", channelClearedPayload);
-        logger13.info(
+        logger14.info(
           `[Messages Router] Emitted channel_cleared event to internal bus for deleted channel ${channelId}`
         );
         if (serverInstance.socketIO) {
@@ -2511,7 +2671,7 @@ function createChannelsRouter(agents, serverInstance) {
         }
         res.status(204).send();
       } catch (error) {
-        logger13.error(`[Messages Router] Error deleting channel ${channelId}:`, error);
+        logger14.error(`[Messages Router] Error deleting channel ${channelId}:`, error);
         res.status(500).json({ success: false, error: "Failed to delete channel" });
       }
     }
@@ -2522,7 +2682,7 @@ function createChannelsRouter(agents, serverInstance) {
     createFileSystemRateLimit(),
     channelUpload(),
     async (req, res) => {
-      const channelId = validateUuid12(req.params.channelId);
+      const channelId = validateUuid13(req.params.channelId);
       if (!channelId) {
         res.status(400).json({ success: false, error: "Invalid channelId format" });
         return;
@@ -2557,7 +2717,7 @@ function createChannelsRouter(agents, serverInstance) {
           return;
         }
         const result = await processUploadedFile(mediaFile, channelId, "channels");
-        logger13.info(
+        logger14.info(
           `[MessagesRouter /upload-media] Secure file uploaded for channel ${channelId}: ${result.filename}. URL: ${result.url}`
         );
         res.json({
@@ -2573,7 +2733,7 @@ function createChannelsRouter(agents, serverInstance) {
         });
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        logger13.error(
+        logger14.error(
           `[MessagesRouter /upload-media] Error processing upload for channel ${channelId}: ${errorMessage}`,
           error
         );
@@ -2587,7 +2747,7 @@ function createChannelsRouter(agents, serverInstance) {
   router.post(
     "/central-channels/:channelId/generate-title",
     async (req, res) => {
-      const channelId = validateUuid12(req.params.channelId);
+      const channelId = validateUuid13(req.params.channelId);
       const { agentId } = req.body;
       if (!channelId) {
         return res.status(400).json({
@@ -2595,7 +2755,7 @@ function createChannelsRouter(agents, serverInstance) {
           error: "Invalid channel ID format"
         });
       }
-      if (!agentId || !validateUuid12(agentId)) {
+      if (!agentId || !validateUuid13(agentId)) {
         return res.status(400).json({
           success: false,
           error: "Valid agent ID is required"
@@ -2609,7 +2769,7 @@ function createChannelsRouter(agents, serverInstance) {
             error: "Agent not found or not active"
           });
         }
-        logger13.info(`[CHANNEL SUMMARIZE] Summarizing channel ${channelId}`);
+        logger14.info(`[CHANNEL SUMMARIZE] Summarizing channel ${channelId}`);
         const limit = req.query.limit ? Number.parseInt(req.query.limit, 10) : 50;
         const before = req.query.before ? Number.parseInt(req.query.before, 10) : void 0;
         const beforeDate = before ? new Date(before) : void 0;
@@ -2663,22 +2823,22 @@ Respond with just the title, nothing else.
           // Keep titles short
         });
         if (!newTitle || newTitle.trim().length === 0) {
-          logger13.warn(`[ChatTitleEvaluator] Failed to generate title for room ${channelId}`);
+          logger14.warn(`[ChatTitleEvaluator] Failed to generate title for room ${channelId}`);
           return;
         }
         const cleanTitle = newTitle.trim().replace(/^["']|["']$/g, "");
-        logger13.info(`[ChatTitleEvaluator] Generated title: "${cleanTitle}" for room ${channelId}`);
+        logger14.info(`[ChatTitleEvaluator] Generated title: "${cleanTitle}" for room ${channelId}`);
         const result = {
           title: cleanTitle,
           channelId
         };
-        logger13.success(`[CHANNEL SUMMARIZE] Successfully summarized channel ${channelId}`);
+        logger14.success(`[CHANNEL SUMMARIZE] Successfully summarized channel ${channelId}`);
         res.json({
           success: true,
           data: result
         });
       } catch (error) {
-        logger13.error("[CHANNEL SUMMARIZE] Error summarizing channel:", error);
+        logger14.error("[CHANNEL SUMMARIZE] Error summarizing channel:", error);
         res.status(500).json({
           success: false,
           error: "Failed to summarize channel",
@@ -2692,7 +2852,7 @@ Respond with just the title, nothing else.
 
 // src/api/messaging/index.ts
 function messagingRouter(agents, serverInstance) {
-  const router = express11.Router();
+  const router = express12.Router();
   if (!serverInstance) {
     throw new Error("ServerInstance is required for messaging router");
   }
@@ -2703,17 +2863,17 @@ function messagingRouter(agents, serverInstance) {
 }
 
 // src/api/media/index.ts
-import express14 from "express";
+import express15 from "express";
 
 // src/api/media/agents.ts
-import { validateUuid as validateUuid13, logger as logger14, getContentTypeFromMimeType } from "@elizaos/core";
-import express12 from "express";
+import { validateUuid as validateUuid14, logger as logger15, getContentTypeFromMimeType } from "@elizaos/core";
+import express13 from "express";
 function createAgentMediaRouter() {
-  const router = express12.Router();
+  const router = express13.Router();
   router.post("/:agentId/upload-media", agentMediaUpload(), async (req, res) => {
     const agentMediaReq = req;
-    logger14.debug("[MEDIA UPLOAD] Processing media upload");
-    const agentId = validateUuid13(agentMediaReq.params.agentId);
+    logger15.debug("[MEDIA UPLOAD] Processing media upload");
+    const agentId = validateUuid14(agentMediaReq.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
@@ -2745,7 +2905,7 @@ function createAgentMediaRouter() {
     }
     try {
       const result = await processUploadedFile(mediaFile, agentId, "agents");
-      logger14.info(
+      logger15.info(
         `[MEDIA UPLOAD] Successfully uploaded ${mediaType}: ${result.filename}. URL: ${result.url}`
       );
       sendSuccess(res, {
@@ -2756,7 +2916,7 @@ function createAgentMediaRouter() {
         size: mediaFile.size
       });
     } catch (error) {
-      logger14.error(`[MEDIA UPLOAD] Error processing upload: ${error}`);
+      logger15.error(`[MEDIA UPLOAD] Error processing upload: ${error}`);
       cleanupUploadedFile(mediaFile);
       sendError(
         res,
@@ -2771,11 +2931,11 @@ function createAgentMediaRouter() {
 }
 
 // src/api/media/channels.ts
-import { validateUuid as validateUuid14, logger as logger15 } from "@elizaos/core";
-import express13 from "express";
+import { validateUuid as validateUuid15, logger as logger16 } from "@elizaos/core";
+import express14 from "express";
 import rateLimit2 from "express-rate-limit";
 function createChannelMediaRouter() {
-  const router = express13.Router();
+  const router = express14.Router();
   const uploadMediaRateLimiter = rateLimit2({
     windowMs: 15 * 60 * 1e3,
     // 15 minutes
@@ -2790,7 +2950,7 @@ function createChannelMediaRouter() {
     channelUpload(),
     async (req, res) => {
       const channelMediaReq = req;
-      const channelId = validateUuid14(channelMediaReq.params.channelId);
+      const channelId = validateUuid15(channelMediaReq.params.channelId);
       if (!channelId) {
         res.status(400).json({ success: false, error: "Invalid channelId format" });
         return;
@@ -2815,7 +2975,7 @@ function createChannelMediaRouter() {
       }
       try {
         const result = await processUploadedFile(mediaFile, channelId, "channels");
-        logger15.info(
+        logger16.info(
           `[Channel Media Upload] File uploaded for channel ${channelId}: ${result.filename}. URL: ${result.url}`
         );
         res.json({
@@ -2830,7 +2990,7 @@ function createChannelMediaRouter() {
           }
         });
       } catch (error) {
-        logger15.error(
+        logger16.error(
           `[Channel Media Upload] Error processing upload for channel ${channelId}: ${error.message}`,
           error
         );
@@ -2844,7 +3004,7 @@ function createChannelMediaRouter() {
 
 // src/api/media/index.ts
 function mediaRouter() {
-  const router = express14.Router();
+  const router = express15.Router();
   router.use("/agents", createAgentMediaRouter());
   router.use("/channels", createChannelMediaRouter());
   return router;
@@ -2854,13 +3014,13 @@ function mediaRouter() {
 import express17 from "express";
 
 // src/api/memory/groups.ts
-import { validateUuid as validateUuid15, logger as logger16, createUniqueUuid as createUniqueUuid3, ChannelType as ChannelType2 } from "@elizaos/core";
-import express15 from "express";
+import { validateUuid as validateUuid16, logger as logger17, createUniqueUuid as createUniqueUuid4, ChannelType as ChannelType3 } from "@elizaos/core";
+import express16 from "express";
 function createGroupMemoryRouter(agents, serverInstance) {
-  const router = express15.Router();
+  const router = express16.Router();
   const db = serverInstance?.database;
   router.post("/groups/:serverId", async (req, res) => {
-    const serverId = validateUuid15(req.params.serverId);
+    const serverId = validateUuid16(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");
@@ -2870,7 +3030,7 @@ function createGroupMemoryRouter(agents, serverInstance) {
     for (const agentId of agentIds) {
       try {
         const runtime = getRuntime(agents, agentId);
-        const roomId = createUniqueUuid3(runtime, serverId);
+        const roomId = createUniqueUuid4(runtime, serverId);
         const roomName = name || `Chat ${(/* @__PURE__ */ new Date()).toLocaleString()}`;
         await runtime.ensureWorldExists({
           id: worldId,
@@ -2882,7 +3042,7 @@ function createGroupMemoryRouter(agents, serverInstance) {
           id: roomId,
           name: roomName,
           source,
-          type: ChannelType2.API,
+          type: ChannelType3.API,
           worldId,
           serverId,
           metadata,
@@ -2896,10 +3056,10 @@ function createGroupMemoryRouter(agents, serverInstance) {
           name: roomName,
           source: "client",
           worldId,
-          type: ChannelType2.API
+          type: ChannelType3.API
         });
       } catch (error) {
-        logger16.error(`[ROOM CREATE] Error creating room for agent ${agentId}:`, error);
+        logger17.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",
@@ -2922,7 +3082,7 @@ function createGroupMemoryRouter(agents, serverInstance) {
     });
   });
   router.delete("/groups/:serverId", async (req, res) => {
-    const worldId = validateUuid15(req.params.serverId);
+    const worldId = validateUuid16(req.params.serverId);
     if (!worldId) {
       return sendError(res, 400, "INVALID_ID", "Invalid serverId (worldId) format");
     }
@@ -2933,7 +3093,7 @@ function createGroupMemoryRouter(agents, serverInstance) {
       await db.deleteRoomsByWorldId(worldId);
       res.status(204).send();
     } catch (error) {
-      logger16.error("[GROUP DELETE] Error deleting group:", error);
+      logger17.error("[GROUP DELETE] Error deleting group:", error);
       sendError(
         res,
         500,
@@ -2944,7 +3104,7 @@ function createGroupMemoryRouter(agents, serverInstance) {
     }
   });
   router.delete("/groups/:serverId/memories", async (req, res) => {
-    const worldId = validateUuid15(req.params.serverId);
+    const worldId = validateUuid16(req.params.serverId);
     if (!worldId) {
       return sendError(res, 400, "INVALID_ID", "Invalid serverId (worldId) format");
     }
@@ -2959,7 +3119,7 @@ function createGroupMemoryRouter(agents, serverInstance) {
       }
       res.status(204).send();
     } catch (error) {
-      logger16.error("[GROUP MEMORIES DELETE] Error clearing memories:", error);
+      logger17.error("[GROUP MEMORIES DELETE] Error clearing memories:", error);
       sendError(
         res,
         500,
@@ -2972,151 +3132,6 @@ function createGroupMemoryRouter(agents, serverInstance) {
   return router;
 }
 
-// src/api/memory/rooms.ts
-import { validateUuid as validateUuid16, logger as logger17, createUniqueUuid as createUniqueUuid4, ChannelType as ChannelType3 } from "@elizaos/core";
-import express16 from "express";
-function createRoomManagementRouter(agents) {
-  const router = express16.Router();
-  router.post("/:agentId/rooms", async (req, res) => {
-    const agentId = validateUuid16(req.params.agentId);
-    if (!agentId) {
-      return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
-    }
-    const runtime = agents.get(agentId);
-    if (!runtime) {
-      return sendError(res, 404, "NOT_FOUND", "Agent not found");
-    }
-    try {
-      const { name, type = ChannelType3.DM, source = "client", worldId, metadata } = req.body;
-      if (!name) {
-        return sendError(res, 400, "MISSING_PARAM", "Room name is required");
-      }
-      const roomId = createUniqueUuid4(runtime, `room-${Date.now()}`);
-      const serverId = req.body.serverId || `server-${Date.now()}`;
-      let resolvedWorldId = worldId;
-      if (!resolvedWorldId) {
-        const worldName = `World for ${name}`;
-        resolvedWorldId = createUniqueUuid4(runtime, `world-${Date.now()}`);
-        await runtime.ensureWorldExists({
-          id: resolvedWorldId,
-          name: worldName,
-          agentId: runtime.agentId,
-          serverId,
-          metadata
-        });
-      }
-      await runtime.ensureRoomExists({
-        id: roomId,
-        name,
-        source,
-        type,
-        channelId: roomId,
-        serverId,
-        worldId: resolvedWorldId,
-        metadata
-      });
-      await runtime.addParticipant(runtime.agentId, roomId);
-      await runtime.ensureParticipantInRoom(runtime.agentId, roomId);
-      await runtime.setParticipantUserState(roomId, runtime.agentId, "FOLLOWED");
-      sendSuccess(
-        res,
-        {
-          id: roomId,
-          name,
-          agentId,
-          createdAt: Date.now(),
-          source,
-          type,
-          worldId: resolvedWorldId,
-          serverId,
-          metadata
-        },
-        201
-      );
-    } catch (error) {
-      logger17.error(`[ROOM CREATE] Error creating room for agent ${agentId}:`, error);
-      sendError(
-        res,
-        500,
-        "CREATE_ERROR",
-        "Failed to create room",
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  });
-  router.get("/:agentId/rooms", async (req, res) => {
-    const agentId = validateUuid16(req.params.agentId);
-    if (!agentId) {
-      return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
-    }
-    const runtime = agents.get(agentId);
-    if (!runtime) {
-      return sendError(res, 404, "NOT_FOUND", "Agent not found");
-    }
-    try {
-      const worlds = await runtime.getAllWorlds();
-      const participantRoomIds = await runtime.getRoomsForParticipant(agentId);
-      const agentRooms = [];
-      for (const world of worlds) {
-        const worldRooms = await runtime.getRooms(world.id);
-        for (const room of worldRooms) {
-          if (participantRoomIds.includes(room.id)) {
-            agentRooms.push({
-              ...room
-            });
-          }
-        }
-      }
-      sendSuccess(res, { rooms: agentRooms });
-    } catch (error) {
-      logger17.error(`[ROOMS LIST] Error retrieving rooms for agent ${agentId}:`, error);
-      sendError(
-        res,
-        500,
-        "RETRIEVAL_ERROR",
-        "Failed to retrieve agent rooms",
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  });
-  router.get("/:agentId/rooms/:roomId", async (req, res) => {
-    const agentId = validateUuid16(req.params.agentId);
-    const roomId = validateUuid16(req.params.roomId);
-    if (!agentId || !roomId) {
-      return sendError(res, 400, "INVALID_ID", "Invalid agent ID or room ID format");
-    }
-    const runtime = agents.get(agentId);
-    if (!runtime) {
-      return sendError(res, 404, "NOT_FOUND", "Agent not found");
-    }
-    try {
-      const room = await runtime.getRoom(roomId);
-      if (!room) {
-        return sendError(res, 404, "NOT_FOUND", "Room not found");
-      }
-      let worldName;
-      if (room.worldId) {
-        const world = await runtime.getWorld(room.worldId);
-        worldName = world?.name;
-      }
-      sendSuccess(res, {
-        ...room,
-        ...worldName && { worldName }
-      });
-    } catch (error) {
-      logger17.error(`[ROOM DETAILS] Error retrieving room ${roomId} for agent ${agentId}:`, error);
-      sendError(
-        res,
-        500,
-        "RETRIEVAL_ERROR",
-        "Failed to retrieve room details",
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  });
-  return router;
-}
-
 // src/api/memory/index.ts
 function memoryRouter(agents, serverInstance) {
   const router = express17.Router();
@@ -5938,7 +5953,7 @@ var AgentServer = class {
           next();
         },
         apiRouter,
-        (err, req, res) => {
+        (err, req, res, _next) => {
           logger29.error(`API error: ${req.method} ${req.path}`, err);
           res.status(500).json({
             success: false,