@elizaos/server 1.0.11 → 1.0.13

package/dist/index.js

@@ -381,13 +381,11 @@ var import_cors2 = __toESM(require_lib(), 1);
 import {
   logger as logger29
 } from "@elizaos/core";
-import bodyParser2 from "body-parser";
 import express30 from "express";
-import fileUpload2 from "express-fileupload";
 import helmet2 from "helmet";
-import * as fs6 from "fs";
+import * as fs9 from "fs";
 import http from "http";
-import path6, { basename, dirname, extname, join } from "path";
+import path9, { basename, dirname, extname, join } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/api/index.ts
@@ -400,7 +398,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 {
@@ -499,7 +497,7 @@ function createAgentCrudRouter(agents, serverInstance) {
   });
   router.post("/", async (req, res) => {
     logger.debug("[AGENT CREATE] Creating new agent");
-    const { characterPath, characterJson } = req.body;
+    const { characterPath, characterJson, agent } = req.body;
     if (!db) {
       return sendError(res, 500, "DB_ERROR", "Database not available");
     }
@@ -511,6 +509,9 @@ function createAgentCrudRouter(agents, serverInstance) {
       } else if (characterPath) {
         logger.debug(`[AGENT CREATE] Loading character from path: ${characterPath}`);
         character = await serverInstance?.loadCharacterTryPath(characterPath);
+      } else if (agent) {
+        logger.debug("[AGENT CREATE] Parsing character from agent object");
+        character = await serverInstance?.jsonToCharacter(agent);
       } else {
         throw new Error("No character configuration provided");
       }
@@ -524,12 +525,12 @@ function createAgentCrudRouter(agents, serverInstance) {
       }
       const ensureAgentExists = async (character2) => {
         const agentId = stringToUuid(character2.name);
-        let agent = await db.getAgent(agentId);
-        if (!agent) {
+        let agent2 = await db.getAgent(agentId);
+        if (!agent2) {
           await db.createAgent({ ...character2, id: agentId });
-          agent = await db.getAgent(agentId);
+          agent2 = await db.getAgent(agentId);
         }
-        return agent;
+        return agent2;
       };
       const newAgent = await ensureAgentExists(character);
       if (!newAgent) {
@@ -1183,27 +1184,197 @@ function createAgentMemoryRouter(agents) {
       );
     }
   });
+  router.delete("/:agentId/memories/:memoryId", async (req, res) => {
+    try {
+      const agentId = validateUuid6(req.params.agentId);
+      const memoryId = validateUuid6(req.params.memoryId);
+      if (!agentId || !memoryId) {
+        return sendError(res, 400, "INVALID_ID", "Invalid agent ID or memory ID format");
+      }
+      const runtime = agents.get(agentId);
+      if (!runtime) {
+        return sendError(res, 404, "NOT_FOUND", "Agent not found");
+      }
+      await runtime.deleteMemory(memoryId);
+      sendSuccess(res, { message: "Memory deleted successfully" });
+    } catch (error) {
+      logger6.error(`[DELETE MEMORY] Error deleting memory ${req.params.memoryId}:`, error);
+      sendError(
+        res,
+        500,
+        "DELETE_ERROR",
+        "Error deleting memory",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  });
+  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 +1387,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 +1403,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 +1418,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 +1448,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 +1469,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 +1488,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 +1510,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 +1533,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 +1541,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 +1572,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 +1604,7 @@ function createServersRouter(serverInstance) {
           }
         });
       } catch (error) {
-        logger8.error(
+        logger9.error(
           `[MessagesRouter] Error adding agent ${agentId} to server ${serverId}:`,
           error
         );
@@ -1444,8 +1615,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 +1640,7 @@ function createServersRouter(serverInstance) {
           }
         });
       } catch (error) {
-        logger8.error(
+        logger9.error(
           `[MessagesRouter] Error removing agent ${agentId} from server ${serverId}:`,
           error
         );
@@ -1480,7 +1651,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 +1669,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 +1677,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 +1695,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,190 +1707,17 @@ function createServersRouter(serverInstance) {
 import {
   composePromptFromState,
   ModelType,
-  ChannelType,
-  logger as logger13,
+  ChannelType as ChannelType2,
+  logger as logger12,
   validateUuid as validateUuid12
 } from "@elizaos/core";
-import express10 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";
-
-// src/api/shared/file-utils.ts
-import fs from "fs";
-import path from "path";
-import { logger as logger9 } 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`);
-  }
-  const basePath = path.resolve(process.cwd(), ".eliza", "data", "uploads", type);
-  const targetPath = path.join(basePath, id);
-  if (!targetPath.startsWith(basePath)) {
-    throw new Error(`Invalid ${type.slice(0, -1)} ID: path traversal detected`);
-  }
-  return targetPath;
-}
-function sanitizeFilename(filename) {
-  let sanitized = filename.replace(/[\0\/\\:*?"<>|]/g, "_");
-  sanitized = sanitized.replace(/^[.\s]+/, "");
-  if (sanitized.length > 255) {
-    const ext = path.extname(sanitized);
-    const name = path.basename(sanitized, ext);
-    sanitized = name.substring(0, 255 - ext.length) + ext;
-  }
-  if (!sanitized || sanitized.trim() === "") {
-    sanitized = "file";
-  }
-  return sanitized;
-}
-var cleanupFile = (filePath) => {
-  if (!filePath) return;
-  try {
-    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}`);
-      return;
-    }
-    if (fs.existsSync(normalizedPath)) {
-      fs.unlinkSync(normalizedPath);
-      logger9.debug(`[FILE] Successfully cleaned up file: ${normalizedPath}`);
-    }
-  } catch (error) {
-    logger9.error(`Error cleaning up file ${filePath}:`, error);
-  }
-};
-var cleanupUploadedFile = (file) => {
-  if (file.tempFilePath) {
-    cleanupFile(file.tempFilePath);
-  }
-};
-
-// src/api/shared/constants.ts
-var MAX_FILE_SIZE = 50 * 1024 * 1024;
-var MAX_FILE_SIZE_DISPLAY = "50MB";
-var ALLOWED_AUDIO_MIME_TYPES = [
-  "audio/mpeg",
-  "audio/mp3",
-  "audio/wav",
-  "audio/ogg",
-  "audio/webm",
-  "audio/mp4",
-  "audio/aac",
-  "audio/flac",
-  "audio/x-wav",
-  "audio/wave"
-];
-var ALLOWED_MEDIA_MIME_TYPES = [
-  ...ALLOWED_AUDIO_MIME_TYPES,
-  "image/jpeg",
-  "image/png",
-  "image/gif",
-  "image/webp",
-  "video/mp4",
-  "video/webm",
-  "application/pdf",
-  "text/plain"
-];
-
-// src/upload.ts
-function generateSecureFilename(originalName) {
-  const uniqueSuffix = `${Date.now()}-${Math.round(Math.random() * 1e9)}`;
-  const sanitizedName = sanitizeFilename(originalName);
-  return `${uniqueSuffix}-${sanitizedName}`;
-}
-function ensureUploadDir(id, type) {
-  if (!validateUuid9(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}`);
-  return uploadDir;
-}
-var agentAudioUpload = () => fileUpload({
-  limits: {
-    fileSize: MAX_FILE_SIZE,
-    // 50MB max file size
-    files: 1
-    // Only allow 1 file per request
-  },
-  useTempFiles: true,
-  tempFileDir: "/tmp/",
-  parseNested: true,
-  abortOnLimit: true,
-  createParentPath: true,
-  preserveExtension: true,
-  safeFileNames: true,
-  uploadTimeout: 6e4
-  // 60 seconds timeout
-});
-var agentMediaUpload = () => fileUpload({
-  limits: {
-    fileSize: MAX_FILE_SIZE,
-    // 50MB max file size
-    files: 1
-    // Only allow 1 file per request
-  },
-  useTempFiles: true,
-  tempFileDir: "/tmp/",
-  parseNested: true,
-  abortOnLimit: true,
-  createParentPath: true,
-  preserveExtension: true,
-  safeFileNames: true,
-  uploadTimeout: 6e4
-  // 60 seconds timeout
-});
-var channelUpload = () => fileUpload({
-  limits: {
-    fileSize: MAX_FILE_SIZE,
-    // 50MB max file size
-    files: 1
-    // Only allow 1 file per request
-  },
-  useTempFiles: true,
-  tempFileDir: "/tmp/",
-  parseNested: true,
-  abortOnLimit: true,
-  createParentPath: true,
-  preserveExtension: true,
-  safeFileNames: true,
-  uploadTimeout: 6e4
-  // 60 seconds timeout
-});
-function validateAudioFile(file) {
-  return ALLOWED_AUDIO_MIME_TYPES.includes(file.mimetype);
-}
-function validateMediaFile(file) {
-  return ALLOWED_MEDIA_MIME_TYPES.includes(file.mimetype);
-}
-async function processUploadedFile(file, targetId, type) {
-  try {
-    const uploadDir = ensureUploadDir(targetId, type);
-    const filename = generateSecureFilename(file.name);
-    const finalPath = path2.join(uploadDir, filename);
-    await file.mv(finalPath);
-    const url = `/media/uploads/${type}/${targetId}/${filename}`;
-    logger10.debug(`[UPLOAD] File processed successfully: ${filename}`);
-    return { filename, path: finalPath, url };
-  } catch (error) {
-    logger10.error("[UPLOAD] Error processing uploaded file:", error);
-    throw error;
-  }
-}
+import express11 from "express";
 
 // src/api/shared/middleware.ts
-import { validateUuid as validateUuid11, logger as logger12 } from "@elizaos/core";
+import { validateUuid as validateUuid11, logger as logger11 } from "@elizaos/core";
 
 // src/api/shared/validation.ts
-import { validateUuid as validateUuid10, logger as logger11 } from "@elizaos/core";
+import { validateUuid as validateUuid10, logger as logger10 } from "@elizaos/core";
 var getRuntime = (agents, agentId) => {
   const runtime = agents.get(agentId);
   if (!runtime) {
@@ -1743,7 +1741,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}`);
+      logger11.warn(`[SECURITY] Suspicious User-Agent from ${clientIp}: ${userAgent}`);
     }
     const url = req.originalUrl || req.url;
     const queryString = JSON.stringify(req.query);
