@elizaos/server 1.5.8-alpha.20 → 1.5.8-alpha.22

package/dist/index.js

@@ -732,7 +732,7 @@ import {
   parseBooleanFromText
 } from "@elizaos/core";
 import cors2 from "cors";
-import express32 from "express";
+import express33 from "express";
 
 // ../../node_modules/helmet/index.mjs
 var dangerouslyDisableDefaultSrc = Symbol("dangerouslyDisableDefaultSrc");
@@ -1281,14 +1281,14 @@ import path6, { basename, dirname, extname, join } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/api/index.ts
-import { logger as logger26, validateUuid as validateUuid22 } from "@elizaos/core";
+import { logger as logger26, validateUuid as validateUuid23 } from "@elizaos/core";
 import cors from "cors";
-import express31 from "express";
+import express32 from "express";
 var import_path_to_regexp = __toESM(require_dist(), 1);
 import { Server as SocketIOServer } from "socket.io";
 
 // src/api/agents/index.ts
-import express8 from "express";
+import express9 from "express";
 
 // src/api/agents/crud.ts
 import {
@@ -1816,15 +1816,293 @@ function createAgentLogsRouter(agents) {
   return router;
 }
 
+// src/api/agents/runs.ts
+import { validateUuid as validateUuid6 } from "@elizaos/core";
+import express6 from "express";
+function createAgentRunsRouter(agents) {
+  const router = express6.Router();
+  router.get("/:agentId/runs", async (req, res) => {
+    const agentId = validateUuid6(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");
+    }
+    const { roomId, status, limit = 20, from, to } = req.query;
+    if (roomId && !validateUuid6(roomId)) {
+      return sendError(res, 400, "INVALID_ID", "Invalid room ID format");
+    }
+    try {
+      const limitNum = Math.min(Number(limit) || 20, 100);
+      const fromTime = from ? Number(from) : undefined;
+      const toTime = to ? Number(to) : undefined;
+      const runEventLogs = await runtime.getLogs({
+        entityId: agentId,
+        roomId: roomId ? roomId : undefined,
+        type: "run_event",
+        count: limitNum * 3
+      });
+      const runMap = new Map;
+      for (const log of runEventLogs) {
+        const body = log.body;
+        const runId = body.runId;
+        if (!runId)
+          continue;
+        const logTime = new Date(log.createdAt).getTime();
+        if (fromTime && logTime < fromTime)
+          continue;
+        if (toTime && logTime > toTime)
+          continue;
+        if (!runMap.has(runId)) {
+          runMap.set(runId, {
+            runId,
+            status: "started",
+            startedAt: null,
+            endedAt: null,
+            durationMs: null,
+            messageId: body.messageId,
+            roomId: body.roomId,
+            entityId: body.entityId,
+            metadata: body.metadata || {}
+          });
+        }
+        const run = runMap.get(runId);
+        const eventStatus = body.status;
+        if (eventStatus === "started") {
+          run.startedAt = logTime;
+        } else if (eventStatus === "completed" || eventStatus === "timeout" || eventStatus === "error") {
+          run.status = eventStatus;
+          run.endedAt = logTime;
+          if (run.startedAt) {
+            run.durationMs = logTime - run.startedAt;
+          }
+        }
+      }
+      let runs = Array.from(runMap.values());
+      if (status && status !== "all") {
+        runs = runs.filter((run) => run.status === status);
+      }
+      runs.sort((a, b) => (b.startedAt || 0) - (a.startedAt || 0));
+      const limitedRuns = runs.slice(0, limitNum);
+      const runIdSet = new Set(limitedRuns.map((r) => r.runId));
+      const [actionLogs, evaluatorLogs, genericLogs] = await Promise.all([
+        runtime.getLogs({
+          entityId: agentId,
+          roomId: roomId ? roomId : undefined,
+          type: "action",
+          count: 5000
+        }),
+        runtime.getLogs({
+          entityId: agentId,
+          roomId: roomId ? roomId : undefined,
+          type: "evaluator",
+          count: 5000
+        }),
+        runtime.getLogs({
+          entityId: agentId,
+          roomId: roomId ? roomId : undefined,
+          count: 5000
+        })
+      ]);
+      const countsByRunId = {};
+      for (const run of limitedRuns) {
+        countsByRunId[run.runId] = { actions: 0, modelCalls: 0, errors: 0, evaluators: 0 };
+      }
+      for (const log of actionLogs) {
+        const rid = log.body.runId;
+        if (!rid || !runIdSet.has(rid))
+          continue;
+        const entry = countsByRunId[rid];
+        if (!entry)
+          continue;
+        entry.actions += 1;
+        const bodyForAction = log.body;
+        if (bodyForAction.result?.success === false)
+          entry.errors += 1;
+        const promptCount = Number(bodyForAction.promptCount || 0);
+        if (promptCount > 0)
+          entry.modelCalls += promptCount;
+      }
+      for (const log of evaluatorLogs) {
+        const rid = log.body.runId;
+        if (!rid || !runIdSet.has(rid))
+          continue;
+        const entry = countsByRunId[rid];
+        if (!entry)
+          continue;
+        entry.evaluators += 1;
+      }
+      for (const log of genericLogs) {
+        const rid = log.body.runId;
+        if (!rid || !runIdSet.has(rid))
+          continue;
+        const entry = countsByRunId[rid];
+        if (!entry)
+          continue;
+        if (typeof log.type === "string" && log.type.startsWith("useModel:")) {
+          entry.modelCalls += 1;
+        } else if (log.type === "embedding_event" && log.body.status === "failed") {
+          entry.errors += 1;
+        }
+      }
+      for (const run of limitedRuns) {
+        run.counts = countsByRunId[run.runId] || { actions: 0, modelCalls: 0, errors: 0, evaluators: 0 };
+      }
+      const response = {
+        runs: limitedRuns,
+        total: runs.length,
+        hasMore: runs.length > limitNum
+      };
+      sendSuccess(res, response);
+    } catch (error) {
+      sendError(res, 500, "RUNS_ERROR", "Error retrieving agent runs", error instanceof Error ? error.message : String(error));
+    }
+  });
+  router.get("/:agentId/runs/:runId", async (req, res) => {
+    const agentId = validateUuid6(req.params.agentId);
+    const runId = validateUuid6(req.params.runId);
+    const { roomId } = req.query;
+    if (!agentId || !runId) {
+      return sendError(res, 400, "INVALID_ID", "Invalid agent or run ID format");
+    }
+    if (roomId && !validateUuid6(roomId)) {
+      return sendError(res, 400, "INVALID_ID", "Invalid room ID format");
+    }
+    const runtime = agents.get(agentId);
+    if (!runtime) {
+      return sendError(res, 404, "NOT_FOUND", "Agent not found");
+    }
+    try {
+      const logs = await runtime.getLogs({
+        entityId: agentId,
+        roomId: roomId ? roomId : undefined,
+        count: 2000
+      });
+      const related = logs.filter((l) => l.body.runId === runId);
+      const runEvents = related.filter((l) => l.type === "run_event").sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+      const started = runEvents.find((e) => e.body.status === "started");
+      const last = runEvents[runEvents.length - 1];
+      const startedAt = started ? new Date(started.createdAt).getTime() : undefined;
+      const endedAt = last && last.body.status !== "started" ? new Date(last.createdAt).getTime() : undefined;
+      const status = last?.body?.status || "started";
+      const durationMs = startedAt && endedAt ? endedAt - startedAt : undefined;
+      const actionLogs = related.filter((l) => l.type === "action");
+      const actionEventLogs = related.filter((l) => l.type === "action_event");
+      const evaluatorLogs = related.filter((l) => l.type === "evaluator");
+      const embeddingLogs = related.filter((l) => l.type === "embedding_event");
+      const modelLogs = related.filter((l) => typeof l.type === "string" && l.type.startsWith("useModel:"));
+      const counts = {
+        actions: actionEventLogs.length || actionLogs.length,
+        modelCalls: (actionLogs.reduce((sum, l) => sum + Number(l.body.promptCount || 0), 0) || 0) + modelLogs.length,
+        errors: actionLogs.filter((l) => l.body.result?.success === false).length + embeddingLogs.filter((l) => l.body.status === "failed").length,
+        evaluators: evaluatorLogs.length
+      };
+      const events = [];
+      for (const e of runEvents) {
+        const t = new Date(e.createdAt).getTime();
+        const body = e.body;
+        const st = body.status;
+        if (st === "started") {
+          events.push({ type: "RUN_STARTED", timestamp: t, data: { source: body.source ?? undefined, messageId: body.messageId } });
+        } else {
+          events.push({ type: "RUN_ENDED", timestamp: t, data: { status: st, error: body.error, durationMs: body.duration } });
+        }
+      }
+      for (const e of actionEventLogs) {
+        const body = e.body;
+        events.push({
+          type: "ACTION_STARTED",
+          timestamp: new Date(e.createdAt).getTime(),
+          data: {
+            actionId: body.actionId,
+            actionName: body.actionName || body.content?.actions?.[0],
+            messageId: body.messageId,
+            planStep: body.planStep
+          }
+        });
+      }
+      for (const e of actionLogs) {
+        const body = e.body;
+        events.push({
+          type: "ACTION_COMPLETED",
+          timestamp: new Date(e.createdAt).getTime(),
+          data: {
+            actionId: body.actionId,
+            actionName: body.action,
+            success: body.result?.success !== false,
+            result: body.result,
+            promptCount: body.promptCount
+          }
+        });
+      }
+      for (const e of modelLogs) {
+        const body = e.body;
+        events.push({
+          type: "MODEL_USED",
+          timestamp: new Date(e.createdAt).getTime(),
+          data: {
+            modelType: body.modelType || (typeof e.type === "string" ? e.type.replace("useModel:", "") : undefined),
+            provider: body.provider,
+            executionTime: body.executionTime,
+            actionContext: body.actionContext
+          }
+        });
+      }
+      for (const e of evaluatorLogs) {
+        const body = e.body;
+        events.push({
+          type: "EVALUATOR_COMPLETED",
+          timestamp: new Date(e.createdAt).getTime(),
+          data: {
+            evaluatorName: body.evaluator,
+            success: true
+          }
+        });
+      }
+      for (const e of embeddingLogs) {
+        const body = e.body;
+        events.push({
+          type: "EMBEDDING_EVENT",
+          timestamp: new Date(e.createdAt).getTime(),
+          data: {
+            status: body.status,
+            memoryId: body.memoryId,
+            durationMs: body.duration
+          }
+        });
+      }
+      events.sort((a, b) => a.timestamp - b.timestamp);
+      const firstRunEvent = started || runEvents[0] || related[0];
+      const summary = {
+        runId,
+        status,
+        startedAt: startedAt || (firstRunEvent ? new Date(firstRunEvent.createdAt).getTime() : undefined),
+        endedAt,
+        durationMs,
+        messageId: firstRunEvent?.body?.messageId,
+        roomId: firstRunEvent?.body?.roomId || roomId,
+        entityId: firstRunEvent?.body?.entityId || agentId,
+        counts
+      };
+      sendSuccess(res, { summary, events });
+    } catch (error) {
+      sendError(res, 500, "RUN_DETAIL_ERROR", "Error retrieving run details", error instanceof Error ? error.message : String(error));
+    }
+  });
+  return router;
+}
+
 // src/api/memory/agents.ts
 import { MemoryType, createUniqueUuid as createUniqueUuid2 } from "@elizaos/core";
-import { validateUuid as validateUuid6, logger as logger6 } from "@elizaos/core";
-import express6 from "express";
+import { validateUuid as validateUuid7, logger as logger6 } from "@elizaos/core";
+import express7 from "express";
 function createAgentMemoryRouter(agents) {
-  const router = express6.Router();
+  const router = express7.Router();
   router.get("/:agentId/rooms/:roomId/memories", async (req, res) => {
-    const agentId = validateUuid6(req.params.agentId);
-    const roomId = validateUuid6(req.params.roomId);
+    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");
     }
@@ -1854,7 +2132,7 @@ function createAgentMemoryRouter(agents) {
     }
   });
   router.get("/:agentId/memories", async (req, res) => {
-    const agentId = validateUuid6(req.params.agentId);
+    const agentId = validateUuid7(req.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID");
     }
@@ -1867,14 +2145,14 @@ function createAgentMemoryRouter(agents) {
       const includeEmbedding = req.query.includeEmbedding === "true";
       let roomIdToUse;
       if (req.query.channelId) {
-        const channelId = validateUuid6(req.query.channelId);
+        const channelId = validateUuid7(req.query.channelId);
         if (!channelId) {
           return sendError(res, 400, "INVALID_ID", "Invalid channel ID format");
         }
         roomIdToUse = createUniqueUuid2(runtime, channelId);
         logger6.info(`[AGENT MEMORIES] Converting channelId ${channelId} to roomId ${roomIdToUse} for agent ${agentId}`);
       } else if (req.query.roomId) {
-        const roomId = validateUuid6(req.query.roomId);
+        const roomId = validateUuid7(req.query.roomId);
         if (!roomId) {
           return sendError(res, 400, "INVALID_ID", "Invalid room ID format");
         }
@@ -1896,8 +2174,8 @@ function createAgentMemoryRouter(agents) {
     }
   });
   router.patch("/:agentId/memories/:memoryId", async (req, res) => {
-    const agentId = validateUuid6(req.params.agentId);
-    const memoryId = validateUuid6(req.params.memoryId);
+    const agentId = validateUuid7(req.params.agentId);
+    const memoryId = validateUuid7(req.params.memoryId);
     const { id: _idFromData, ...restOfMemoryData } = req.body;
     if (!agentId || !memoryId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID or memory ID format");
@@ -1910,10 +2188,10 @@ function createAgentMemoryRouter(agents) {
       const memoryToUpdate = {
         id: memoryId,
         ...restOfMemoryData,
-        agentId: restOfMemoryData.agentId ? validateUuid6(restOfMemoryData.agentId) || undefined : agentId,
-        roomId: restOfMemoryData.roomId ? validateUuid6(restOfMemoryData.roomId) || undefined : undefined,
-        entityId: restOfMemoryData.entityId ? validateUuid6(restOfMemoryData.entityId) || undefined : undefined,
-        worldId: restOfMemoryData.worldId ? validateUuid6(restOfMemoryData.worldId) || undefined : undefined,
+        agentId: restOfMemoryData.agentId ? validateUuid7(restOfMemoryData.agentId) || undefined : agentId,
+        roomId: restOfMemoryData.roomId ? validateUuid7(restOfMemoryData.roomId) || undefined : undefined,
+        entityId: restOfMemoryData.entityId ? validateUuid7(restOfMemoryData.entityId) || undefined : undefined,
+        worldId: restOfMemoryData.worldId ? validateUuid7(restOfMemoryData.worldId) || undefined : undefined,
         metadata: restOfMemoryData.metadata
       };
       Object.keys(memoryToUpdate).forEach((key) => {
@@ -1931,7 +2209,7 @@ function createAgentMemoryRouter(agents) {
   });
   router.delete("/:agentId/memories", async (req, res) => {
     try {
-      const agentId = validateUuid6(req.params.agentId);
+      const agentId = validateUuid7(req.params.agentId);
       if (!agentId) {
         return sendError(res, 400, "INVALID_ID", "Invalid agent ID");
       }
@@ -1949,8 +2227,8 @@ function createAgentMemoryRouter(agents) {
   });
   router.delete("/:agentId/memories/all/:roomId", async (req, res) => {
     try {
-      const agentId = validateUuid6(req.params.agentId);
-      const roomId = validateUuid6(req.params.roomId);
+      const agentId = validateUuid7(req.params.agentId);
+      const roomId = validateUuid7(req.params.roomId);
       if (!agentId) {
         return sendError(res, 400, "INVALID_ID", "Invalid agent ID");
       }
@@ -1971,8 +2249,8 @@ function createAgentMemoryRouter(agents) {
   });
   router.delete("/:agentId/memories/:memoryId", async (req, res) => {
     try {
-      const agentId = validateUuid6(req.params.agentId);
-      const memoryId = validateUuid6(req.params.memoryId);
+      const agentId = validateUuid7(req.params.agentId);
+      const memoryId = validateUuid7(req.params.memoryId);
       if (!agentId || !memoryId) {
         return sendError(res, 400, "INVALID_ID", "Invalid agent ID or memory ID format");
       }
@@ -1991,12 +2269,12 @@ function createAgentMemoryRouter(agents) {
 }
 
 // src/api/memory/rooms.ts
-import { validateUuid as validateUuid7, logger as logger7, createUniqueUuid as createUniqueUuid3, ChannelType } from "@elizaos/core";
-import express7 from "express";
+import { validateUuid as validateUuid8, logger as logger7, createUniqueUuid as createUniqueUuid3, ChannelType } from "@elizaos/core";
+import express8 from "express";
 function createRoomManagementRouter(agents) {
-  const router = express7.Router();
+  const router = express8.Router();
   router.post("/:agentId/rooms", async (req, res) => {
-    const agentId = validateUuid7(req.params.agentId);
+    const agentId = validateUuid8(req.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
@@ -2053,7 +2331,7 @@ function createRoomManagementRouter(agents) {
     }
   });
   router.get("/:agentId/rooms", async (req, res) => {
-    const agentId = validateUuid7(req.params.agentId);
+    const agentId = validateUuid8(req.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
@@ -2082,8 +2360,8 @@ function createRoomManagementRouter(agents) {
     }
   });
   router.get("/:agentId/rooms/:roomId", async (req, res) => {
-    const agentId = validateUuid7(req.params.agentId);
-    const roomId = validateUuid7(req.params.roomId);
+    const agentId = validateUuid8(req.params.agentId);
+    const roomId = validateUuid8(req.params.roomId);
     if (!agentId || !roomId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID or room ID format");
     }
@@ -2115,23 +2393,24 @@ function createRoomManagementRouter(agents) {
 
 // src/api/agents/index.ts
 function agentsRouter(agents, serverInstance) {
-  const router = express8.Router();
+  const router = express9.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("/", createAgentRunsRouter(agents));
   router.use("/", createAgentMemoryRouter(agents));
   router.use("/", createRoomManagementRouter(agents));
   return router;
 }
 
 // src/api/messaging/index.ts
-import express13 from "express";
+import express14 from "express";
 
 // src/api/messaging/core.ts
-import { logger as logger8, validateUuid as validateUuid8 } from "@elizaos/core";
-import express9 from "express";
+import { logger as logger8, validateUuid as validateUuid9 } from "@elizaos/core";
+import express10 from "express";
 
 // src/bus.ts
 class InternalMessageBus extends EventTarget {
@@ -2202,7 +2481,7 @@ var bus_default = internalMessageBus;
 // src/api/messaging/core.ts
 var DEFAULT_SERVER_ID = "00000000-0000-0000-0000-000000000000";
 function createMessagingCoreRouter(serverInstance) {
-  const router = express9.Router();
+  const router = express10.Router();
   router.post("/submit", async (req, res) => {
     const {
       channel_id,
@@ -2214,14 +2493,14 @@ function createMessagingCoreRouter(serverInstance) {
       raw_message,
       metadata
     } = req.body;
-    const isValidServerId = server_id === DEFAULT_SERVER_ID || validateUuid8(server_id);
-    if (!validateUuid8(channel_id) || !validateUuid8(author_id) || !content || !isValidServerId || !source_type || !raw_message) {
+    const isValidServerId = server_id === DEFAULT_SERVER_ID || validateUuid9(server_id);
+    if (!validateUuid9(channel_id) || !validateUuid9(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 && !validateUuid8(in_reply_to_message_id)) {
+    if (in_reply_to_message_id && !validateUuid9(in_reply_to_message_id)) {
       return res.status(400).json({
         success: false,
         error: "Invalid in_reply_to_message_id format"
@@ -2229,12 +2508,12 @@ function createMessagingCoreRouter(serverInstance) {
     }
     try {
       const newRootMessageData = {
-        channelId: validateUuid8(channel_id),
-        authorId: validateUuid8(author_id),
+        channelId: validateUuid9(channel_id),
+        authorId: validateUuid9(author_id),
         content,
         rawMessage: raw_message,
         sourceType: source_type || "agent_response",
-        inReplyToRootMessageId: in_reply_to_message_id ? validateUuid8(in_reply_to_message_id) || undefined : undefined,
+        inReplyToRootMessageId: in_reply_to_message_id ? validateUuid9(in_reply_to_message_id) || undefined : undefined,
         metadata
       };
       const createdMessage = await serverInstance.createMessage(newRootMessageData);
@@ -2271,28 +2550,28 @@ function createMessagingCoreRouter(serverInstance) {
       raw_message,
       metadata
     } = req.body;
-    const isValidServerId = server_id === DEFAULT_SERVER_ID || validateUuid8(server_id);
-    if (!validateUuid8(channel_id) || !validateUuid8(author_id) || !content || !isValidServerId || !source_type || !raw_message) {
+    const isValidServerId = server_id === DEFAULT_SERVER_ID || validateUuid9(server_id);
+    if (!validateUuid9(channel_id) || !validateUuid9(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 && !validateUuid8(in_reply_to_message_id)) {
+    if (in_reply_to_message_id && !validateUuid9(in_reply_to_message_id)) {
       return res.status(400).json({ success: false, error: "Invalid in_reply_to_message_id format" });
     }
-    if (messageId && !validateUuid8(messageId)) {
+    if (messageId && !validateUuid9(messageId)) {
       return res.status(400).json({ success: false, error: "Invalid messageId format" });
     }
     try {
       const baseData = {
         messageId,
-        channelId: validateUuid8(channel_id),
-        authorId: validateUuid8(author_id),
+        channelId: validateUuid9(channel_id),
+        authorId: validateUuid9(author_id),
         content,
         rawMessage: raw_message,
         sourceType: source_type || "agent_response",
-        inReplyToRootMessageId: in_reply_to_message_id ? validateUuid8(in_reply_to_message_id) || undefined : undefined,
+        inReplyToRootMessageId: in_reply_to_message_id ? validateUuid9(in_reply_to_message_id) || undefined : undefined,
         metadata
       };
       const savedMessage = await serverInstance.createMessage(baseData);
@@ -2321,7 +2600,7 @@ function createMessagingCoreRouter(serverInstance) {
   });
   router.patch("/action/:id", async (req, res) => {
     const { id } = req.params;
-    if (!validateUuid8(id)) {
+    if (!validateUuid9(id)) {
       return res.status(400).json({ success: false, error: "Invalid message id" });
     }
     const {
@@ -2333,13 +2612,13 @@ function createMessagingCoreRouter(serverInstance) {
       author_id,
       server_id
     } = req.body ?? {};
-    if (in_reply_to_message_id && !validateUuid8(in_reply_to_message_id)) {
+    if (in_reply_to_message_id && !validateUuid9(in_reply_to_message_id)) {
       return res.status(400).json({ success: false, error: "Invalid in_reply_to_message_id format" });
     }
-    if (author_id && !validateUuid8(author_id)) {
+    if (author_id && !validateUuid9(author_id)) {
       return res.status(400).json({ success: false, error: "Invalid author_id format" });
     }
-    if (server_id && !(server_id === DEFAULT_SERVER_ID || validateUuid8(server_id))) {
+    if (server_id && !(server_id === DEFAULT_SERVER_ID || validateUuid9(server_id))) {
       return res.status(400).json({ success: false, error: "Invalid server_id format" });
     }
     try {
@@ -2347,7 +2626,7 @@ function createMessagingCoreRouter(serverInstance) {
         content,
         rawMessage: raw_message,
         sourceType: source_type,
-        inReplyToRootMessageId: in_reply_to_message_id ? validateUuid8(in_reply_to_message_id) || undefined : undefined,
+        inReplyToRootMessageId: in_reply_to_message_id ? validateUuid9(in_reply_to_message_id) || undefined : undefined,
         metadata
       });
       if (!updated) {
@@ -2389,7 +2668,7 @@ function createMessagingCoreRouter(serverInstance) {
         rawMessage: messagePayload.raw_message,
         sourceId: messagePayload.source_id,
         sourceType: messagePayload.source_type,
-        inReplyToRootMessageId: messagePayload.in_reply_to_message_id ? validateUuid8(messagePayload.in_reply_to_message_id) || undefined : undefined,
+        inReplyToRootMessageId: messagePayload.in_reply_to_message_id ? validateUuid9(messagePayload.in_reply_to_message_id) || undefined : undefined,
         metadata: messagePayload.metadata
       };
       const createdRootMessage = await serverInstance.createMessage(messageToCreate);
@@ -2435,11 +2714,11 @@ function createMessagingCoreRouter(serverInstance) {
 }
 
 // src/api/messaging/servers.ts
-import { logger as logger9, validateUuid as validateUuid9 } from "@elizaos/core";
-import express10 from "express";
+import { logger as logger9, validateUuid as validateUuid10 } from "@elizaos/core";
+import express11 from "express";
 var DEFAULT_SERVER_ID2 = "00000000-0000-0000-0000-000000000000";
 function createServersRouter(serverInstance) {
-  const router = express10.Router();
+  const router = express11.Router();
   router.get("/central-servers", async (_req, res) => {
     try {
       const servers = await serverInstance.getServers();
@@ -2471,9 +2750,9 @@ function createServersRouter(serverInstance) {
     }
   });
   router.post("/servers/:serverId/agents", async (req, res) => {
-    const serverId = req.params.serverId === DEFAULT_SERVER_ID2 ? DEFAULT_SERVER_ID2 : validateUuid9(req.params.serverId);
+    const serverId = req.params.serverId === DEFAULT_SERVER_ID2 ? DEFAULT_SERVER_ID2 : validateUuid10(req.params.serverId);
     const { agentId } = req.body;
-    if (!serverId || !validateUuid9(agentId)) {
+    if (!serverId || !validateUuid10(agentId)) {
       return res.status(400).json({
         success: false,
         error: "Invalid serverId or agentId format"
@@ -2501,8 +2780,8 @@ function createServersRouter(serverInstance) {
     }
   });
   router.delete("/servers/:serverId/agents/:agentId", async (req, res) => {
-    const serverId = req.params.serverId === DEFAULT_SERVER_ID2 ? DEFAULT_SERVER_ID2 : validateUuid9(req.params.serverId);
-    const agentId = validateUuid9(req.params.agentId);
+    const serverId = req.params.serverId === DEFAULT_SERVER_ID2 ? DEFAULT_SERVER_ID2 : validateUuid10(req.params.serverId);
+    const agentId = validateUuid10(req.params.agentId);
     if (!serverId || !agentId) {
       return res.status(400).json({
         success: false,
@@ -2531,7 +2810,7 @@ function createServersRouter(serverInstance) {
     }
   });
   router.get("/servers/:serverId/agents", async (req, res) => {
-    const serverId = req.params.serverId === DEFAULT_SERVER_ID2 ? DEFAULT_SERVER_ID2 : validateUuid9(req.params.serverId);
+    const serverId = req.params.serverId === DEFAULT_SERVER_ID2 ? DEFAULT_SERVER_ID2 : validateUuid10(req.params.serverId);
     if (!serverId) {
       return res.status(400).json({
         success: false,
@@ -2553,7 +2832,7 @@ function createServersRouter(serverInstance) {
     }
   });
   router.get("/agents/:agentId/servers", async (req, res) => {
-    const agentId = validateUuid9(req.params.agentId);
+    const agentId = validateUuid10(req.params.agentId);
     if (!agentId) {
       return res.status(400).json({
         success: false,
@@ -2583,15 +2862,15 @@ import {
   ModelType,
   ChannelType as ChannelType2,
   logger as logger12,
-  validateUuid as validateUuid12
+  validateUuid as validateUuid13
 } from "@elizaos/core";
-import express11 from "express";
+import express12 from "express";
 
 // src/api/shared/middleware.ts
-import { validateUuid as validateUuid11, logger as logger11 } from "@elizaos/core";
+import { validateUuid as validateUuid12, logger as logger11 } from "@elizaos/core";
 
 // src/api/shared/validation.ts
-import { validateUuid as validateUuid10, logger as logger10 } from "@elizaos/core";
+import { validateUuid as validateUuid11, logger as logger10 } from "@elizaos/core";
 var getRuntime = (agents, agentId) => {
   const runtime = agents.get(agentId);
   if (!runtime) {
@@ -3336,9 +3615,9 @@ async function saveChannelUploadedFile(file, channelId) {
   return { filename, url };
 }
 function createChannelsRouter(agents, serverInstance) {
-  const router = express11.Router();
+  const router = express12.Router();
   router.post("/central-channels/:channelId/messages", async (req, res) => {
-    const channelIdParam = validateUuid12(req.params.channelId);
+    const channelIdParam = validateUuid13(req.params.channelId);
     const {
       author_id,
       content,
@@ -3348,8 +3627,8 @@ function createChannelsRouter(agents, serverInstance) {
       metadata,
       source_type
     } = req.body;
-    const isValidServerId = server_id === DEFAULT_SERVER_ID3 || validateUuid12(server_id);
-    if (!channelIdParam || !validateUuid12(author_id) || !content || !isValidServerId) {
+    const isValidServerId = server_id === DEFAULT_SERVER_ID3 || validateUuid13(server_id);
+    if (!channelIdParam || !validateUuid13(author_id) || !content || !isValidServerId) {
       return res.status(400).json({
         success: false,
         error: "Missing required fields: channelId, server_id, author_id, content"
@@ -3395,7 +3674,7 @@ function createChannelsRouter(agents, serverInstance) {
           const participants = [author_id];
           if (isDmChannel) {
             const otherParticipant = metadata?.targetUserId || metadata?.recipientId;
-            if (otherParticipant && validateUuid12(otherParticipant)) {
+            if (otherParticipant && validateUuid13(otherParticipant)) {
               participants.push(otherParticipant);
               logger12.info(`[Messages Router] DM channel will include participants: ${participants.join(", ")}`);
             } else {
@@ -3416,7 +3695,7 @@ function createChannelsRouter(agents, serverInstance) {
         channelId: channelIdParam,
         authorId: author_id,
         content,
-        inReplyToRootMessageId: in_reply_to_message_id ? validateUuid12(in_reply_to_message_id) || undefined : undefined,
+        inReplyToRootMessageId: in_reply_to_message_id ? validateUuid13(in_reply_to_message_id) || undefined : undefined,
         rawMessage: raw_message,
         metadata,
         sourceType: source_type || "eliza_gui"
@@ -3460,7 +3739,7 @@ function createChannelsRouter(agents, serverInstance) {
     }
   });
   router.get("/central-channels/:channelId/messages", async (req, res) => {
-    const channelId = validateUuid12(req.params.channelId);
+    const channelId = validateUuid13(req.params.channelId);
     const limit = req.query.limit ? Number.parseInt(req.query.limit, 10) : 50;
     const before = req.query.before ? Number.parseInt(req.query.before, 10) : undefined;
     const beforeDate = before ? new Date(before) : undefined;
@@ -3489,7 +3768,7 @@ function createChannelsRouter(agents, serverInstance) {
     }
   });
   router.get("/central-servers/:serverId/channels", async (req, res) => {
-    const serverId = req.params.serverId === DEFAULT_SERVER_ID3 ? DEFAULT_SERVER_ID3 : validateUuid12(req.params.serverId);
+    const serverId = req.params.serverId === DEFAULT_SERVER_ID3 ? DEFAULT_SERVER_ID3 : validateUuid13(req.params.serverId);
     if (!serverId) {
       return res.status(400).json({ success: false, error: "Invalid serverId" });
     }
@@ -3523,7 +3802,7 @@ function createChannelsRouter(agents, serverInstance) {
         error: "Missing required fields: type."
       });
     }
-    if (!validateUuid12(serverId)) {
+    if (!validateUuid13(serverId)) {
       return res.status(400).json({
         success: false,
         error: "Invalid serverId format"
@@ -3546,9 +3825,9 @@ function createChannelsRouter(agents, serverInstance) {
     }
   });
   router.get("/dm-channel", async (req, res) => {
-    const targetUserId = validateUuid12(req.query.targetUserId);
-    const currentUserId = validateUuid12(req.query.currentUserId);
-    const providedDmServerId = req.query.dmServerId === DEFAULT_SERVER_ID3 ? DEFAULT_SERVER_ID3 : validateUuid12(req.query.dmServerId);
+    const targetUserId = validateUuid13(req.query.targetUserId);
+    const currentUserId = validateUuid13(req.query.currentUserId);
+    const providedDmServerId = req.query.dmServerId === DEFAULT_SERVER_ID3 ? DEFAULT_SERVER_ID3 : validateUuid13(req.query.dmServerId);
     if (!targetUserId || !currentUserId) {
       res.status(400).json({ success: false, error: "Missing targetUserId or currentUserId" });
       return;
@@ -3588,8 +3867,8 @@ function createChannelsRouter(agents, serverInstance) {
       server_id,
       metadata
     } = req.body;
-    const isValidServerId = server_id === DEFAULT_SERVER_ID3 || validateUuid12(server_id);
-    if (!name || !isValidServerId || !Array.isArray(participantCentralUserIds) || participantCentralUserIds.some((id) => !validateUuid12(id))) {
+    const isValidServerId = server_id === DEFAULT_SERVER_ID3 || validateUuid13(server_id);
+    if (!name || !isValidServerId || !Array.isArray(participantCentralUserIds) || participantCentralUserIds.some((id) => !validateUuid13(id))) {
       return res.status(400).json({
         success: false,
         error: 'Invalid payload. Required: name, server_id (UUID or "0"), participantCentralUserIds (array of UUIDs). Optional: type, metadata.'
@@ -3613,7 +3892,7 @@ function createChannelsRouter(agents, serverInstance) {
     }
   });
   router.get("/central-channels/:channelId/details", async (req, res) => {
-    const channelId = validateUuid12(req.params.channelId);
+    const channelId = validateUuid13(req.params.channelId);
     if (!channelId) {
       return res.status(400).json({ success: false, error: "Invalid channelId" });
     }
@@ -3629,7 +3908,7 @@ function createChannelsRouter(agents, serverInstance) {
     }
   });
   router.get("/central-channels/:channelId/participants", async (req, res) => {
-    const channelId = validateUuid12(req.params.channelId);
+    const channelId = validateUuid13(req.params.channelId);
     if (!channelId) {
       return res.status(400).json({ success: false, error: "Invalid channelId" });
     }
@@ -3642,9 +3921,9 @@ function createChannelsRouter(agents, serverInstance) {
     }
   });
   router.post("/central-channels/:channelId/agents", async (req, res) => {
-    const channelId = validateUuid12(req.params.channelId);
+    const channelId = validateUuid13(req.params.channelId);
     const { agentId } = req.body;
-    if (!channelId || !validateUuid12(agentId)) {
+    if (!channelId || !validateUuid13(agentId)) {
       return res.status(400).json({
         success: false,
         error: "Invalid channelId or agentId format"
@@ -3678,8 +3957,8 @@ function createChannelsRouter(agents, serverInstance) {
     }
   });
   router.delete("/central-channels/:channelId/agents/:agentId", async (req, res) => {
-    const channelId = validateUuid12(req.params.channelId);
-    const agentId = validateUuid12(req.params.agentId);
+    const channelId = validateUuid13(req.params.channelId);
+    const agentId = validateUuid13(req.params.agentId);
     if (!channelId || !agentId) {
       return res.status(400).json({
         success: false,
@@ -3724,7 +4003,7 @@ function createChannelsRouter(agents, serverInstance) {
     }
   });
   router.get("/central-channels/:channelId/agents", async (req, res) => {
-    const channelId = validateUuid12(req.params.channelId);
+    const channelId = validateUuid13(req.params.channelId);
     if (!channelId) {
       return res.status(400).json({
         success: false,
@@ -3749,8 +4028,8 @@ function createChannelsRouter(agents, serverInstance) {
     }
   });
   router.delete("/central-channels/:channelId/messages/:messageId", async (req, res) => {
-    const channelId = validateUuid12(req.params.channelId);
-    const messageId = validateUuid12(req.params.messageId);
+    const channelId = validateUuid13(req.params.channelId);
+    const messageId = validateUuid13(req.params.messageId);
     if (!channelId || !messageId) {
       return res.status(400).json({ success: false, error: "Invalid channelId or messageId" });
     }
@@ -3776,7 +4055,7 @@ function createChannelsRouter(agents, serverInstance) {
     }
   });
   router.delete("/central-channels/:channelId/messages", async (req, res) => {
-    const channelId = validateUuid12(req.params.channelId);
+    const channelId = validateUuid13(req.params.channelId);
     if (!channelId) {
       return res.status(400).json({ success: false, error: "Invalid channelId" });
     }
@@ -3799,7 +4078,7 @@ function createChannelsRouter(agents, serverInstance) {
     }
   });
   router.patch("/central-channels/:channelId", async (req, res) => {
-    const channelId = validateUuid12(req.params.channelId);
+    const channelId = validateUuid13(req.params.channelId);
     if (!channelId) {
       return res.status(400).json({ success: false, error: "Invalid channelId" });
     }
@@ -3823,7 +4102,7 @@ function createChannelsRouter(agents, serverInstance) {
     }
   });
   router.delete("/central-channels/:channelId", async (req, res) => {
-    const channelId = validateUuid12(req.params.channelId);
+    const channelId = validateUuid13(req.params.channelId);
     if (!channelId) {
       return res.status(400).json({ success: false, error: "Invalid channelId" });
     }
@@ -3849,7 +4128,7 @@ function createChannelsRouter(agents, serverInstance) {
     }
   });
   router.post("/channels/:channelId/upload-media", createUploadRateLimit(), createFileSystemRateLimit(), channelUploadMiddleware.single("file"), async (req, res) => {
-    const channelId = validateUuid12(req.params.channelId);
+    const channelId = validateUuid13(req.params.channelId);
     if (!channelId) {
       res.status(400).json({ success: false, error: "Invalid channelId format" });
       return;
@@ -3882,7 +4161,7 @@ function createChannelsRouter(agents, serverInstance) {
     }
   });
   router.post("/central-channels/:channelId/generate-title", async (req, res) => {
-    const channelId = validateUuid12(req.params.channelId);
+    const channelId = validateUuid13(req.params.channelId);
     const { agentId } = req.body;
     if (!channelId) {
       return res.status(400).json({
@@ -3890,7 +4169,7 @@ function createChannelsRouter(agents, serverInstance) {
         error: "Invalid channel ID format"
       });
     }
-    if (!agentId || !validateUuid12(agentId)) {
+    if (!agentId || !validateUuid13(agentId)) {
       return res.status(400).json({
         success: false,
         error: "Valid agent ID is required"
@@ -3984,8 +4263,8 @@ Respond with just the title, nothing else.
 }
 
 // src/api/messaging/sessions.ts
-import { logger as logger13, validateUuid as validateUuid13, ChannelType as ChannelType3 } from "@elizaos/core";
-import express12 from "express";
+import { logger as logger13, validateUuid as validateUuid14, ChannelType as ChannelType3 } from "@elizaos/core";
+import express13 from "express";
 
 // ../../node_modules/uuid/dist/esm/stringify.js
 var byteToHex = [];
@@ -4404,7 +4683,7 @@ function asyncHandler(fn) {
   };
 }
 function createSessionsRouter(agents, serverInstance) {
-  const router = express12.Router();
+  const router = express13.Router();
   router.get("/sessions/health", (_req, res) => {
     const now = Date.now();
     let activeSessions = 0;
@@ -4437,10 +4716,10 @@ function createSessionsRouter(agents, serverInstance) {
     if (!isCreateSessionRequest(body)) {
       throw new MissingFieldsError(["agentId", "userId"]);
     }
-    if (!validateUuid13(body.agentId)) {
+    if (!validateUuid14(body.agentId)) {
       throw new InvalidUuidError("agentId", body.agentId);
     }
-    if (!validateUuid13(body.userId)) {
+    if (!validateUuid14(body.userId)) {
       throw new InvalidUuidError("userId", body.userId);
     }
     const agent = agents.get(body.agentId);
@@ -4858,7 +5137,7 @@ function createSessionsRouter(agents, serverInstance) {
 
 // src/api/messaging/index.ts
 function messagingRouter(agents, serverInstance) {
-  const router = express13.Router();
+  const router = express14.Router();
   if (!serverInstance) {
     throw new Error("ServerInstance is required for messaging router");
   }
@@ -4870,11 +5149,11 @@ function messagingRouter(agents, serverInstance) {
 }
 
 // src/api/media/index.ts
-import express16 from "express";
+import express17 from "express";
 
 // src/api/media/agents.ts
-import { validateUuid as validateUuid14, logger as logger14, getContentTypeFromMimeType } from "@elizaos/core";
-import express14 from "express";
+import { validateUuid as validateUuid15, logger as logger14, getContentTypeFromMimeType } from "@elizaos/core";
+import express15 from "express";
 import multer2 from "multer";
 import fs2 from "fs";
 import path2 from "path";
@@ -4908,10 +5187,10 @@ async function saveUploadedFile(file, agentId) {
   return { filename, url };
 }
 function createAgentMediaRouter() {
-  const router = express14.Router();
+  const router = express15.Router();
   router.post("/:agentId/upload-media", upload.single("file"), async (req, res) => {
     logger14.debug("[MEDIA UPLOAD] Processing media upload with multer");
-    const agentId = validateUuid14(req.params.agentId);
+    const agentId = validateUuid15(req.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
@@ -4941,8 +5220,8 @@ function createAgentMediaRouter() {
 }
 
 // src/api/media/channels.ts
-import { validateUuid as validateUuid15, logger as logger15 } from "@elizaos/core";
-import express15 from "express";
+import { validateUuid as validateUuid16, logger as logger15 } from "@elizaos/core";
+import express16 from "express";
 import multer3 from "multer";
 import fs3 from "fs";
 import path3 from "path";
@@ -4977,14 +5256,14 @@ async function saveUploadedFile2(file, channelId) {
   return { filename, url };
 }
 function createChannelMediaRouter() {
-  const router = express15.Router();
+  const router = express16.Router();
   const uploadMediaRateLimiter = lib_default({
     windowMs: 15 * 60 * 1000,
     max: 100,
     message: { success: false, error: "Too many requests, please try again later." }
   });
   router.post("/:channelId/upload-media", uploadMediaRateLimiter, upload2.single("file"), async (req, res) => {
-    const channelId = validateUuid15(req.params.channelId);
+    const channelId = validateUuid16(req.params.channelId);
     if (!channelId) {
       res.status(400).json({ success: false, error: "Invalid channelId format" });
       return;
@@ -5016,18 +5295,18 @@ function createChannelMediaRouter() {
 
 // src/api/media/index.ts
 function mediaRouter() {
-  const router = express16.Router();
+  const router = express17.Router();
   router.use("/agents", createAgentMediaRouter());
   router.use("/channels", createChannelMediaRouter());
   return router;
 }
 
 // src/api/memory/index.ts
-import express18 from "express";
+import express19 from "express";
 
 // src/api/memory/groups.ts
-import { validateUuid as validateUuid17, logger as logger18, createUniqueUuid as createUniqueUuid4, ChannelType as ChannelType4 } from "@elizaos/core";
-import express17 from "express";
+import { validateUuid as validateUuid18, logger as logger18, createUniqueUuid as createUniqueUuid4, ChannelType as ChannelType4 } from "@elizaos/core";
+import express18 from "express";
 // src/api/shared/file-utils.ts
 import { logger as logger16 } from "@elizaos/core";
 var cleanupUploadedFile = (file) => {
@@ -5035,7 +5314,7 @@ var cleanupUploadedFile = (file) => {
 };
 // src/upload.ts
 import multer4 from "multer";
-import { validateUuid as validateUuid16, logger as logger17 } from "@elizaos/core";
+import { validateUuid as validateUuid17, logger as logger17 } from "@elizaos/core";
 var storage3 = multer4.memoryStorage();
 var agentAudioUpload = () => multer4({
   storage: storage3,
@@ -5057,10 +5336,10 @@ function validateAudioFile(file) {
 }
 // src/api/memory/groups.ts
 function createGroupMemoryRouter(agents, serverInstance) {
-  const router = express17.Router();
+  const router = express18.Router();
   const db = serverInstance?.database;
   router.post("/groups/:serverId", async (req, res) => {
-    const serverId = validateUuid17(req.params.serverId);
+    const serverId = validateUuid18(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");
@@ -5122,7 +5401,7 @@ function createGroupMemoryRouter(agents, serverInstance) {
     });
   });
   router.delete("/groups/:serverId", async (req, res) => {
-    const worldId = validateUuid17(req.params.serverId);
+    const worldId = validateUuid18(req.params.serverId);
     if (!worldId) {
       return sendError(res, 400, "INVALID_ID", "Invalid serverId (worldId) format");
     }
@@ -5138,7 +5417,7 @@ function createGroupMemoryRouter(agents, serverInstance) {
     }
   });
   router.delete("/groups/:serverId/memories", async (req, res) => {
-    const worldId = validateUuid17(req.params.serverId);
+    const worldId = validateUuid18(req.params.serverId);
     if (!worldId) {
       return sendError(res, 400, "INVALID_ID", "Invalid serverId (worldId) format");
     }
@@ -5162,7 +5441,7 @@ function createGroupMemoryRouter(agents, serverInstance) {
 
 // src/api/memory/index.ts
 function memoryRouter(agents, serverInstance) {
-  const router = express18.Router();
+  const router = express19.Router();
   router.use("/", createAgentMemoryRouter(agents));
   router.use("/", createGroupMemoryRouter(agents, serverInstance));
   router.use("/", createRoomManagementRouter(agents));
@@ -5170,19 +5449,19 @@ function memoryRouter(agents, serverInstance) {
 }
 
 // src/api/audio/index.ts
-import express22 from "express";
+import express23 from "express";
 
 // src/api/audio/processing.ts
-import { logger as logger19, ModelType as ModelType2, validateUuid as validateUuid18 } from "@elizaos/core";
-import express19 from "express";
+import { logger as logger19, ModelType as ModelType2, validateUuid as validateUuid19 } from "@elizaos/core";
+import express20 from "express";
 function createAudioProcessingRouter(agents) {
-  const router = express19.Router();
+  const router = express20.Router();
   router.use(createUploadRateLimit());
   router.use(createFileSystemRateLimit());
   router.post("/:agentId/audio-messages", agentAudioUpload().single("file"), async (req, res) => {
     const audioReq = req;
     logger19.debug("[AUDIO MESSAGE] Processing audio message");
-    const agentId = validateUuid18(req.params.agentId);
+    const agentId = validateUuid19(req.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
@@ -5217,7 +5496,7 @@ function createAudioProcessingRouter(agents) {
   router.post("/:agentId/transcriptions", agentAudioUpload().single("file"), async (req, res) => {
     const audioReq = req;
     logger19.debug("[TRANSCRIPTION] Request to transcribe audio");
-    const agentId = validateUuid18(req.params.agentId);
+    const agentId = validateUuid19(req.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
@@ -5258,8 +5537,8 @@ function createAudioProcessingRouter(agents) {
 }
 
 // src/api/audio/synthesis.ts
-import { validateUuid as validateUuid19, logger as logger20, ModelType as ModelType3 } from "@elizaos/core";
-import express20 from "express";
+import { validateUuid as validateUuid20, logger as logger20, ModelType as ModelType3 } from "@elizaos/core";
+import express21 from "express";
 
 // src/api/audio/audioBuffer.ts
 import { Readable } from "node:stream";
@@ -5315,9 +5594,9 @@ async function convertToAudioBuffer(speechResponse, detectMimeType) {
 
 // src/api/audio/synthesis.ts
 function createSynthesisRouter(agents) {
-  const router = express20.Router();
+  const router = express21.Router();
   router.post("/:agentId/audio-messages/synthesize", async (req, res) => {
-    const agentId = validateUuid19(req.params.agentId);
+    const agentId = validateUuid20(req.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
@@ -5345,7 +5624,7 @@ function createSynthesisRouter(agents) {
   });
   router.post("/:agentId/speech/generate", async (req, res) => {
     logger20.debug("[SPEECH GENERATE] Request to generate speech from text");
-    const agentId = validateUuid19(req.params.agentId);
+    const agentId = validateUuid20(req.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
@@ -5379,7 +5658,7 @@ function createSynthesisRouter(agents) {
 
 // src/api/audio/conversation.ts
 import {
-  validateUuid as validateUuid20,
+  validateUuid as validateUuid21,
   logger as logger21,
   ModelType as ModelType4,
   ChannelType as ChannelType5,
@@ -5387,11 +5666,11 @@ import {
   composePrompt,
   messageHandlerTemplate
 } from "@elizaos/core";
-import express21 from "express";
+import express22 from "express";
 function createConversationRouter(agents) {
-  const router = express21.Router();
+  const router = express22.Router();
   router.post("/:agentId/speech/conversation", async (req, res) => {
-    const agentId = validateUuid20(req.params.agentId);
+    const agentId = validateUuid21(req.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
@@ -5493,7 +5772,7 @@ function createConversationRouter(agents) {
 
 // src/api/audio/index.ts
 function audioRouter(agents) {
-  const router = express22.Router();
+  const router = express23.Router();
   router.use("/", createAudioProcessingRouter(agents));
   router.use("/", createSynthesisRouter(agents));
   router.use("/", createConversationRouter(agents));
@@ -5501,13 +5780,13 @@ function audioRouter(agents) {
 }
 
 // src/api/runtime/index.ts
-import express26 from "express";
+import express27 from "express";
 
 // src/api/runtime/health.ts
 import { logger as logger22 } from "@elizaos/core";
-import express23 from "express";
+import express24 from "express";
 function createHealthRouter(agents, serverInstance) {
-  const router = express23.Router();
+  const router = express24.Router();
   router.get("/ping", (_req, res) => {
     res.json({ pong: true, timestamp: Date.now() });
   });
@@ -5548,7 +5827,7 @@ function createHealthRouter(agents, serverInstance) {
 
 // src/api/runtime/logging.ts
 import { logger as logger23, recentLogs } from "@elizaos/core";
-import express24 from "express";
+import express25 from "express";
 var LOG_LEVELS = {
   fatal: 60,
   error: 50,
@@ -5561,7 +5840,7 @@ var LOG_LEVELS = {
   trace: 10
 };
 function createLoggingRouter() {
-  const router = express24.Router();
+  const router = express25.Router();
   const logsHandler = async (req, res) => {
     const since = req.query.since ? Number(req.query.since) : Date.now() - 3600000;
     const requestedLevel = req.query.level?.toString().toLowerCase() || "all";
@@ -5681,9 +5960,9 @@ function createLoggingRouter() {
 }
 
 // src/api/runtime/debug.ts
-import express25 from "express";
+import express26 from "express";
 function createDebugRouter(serverInstance) {
-  const router = express25.Router();
+  const router = express26.Router();
   router.get("/servers", async (_req, res) => {
     try {
       const servers = await serverInstance?.getServers();
@@ -5704,7 +5983,7 @@ function createDebugRouter(serverInstance) {
 
 // src/api/runtime/index.ts
 function runtimeRouter(agents, serverInstance) {
-  const router = express26.Router();
+  const router = express27.Router();
   router.use("/", createHealthRouter(agents, serverInstance));
   router.use("/", createLoggingRouter());
   router.use("/debug", createDebugRouter(serverInstance));
@@ -5712,19 +5991,19 @@ function runtimeRouter(agents, serverInstance) {
 }
 
 // src/api/tee/index.ts
-import express27 from "express";
+import express28 from "express";
 function teeRouter() {
-  const router = express27.Router();
+  const router = express28.Router();
   return router;
 }
 
 // src/api/system/index.ts
-import express30 from "express";
+import express31 from "express";
 
 // src/api/system/environment.ts
 var import_dotenv = __toESM(require_main(), 1);
 import { logger as logger24 } from "@elizaos/core";
-import express28 from "express";
+import express29 from "express";
 import { existsSync, writeFileSync } from "fs";
 import path4 from "path";
 import fs4 from "fs/promises";
@@ -5768,7 +6047,7 @@ function resolveEnvFile(startDir = process.cwd()) {
   return path4.join(startDir, ".env");
 }
 function createEnvironmentRouter() {
-  const router = express28.Router();
+  const router = express29.Router();
   router.get("/local", async (_req, res) => {
     try {
       const localEnvPath = getLocalEnvPath();
@@ -5835,11 +6114,11 @@ function createEnvironmentRouter() {
 }
 
 // src/api/system/version.ts
-import express29 from "express";
+import express30 from "express";
 // package.json
 var package_default = {
   name: "@elizaos/server",
-  version: "1.5.8-alpha.20",
+  version: "1.5.8-alpha.22",
   description: "ElizaOS Server - Core server infrastructure for ElizaOS agents",
   publishConfig: {
     access: "public",
@@ -5931,7 +6210,7 @@ function getVersionInfo() {
   }
 }
 function createVersionRouter() {
-  const router = express29.Router();
+  const router = express30.Router();
   router.get("/", (_, res) => {
     const versionInfo = getVersionInfo();
     const statusCode = versionInfo.error ? 500 : 200;
@@ -5942,7 +6221,7 @@ function createVersionRouter() {
 
 // src/api/system/index.ts
 function systemRouter() {
-  const router = express30.Router();
+  const router = express31.Router();
   router.use("/env", createEnvironmentRouter());
   router.use("/version", createVersionRouter());
   return router;
@@ -5953,7 +6232,7 @@ import {
   logger as logger25,
   customLevels,
   SOCKET_MESSAGE_TYPE,
-  validateUuid as validateUuid21,
+  validateUuid as validateUuid22,
   ChannelType as ChannelType6,
   EventType
 } from "@elizaos/core";
@@ -6049,7 +6328,7 @@ class SocketIORouter {
       return;
     }
     if (agentId) {
-      const agentUuid = validateUuid21(agentId);
+      const agentUuid = validateUuid22(agentId);
       if (agentUuid) {
         this.connections.set(socket.id, agentUuid);
         logger25.info(`[SocketIO] Socket ${socket.id} associated with agent ${agentUuid}`);
@@ -6087,7 +6366,7 @@ class SocketIORouter {
       message: successMessage,
       channelId,
       roomId: channelId,
-      ...agentId && { agentId: validateUuid21(agentId) || agentId }
+      ...agentId && { agentId: validateUuid22(agentId) || agentId }
     };
     socket.emit("channel_joined", responsePayload);
     socket.emit("room_joined", responsePayload);
@@ -6098,8 +6377,8 @@ class SocketIORouter {
     const { senderId, senderName, message, serverId, source, metadata, attachments } = payload;
     logger25.info(`[SocketIO ${socket.id}] Received SEND_MESSAGE for central submission: channel ${channelId} from ${senderName || senderId}`);
     logger25.info(`[SocketIO ${socket.id}] Full payload for debugging:`, JSON.stringify(payload, null, 2));
-    const isValidServerId = serverId === DEFAULT_SERVER_ID5 || validateUuid21(serverId);
-    if (!validateUuid21(channelId) || !isValidServerId || !validateUuid21(senderId) || !message) {
+    const isValidServerId = serverId === DEFAULT_SERVER_ID5 || validateUuid22(serverId);
+    if (!validateUuid22(channelId) || !isValidServerId || !validateUuid22(senderId) || !message) {
       this.sendErrorResponse(socket, `For SEND_MESSAGE: channelId, serverId (server_id), senderId (author_id), and message are required.`);
       return;
     }
@@ -6163,7 +6442,7 @@ class SocketIORouter {
           let participants = [senderId];
           if (isDmChannel) {
             const otherParticipant = metadata?.targetUserId || metadata?.recipientId || payload.targetUserId;
-            if (otherParticipant && validateUuid21(otherParticipant)) {
+            if (otherParticipant && validateUuid22(otherParticipant)) {
               participants.push(otherParticipant);
               logger25.info(`[SocketIO ${socket.id}] DM channel will include participants: ${participants.join(", ")}`);
             } else {
@@ -6433,7 +6712,7 @@ function createPluginRouteHandler(agents) {
       }
       return handled;
     }
-    if (agentIdFromQuery && validateUuid22(agentIdFromQuery)) {
+    if (agentIdFromQuery && validateUuid23(agentIdFromQuery)) {
       const runtime = agents.get(agentIdFromQuery);
       if (runtime) {
         logger26.debug(`Agent-scoped request for Agent ID: ${agentIdFromQuery} from query. Path: ${reqPath}`);
@@ -6453,7 +6732,7 @@ function createPluginRouteHandler(agents) {
           return next();
         }
       }
-    } else if (agentIdFromQuery && !validateUuid22(agentIdFromQuery)) {
+    } else if (agentIdFromQuery && !validateUuid23(agentIdFromQuery)) {
       logger26.warn(`Invalid Agent ID format in query: ${agentIdFromQuery}. Path: ${reqPath}.`);
       if (reqPath.startsWith("/api/")) {
         res.status(400).json({
@@ -6483,7 +6762,7 @@ function createPluginRouteHandler(agents) {
   };
 }
 function createApiRouter(agents, serverInstance) {
-  const router = express31.Router();
+  const router = express32.Router();
   router.use(helmet({
     contentSecurityPolicy: false,
     crossOriginResourcePolicy: { policy: "cross-origin" },
@@ -6537,7 +6816,7 @@ import {
   Service,
   createUniqueUuid as createUniqueUuid6,
   logger as logger28,
-  validateUuid as validateUuid23
+  validateUuid as validateUuid24
 } from "@elizaos/core";
 class MessageBusService extends Service {
   static serviceType = "message-bus-service";
@@ -6594,7 +6873,7 @@ class MessageBusService extends Service {
             const data = await response.json();
             if (data.success && data.data?.channels && Array.isArray(data.data.channels)) {
               data.data.channels.forEach((channel) => {
-                if (channel.id && validateUuid23(channel.id)) {
+                if (channel.id && validateUuid24(channel.id)) {
                   this.validChannelIds.add(channel.id);
                 }
               });
@@ -6615,7 +6894,7 @@ class MessageBusService extends Service {
   async getChannelParticipants(channelId) {
     try {
       const serverApiUrl = this.getCentralMessageServerUrl();
-      if (!validateUuid23(channelId)) {
+      if (!validateUuid24(channelId)) {
         logger28.warn(`[${this.runtime.character.name}] MessageBusService: Invalid channel ID format: ${channelId}`);
         return [];
       }
@@ -7548,7 +7827,7 @@ class AgentServer {
       if (options?.clientPath) {
         this.clientPath = options.clientPath;
       }
-      this.app = express32();
+      this.app = express33();
       const isProd = false;
       logger30.debug("Setting up security headers...");
       if (!isProd) {
@@ -7613,7 +7892,7 @@ class AgentServer {
         methods: ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
         allowedHeaders: ["Content-Type", "Authorization", "X-API-KEY"]
       }));
-      this.app.use(express32.json({
+      this.app.use(express33.json({
         limit: process.env.EXPRESS_MAX_PAYLOAD || "2mb"
       }));
       const serverAuthToken = process.env.ELIZA_SERVER_AUTH_TOKEN;
@@ -7838,7 +8117,7 @@ class AgentServer {
         }
         if (clientPath) {
           this.clientPath = clientPath;
-          this.app.use(express32.static(clientPath, staticOptions));
+          this.app.use(express33.static(clientPath, staticOptions));
           logger30.info(`[STATIC] Serving static files from: ${clientPath}`);
         } else {
           logger30.warn("[STATIC] Client dist path not found. Searched locations:");