@@ -1769,12 +1767,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}`);
+        logger11.warn(`[SECURITY] ${indicator.name} detected from ${clientIp}: ${url}`);
         break;
       }
     }
     if (hasSqlPattern) {
-      logger12.warn(`[SECURITY] SQL injection pattern detected from ${clientIp}: ${url}`);
+      logger11.warn(`[SECURITY] SQL injection pattern detected from ${clientIp}: ${url}`);
     }
     next();
   };
@@ -1823,7 +1821,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}`);
+      logger11.warn(`[SECURITY] Rate limit exceeded for IP: ${clientIp}`);
       res.status(429).json({
         success: false,
         error: {
@@ -1851,7 +1849,7 @@ var createFileSystemRateLimit = () => {
     legacyHeaders: false,
     handler: (req, res) => {
       const clientIp = req.ip || "unknown";
-      logger12.warn(
+      logger11.warn(
         `[SECURITY] File system rate limit exceeded for IP: ${clientIp}, endpoint: ${req.path}`
       );
       res.status(429).json({
@@ -1881,7 +1879,7 @@ var createUploadRateLimit = () => {
     legacyHeaders: false,
     handler: (req, res) => {
       const clientIp = req.ip || "unknown";
-      logger12.warn(
+      logger11.warn(
         `[SECURITY] Upload rate limit exceeded for IP: ${clientIp}, endpoint: ${req.path}`
       );
       res.status(429).json({
@@ -1895,10 +1893,69 @@ var createUploadRateLimit = () => {
   });
 };
 
+// src/api/shared/constants.ts
+var MAX_FILE_SIZE = 50 * 1024 * 1024;
+var MAX_FILE_SIZE_DISPLAY = "50MB";
+var ALLOWED_AUDIO_MIME_TYPES = [
+  "audio/mpeg",
+  "audio/mp3",
+  "audio/wav",
+  "audio/ogg",
+  "audio/webm",
+  "audio/mp4",
+  "audio/aac",
+  "audio/flac",
+  "audio/x-wav",
+  "audio/wave"
+];
+var ALLOWED_MEDIA_MIME_TYPES = [
+  ...ALLOWED_AUDIO_MIME_TYPES,
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+  "video/mp4",
+  "video/webm",
+  "application/pdf",
+  "text/plain"
+];
+
 // src/api/messaging/channels.ts
+import multer from "multer";
+import fs from "fs";
+import path from "path";
 var DEFAULT_SERVER_ID3 = "00000000-0000-0000-0000-000000000000";
+var channelStorage = multer.memoryStorage();
+var channelUploadMiddleware = multer({
+  storage: channelStorage,
+  limits: {
+    fileSize: MAX_FILE_SIZE,
+    files: 1
+  },
+  fileFilter: (req, file, cb) => {
+    if (ALLOWED_MEDIA_MIME_TYPES.includes(file.mimetype)) {
+      cb(null, true);
+    } else {
+      cb(new Error("Invalid file type"), false);
+    }
+  }
+});
+async function saveChannelUploadedFile(file, channelId) {
+  const uploadDir = path.join(process.cwd(), ".eliza/data/uploads/channels", channelId);
+  if (!fs.existsSync(uploadDir)) {
+    fs.mkdirSync(uploadDir, { recursive: true });
+  }
+  const timestamp = Date.now();
+  const random = Math.round(Math.random() * 1e9);
+  const ext = path.extname(file.originalname);
+  const filename = `${timestamp}-${random}${ext}`;
+  const filePath = path.join(uploadDir, filename);
+  fs.writeFileSync(filePath, file.buffer);
+  const url = `/media/uploads/channels/${channelId}/${filename}`;
+  return { filename, url };
+}
 function createChannelsRouter(agents, serverInstance) {
-  const router = express10.Router();
+  const router = express11.Router();
   router.post(
     "/central-channels/:channelId/messages",
     async (req, res) => {
@@ -1925,53 +1982,53 @@ function createChannelsRouter(agents, serverInstance) {
         });
       }
       try {
-        logger13.info(
+        logger12.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}`);
+          logger12.info(`[Messages Router] Channel ${channelIdParam} exists: ${channelExists}`);
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
-          logger13.info(
+          logger12.info(
             `[Messages Router] Channel ${channelIdParam} does not exist, will create it. Error: ${errorMessage}`
           );
         }
         if (!channelExists) {
-          logger13.info(
+          logger12.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(
+            logger12.info(
               `[Messages Router] Server ${server_id} exists: ${serverExists}. Available servers: ${servers.map((s) => s.id).join(", ")}`
             );
             if (!serverExists) {
-              logger13.error(
+              logger12.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(
+            logger12.info(
               "[Messages Router] Creating channel with data:",
               JSON.stringify(channelData, null, 2)
             );
@@ -1980,29 +2037,29 @@ function createChannelsRouter(agents, serverInstance) {
               const otherParticipant = metadata?.targetUserId || metadata?.recipientId;
               if (otherParticipant && validateUuid12(otherParticipant)) {
                 participants.push(otherParticipant);
-                logger13.info(
+                logger12.info(
                   `[Messages Router] DM channel will include participants: ${participants.join(", ")}`
                 );
               } else {
-                logger13.warn(
+                logger12.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`
+            logger12.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(
+            logger12.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(
+          logger12.info(
             `[Messages Router] Channel ${channelIdParam} already exists, proceeding with message creation`
           );
         }
@@ -2036,7 +2093,7 @@ function createChannelsRouter(agents, serverInstance) {
           // Will be undefined here, which is fine
         };
         bus_default.emit("new_message", messageForBus);
-        logger13.info(
+        logger12.info(
           "[Messages Router /central-channels/:channelId/messages] GUI Message published to internal bus:",
           messageForBus.id
         );
@@ -2056,7 +2113,7 @@ function createChannelsRouter(agents, serverInstance) {
         }
         res.status(201).json({ success: true, data: messageForBus });
       } catch (error) {
-        logger13.error(
+        logger12.error(
           "[Messages Router /central-channels/:channelId/messages] Error processing GUI message:",
           error
         );
@@ -2094,7 +2151,7 @@ function createChannelsRouter(agents, serverInstance) {
         });
         res.json({ success: true, data: { messages: messagesForGui } });
       } catch (error) {
-        logger13.error(
+        logger12.error(
           `[Messages Router /central-channels/:channelId/messages] Error fetching messages for channel ${channelId}:`,
           error
         );
@@ -2113,7 +2170,7 @@ function createChannelsRouter(agents, serverInstance) {
         const channels = await serverInstance.getChannelsForServer(serverId);
         res.json({ success: true, data: { channels } });
       } catch (error) {
-        logger13.error(
+        logger12.error(
           `[Messages Router /central-servers/:serverId/channels] Error fetching channels for server ${serverId}:`,
           error
         );
@@ -2122,22 +2179,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: messageServerId, name, type"
+        error: "Missing required fields: serverId."
       });
     }
-    if (!validateUuid12(messageServerId)) {
+    if (!name) {
       return res.status(400).json({
         success: false,
-        error: "Invalid messageServerId format"
+        error: "Missing required fields: name."
+      });
+    }
+    if (!type) {
+      return res.status(400).json({
+        success: false,
+        error: "Missing required fields: type."
+      });
+    }
+    if (!validateUuid12(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,7 +2218,7 @@ function createChannelsRouter(agents, serverInstance) {
       });
       res.status(201).json({ success: true, data: { channel } });
     } catch (error) {
-      logger13.error("[Messages Router /channels] Error creating channel:", error);
+      logger12.error("[Messages Router /channels] Error creating channel:", error);
       res.status(500).json({ success: false, error: "Failed to create channel" });
     }
   });
@@ -2170,7 +2241,7 @@ function createChannelsRouter(agents, serverInstance) {
         if (existingServer) {
           dmServerIdToUse = providedDmServerId;
         } else {
-          logger13.warn(
+          logger12.warn(
             `Provided dmServerId ${providedDmServerId} not found, using default DM server logic.`
           );
           dmServerIdToUse = DEFAULT_SERVER_ID3;
@@ -2188,7 +2259,7 @@ function createChannelsRouter(agents, serverInstance) {
         stack: error.stack,
         originalError: error
       } : { message: String(error) };
-      logger13.error("Error finding/creating DM channel:", errorDetails);
+      logger12.error("Error finding/creating DM channel:", errorDetails);
       res.status(500).json({ success: false, error: "Failed to find or create DM channel" });
     }
   });
@@ -2196,7 +2267,7 @@ function createChannelsRouter(agents, serverInstance) {
     const {
       name,
       participantCentralUserIds,
-      type = ChannelType.GROUP,
+      type = ChannelType2.GROUP,
       server_id,
       metadata
     } = req.body;
@@ -2224,7 +2295,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(
+      logger12.error(
         "[Messages Router /central-channels] Error creating group channel:",
         errorMessage
       );
@@ -2245,7 +2316,7 @@ function createChannelsRouter(agents, serverInstance) {
         }
         res.json({ success: true, data: channelDetails });
       } catch (error) {
-        logger13.error(`[Messages Router] Error fetching details for channel ${channelId}:`, error);
+        logger12.error(`[Messages Router] Error fetching details for channel ${channelId}:`, error);
         res.status(500).json({ success: false, error: "Failed to fetch channel details" });
       }
     }
@@ -2261,7 +2332,7 @@ function createChannelsRouter(agents, serverInstance) {
         const participants = await serverInstance.getChannelParticipants(channelId);
         res.json({ success: true, data: participants });
       } catch (error) {
-        logger13.error(
+        logger12.error(
           `[Messages Router] Error fetching participants for channel ${channelId}:`,
           error
         );
@@ -2289,7 +2360,7 @@ function createChannelsRouter(agents, serverInstance) {
           });
         }
         await serverInstance.addParticipantsToChannel(channelId, [agentId]);
-        logger13.info(`[Messages Router] Added agent ${agentId} to channel ${channelId}`);
+        logger12.info(`[Messages Router] Added agent ${agentId} to channel ${channelId}`);
         res.status(201).json({
           success: true,
           data: {
@@ -2299,7 +2370,7 @@ function createChannelsRouter(agents, serverInstance) {
           }
         });
       } catch (error) {
-        logger13.error(
+        logger12.error(
           `[Messages Router] Error adding agent ${agentId} to channel ${channelId}:`,
           error
         );
@@ -2341,7 +2412,7 @@ function createChannelsRouter(agents, serverInstance) {
         await serverInstance.updateChannel(channelId, {
           participantCentralUserIds: updatedParticipants
         });
-        logger13.info(`[Messages Router] Removed agent ${agentId} from channel ${channelId}`);
+        logger12.info(`[Messages Router] Removed agent ${agentId} from channel ${channelId}`);
         res.status(200).json({
           success: true,
           data: {
@@ -2351,7 +2422,7 @@ function createChannelsRouter(agents, serverInstance) {
           }
         });
       } catch (error) {
-        logger13.error(
+        logger12.error(
           `[Messages Router] Error removing agent ${agentId} from channel ${channelId}:`,
           error
         );
@@ -2385,7 +2456,7 @@ function createChannelsRouter(agents, serverInstance) {
           }
         });
       } catch (error) {
-        logger13.error(`[Messages Router] Error fetching agents for channel ${channelId}:`, error);
+        logger12.error(`[Messages Router] Error fetching agents for channel ${channelId}:`, error);
         res.status(500).json({
           success: false,
           error: "Failed to fetch channel agents"
@@ -2403,13 +2474,13 @@ function createChannelsRouter(agents, serverInstance) {
       }
       try {
         await serverInstance.deleteMessage(messageId);
-        logger13.info(`[Messages Router] Deleted message ${messageId} from central database`);
+        logger12.info(`[Messages Router] Deleted message ${messageId} from central database`);
         const deletedMessagePayload = {
           messageId,
           channelId
         };
         bus_default.emit("message_deleted", deletedMessagePayload);
-        logger13.info(
+        logger12.info(
           `[Messages Router] Emitted message_deleted event to internal bus for message ${messageId}`
         );
         if (serverInstance.socketIO) {
@@ -2420,7 +2491,7 @@ function createChannelsRouter(agents, serverInstance) {
         }
         res.status(204).send();
       } catch (error) {
-        logger13.error(
+        logger12.error(
           `[Messages Router] Error deleting message ${messageId} from channel ${channelId}:`,
           error
         );
@@ -2441,7 +2512,7 @@ function createChannelsRouter(agents, serverInstance) {
           channelId
         };
         bus_default.emit("channel_cleared", channelClearedPayload);
-        logger13.info(
+        logger12.info(
           `[Messages Router] Emitted channel_cleared event to internal bus for channel ${channelId}`
         );
         if (serverInstance.socketIO) {
@@ -2451,7 +2522,7 @@ function createChannelsRouter(agents, serverInstance) {
         }
         res.status(204).send();
       } catch (error) {
-        logger13.error(`[Messages Router] Error clearing messages for channel ${channelId}:`, error);
+        logger12.error(`[Messages Router] Error clearing messages for channel ${channelId}:`, error);
         res.status(500).json({ success: false, error: "Failed to clear messages" });
       }
     }
@@ -2478,7 +2549,7 @@ function createChannelsRouter(agents, serverInstance) {
         }
         res.json({ success: true, data: updatedChannel });
       } catch (error) {
-        logger13.error(`[Messages Router] Error updating channel ${channelId}:`, error);
+        logger12.error(`[Messages Router] Error updating channel ${channelId}:`, error);
         res.status(500).json({ success: false, error: "Failed to update channel" });
       }
     }
@@ -2494,14 +2565,14 @@ function createChannelsRouter(agents, serverInstance) {
         const messages = await serverInstance.getMessagesForChannel(channelId);
         const messageCount = messages.length;
         await serverInstance.deleteChannel(channelId);
-        logger13.info(
+        logger12.info(
           `[Messages Router] Deleted channel ${channelId} with ${messageCount} messages from central database`
         );
         const channelClearedPayload = {
           channelId
         };
         bus_default.emit("channel_cleared", channelClearedPayload);
-        logger13.info(
+        logger12.info(
           `[Messages Router] Emitted channel_cleared event to internal bus for deleted channel ${channelId}`
         );
         if (serverInstance.socketIO) {
@@ -2511,7 +2582,7 @@ function createChannelsRouter(agents, serverInstance) {
         }
         res.status(204).send();
       } catch (error) {
-        logger13.error(`[Messages Router] Error deleting channel ${channelId}:`, error);
+        logger12.error(`[Messages Router] Error deleting channel ${channelId}:`, error);
         res.status(500).json({ success: false, error: "Failed to delete channel" });
       }
     }
@@ -2520,44 +2591,24 @@ function createChannelsRouter(agents, serverInstance) {
     "/channels/:channelId/upload-media",
     createUploadRateLimit(),
     createFileSystemRateLimit(),
-    channelUpload(),
+    channelUploadMiddleware.single("file"),
     async (req, res) => {
       const channelId = validateUuid12(req.params.channelId);
       if (!channelId) {
         res.status(400).json({ success: false, error: "Invalid channelId format" });
         return;
       }
-      let mediaFile;
-      if (req.files && !Array.isArray(req.files)) {
-        mediaFile = req.files.file;
-      } else if (Array.isArray(req.files) && req.files.length > 0) {
-        mediaFile = req.files[0];
-      } else {
-        res.status(400).json({ success: false, error: "No media file provided" });
-        return;
-      }
-      if (!mediaFile) {
+      if (!req.file) {
         res.status(400).json({ success: false, error: "No media file provided" });
         return;
       }
       try {
-        if (!validateMediaFile(mediaFile)) {
-          cleanupUploadedFile(mediaFile);
-          res.status(400).json({ success: false, error: `Invalid file type: ${mediaFile.mimetype}` });
-          return;
-        }
-        if (!mediaFile.name || mediaFile.name.includes("..") || mediaFile.name.includes("/")) {
-          cleanupUploadedFile(mediaFile);
+        if (!req.file.originalname || req.file.originalname.includes("..") || req.file.originalname.includes("/")) {
           res.status(400).json({ success: false, error: "Invalid filename detected" });
           return;
         }
-        if (mediaFile.size > MAX_FILE_SIZE) {
-          cleanupUploadedFile(mediaFile);
-          res.status(400).json({ success: false, error: "File too large" });
-          return;
-        }
-        const result = await processUploadedFile(mediaFile, channelId, "channels");
-        logger13.info(
+        const result = await saveChannelUploadedFile(req.file, channelId);
+        logger12.info(
           `[MessagesRouter /upload-media] Secure file uploaded for channel ${channelId}: ${result.filename}. URL: ${result.url}`
         );
         res.json({
@@ -2565,21 +2616,18 @@ function createChannelsRouter(agents, serverInstance) {
           data: {
             url: result.url,
             // Relative URL, client prepends server origin
-            type: mediaFile.mimetype,
+            type: req.file.mimetype,
             filename: result.filename,
-            originalName: mediaFile.name,
-            size: mediaFile.size
+            originalName: req.file.originalname,
+            size: req.file.size
           }
         });
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        logger13.error(
+        logger12.error(
           `[MessagesRouter /upload-media] Error processing upload for channel ${channelId}: ${errorMessage}`,
           error
         );
-        if (mediaFile) {
-          cleanupUploadedFile(mediaFile);
-        }
         res.status(500).json({ success: false, error: "Failed to process media upload" });
       }
     }
@@ -2609,7 +2657,7 @@ function createChannelsRouter(agents, serverInstance) {
             error: "Agent not found or not active"
           });
         }
-        logger13.info(`[CHANNEL SUMMARIZE] Summarizing channel ${channelId}`);
+        logger12.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 +2711,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}`);
+          logger12.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}`);
+        logger12.info(`[ChatTitleEvaluator] Generated title: "${cleanTitle}" for room ${channelId}`);
         const result = {
           title: cleanTitle,
           channelId
         };
-        logger13.success(`[CHANNEL SUMMARIZE] Successfully summarized channel ${channelId}`);
+        logger12.success(`[CHANNEL SUMMARIZE] Successfully summarized channel ${channelId}`);
         res.json({
           success: true,
           data: result
         });
       } catch (error) {
-        logger13.error("[CHANNEL SUMMARIZE] Error summarizing channel:", error);
+        logger12.error("[CHANNEL SUMMARIZE] Error summarizing channel:", error);
         res.status(500).json({
           success: false,
           error: "Failed to summarize channel",
@@ -2692,7 +2740,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,61 +2751,77 @@ 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 validateUuid13, logger as logger13, getContentTypeFromMimeType } from "@elizaos/core";
+import express13 from "express";
+import multer2 from "multer";
+import fs2 from "fs";
+import path2 from "path";
+var storage = multer2.memoryStorage();
+var upload = multer2({
+  storage,
+  limits: {
+    fileSize: MAX_FILE_SIZE,
+    files: 1
+  },
+  fileFilter: (req, file, cb) => {
+    if (ALLOWED_MEDIA_MIME_TYPES.includes(file.mimetype)) {
+      cb(null, true);
+    } else {
+      cb(new Error("Invalid file type"), false);
+    }
+  }
+});
+async function saveUploadedFile(file, agentId) {
+  const uploadDir = path2.join(process.cwd(), ".eliza/data/uploads/agents", agentId);
+  if (!fs2.existsSync(uploadDir)) {
+    fs2.mkdirSync(uploadDir, { recursive: true });
+  }
+  const timestamp = Date.now();
+  const random = Math.round(Math.random() * 1e9);
+  const ext = path2.extname(file.originalname);
+  const filename = `${timestamp}-${random}${ext}`;
+  const filePath = path2.join(uploadDir, filename);
+  fs2.writeFileSync(filePath, file.buffer);
+  const url = `/media/uploads/agents/${agentId}/${filename}`;
+  return { filename, url };
+}
 function createAgentMediaRouter() {
-  const router = express12.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);
+  const router = express13.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);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
-    let mediaFile;
-    if (agentMediaReq.files && !Array.isArray(agentMediaReq.files)) {
-      mediaFile = agentMediaReq.files.file;
-    } else if (Array.isArray(agentMediaReq.files) && agentMediaReq.files.length > 0) {
-      mediaFile = agentMediaReq.files[0];
-    } else {
-      return sendError(res, 400, "INVALID_REQUEST", "No media file provided");
-    }
-    if (!mediaFile) {
+    if (!req.file) {
       return sendError(res, 400, "INVALID_REQUEST", "No media file provided");
     }
-    const mimetype = mediaFile.mimetype;
-    if (!validateMediaFile(mediaFile)) {
-      cleanupUploadedFile(mediaFile);
-      return sendError(res, 400, "INVALID_FILE_TYPE", "Unsupported media file type");
-    }
-    const mediaType = getContentTypeFromMimeType(mimetype);
+    const mediaType = getContentTypeFromMimeType(req.file.mimetype);
     if (!mediaType) {
-      cleanupUploadedFile(mediaFile);
       return sendError(
         res,
         400,
         "UNSUPPORTED_MEDIA_TYPE",
-        `Unsupported media MIME type: ${mimetype}`
+        `Unsupported media MIME type: ${req.file.mimetype}`
       );
     }
     try {
-      const result = await processUploadedFile(mediaFile, agentId, "agents");
-      logger14.info(
+      const result = await saveUploadedFile(req.file, agentId);
+      logger13.info(
         `[MEDIA UPLOAD] Successfully uploaded ${mediaType}: ${result.filename}. URL: ${result.url}`
       );
       sendSuccess(res, {
         url: result.url,
         type: mediaType,
         filename: result.filename,
-        originalName: mediaFile.name,
-        size: mediaFile.size
+        originalName: req.file.originalname,
+        size: req.file.size
       });
     } catch (error) {
-      logger14.error(`[MEDIA UPLOAD] Error processing upload: ${error}`);
-      cleanupUploadedFile(mediaFile);
+      logger13.error(`[MEDIA UPLOAD] Error processing upload: ${error}`);
       sendError(
         res,
         500,
@@ -2771,11 +2835,43 @@ function createAgentMediaRouter() {
 }
 
 // src/api/media/channels.ts
-import { validateUuid as validateUuid14, logger as logger15 } from "@elizaos/core";
-import express13 from "express";
+import { validateUuid as validateUuid14, logger as logger14 } from "@elizaos/core";
+import express14 from "express";
 import rateLimit2 from "express-rate-limit";
+import multer3 from "multer";
+import fs3 from "fs";
+import path3 from "path";
+var storage2 = multer3.memoryStorage();
+var upload2 = multer3({
+  storage: storage2,
+  limits: {
+    fileSize: MAX_FILE_SIZE,
+    files: 1
+  },
+  fileFilter: (req, file, cb) => {
+    if (ALLOWED_MEDIA_MIME_TYPES.includes(file.mimetype)) {
+      cb(null, true);
+    } else {
+      cb(new Error("Invalid file type"), false);
+    }
+  }
+});
+async function saveUploadedFile2(file, channelId) {
+  const uploadDir = path3.join(process.cwd(), ".eliza/data/uploads/channels", channelId);
+  if (!fs3.existsSync(uploadDir)) {
+    fs3.mkdirSync(uploadDir, { recursive: true });
+  }
+  const timestamp = Date.now();
+  const random = Math.round(Math.random() * 1e9);
+  const ext = path3.extname(file.originalname);
+  const filename = `${timestamp}-${random}${ext}`;
+  const filePath = path3.join(uploadDir, filename);
+  fs3.writeFileSync(filePath, file.buffer);
+  const url = `/media/uploads/channels/${channelId}/${filename}`;
+  return { filename, url };
+}
 function createChannelMediaRouter() {
-  const router = express13.Router();
+  const router = express14.Router();
   const uploadMediaRateLimiter = rateLimit2({
     windowMs: 15 * 60 * 1e3,
     // 15 minutes
@@ -2787,35 +2883,20 @@ function createChannelMediaRouter() {
     "/:channelId/upload-media",
     uploadMediaRateLimiter,
     // Apply rate limiter
-    channelUpload(),
+    upload2.single("file"),
     async (req, res) => {
-      const channelMediaReq = req;
-      const channelId = validateUuid14(channelMediaReq.params.channelId);
+      const channelId = validateUuid14(req.params.channelId);
       if (!channelId) {
         res.status(400).json({ success: false, error: "Invalid channelId format" });
         return;
       }
-      let mediaFile;
-      if (channelMediaReq.files && !Array.isArray(channelMediaReq.files)) {
-        mediaFile = channelMediaReq.files.file;
-      } else if (Array.isArray(channelMediaReq.files) && channelMediaReq.files.length > 0) {
-        mediaFile = channelMediaReq.files[0];
-      } else {
-        res.status(400).json({ success: false, error: "No media file provided" });
-        return;
-      }
-      if (!mediaFile) {
-        res.status(400).json({ success: false, error: "No media file provided" });
-        return;
-      }
-      if (!validateMediaFile(mediaFile)) {
-        cleanupUploadedFile(mediaFile);
-        res.status(400).json({ success: false, error: `Invalid file type: ${mediaFile.mimetype}` });
+      if (!req.file) {
+        res.status(400).json({ success: false, error: "No media file provided" });
         return;
       }
       try {
-        const result = await processUploadedFile(mediaFile, channelId, "channels");
-        logger15.info(
+        const result = await saveUploadedFile2(req.file, channelId);
+        logger14.info(
           `[Channel Media Upload] File uploaded for channel ${channelId}: ${result.filename}. URL: ${result.url}`
         );
         res.json({
@@ -2823,18 +2904,17 @@ function createChannelMediaRouter() {
           data: {
             url: result.url,
             // Relative URL, client prepends server origin
-            type: mediaFile.mimetype,
+            type: req.file.mimetype,
             filename: result.filename,
-            originalName: mediaFile.name,
-            size: mediaFile.size
+            originalName: req.file.originalname,
+            size: req.file.size
           }
         });
       } catch (error) {
-        logger15.error(
+        logger14.error(
           `[Channel Media Upload] Error processing upload for channel ${channelId}: ${error.message}`,
           error
         );
-        cleanupUploadedFile(mediaFile);
         res.status(500).json({ success: false, error: "Failed to process media upload" });
       }
     }
@@ -2844,7 +2924,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 +2934,47 @@ 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";
+
+// src/api/shared/file-utils.ts
+import fs4 from "fs";
+import path4 from "path";
+import { logger as logger15 } from "@elizaos/core";
+var cleanupUploadedFile = (file) => {
+  logger15.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";
+var storage3 = multer4.memoryStorage();
+var agentAudioUpload = () => multer4({
+  storage: storage3,
+  limits: {
+    fileSize: MAX_FILE_SIZE,
+    files: 1
+  },
+  fileFilter: (req, file, cb) => {
+    if (ALLOWED_AUDIO_MIME_TYPES.includes(file.mimetype)) {
+      cb(null, true);
+    } else {
+      cb(new Error("Invalid audio file type"), false);
+    }
+  }
+});
+function validateAudioFile(file) {
+  return ALLOWED_AUDIO_MIME_TYPES.includes(file.mimetype);
+}
+
+// src/api/memory/groups.ts
 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 +2984,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 +2996,7 @@ function createGroupMemoryRouter(agents, serverInstance) {
           id: roomId,
           name: roomName,
           source,
-          type: ChannelType2.API,
+          type: ChannelType3.API,
           worldId,
           serverId,
           metadata,
@@ -2896,10 +3010,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 +3036,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 +3047,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 +3058,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 +3073,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,144 +3086,121 @@ 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);
+// src/api/memory/index.ts
+function memoryRouter(agents, serverInstance) {
+  const router = express17.Router();
+  router.use("/", createAgentMemoryRouter(agents));
+  router.use("/", createGroupMemoryRouter(agents, serverInstance));
+  router.use("/", createRoomManagementRouter(agents));
+  return router;
+}
+
+// src/api/audio/index.ts
+import express21 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 fs6 from "fs";
+import os from "os";
+import path6 from "path";
+function createAudioProcessingRouter(agents) {
+  const router = express18.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);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
+    const audioFile = audioReq.file;
+    if (!audioFile) {
+      return sendError(res, 400, "INVALID_REQUEST", "No audio file provided");
+    }
     const runtime = agents.get(agentId);
     if (!runtime) {
+      cleanupUploadedFile(audioFile);
       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");
+      if (!validateAudioFile(audioFile)) {
+        cleanupUploadedFile(audioFile);
+        return sendError(res, 400, "INVALID_FILE_TYPE", "Invalid audio file type");
       }
-      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
-        });
+      if (audioFile.size > MAX_FILE_SIZE) {
+        cleanupUploadedFile(audioFile);
+        return sendError(
+          res,
+          413,
+          "FILE_TOO_LARGE",
+          `Audio file too large (max ${MAX_FILE_SIZE_DISPLAY})`
+        );
       }
-      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
-      );
+      const transcription = await runtime.useModel(ModelType2.TRANSCRIPTION, audioFile.buffer);
+      logger18.info(`[AUDIO MESSAGE] Transcription for agent ${agentId}: ${transcription}`);
+      cleanupUploadedFile(audioFile);
+      sendSuccess(res, { transcription, message: "Audio transcribed, further processing TBD." });
     } catch (error) {
-      logger17.error(`[ROOM CREATE] Error creating room for agent ${agentId}:`, error);
+      logger18.error("[AUDIO MESSAGE] Error processing audio:", error);
+      cleanupUploadedFile(audioFile);
       sendError(
         res,
         500,
-        "CREATE_ERROR",
-        "Failed to create room",
+        "PROCESSING_ERROR",
+        "Error processing audio message",
         error instanceof Error ? error.message : String(error)
       );
     }
   });
-  router.get("/:agentId/rooms", async (req, res) => {
-    const agentId = validateUuid16(req.params.agentId);
+  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);
     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 audioFile = audioReq.file;
+    if (!audioFile) {
+      return sendError(res, 400, "INVALID_REQUEST", "No audio file provided");
     }
     const runtime = agents.get(agentId);
     if (!runtime) {
+      cleanupUploadedFile(audioFile);
       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");
+      logger18.debug("[TRANSCRIPTION] Reading audio file");
+      if (!validateAudioFile(audioFile)) {
+        cleanupUploadedFile(audioFile);
+        return sendError(res, 400, "INVALID_FILE_TYPE", "Invalid audio file type");
       }
-      let worldName;
-      if (room.worldId) {
-        const world = await runtime.getWorld(room.worldId);
-        worldName = world?.name;
+      if (audioFile.size > MAX_FILE_SIZE) {
+        cleanupUploadedFile(audioFile);
+        return sendError(
+          res,
+          413,
+          "FILE_TOO_LARGE",
+          `Audio file too large (max ${MAX_FILE_SIZE_DISPLAY})`
+        );
       }
-      sendSuccess(res, {
-        ...room,
-        ...worldName && { worldName }
-      });
+      logger18.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");
+      sendSuccess(res, { text: transcription });
     } catch (error) {
-      logger17.error(`[ROOM DETAILS] Error retrieving room ${roomId} for agent ${agentId}:`, error);
+      logger18.error("[TRANSCRIPTION] Error transcribing audio:", error);
+      cleanupUploadedFile(audioFile);
       sendError(
         res,
         500,
-        "RETRIEVAL_ERROR",
-        "Failed to retrieve room details",
+        "PROCESSING_ERROR",
+        "Error transcribing audio",
         error instanceof Error ? error.message : String(error)
       );
     }
@@ -3117,202 +3208,6 @@ function createRoomManagementRouter(agents) {
   return router;
 }
 
-// src/api/memory/index.ts
-function memoryRouter(agents, serverInstance) {
-  const router = express17.Router();
-  router.use("/", createAgentMemoryRouter(agents));
-  router.use("/", createGroupMemoryRouter(agents, serverInstance));
-  router.use("/", createRoomManagementRouter(agents));
-  return router;
-}
-
-// src/api/audio/index.ts
-import express21 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 fs3 from "fs";
-import os from "os";
-import path3 from "path";
-function validateSecureFilePath(filePath) {
-  if (!filePath) {
-    throw new Error("File path is required");
-  }
-  const resolvedPath = path3.resolve(filePath);
-  const normalizedPath = path3.normalize(resolvedPath);
-  if (normalizedPath.includes("..") || normalizedPath !== resolvedPath) {
-    throw new Error("Invalid file path: path traversal detected");
-  }
-  const allowedBasePaths = [process.cwd(), os.tmpdir(), os.homedir()];
-  const isPathAllowed = allowedBasePaths.some(
-    (basePath) => normalizedPath.startsWith(path3.resolve(basePath))
-  );
-  if (!isPathAllowed) {
-    throw new Error("Invalid file path: path outside allowed directories");
-  }
-  try {
-    const stats = fs3.statSync(normalizedPath);
-    if (!stats.isFile()) {
-      throw new Error("Path does not point to a regular file");
-    }
-  } catch (error) {
-    throw new Error(`File access error: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  return normalizedPath;
-}
-function getUploadedFile(req) {
-  if (req.files && !Array.isArray(req.files)) {
-    return req.files.file;
-  } else if (Array.isArray(req.files) && req.files.length > 0) {
-    return req.files[0];
-  }
-  return null;
-}
-function createAudioProcessingRouter(agents) {
-  const router = express18.Router();
-  router.use(createUploadRateLimit());
-  router.use(createFileSystemRateLimit());
-  router.post(
-    "/:agentId/audio-messages",
-    agentAudioUpload(),
-    // Use agentAudioUpload
-    async (req, res) => {
-      const audioReq = req;
-      logger18.debug("[AUDIO MESSAGE] Processing audio message");
-      const agentId = validateUuid17(req.params.agentId);
-      if (!agentId) {
-        return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
-      }
-      const audioFile = getUploadedFile(audioReq);
-      if (!audioFile) {
-        return sendError(res, 400, "INVALID_REQUEST", "No audio file provided");
-      }
-      const runtime = agents.get(agentId);
-      if (!runtime) {
-        cleanupUploadedFile(audioFile);
-        return sendError(res, 404, "NOT_FOUND", "Agent not found");
-      }
-      try {
-        if (!validateAudioFile(audioFile)) {
-          cleanupUploadedFile(audioFile);
-          return sendError(res, 400, "INVALID_FILE_TYPE", "Invalid audio file type");
-        }
-        let securePath;
-        try {
-          const filePath = audioFile.tempFilePath || "";
-          securePath = validateSecureFilePath(filePath);
-        } catch (pathError) {
-          cleanupUploadedFile(audioFile);
-          return sendError(
-            res,
-            403,
-            "INVALID_PATH",
-            `Invalid file path: ${pathError instanceof Error ? pathError.message : String(pathError)}`
-          );
-        }
-        const stats = await fs3.promises.stat(securePath);
-        if (stats.size > MAX_FILE_SIZE) {
-          cleanupUploadedFile(audioFile);
-          return sendError(
-            res,
-            413,
-            "FILE_TOO_LARGE",
-            `Audio file too large (max ${MAX_FILE_SIZE_DISPLAY})`
-          );
-        }
-        const audioBuffer = await fs3.promises.readFile(securePath);
-        const transcription = await runtime.useModel(ModelType2.TRANSCRIPTION, audioBuffer);
-        logger18.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);
-        cleanupUploadedFile(audioFile);
-        sendError(
-          res,
-          500,
-          "PROCESSING_ERROR",
-          "Error processing audio message",
-          error instanceof Error ? error.message : String(error)
-        );
-      }
-    }
-  );
-  router.post(
-    "/:agentId/transcriptions",
-    agentAudioUpload(),
-    // Use agentAudioUpload
-    async (req, res) => {
-      const audioReq = req;
-      logger18.debug("[TRANSCRIPTION] Request to transcribe audio");
-      const agentId = validateUuid17(req.params.agentId);
-      if (!agentId) {
-        return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
-      }
-      const audioFile = getUploadedFile(audioReq);
-      if (!audioFile) {
-        return sendError(res, 400, "INVALID_REQUEST", "No audio file provided");
-      }
-      const runtime = agents.get(agentId);
-      if (!runtime) {
-        cleanupUploadedFile(audioFile);
-        return sendError(res, 404, "NOT_FOUND", "Agent not found");
-      }
-      try {
-        logger18.debug("[TRANSCRIPTION] Reading audio file");
-        if (!validateAudioFile(audioFile)) {
-          cleanupUploadedFile(audioFile);
-          return sendError(res, 400, "INVALID_FILE_TYPE", "Invalid audio file type");
-        }
-        let securePath;
-        try {
-          const filePath = audioFile.tempFilePath || "";
-          securePath = validateSecureFilePath(filePath);
-        } catch (pathError) {
-          cleanupUploadedFile(audioFile);
-          return sendError(
-            res,
-            403,
-            "INVALID_PATH",
-            `Invalid file path: ${pathError instanceof Error ? pathError.message : String(pathError)}`
-          );
-        }
-        const stats = await fs3.promises.stat(securePath);
-        if (stats.size > MAX_FILE_SIZE) {
-          cleanupUploadedFile(audioFile);
-          return sendError(
-            res,
-            413,
-            "FILE_TOO_LARGE",
-            `Audio file too large (max ${MAX_FILE_SIZE_DISPLAY})`
-          );
-        }
-        const audioBuffer = await fs3.promises.readFile(securePath);
-        logger18.debug("[TRANSCRIPTION] Transcribing audio");
-        const transcription = await runtime.useModel(ModelType2.TRANSCRIPTION, audioBuffer);
-        cleanupUploadedFile(audioFile);
-        if (!transcription) {
-          return sendError(res, 500, "PROCESSING_ERROR", "Failed to transcribe audio");
-        }
-        logger18.success("[TRANSCRIPTION] Successfully transcribed audio");
-        sendSuccess(res, { text: transcription });
-      } catch (error) {
-        logger18.error("[TRANSCRIPTION] Error transcribing audio:", error);
-        cleanupUploadedFile(audioFile);
-        sendError(
-          res,
-          500,
-          "PROCESSING_ERROR",
-          "Error transcribing audio",
-          error instanceof Error ? error.message : String(error)
-        );
-      }
-    }
-  );
-  return router;
-}
-
 // src/api/audio/synthesis.ts
 import { validateUuid as validateUuid18, logger as logger19, ModelType as ModelType3 } from "@elizaos/core";
 import express19 from "express";
@@ -3806,15 +3701,15 @@ import express28 from "express";
 import { logger as logger23 } from "@elizaos/core";
 import express27 from "express";
 import { existsSync, writeFileSync } from "fs";
-import path4 from "path";
+import path7 from "path";
 import dotenv from "dotenv";
-import fs4 from "fs/promises";
+import fs7 from "fs/promises";
 async function parseEnvFile(filePath) {
   try {
     if (!existsSync(filePath)) {
       return {};
     }
-    const content = await fs4.readFile(filePath, "utf-8");
+    const content = await fs7.readFile(filePath, "utf-8");
     if (content.trim() === "") {
       return {};
     }
@@ -3834,17 +3729,17 @@ function getLocalEnvPath() {
 function resolveEnvFile(startDir = process.cwd()) {
   let currentDir = startDir;
   while (true) {
-    const candidate = path4.join(currentDir, ".env");
+    const candidate = path7.join(currentDir, ".env");
     if (existsSync(candidate)) {
       return candidate;
     }
-    const parentDir = path4.dirname(currentDir);
+    const parentDir = path7.dirname(currentDir);
     if (parentDir === currentDir) {
       break;
     }
     currentDir = parentDir;
   }
-  return path4.join(startDir, ".env");
+  return path7.join(startDir, ".env");
 }
 function createEnvironmentRouter() {
   const router = express27.Router();
@@ -4595,6 +4490,7 @@ function createApiRouter(agents, serverInstance) {
   );
   router.use(createApiRateLimit());
   router.use(securityMiddleware());
+  router.use("/media", mediaRouter());
   router.use(validateContentTypeMiddleware());
   router.use(
     bodyParser.json({
@@ -4614,7 +4510,6 @@ function createApiRouter(agents, serverInstance) {
   );
   router.use("/agents", agentsRouter(agents, serverInstance));
   router.use("/messaging", messagingRouter(agents, serverInstance));
-  router.use("/media", mediaRouter());
   router.use("/memory", memoryRouter(agents, serverInstance));
   router.use("/audio", audioRouter(agents));
   router.use("/server", runtimeRouter(agents, serverInstance));
@@ -5018,7 +4913,14 @@ var MessageBusService = class _MessageBusService extends Service {
       await this.runtime.emitEvent(EventType2.MESSAGE_RECEIVED, {
         runtime: this.runtime,
         message: agentMemory,
-        callback: callbackForCentralBus
+        callback: callbackForCentralBus,
+        onComplete: async () => {
+          const room = await this.runtime.getRoom(agentRoomId);
+          const world = await this.runtime.getWorld(agentWorldId);
+          const channelId = room?.channelId;
+          const serverId = world?.serverId;
+          await this.notifyMessageComplete(channelId, serverId);
+        }
       });
     } catch (error) {
       logger27.error(
@@ -5095,7 +4997,6 @@ var MessageBusService = class _MessageBusService extends Service {
         logger27.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.`
         );
-        await this.notifyMessageComplete(channelId, serverId);
         return;
       }
       const shouldSkip = content.actions?.includes("IGNORE") || !content.text || content.text.trim() === "";
@@ -5103,7 +5004,6 @@ var MessageBusService = class _MessageBusService extends Service {
         logger27.info(
           `[${this.runtime.character.name}] MessageBusService: Skipping response (reason: ${content.actions?.includes("IGNORE") ? "IGNORE action" : "No text"})`
         );
-        await this.notifyMessageComplete(channelId, serverId);
         return;
       }
       let centralInReplyToRootMessageId = void 0;
@@ -5248,8 +5148,8 @@ var messageBusConnectorPlugin = {
 };
 
 // src/loader.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs8 from "fs";
+import path8 from "path";
 import { fileURLToPath } from "url";
 import {
   logger as logger28,
@@ -5257,10 +5157,10 @@ import {
   validateCharacter
 } from "@elizaos/core";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path5.dirname(__filename);
+var __dirname = path8.dirname(__filename);
 function tryLoadFile(filePath) {
   try {
-    return fs5.readFileSync(filePath, "utf8");
+    return fs8.readFileSync(filePath, "utf8");
   } catch (e) {
     throw new Error(`Error loading file ${filePath}: ${e}`);
   }
@@ -5357,36 +5257,36 @@ async function loadCharacter(filePath) {
   }
   return jsonToCharacter(parseResult.data);
 }
-function handleCharacterLoadError(path7, error) {
+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: ${path7}`);
+    logger28.error(`Character file not found: ${path10}`);
     throw new Error(
-      `Character '${path7}' not found. Please check if the file exists and the path is correct.`
+      `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: ${path7}`);
-    throw new Error(`Character file '${path7}' contains invalid character data. ${errorMsg}`);
+    logger28.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: ${path7}`);
-    throw new Error(`Character file '${path7}' has malformed JSON. Please check the file content.`);
+    logger28.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: ${path7}`);
+    logger28.error(`Invalid JSON in character file: ${path10}`);
     throw new Error(
-      `Character file '${path7}' has invalid JSON format. Please check the file content.`
+      `Character file '${path10}' has invalid JSON format. Please check the file content.`
     );
   } else {
-    logger28.error(`Error loading character from ${path7}: ${errorMsg}`);
-    throw new Error(`Failed to load character '${path7}': ${errorMsg}`);
+    logger28.error(`Error loading character from ${path10}: ${errorMsg}`);
+    throw new Error(`Failed to load character '${path10}': ${errorMsg}`);
   }
 }
-async function safeLoadCharacter(path7) {
+async function safeLoadCharacter(path10) {
   try {
-    const character = await loadCharacter(path7);
-    logger28.info(`Successfully loaded character from: ${path7}`);
+    const character = await loadCharacter(path10);
+    logger28.info(`Successfully loaded character from: ${path10}`);
     return character;
   } catch (e) {
-    return handleCharacterLoadError(path7, e);
+    return handleCharacterLoadError(path10, e);
   }
 }
 async function loadCharacterTryPath(characterPath) {
@@ -5406,27 +5306,27 @@ async function loadCharacterTryPath(characterPath) {
   const jsonPath = hasJsonExtension ? characterPath : `${characterPath}.json`;
   const basePathsToTry = [
     basePath,
-    path5.resolve(process.cwd(), basePath),
-    path5.resolve(process.cwd(), "..", "..", basePath),
-    path5.resolve(process.cwd(), "..", "..", "..", basePath),
-    path5.resolve(process.cwd(), "agent", basePath),
-    path5.resolve(__dirname, basePath),
-    path5.resolve(__dirname, "characters", path5.basename(basePath)),
-    path5.resolve(__dirname, "../characters", path5.basename(basePath)),
-    path5.resolve(__dirname, "../../characters", path5.basename(basePath)),
-    path5.resolve(__dirname, "../../../characters", path5.basename(basePath))
+    path8.resolve(process.cwd(), basePath),
+    path8.resolve(process.cwd(), "..", "..", basePath),
+    path8.resolve(process.cwd(), "..", "..", "..", basePath),
+    path8.resolve(process.cwd(), "agent", basePath),
+    path8.resolve(__dirname, basePath),
+    path8.resolve(__dirname, "characters", path8.basename(basePath)),
+    path8.resolve(__dirname, "../characters", path8.basename(basePath)),
+    path8.resolve(__dirname, "../../characters", path8.basename(basePath)),
+    path8.resolve(__dirname, "../../../characters", path8.basename(basePath))
   ];
   const jsonPathsToTry = hasJsonExtension ? [] : [
     jsonPath,
-    path5.resolve(process.cwd(), jsonPath),
-    path5.resolve(process.cwd(), "..", "..", jsonPath),
-    path5.resolve(process.cwd(), "..", "..", "..", jsonPath),
-    path5.resolve(process.cwd(), "agent", jsonPath),
-    path5.resolve(__dirname, jsonPath),
-    path5.resolve(__dirname, "characters", path5.basename(jsonPath)),
-    path5.resolve(__dirname, "../characters", path5.basename(jsonPath)),
-    path5.resolve(__dirname, "../../characters", path5.basename(jsonPath)),
-    path5.resolve(__dirname, "../../../characters", path5.basename(jsonPath))
+    path8.resolve(process.cwd(), jsonPath),
+    path8.resolve(process.cwd(), "..", "..", jsonPath),
+    path8.resolve(process.cwd(), "..", "..", "..", jsonPath),
+    path8.resolve(process.cwd(), "agent", jsonPath),
+    path8.resolve(__dirname, jsonPath),
+    path8.resolve(__dirname, "characters", path8.basename(jsonPath)),
+    path8.resolve(__dirname, "../characters", path8.basename(jsonPath)),
+    path8.resolve(__dirname, "../../characters", path8.basename(jsonPath)),
+    path8.resolve(__dirname, "../../../characters", path8.basename(jsonPath))
   ];
   const pathsToTry = Array.from(/* @__PURE__ */ new Set([...basePathsToTry, ...jsonPathsToTry]));
   let lastError = null;
@@ -5451,11 +5351,11 @@ function commaSeparatedStringToArray(commaSeparated) {
 }
 async function readCharactersFromStorage(characterPaths) {
   try {
-    const uploadDir = path5.join(process.cwd(), ".eliza", "data", "characters");
-    await fs5.promises.mkdir(uploadDir, { recursive: true });
-    const fileNames = await fs5.promises.readdir(uploadDir);
+    const uploadDir = path8.join(process.cwd(), ".eliza", "data", "characters");
+    await fs8.promises.mkdir(uploadDir, { recursive: true });
+    const fileNames = await fs8.promises.readdir(uploadDir);
     for (const fileName of fileNames) {
-      characterPaths.push(path5.join(uploadDir, fileName));
+      characterPaths.push(path8.join(uploadDir, fileName));
     }
   } catch (err) {
     logger28.error(`Error reading directory: ${err.message}`);
@@ -5511,11 +5411,11 @@ function expandTildePath(filepath) {
     if (filepath === "~") {
       return process.cwd();
     } else if (filepath.startsWith("~/")) {
-      return path6.join(process.cwd(), filepath.slice(2));
+      return path9.join(process.cwd(), filepath.slice(2));
     } else if (filepath.startsWith("~~")) {
       return filepath;
     } else {
-      return path6.join(process.cwd(), filepath.slice(1));
+      return path9.join(process.cwd(), filepath.slice(1));
     }
   }
   return filepath;
@@ -5525,11 +5425,11 @@ function resolvePgliteDir(dir, fallbackDir) {
   if (existsSync3(envPath)) {
     dotenv2.config({ path: envPath });
   }
-  const base = dir ?? process.env.PGLITE_DATA_DIR ?? fallbackDir ?? path6.join(process.cwd(), ".eliza", ".elizadb");
+  const base = dir ?? process.env.PGLITE_DATA_DIR ?? fallbackDir ?? path9.join(process.cwd(), ".eliza", ".elizadb");
   const resolved = expandTildePath(base);
-  const legacyPath = path6.join(process.cwd(), ".elizadb");
+  const legacyPath = path9.join(process.cwd(), ".elizadb");
   if (resolved === legacyPath) {
-    const newPath = path6.join(process.cwd(), ".eliza", ".elizadb");
+    const newPath = path9.join(process.cwd(), ".eliza", ".elizadb");
     process.env.PGLITE_DATA_DIR = newPath;
     return newPath;
   }
@@ -5769,26 +5669,10 @@ var AgentServer = class {
         })
       );
       this.app.use(
-        bodyParser2.json({
+        express30.json({
           limit: process.env.EXPRESS_MAX_PAYLOAD || "100kb"
         })
       );
-      this.app.use(
-        fileUpload2({
-          useTempFiles: true,
-          tempFileDir: "/tmp/",
-          createParentPath: true,
-          preserveExtension: true,
-          safeFileNames: true,
-          limits: {
-            fileSize: 50 * 1024 * 1024
-            // 50MB default limit
-          },
-          abortOnLimit: true,
-          uploadTimeout: 6e4
-          // 60 seconds
-        })
-      );
       const serverAuthToken = process.env.ELIZA_SERVER_AUTH_TOKEN;
       if (serverAuthToken) {
         logger29.info("Server authentication enabled. Requires X-API-KEY header for /api routes.");
@@ -5800,10 +5684,10 @@ var AgentServer = class {
           "Server authentication is disabled. Set ELIZA_SERVER_AUTH_TOKEN environment variable to enable."
         );
       }
-      const uploadsBasePath = path6.join(process.cwd(), ".eliza", "data", "uploads", "agents");
-      const generatedBasePath = path6.join(process.cwd(), ".eliza", "data", "generated");
-      fs6.mkdirSync(uploadsBasePath, { recursive: true });
-      fs6.mkdirSync(generatedBasePath, { recursive: true });
+      const uploadsBasePath = path9.join(process.cwd(), ".eliza", "data", "uploads", "agents");
+      const generatedBasePath = path9.join(process.cwd(), ".eliza", "data", "generated");
+      fs9.mkdirSync(uploadsBasePath, { recursive: true });
+      fs9.mkdirSync(generatedBasePath, { recursive: true });
       this.app.get(
         "/media/uploads/agents/:agentId/:filename",
         // @ts-expect-error - this is a valid express route
@@ -5820,7 +5704,7 @@ var AgentServer = class {
           if (!filePath.startsWith(agentUploadsPath)) {
             return res.status(403).json({ error: "Access denied" });
           }
-          if (!fs6.existsSync(filePath)) {
+          if (!fs9.existsSync(filePath)) {
             return res.status(404).json({ error: "File does not exist!!!!!!!" });
           }
           res.sendFile(sanitizedFilename, { root: agentUploadsPath }, (err) => {
@@ -5924,7 +5808,7 @@ var AgentServer = class {
           }
         }
       };
-      const clientPath = path6.resolve(__dirname2, "../../cli/dist");
+      const clientPath = path9.resolve(__dirname2, "../../cli/dist");
       this.app.use(express30.static(clientPath, staticOptions));
       const pluginRouteHandler = createPluginRouteHandler(this.agents);
       this.app.use(pluginRouteHandler);
@@ -5938,7 +5822,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,
@@ -5967,8 +5851,8 @@ var AgentServer = class {
           res.setHeader("Content-Type", "application/javascript");
           return res.status(404).send(`// JavaScript module not found: ${req.path}`);
         }
-        const cliDistPath = path6.resolve(__dirname2, "../../cli/dist");
-        res.sendFile(path6.join(cliDistPath, "index.html"));
+        const cliDistPath = path9.resolve(__dirname2, "../../cli/dist");
+        res.sendFile(path9.join(cliDistPath, "index.html"));
       });
       this.server = http.createServer(this.app);
       this.socketIO = setupSocketIO(this.server, this.agents, this);