@elizaos/server 1.5.10 → 1.5.11-alpha.2

package/dist/index.js

@@ -21934,11 +21934,12 @@ var require_src32 = __commonJS((exports) => {
 
 // src/index.ts
 import {
-  logger as logger30,
+  logger as logger31,
   parseBooleanFromText,
   getDatabaseDir,
   getGeneratedDir as getGeneratedDir2,
-  getUploadsAgentsDir as getUploadsAgentsDir4
+  getUploadsAgentsDir as getUploadsAgentsDir4,
+  ElizaOS as ElizaOS2
 } from "@elizaos/core";
 import cors2 from "cors";
 import express33 from "express";
@@ -22483,10 +22484,10 @@ var helmet = Object.assign(function helmet2(options = {}) {
 });
 
 // src/index.ts
-import * as fs6 from "node:fs";
+import * as fs7 from "node:fs";
 import http4 from "node:http";
 import os3 from "node:os";
-import path8, { basename as basename2, dirname as dirname3, extname, join as join4 } from "node:path";
+import path9, { basename as basename2, dirname as dirname3, extname, join as join5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/api/index.ts
@@ -22529,7 +22530,7 @@ var sendSuccess = (res, data, status = 200) => {
 };
 
 // src/api/agents/crud.ts
-function createAgentCrudRouter(agents, serverInstance) {
+function createAgentCrudRouter(elizaOS, serverInstance) {
   const router = express.Router();
   const db = serverInstance?.database;
   router.get("/", async (_, res) => {
@@ -22538,7 +22539,7 @@ function createAgentCrudRouter(agents, serverInstance) {
         return sendError(res, 500, "DB_ERROR", "Database not available");
       }
       const allAgents = await db.getAgents();
-      const runtimes = Array.from(agents.keys());
+      const runtimes = elizaOS.getAgents().map((a) => a.agentId);
       const response = allAgents.map((agent) => ({
         id: agent.id,
         name: agent.name || "",
@@ -22570,7 +22571,7 @@ function createAgentCrudRouter(agents, serverInstance) {
       if (!agent) {
         return sendError(res, 404, "NOT_FOUND", "Agent not found");
       }
-      const runtime = agents.get(agentId);
+      const runtime = elizaOS.getAgent(agentId);
       const response = {
         ...agent,
         status: runtime ? "active" : "inactive"
@@ -22670,12 +22671,13 @@ function createAgentCrudRouter(agents, serverInstance) {
         await db.updateAgent(agentId, updates);
       }
       const updatedAgent = await db.getAgent(agentId);
-      const isActive = !!agents.get(agentId);
-      if (isActive && updatedAgent) {
-        serverInstance?.unregisterAgent(agentId);
-        await serverInstance?.startAgent(updatedAgent);
+      const activeRuntime = elizaOS.getAgent(agentId);
+      if (activeRuntime && updatedAgent) {
+        const { enabled, status: status2, createdAt, updatedAt, ...characterData } = updatedAgent;
+        await elizaOS.updateAgent(agentId, characterData);
+        logger.debug(`[AGENT UPDATE] Updated active agent ${agentId} without restart`);
       }
-      const runtime = agents.get(agentId);
+      const runtime = elizaOS.getAgent(agentId);
       const status = runtime ? "active" : "inactive";
       sendSuccess(res, { ...updatedAgent, status });
     } catch (error) {
@@ -22719,11 +22721,11 @@ function createAgentCrudRouter(agents, serverInstance) {
     let lastError = null;
     while (retryCount <= MAX_RETRIES) {
       try {
-        const runtime = agents.get(agentId);
+        const runtime = elizaOS.getAgent(agentId);
         if (runtime) {
           logger.debug(`[AGENT DELETE] Agent ${agentId} is running, unregistering from server`);
           try {
-            serverInstance?.unregisterAgent(agentId);
+            await serverInstance?.unregisterAgent(agentId);
             logger.debug(`[AGENT DELETE] Agent ${agentId} unregistered successfully`);
           } catch (stopError) {
             logger.error(`[AGENT DELETE] Error stopping agent ${agentId}:`, stopError instanceof Error ? stopError.message : String(stopError));
@@ -22782,7 +22784,7 @@ function createAgentCrudRouter(agents, serverInstance) {
 // src/api/agents/lifecycle.ts
 import { validateUuid as validateUuid2, logger as logger2 } from "@elizaos/core";
 import express2 from "express";
-function createAgentLifecycleRouter(agents, serverInstance) {
+function createAgentLifecycleRouter(elizaOS, serverInstance) {
   const router = express2.Router();
   const db = serverInstance?.database;
   router.post("/:agentId/start", async (req, res) => {
@@ -22799,7 +22801,7 @@ function createAgentLifecycleRouter(agents, serverInstance) {
         logger2.debug("[AGENT START] Agent not found");
         return sendError(res, 404, "NOT_FOUND", "Agent not found");
       }
-      const isActive = !!agents.get(agentId);
+      const isActive = !!elizaOS.getAgent(agentId);
       if (isActive) {
         logger2.debug(`[AGENT START] Agent ${agentId} is already running`);
         return sendSuccess(res, {
@@ -22808,8 +22810,8 @@ function createAgentLifecycleRouter(agents, serverInstance) {
           status: "active"
         });
       }
-      await serverInstance?.startAgent(agent);
-      const runtime = agents.get(agentId);
+      await serverInstance?.startAgents([agent]);
+      const runtime = elizaOS.getAgent(agentId);
       if (!runtime) {
         throw new Error("Failed to start agent");
       }
@@ -22830,11 +22832,11 @@ function createAgentLifecycleRouter(agents, serverInstance) {
       logger2.debug("[AGENT STOP] Invalid agent ID format");
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
-    serverInstance?.unregisterAgent(agentId);
+    await serverInstance?.unregisterAgent(agentId);
     logger2.debug(`[AGENT STOP] Successfully stopped agent: ${runtime.character.name} (${agentId})`);
     sendSuccess(res, {
       message: "Agent stopped"
@@ -22846,11 +22848,11 @@ function createAgentLifecycleRouter(agents, serverInstance) {
 // src/api/agents/worlds.ts
 import { validateUuid as validateUuid3, logger as logger3, createUniqueUuid } from "@elizaos/core";
 import express3 from "express";
-function createAgentWorldsRouter(agents) {
+function createAgentWorldsRouter(elizaOS) {
   const router = express3.Router();
   router.get("/worlds", async (_req, res) => {
     try {
-      const runtime = Array.from(agents.values())[0];
+      const runtime = elizaOS.getAgents()[0];
       if (!runtime) {
         return sendError(res, 404, "NOT_FOUND", "No active agents found to get worlds");
       }
@@ -22887,7 +22889,7 @@ function createAgentWorldsRouter(agents) {
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
@@ -22899,7 +22901,7 @@ function createAgentWorldsRouter(agents) {
     if (!agentId || !worldId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID or world ID format");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
@@ -22928,14 +22930,14 @@ function createAgentWorldsRouter(agents) {
 // src/api/agents/panels.ts
 import { validateUuid as validateUuid4, logger as logger4 } from "@elizaos/core";
 import express4 from "express";
-function createAgentPanelsRouter(agents) {
+function createAgentPanelsRouter(elizaOS) {
   const router = express4.Router();
   router.get("/:agentId/panels", async (req, res) => {
     const agentId = validateUuid4(req.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
@@ -22956,7 +22958,7 @@ function createAgentPanelsRouter(agents) {
 // src/api/agents/logs.ts
 import { validateUuid as validateUuid5, logger as logger5 } from "@elizaos/core";
 import express5 from "express";
-function createAgentLogsRouter(agents) {
+function createAgentLogsRouter(elizaOS) {
   const router = express5.Router();
   router.get("/:agentId/logs", async (req, res) => {
     const agentId = validateUuid5(req.params.agentId);
@@ -22964,7 +22966,7 @@ function createAgentLogsRouter(agents) {
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
@@ -23010,7 +23012,7 @@ function createAgentLogsRouter(agents) {
     if (!agentId || !logId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent or log ID format");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
@@ -23028,14 +23030,14 @@ function createAgentLogsRouter(agents) {
 // src/api/agents/runs.ts
 import { validateUuid as validateUuid6 } from "@elizaos/core";
 import express6 from "express";
-function createAgentRunsRouter(agents) {
+function createAgentRunsRouter(elizaOS) {
   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);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
@@ -23184,7 +23186,7 @@ function createAgentRunsRouter(agents) {
     if (roomId && !validateUuid6(roomId)) {
       return sendError(res, 400, "INVALID_ID", "Invalid room ID format");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
@@ -23320,7 +23322,7 @@ function createAgentRunsRouter(agents) {
 import { MemoryType, createUniqueUuid as createUniqueUuid2 } from "@elizaos/core";
 import { validateUuid as validateUuid7, logger as logger6 } from "@elizaos/core";
 import express7 from "express";
-function createAgentMemoryRouter(agents) {
+function createAgentMemoryRouter(elizaOS) {
   const router = express7.Router();
   router.get("/:agentId/rooms/:roomId/memories", async (req, res) => {
     const agentId = validateUuid7(req.params.agentId);
@@ -23328,7 +23330,7 @@ function createAgentMemoryRouter(agents) {
     if (!agentId || !roomId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID or room ID format");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
@@ -23358,7 +23360,7 @@ function createAgentMemoryRouter(agents) {
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
@@ -23402,7 +23404,7 @@ function createAgentMemoryRouter(agents) {
     if (!agentId || !memoryId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID or memory ID format");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
@@ -23435,7 +23437,7 @@ function createAgentMemoryRouter(agents) {
       if (!agentId) {
         return sendError(res, 400, "INVALID_ID", "Invalid agent ID");
       }
-      const runtime = agents.get(agentId);
+      const runtime = elizaOS.getAgent(agentId);
       if (!runtime) {
         return sendError(res, 404, "NOT_FOUND", "Agent not found");
       }
@@ -23457,7 +23459,7 @@ function createAgentMemoryRouter(agents) {
       if (!roomId) {
         return sendError(res, 400, "INVALID_ID", "Invalid room ID");
       }
-      const runtime = agents.get(agentId);
+      const runtime = elizaOS.getAgent(agentId);
       if (!runtime) {
         return sendError(res, 404, "NOT_FOUND", "Agent not found");
       }
@@ -23476,7 +23478,7 @@ function createAgentMemoryRouter(agents) {
       if (!agentId || !memoryId) {
         return sendError(res, 400, "INVALID_ID", "Invalid agent ID or memory ID format");
       }
-      const runtime = agents.get(agentId);
+      const runtime = elizaOS.getAgent(agentId);
       if (!runtime) {
         return sendError(res, 404, "NOT_FOUND", "Agent not found");
       }
@@ -23493,14 +23495,14 @@ function createAgentMemoryRouter(agents) {
 // src/api/memory/rooms.ts
 import { validateUuid as validateUuid8, logger as logger7, createUniqueUuid as createUniqueUuid3, ChannelType } from "@elizaos/core";
 import express8 from "express";
-function createRoomManagementRouter(agents) {
+function createRoomManagementRouter(elizaOS) {
   const router = express8.Router();
   router.post("/:agentId/rooms", async (req, res) => {
     const agentId = validateUuid8(req.params.agentId);
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
@@ -23557,7 +23559,7 @@ function createRoomManagementRouter(agents) {
     if (!agentId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID format");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
@@ -23587,7 +23589,7 @@ function createRoomManagementRouter(agents) {
     if (!agentId || !roomId) {
       return sendError(res, 400, "INVALID_ID", "Invalid agent ID or room ID format");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
@@ -23614,16 +23616,16 @@ function createRoomManagementRouter(agents) {
 }
 
 // src/api/agents/index.ts
-function agentsRouter(agents, serverInstance) {
+function agentsRouter(elizaOS, serverInstance) {
   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));
+  router.use("/", createAgentCrudRouter(elizaOS, serverInstance));
+  router.use("/", createAgentLifecycleRouter(elizaOS, serverInstance));
+  router.use("/", createAgentWorldsRouter(elizaOS));
+  router.use("/", createAgentPanelsRouter(elizaOS));
+  router.use("/", createAgentLogsRouter(elizaOS));
+  router.use("/", createAgentRunsRouter(elizaOS));
+  router.use("/", createAgentMemoryRouter(elizaOS));
+  router.use("/", createRoomManagementRouter(elizaOS));
   return router;
 }
 
@@ -24178,8 +24180,8 @@ import { validateUuid as validateUuid12, logger as logger11 } from "@elizaos/cor
 
 // src/api/shared/validation.ts
 import { validateUuid as validateUuid11, logger as logger10 } from "@elizaos/core";
-var getRuntime = (agents, agentId) => {
-  const runtime = agents.get(agentId);
+var getRuntime = (elizaOS, agentId) => {
+  const runtime = elizaOS.getAgent(agentId);
   if (!runtime) {
     throw new Error(`Agent not found: ${agentId}`);
   }
@@ -24921,7 +24923,7 @@ async function saveChannelUploadedFile(file, channelId) {
   const url = `/media/uploads/channels/${channelId}/${filename}`;
   return { filename, url };
 }
-function createChannelsRouter(agents, serverInstance) {
+function createChannelsRouter(elizaOS, serverInstance) {
   const router = express12.Router();
   router.post("/central-channels/:channelId/messages", async (req, res) => {
     const channelIdParam = validateUuid13(req.params.channelId);
@@ -25494,7 +25496,7 @@ function createChannelsRouter(agents, serverInstance) {
       });
     }
     try {
-      const runtime = agents.get(agentId);
+      const runtime = elizaOS.getAgent(agentId);
       if (!runtime) {
         return res.status(404).json({
           success: false,
@@ -26000,7 +26002,7 @@ function asyncHandler(fn) {
     Promise.resolve(fn(req, res, next)).catch(next);
   };
 }
-function createSessionsRouter(agents, serverInstance) {
+function createSessionsRouter(elizaOS, serverInstance) {
   const router = express13.Router();
   router.get("/sessions/health", (_req, res) => {
     const now = Date.now();
@@ -26040,7 +26042,7 @@ function createSessionsRouter(agents, serverInstance) {
     if (!validateUuid14(body.userId)) {
       throw new InvalidUuidError("userId", body.userId);
     }
-    const agent = agents.get(body.agentId);
+    const agent = elizaOS.getAgent(body.agentId);
     if (!agent) {
       throw new AgentNotFoundError(body.agentId);
     }
@@ -26348,7 +26350,7 @@ function createSessionsRouter(agents, serverInstance) {
         }
       }
     }
-    const agent = agents.get(session.agentId);
+    const agent = elizaOS.getAgent(session.agentId);
     const agentConfig = agent ? getAgentTimeoutConfig(agent) : undefined;
     session.timeoutConfig = mergeTimeoutConfigs(newConfig, agentConfig);
     session.expiresAt = calculateExpirationDate(session.createdAt, session.lastActivity, session.timeoutConfig, session.renewalCount);
@@ -26465,15 +26467,15 @@ function createSessionsRouter(agents, serverInstance) {
 }
 
 // src/api/messaging/index.ts
-function messagingRouter(agents, serverInstance) {
+function messagingRouter(elizaOS, serverInstance) {
   const router = express14.Router();
   if (!serverInstance) {
     throw new Error("ServerInstance is required for messaging router");
   }
   router.use("/", createMessagingCoreRouter(serverInstance));
   router.use("/", createServersRouter(serverInstance));
-  router.use("/", createChannelsRouter(agents, serverInstance));
-  router.use("/", createSessionsRouter(agents, serverInstance));
+  router.use("/", createChannelsRouter(elizaOS, serverInstance));
+  router.use("/", createSessionsRouter(elizaOS, serverInstance));
   return router;
 }
 
@@ -26669,7 +26671,7 @@ function validateAudioFile(file) {
   return ALLOWED_AUDIO_MIME_TYPES.some((allowed) => allowed === file.mimetype);
 }
 // src/api/memory/groups.ts
-function createGroupMemoryRouter(agents, serverInstance) {
+function createGroupMemoryRouter(elizaOS, serverInstance) {
   const router = express18.Router();
   const db = serverInstance?.database;
   router.post("/groups/:serverId", async (req, res) => {
@@ -26682,7 +26684,7 @@ function createGroupMemoryRouter(agents, serverInstance) {
     let errors = [];
     for (const agentId of agentIds) {
       try {
-        const runtime = getRuntime(agents, agentId);
+        const runtime = getRuntime(elizaOS, agentId);
         const roomId = createUniqueUuid4(runtime, serverId);
         const roomName = name || `Chat ${new Date().toLocaleString()}`;
         await runtime.ensureWorldExists({
@@ -26774,11 +26776,11 @@ function createGroupMemoryRouter(agents, serverInstance) {
 }
 
 // src/api/memory/index.ts
-function memoryRouter(agents, serverInstance) {
+function memoryRouter(elizaOS, serverInstance) {
   const router = express19.Router();
-  router.use("/", createAgentMemoryRouter(agents));
-  router.use("/", createGroupMemoryRouter(agents, serverInstance));
-  router.use("/", createRoomManagementRouter(agents));
+  router.use("/", createAgentMemoryRouter(elizaOS));
+  router.use("/", createGroupMemoryRouter(elizaOS, serverInstance));
+  router.use("/", createRoomManagementRouter(elizaOS));
   return router;
 }
 
@@ -26788,7 +26790,7 @@ import express23 from "express";
 // src/api/audio/processing.ts
 import { logger as logger19, ModelType as ModelType2, validateUuid as validateUuid19 } from "@elizaos/core";
 import express20 from "express";
-function createAudioProcessingRouter(agents) {
+function createAudioProcessingRouter(elizaOS) {
   const router = express20.Router();
   router.use(createUploadRateLimit());
   router.use(createFileSystemRateLimit());
@@ -26803,7 +26805,7 @@ function createAudioProcessingRouter(agents) {
     if (!audioFile) {
       return sendError(res, 400, "INVALID_REQUEST", "No audio file provided");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       cleanupUploadedFile(audioFile);
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
@@ -26838,7 +26840,7 @@ function createAudioProcessingRouter(agents) {
     if (!audioFile) {
       return sendError(res, 400, "INVALID_REQUEST", "No audio file provided");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       cleanupUploadedFile(audioFile);
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
@@ -26927,7 +26929,7 @@ async function convertToAudioBuffer(speechResponse, detectMimeType) {
 }
 
 // src/api/audio/synthesis.ts
-function createSynthesisRouter(agents) {
+function createSynthesisRouter(elizaOS) {
   const router = express21.Router();
   router.post("/:agentId/audio-messages/synthesize", async (req, res) => {
     const agentId = validateUuid20(req.params.agentId);
@@ -26938,7 +26940,7 @@ function createSynthesisRouter(agents) {
     if (!text) {
       return sendError(res, 400, "INVALID_REQUEST", "Text is required for speech synthesis");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
@@ -26966,7 +26968,7 @@ function createSynthesisRouter(agents) {
     if (!text) {
       return sendError(res, 400, "INVALID_REQUEST", "Text is required for speech synthesis");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
@@ -27001,7 +27003,7 @@ import {
   messageHandlerTemplate
 } from "@elizaos/core";
 import express22 from "express";
-function createConversationRouter(agents) {
+function createConversationRouter(elizaOS) {
   const router = express22.Router();
   router.post("/:agentId/speech/conversation", async (req, res) => {
     const agentId = validateUuid21(req.params.agentId);
@@ -27012,7 +27014,7 @@ function createConversationRouter(agents) {
     if (!text) {
       return sendError(res, 400, "INVALID_REQUEST", "Text is required for conversation");
     }
-    const runtime = agents.get(agentId);
+    const runtime = elizaOS.getAgent(agentId);
     if (!runtime) {
       return sendError(res, 404, "NOT_FOUND", "Agent not found");
     }
@@ -27105,11 +27107,11 @@ function createConversationRouter(agents) {
 }
 
 // src/api/audio/index.ts
-function audioRouter(agents) {
+function audioRouter(elizaOS) {
   const router = express23.Router();
-  router.use("/", createAudioProcessingRouter(agents));
-  router.use("/", createSynthesisRouter(agents));
-  router.use("/", createConversationRouter(agents));
+  router.use("/", createAudioProcessingRouter(elizaOS));
+  router.use("/", createSynthesisRouter(elizaOS));
+  router.use("/", createConversationRouter(elizaOS));
   return router;
 }
 
@@ -27119,7 +27121,7 @@ import express27 from "express";
 // src/api/runtime/health.ts
 import { logger as logger22 } from "@elizaos/core";
 import express24 from "express";
-function createHealthRouter(agents, serverInstance) {
+function createHealthRouter(elizaOS, serverInstance) {
   const router = express24.Router();
   router.get("/ping", (_req, res) => {
     res.json({ pong: true, timestamp: Date.now() });
@@ -27134,7 +27136,7 @@ function createHealthRouter(agents, serverInstance) {
     res.setHeader("Content-Type", "application/json");
     res.send(JSON.stringify({
       status: "ok",
-      agentCount: agents.size,
+      agentCount: elizaOS.getAgents().length,
       timestamp: new Date().toISOString()
     }));
   });
@@ -27145,7 +27147,7 @@ function createHealthRouter(agents, serverInstance) {
       version: process.env.APP_VERSION || "unknown",
       timestamp: new Date().toISOString(),
       dependencies: {
-        agents: agents.size > 0 ? "healthy" : "no_agents"
+        agents: elizaOS.getAgents().length > 0 ? "healthy" : "no_agents"
       }
     };
     const statusCode = healthcheck.dependencies.agents === "healthy" ? 200 : 503;
@@ -27316,9 +27318,9 @@ function createDebugRouter(serverInstance) {
 }
 
 // src/api/runtime/index.ts
-function runtimeRouter(agents, serverInstance) {
+function runtimeRouter(elizaOS, serverInstance) {
   const router = express27.Router();
-  router.use("/", createHealthRouter(agents, serverInstance));
+  router.use("/", createHealthRouter(elizaOS, serverInstance));
   router.use("/", createLoggingRouter());
   router.use("/debug", createDebugRouter(serverInstance));
   return router;
@@ -27452,7 +27454,7 @@ import express30 from "express";
 // package.json
 var package_default = {
   name: "@elizaos/server",
-  version: "1.5.10",
+  version: "1.5.11-alpha.2",
   description: "ElizaOS Server - Core server infrastructure for ElizaOS agents",
   publishConfig: {
     access: "public",
@@ -27575,16 +27577,16 @@ import {
 var DEFAULT_SERVER_ID5 = "00000000-0000-0000-0000-000000000000";
 
 class SocketIORouter {
-  agents;
+  elizaOS;
   connections;
   logStreamConnections;
   serverInstance;
-  constructor(agents, serverInstance) {
-    this.agents = agents;
+  constructor(elizaOS, serverInstance) {
+    this.elizaOS = elizaOS;
     this.connections = new Map;
     this.logStreamConnections = new Map;
     this.serverInstance = serverInstance;
-    logger25.info(`[SocketIO] Router initialized with ${this.agents.size} agents`);
+    logger25.info(`[SocketIO] Router initialized with ${this.elizaOS.getAgents().length} agents`);
   }
   setupListeners(io) {
     logger25.info(`[SocketIO] Setting up Socket.IO event listeners`);
@@ -27676,7 +27678,7 @@ class SocketIORouter {
       const finalServerId = serverId || DEFAULT_SERVER_ID5;
       const isDm = metadata?.isDm || metadata?.channelType === ChannelType6.DM;
       logger25.info(`[SocketIO] Emitting ENTITY_JOINED event for entityId: ${entityId}, serverId: ${finalServerId}, isDm: ${isDm}`);
-      const runtime = Array.from(this.agents.values())[0];
+      const runtime = this.elizaOS.getAgents()[0];
       if (runtime) {
         runtime.emitEvent(EventType.ENTITY_JOINED, {
           entityId,
@@ -27722,7 +27724,7 @@ class SocketIORouter {
       const isDmForWorldSetup = metadata?.isDm || metadata?.channelType === ChannelType6.DM;
       if (isDmForWorldSetup && senderId) {
         logger25.info(`[SocketIO] Detected DM channel during message submission, emitting ENTITY_JOINED for proper world setup`);
-        const runtime = Array.from(this.agents.values())[0];
+        const runtime = this.elizaOS.getAgents()[0];
         if (runtime) {
           runtime.emitEvent(EventType.ENTITY_JOINED, {
             entityId: senderId,
@@ -27914,14 +27916,14 @@ class SocketIORouter {
 }
 
 // src/api/index.ts
-function setupSocketIO(server, agents, serverInstance) {
+function setupSocketIO(server, elizaOS, serverInstance) {
   const io = new SocketIOServer(server, {
     cors: {
       origin: "*",
       methods: ["GET", "POST"]
     }
   });
-  const centralSocketRouter = new SocketIORouter(agents, serverInstance);
+  const centralSocketRouter = new SocketIORouter(elizaOS, serverInstance);
   centralSocketRouter.setupListeners(io);
   setupLogStreaming(io, centralSocketRouter);
   return io;
@@ -27952,7 +27954,7 @@ function setupLogStreaming(io, router) {
     };
   }
 }
-function createPluginRouteHandler(agents) {
+function createPluginRouteHandler(elizaOS) {
   return (req, res, next) => {
     logger26.debug("Handling plugin request in the plugin route handler", `path: ${req.path}, method: ${req.method}`, {
       path: req.path,
@@ -27976,7 +27978,7 @@ function createPluginRouteHandler(agents) {
       logger26.debug(`JavaScript request in plugin handler: ${req.method} ${req.path}`);
       res.setHeader("Content-Type", "application/javascript");
     }
-    if (agents.size === 0) {
+    if (elizaOS.getAgents().length === 0) {
       logger26.debug("No agents available, skipping plugin route handling.");
       return next();
     }
@@ -28054,7 +28056,7 @@ function createPluginRouteHandler(agents) {
       return handled;
     }
     if (agentIdFromQuery && validateUuid23(agentIdFromQuery)) {
-      const runtime = agents.get(agentIdFromQuery);
+      const runtime = elizaOS.getAgent(agentIdFromQuery);
       if (runtime) {
         logger26.debug(`Agent-scoped request for Agent ID: ${agentIdFromQuery} from query. Path: ${reqPath}`);
         handled = findRouteInRuntime(runtime);
@@ -28089,7 +28091,7 @@ function createPluginRouteHandler(agents) {
       }
     } else {
       logger26.debug(`No valid agentId in query. Trying global match for path: ${reqPath}`);
-      for (const [_, runtime] of agents) {
+      for (const runtime of elizaOS.getAgents()) {
         if (handled)
           break;
         handled = findRouteInRuntime(runtime);
@@ -28102,7 +28104,7 @@ function createPluginRouteHandler(agents) {
     next();
   };
 }
-function createApiRouter(agents, serverInstance) {
+function createApiRouter(elizaOS, serverInstance) {
   const router = express32.Router();
   router.use(helmet({
     contentSecurityPolicy: false,
@@ -28121,14 +28123,14 @@ function createApiRouter(agents, serverInstance) {
   router.use(securityMiddleware());
   router.use("/media", mediaRouter());
   router.use(validateContentTypeMiddleware());
-  router.use("/agents", agentsRouter(agents, serverInstance));
-  router.use("/messaging", messagingRouter(agents, serverInstance));
-  router.use("/memory", memoryRouter(agents, serverInstance));
-  router.use("/audio", audioRouter(agents));
-  router.use("/server", runtimeRouter(agents, serverInstance));
+  router.use("/agents", agentsRouter(elizaOS, serverInstance));
+  router.use("/messaging", messagingRouter(elizaOS, serverInstance));
+  router.use("/memory", memoryRouter(elizaOS, serverInstance));
+  router.use("/audio", audioRouter(elizaOS));
+  router.use("/server", runtimeRouter(elizaOS, serverInstance));
   router.use("/tee", teeRouter());
   router.use("/system", systemRouter());
-  router.use(createPluginRouteHandler(agents));
+  router.use(createPluginRouteHandler(elizaOS));
   return router;
 }
 
@@ -43543,8 +43545,205 @@ function _init2(options = {}, getDefaultIntegrationsImpl) {
 }
 // src/index.ts
 import sqlPlugin, { createDatabaseAdapter, DatabaseMigrationService } from "@elizaos/plugin-sql";
-import { existsSync as existsSync4 } from "node:fs";
+
+// src/managers/PluginLoader.ts
+import { logger as logger30 } from "@elizaos/core";
+
+class PluginLoader {
+  isValidPluginShape(obj) {
+    if (!obj || typeof obj !== "object" || !obj.name) {
+      return false;
+    }
+    return !!(obj.init || obj.services || obj.providers || obj.actions || obj.evaluators || obj.description);
+  }
+  validatePlugin(plugin) {
+    const errors = [];
+    if (!plugin) {
+      errors.push("Plugin is null or undefined");
+      return { isValid: false, errors };
+    }
+    if (!plugin.name) {
+      errors.push("Plugin must have a name");
+    }
+    if (plugin.actions) {
+      if (!Array.isArray(plugin.actions)) {
+        errors.push("Plugin actions must be an array");
+      } else {
+        const invalidActions = plugin.actions.filter((a) => typeof a !== "object" || !a);
+        if (invalidActions.length > 0) {
+          errors.push("Plugin actions must be an array of action objects");
+        }
+      }
+    }
+    if (plugin.services) {
+      if (!Array.isArray(plugin.services)) {
+        errors.push("Plugin services must be an array");
+      } else {
+        const invalidServices = plugin.services.filter((s) => typeof s !== "function" && (typeof s !== "object" || !s));
+        if (invalidServices.length > 0) {
+          errors.push("Plugin services must be an array of service classes or objects");
+        }
+      }
+    }
+    if (plugin.providers && !Array.isArray(plugin.providers)) {
+      errors.push("Plugin providers must be an array");
+    }
+    if (plugin.evaluators && !Array.isArray(plugin.evaluators)) {
+      errors.push("Plugin evaluators must be an array");
+    }
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+  async loadAndPreparePlugin(pluginName) {
+    try {
+      let pluginModule;
+      try {
+        pluginModule = await import(pluginName);
+      } catch (error2) {
+        logger30.error(`Failed to load plugin ${pluginName}: ${error2}`);
+        return null;
+      }
+      if (!pluginModule) {
+        logger30.error(`Failed to load module for plugin ${pluginName}.`);
+        return null;
+      }
+      const expectedFunctionName = `${pluginName.replace(/^@elizaos\/plugin-/, "").replace(/^@elizaos\//, "").replace(/-./g, (match3) => match3[1].toUpperCase())}Plugin`;
+      const exportsToCheck = [
+        pluginModule[expectedFunctionName],
+        pluginModule.default,
+        ...Object.values(pluginModule)
+      ];
+      for (const potentialPlugin of exportsToCheck) {
+        if (this.isValidPluginShape(potentialPlugin)) {
+          return potentialPlugin;
+        }
+        if (typeof potentialPlugin === "function" && potentialPlugin.length === 0) {
+          try {
+            const produced = potentialPlugin();
+            if (this.isValidPluginShape(produced)) {
+              return produced;
+            }
+          } catch (err) {
+            logger30.debug(`Factory export threw for ${pluginName}: ${err}`);
+          }
+        }
+      }
+      logger30.warn(`Could not find a valid plugin export in ${pluginName}.`);
+      return null;
+    } catch (error2) {
+      logger30.error(`Error loading plugin ${pluginName}: ${error2}`);
+      return null;
+    }
+  }
+  resolvePluginDependencies(availablePlugins, isTestMode = false) {
+    const resolutionOrder = [];
+    const visited = new Set;
+    const visiting = new Set;
+    function visit2(pluginName) {
+      if (!availablePlugins.has(pluginName)) {
+        logger30.warn(`Plugin dependency "${pluginName}" not found and will be skipped.`);
+        return;
+      }
+      if (visited.has(pluginName))
+        return;
+      if (visiting.has(pluginName)) {
+        logger30.error(`Circular dependency detected involving plugin: ${pluginName}`);
+        return;
+      }
+      visiting.add(pluginName);
+      const plugin = availablePlugins.get(pluginName);
+      if (plugin) {
+        const deps = [...plugin.dependencies || []];
+        if (isTestMode) {
+          deps.push(...plugin.testDependencies || []);
+        }
+        for (const dep of deps) {
+          visit2(dep);
+        }
+      }
+      visiting.delete(pluginName);
+      visited.add(pluginName);
+      resolutionOrder.push(pluginName);
+    }
+    for (const name of availablePlugins.keys()) {
+      if (!visited.has(name)) {
+        visit2(name);
+      }
+    }
+    const finalPlugins = resolutionOrder.map((name) => availablePlugins.get(name)).filter((p) => p);
+    logger30.info({ plugins: finalPlugins.map((p) => p.name) }, `Final plugins being loaded:`);
+    return finalPlugins;
+  }
+}
+
+// src/managers/ConfigManager.ts
 var import_dotenv2 = __toESM(require_main(), 1);
+import * as fs6 from "node:fs";
+import * as path8 from "node:path";
+
+class ConfigManager {
+  async loadEnvConfig() {
+    const envPath = this.findEnvFile();
+    if (envPath) {
+      import_dotenv2.default.config({ path: envPath });
+    }
+    return process.env;
+  }
+  findEnvFile() {
+    const possiblePaths = [
+      path8.join(process.cwd(), ".env"),
+      path8.join(process.cwd(), ".env.local")
+    ];
+    for (const envPath of possiblePaths) {
+      if (fs6.existsSync(envPath)) {
+        return envPath;
+      }
+    }
+    return null;
+  }
+  hasCharacterSecrets(character) {
+    return Boolean(character?.settings?.secrets && Object.keys(character.settings.secrets).length > 0);
+  }
+  ensureCharacterSettings(character) {
+    if (!character.settings) {
+      character.settings = {};
+    }
+  }
+  async loadLocalEnvSecrets() {
+    const envPath = this.findEnvFile();
+    if (!envPath)
+      return null;
+    try {
+      const buf = fs6.readFileSync(envPath);
+      return import_dotenv2.default.parse(buf);
+    } catch {
+      return null;
+    }
+  }
+  async setDefaultSecretsFromEnv(character) {
+    this.ensureCharacterSettings(character);
+    if (this.hasCharacterSecrets(character)) {
+      return false;
+    }
+    const envSecrets = await this.loadLocalEnvSecrets();
+    if (!envSecrets) {
+      return false;
+    }
+    if (!character.settings) {
+      character.settings = {};
+    }
+    character.settings.secrets = envSecrets;
+    return true;
+  }
+}
+
+// src/index.ts
+import { encryptedCharacter, stringToUuid as stringToUuid2 } from "@elizaos/core";
+import { existsSync as existsSync5 } from "node:fs";
+var import_dotenv3 = __toESM(require_main(), 1);
+import { ElizaOS as ElizaOS3 } from "@elizaos/core";
 function expandTildePath(filepath) {
   if (!filepath) {
     return filepath;
@@ -43553,19 +43752,19 @@ function expandTildePath(filepath) {
     if (filepath === "~") {
       return process.cwd();
     } else if (filepath.startsWith("~/")) {
-      return path8.join(process.cwd(), filepath.slice(2));
+      return path9.join(process.cwd(), filepath.slice(2));
     } else if (filepath.startsWith("~~")) {
       return filepath;
     } else {
-      return path8.join(process.cwd(), filepath.slice(1));
+      return path9.join(process.cwd(), filepath.slice(1));
     }
   }
   return filepath;
 }
 function resolvePgliteDir(dir, fallbackDir) {
   const envPath = resolveEnvFile();
-  if (existsSync4(envPath)) {
-    import_dotenv2.default.config({ path: envPath });
+  if (existsSync5(envPath)) {
+    import_dotenv3.default.config({ path: envPath });
   }
   if (dir) {
     const resolved2 = expandTildePath(dir);
@@ -43594,119 +43793,229 @@ function isWebUIEnabled() {
 
 class AgentServer {
   app;
-  agents;
   server;
   socketIO;
   isInitialized = false;
   isWebUIEnabled = true;
   clientPath;
+  elizaOS;
+  pluginLoader;
+  configManager;
   database;
-  startAgent;
-  stopAgent;
   loadCharacterTryPath;
   jsonToCharacter;
+  async startAgents(characters, plugins = []) {
+    if (!this.elizaOS || !this.pluginLoader || !this.configManager) {
+      throw new Error("Server not properly initialized");
+    }
+    const preparations = await Promise.all(characters.map(async (character) => {
+      character.id ??= stringToUuid2(character.name);
+      if (!this.configManager?.hasCharacterSecrets(character)) {
+        await this.configManager?.setDefaultSecretsFromEnv(character);
+      }
+      const loadedPlugins = new Map;
+      const pluginsToLoad = new Set(character.plugins || []);
+      for (const p of plugins) {
+        if (typeof p === "string") {
+          pluginsToLoad.add(p);
+        } else if (this.pluginLoader?.isValidPluginShape(p) && !loadedPlugins.has(p.name)) {
+          loadedPlugins.set(p.name, p);
+          (p.dependencies || []).forEach((dep) => {
+            pluginsToLoad.add(dep);
+          });
+        }
+      }
+      const allAvailablePlugins = new Map;
+      for (const p of loadedPlugins.values()) {
+        allAvailablePlugins.set(p.name, p);
+      }
+      for (const name of pluginsToLoad) {
+        if (!allAvailablePlugins.has(name)) {
+          const loaded = await this.pluginLoader?.loadAndPreparePlugin(name);
+          if (loaded) {
+            allAvailablePlugins.set(loaded.name, loaded);
+          }
+        }
+      }
+      let haveSql = false;
+      for (const [name] of allAvailablePlugins.entries()) {
+        if (name === sqlPlugin.name || name === "mysql") {
+          haveSql = true;
+          break;
+        }
+      }
+      if (!haveSql) {
+        allAvailablePlugins.set(sqlPlugin.name, sqlPlugin);
+      }
+      allAvailablePlugins.set(messageBusConnectorPlugin.name, messageBusConnectorPlugin);
+      const finalPlugins = this.pluginLoader?.resolvePluginDependencies(allAvailablePlugins, false);
+      const preparedCharacter = encryptedCharacter(character);
+      return { character: preparedCharacter, plugins: finalPlugins };
+    }));
+    const agentIds = await this.elizaOS.addAgents(preparations.map((p) => ({
+      character: p.character,
+      plugins: p.plugins
+    })));
+    await this.elizaOS.startAgents(agentIds);
+    const runtimes = [];
+    const settings = await this.configManager?.loadEnvConfig();
+    for (const id of agentIds) {
+      const runtime = this.elizaOS.getAgent(id);
+      if (runtime) {
+        Object.assign(runtime, { settings });
+        await this.registerAgent(runtime);
+        if (this.database) {
+          try {
+            const existingAgent = await this.database.getAgent(runtime.agentId);
+            if (!existingAgent) {
+              await this.database.createAgent({
+                ...runtime.character,
+                id: runtime.agentId
+              });
+              logger31.info(`Persisted agent ${runtime.character.name} (${runtime.agentId}) to database`);
+            }
+          } catch (error2) {
+            logger31.error({ error: error2 }, `Failed to persist agent ${runtime.agentId} to database`);
+          }
+        }
+        runtimes.push(runtime);
+      }
+    }
+    return runtimes;
+  }
+  async stopAgents(agentIds) {
+    if (!this.elizaOS) {
+      throw new Error("ElizaOS not initialized");
+    }
+    await this.elizaOS.stopAgents(agentIds);
+  }
+  getAllAgents() {
+    if (!this.elizaOS) {
+      return [];
+    }
+    return this.elizaOS.getAgents();
+  }
+  getAgent(agentId) {
+    if (!this.elizaOS) {
+      return;
+    }
+    return this.elizaOS.getAgent(agentId);
+  }
   constructor() {
     try {
-      logger30.debug("Initializing AgentServer (constructor)...");
-      this.agents = new Map;
+      logger31.debug("Initializing AgentServer (constructor)...");
       this.loadCharacterTryPath = loadCharacterTryPath;
       this.jsonToCharacter = jsonToCharacter;
       this.registerSignalHandlers();
     } catch (error2) {
-      logger30.error({ error: error2 }, "Failed to initialize AgentServer (constructor):");
+      logger31.error({ error: error2 }, "Failed to initialize AgentServer (constructor):");
       throw error2;
     }
   }
   async initialize(options) {
     if (this.isInitialized) {
-      logger30.warn("AgentServer is already initialized, skipping initialization");
+      logger31.warn("AgentServer is already initialized, skipping initialization");
       return;
     }
     try {
-      logger30.debug("Initializing AgentServer (async operations)...");
+      logger31.debug("Initializing AgentServer (async operations)...");
       const agentDataDir = resolvePgliteDir(options?.dataDir);
-      logger30.info(`[INIT] Database Dir for SQL plugin: ${agentDataDir}`);
+      logger31.info(`[INIT] Database Dir for SQL plugin: ${agentDataDir}`);
+      const dbDir = path9.dirname(agentDataDir);
+      if (!fs7.existsSync(dbDir)) {
+        fs7.mkdirSync(dbDir, { recursive: true });
+        logger31.info(`[INIT] Created database directory: ${dbDir}`);
+      }
+      const tempServerAgentId = "00000000-0000-0000-0000-000000000000";
       this.database = createDatabaseAdapter({
         dataDir: agentDataDir,
         postgresUrl: options?.postgresUrl
-      }, "00000000-0000-0000-0000-000000000002");
+      }, tempServerAgentId);
       await this.database.init();
-      logger30.success("Consolidated database initialized successfully");
-      logger30.info("[INIT] Running database migrations for messaging tables...");
+      logger31.success("Database initialized for server operations");
+      logger31.info("[INIT] Running database migrations for messaging tables...");
       try {
         const migrationService = new DatabaseMigrationService;
         const db = this.database.getDatabase();
         await migrationService.initializeWithDatabase(db);
         migrationService.discoverAndRegisterPluginSchemas([sqlPlugin]);
         await migrationService.runAllPluginMigrations();
-        logger30.success("[INIT] Database migrations completed successfully");
+        logger31.success("[INIT] Database migrations completed successfully");
       } catch (migrationError) {
-        logger30.error({ error: migrationError }, "[INIT] Failed to run database migrations:");
+        logger31.error({ error: migrationError }, "[INIT] Failed to run database migrations:");
         throw new Error(`Database migration failed: ${migrationError instanceof Error ? migrationError.message : String(migrationError)}`);
       }
       await new Promise((resolve2) => setTimeout(resolve2, 500));
-      logger30.info("[INIT] Ensuring default server exists...");
+      logger31.info("[INIT] Ensuring default server exists...");
       await this.ensureDefaultServer();
-      logger30.success("[INIT] Default server setup complete");
+      logger31.success("[INIT] Default server setup complete");
+      logger31.info("[INIT] Server uses temporary adapter for migrations only");
+      logger31.info("[INIT] Initializing ElizaOS...");
+      logger31.debug("[INIT] ElizaOS will use agent-specific database adapters from SQL plugin");
+      this.elizaOS = new ElizaOS2;
+      this.elizaOS.enableEditableMode();
+      this.pluginLoader = new PluginLoader;
+      this.configManager = new ConfigManager;
+      logger31.success("[INIT] ElizaOS initialized");
       await this.initializeServer(options);
       await new Promise((resolve2) => setTimeout(resolve2, 250));
       this.isInitialized = true;
     } catch (error2) {
-      logger30.error({ error: error2 }, "Failed to initialize AgentServer (async operations):");
+      logger31.error({ error: error2 }, "Failed to initialize AgentServer (async operations):");
       console.trace(error2);
       throw error2;
     }
   }
   async ensureDefaultServer() {
     try {
-      logger30.info("[AgentServer] Checking for default server...");
+      logger31.info("[AgentServer] Checking for default server...");
       const servers = await this.database.getMessageServers();
-      logger30.debug(`[AgentServer] Found ${servers.length} existing servers`);
+      logger31.debug(`[AgentServer] Found ${servers.length} existing servers`);
       servers.forEach((s) => {
-        logger30.debug(`[AgentServer] Existing server: ID=${s.id}, Name=${s.name}`);
+        logger31.debug(`[AgentServer] Existing server: ID=${s.id}, Name=${s.name}`);
       });
       const defaultServer = servers.find((s) => s.id === "00000000-0000-0000-0000-000000000000");
       if (!defaultServer) {
-        logger30.info("[AgentServer] Creating default server with UUID 00000000-0000-0000-0000-000000000000...");
+        logger31.info("[AgentServer] Creating default server with UUID 00000000-0000-0000-0000-000000000000...");
         try {
           await this.database.db.execute(`
             INSERT INTO message_servers (id, name, source_type, created_at, updated_at)
             VALUES ('00000000-0000-0000-0000-000000000000', 'Default Server', 'eliza_default', NOW(), NOW())
             ON CONFLICT (id) DO NOTHING
           `);
-          logger30.success("[AgentServer] Default server created via raw SQL");
+          logger31.success("[AgentServer] Default server created via raw SQL");
           const checkResult = await this.database.db.execute("SELECT id, name FROM message_servers WHERE id = '00000000-0000-0000-0000-000000000000'");
-          logger30.debug("[AgentServer] Raw SQL check result:", checkResult);
+          logger31.debug("[AgentServer] Raw SQL check result:", checkResult);
         } catch (sqlError) {
-          logger30.error("[AgentServer] Raw SQL insert failed:", sqlError);
+          logger31.error("[AgentServer] Raw SQL insert failed:", sqlError);
           try {
             const server = await this.database.createMessageServer({
               id: "00000000-0000-0000-0000-000000000000",
               name: "Default Server",
               sourceType: "eliza_default"
             });
-            logger30.success("[AgentServer] Default server created via ORM with ID:", server.id);
+            logger31.success("[AgentServer] Default server created via ORM with ID:", server.id);
           } catch (ormError) {
-            logger30.error("[AgentServer] Both SQL and ORM creation failed:", ormError);
+            logger31.error("[AgentServer] Both SQL and ORM creation failed:", ormError);
             throw new Error(`Failed to create default server: ${ormError.message}`);
           }
         }
         const verifyServers = await this.database.getMessageServers();
-        logger30.debug(`[AgentServer] After creation attempt, found ${verifyServers.length} servers`);
+        logger31.debug(`[AgentServer] After creation attempt, found ${verifyServers.length} servers`);
         verifyServers.forEach((s) => {
-          logger30.debug(`[AgentServer] Server after creation: ID=${s.id}, Name=${s.name}`);
+          logger31.debug(`[AgentServer] Server after creation: ID=${s.id}, Name=${s.name}`);
         });
         const verifyDefault = verifyServers.find((s) => s.id === "00000000-0000-0000-0000-000000000000");
         if (!verifyDefault) {
           throw new Error(`Failed to create or verify default server with ID ${DEFAULT_SERVER_ID6}`);
         } else {
-          logger30.success("[AgentServer] Default server creation verified successfully");
+          logger31.success("[AgentServer] Default server creation verified successfully");
         }
       } else {
-        logger30.info("[AgentServer] Default server already exists with ID:", defaultServer.id);
+        logger31.info("[AgentServer] Default server already exists with ID:", defaultServer.id);
       }
     } catch (error2) {
-      logger30.error({ error: error2 }, "[AgentServer] Error ensuring default server:");
+      logger31.error({ error: error2 }, "[AgentServer] Error ensuring default server:");
       throw error2;
     }
   }
@@ -43717,7 +44026,7 @@ class AgentServer {
       }
       this.app = express33();
       const DEFAULT_SENTRY_DSN = "https://c20e2d51b66c14a783b0689d536f7e5c@o4509349865259008.ingest.us.sentry.io/4509352524120064";
-      const sentryDsn = process.env.SENTRY_DSN && process.env.SENTRY_DSN.trim() || DEFAULT_SENTRY_DSN;
+      const sentryDsn = process.env.SENTRY_DSN?.trim() || DEFAULT_SENTRY_DSN;
       const sentryEnabled = Boolean(sentryDsn);
       if (sentryEnabled) {
         try {
@@ -43727,16 +44036,16 @@ class AgentServer {
             integrations: [vercelAIIntegration({ force: sentryEnabled })],
             tracesSampleRate: Number(process.env.SENTRY_TRACES_SAMPLE_RATE || 0)
           });
-          logger30.info("[Sentry] Initialized Sentry for @elizaos/server");
+          logger31.info("[Sentry] Initialized Sentry for @elizaos/server");
         } catch (sentryInitError) {
-          logger30.error({ error: sentryInitError }, "[Sentry] Failed to initialize Sentry");
+          logger31.error({ error: sentryInitError }, "[Sentry] Failed to initialize Sentry");
         }
       }
       const isProd = false;
-      logger30.debug("Setting up security headers...");
+      logger31.debug("Setting up security headers...");
       if (!isProd) {
-        logger30.debug(`NODE_ENV: ${"development"}`);
-        logger30.debug(`CSP will be: ${isProd ? "ENABLED" : "MINIMAL_DEV"}`);
+        logger31.debug(`NODE_ENV: ${"development"}`);
+        logger31.debug(`CSP will be: ${isProd ? "ENABLED" : "MINIMAL_DEV"}`);
       }
       this.app.use(helmet({
         contentSecurityPolicy: isProd ? {
@@ -43784,12 +44093,12 @@ class AgentServer {
         xssFilter: true
       }));
       if (options?.middlewares) {
-        logger30.debug("Applying custom middlewares...");
+        logger31.debug("Applying custom middlewares...");
         for (const middleware2 of options.middlewares) {
           this.app.use(middleware2);
         }
       }
-      logger30.debug("Setting up standard middlewares...");
+      logger31.debug("Setting up standard middlewares...");
       this.app.use(cors2({
         origin: process.env.CORS_ORIGIN || true,
         credentials: true,
@@ -43801,28 +44110,28 @@ class AgentServer {
       }));
       const serverAuthToken = process.env.ELIZA_SERVER_AUTH_TOKEN;
       if (serverAuthToken) {
-        logger30.info("Server authentication enabled. Requires X-API-KEY header for /api routes.");
+        logger31.info("Server authentication enabled. Requires X-API-KEY header for /api routes.");
         this.app.use("/api", (req, res, next) => {
           apiKeyAuthMiddleware(req, res, next);
         });
       } else {
-        logger30.warn("Server authentication is disabled. Set ELIZA_SERVER_AUTH_TOKEN environment variable to enable.");
+        logger31.warn("Server authentication is disabled. Set ELIZA_SERVER_AUTH_TOKEN environment variable to enable.");
       }
       this.isWebUIEnabled = isWebUIEnabled();
       if (this.isWebUIEnabled) {
-        logger30.info("Web UI enabled");
+        logger31.info("Web UI enabled");
       } else {
         const uiEnabledEnv = process.env.ELIZA_UI_ENABLE;
         if (uiEnabledEnv !== undefined && uiEnabledEnv.trim() !== "") {
-          logger30.info(`Web UI disabled by environment variable (ELIZA_UI_ENABLE=${uiEnabledEnv})`);
+          logger31.info(`Web UI disabled by environment variable (ELIZA_UI_ENABLE=${uiEnabledEnv})`);
         } else {
-          logger30.info("Web UI disabled for security (production mode)");
+          logger31.info("Web UI disabled for security (production mode)");
         }
       }
       const uploadsBasePath = getUploadsAgentsDir4();
       const generatedBasePath = getGeneratedDir2();
-      fs6.mkdirSync(uploadsBasePath, { recursive: true });
-      fs6.mkdirSync(generatedBasePath, { recursive: true });
+      fs7.mkdirSync(uploadsBasePath, { recursive: true });
+      fs7.mkdirSync(generatedBasePath, { recursive: true });
       this.app.get("/media/uploads/agents/:agentId/:filename", (req, res) => {
         const agentId = req.params.agentId;
         const filename = req.params.filename;
@@ -43832,26 +44141,26 @@ class AgentServer {
           return;
         }
         const sanitizedFilename = basename2(filename);
-        const agentUploadsPath = join4(uploadsBasePath, agentId);
-        const filePath = join4(agentUploadsPath, sanitizedFilename);
+        const agentUploadsPath = join5(uploadsBasePath, agentId);
+        const filePath = join5(agentUploadsPath, sanitizedFilename);
         if (!filePath.startsWith(agentUploadsPath)) {
           res.status(403).json({ error: "Access denied" });
           return;
         }
-        if (!fs6.existsSync(filePath)) {
+        if (!fs7.existsSync(filePath)) {
           res.status(404).json({ error: "File does not exist!!!!!!!" });
           return;
         }
         res.sendFile(sanitizedFilename, { root: agentUploadsPath }, (err) => {
           if (err) {
             if (err.message === "Request aborted") {
-              logger30.warn(`[MEDIA] Download aborted: ${req.originalUrl}`);
+              logger31.warn(`[MEDIA] Download aborted: ${req.originalUrl}`);
             } else if (!res.headersSent) {
-              logger30.warn(`[MEDIA] File not found: ${agentUploadsPath}/${sanitizedFilename}`);
+              logger31.warn(`[MEDIA] File not found: ${agentUploadsPath}/${sanitizedFilename}`);
               res.status(404).json({ error: "File not found" });
             }
           } else {
-            logger30.debug(`[MEDIA] Successfully served: ${sanitizedFilename}`);
+            logger31.debug(`[MEDIA] Successfully served: ${sanitizedFilename}`);
           }
         });
       });
@@ -43864,17 +44173,17 @@ class AgentServer {
           return;
         }
         const sanitizedFilename = basename2(filename);
-        const agentGeneratedPath = join4(generatedBasePath, agentId);
-        const filePath = join4(agentGeneratedPath, sanitizedFilename);
+        const agentGeneratedPath = join5(generatedBasePath, agentId);
+        const filePath = join5(agentGeneratedPath, sanitizedFilename);
         if (!filePath.startsWith(agentGeneratedPath)) {
           res.status(403).json({ error: "Access denied" });
           return;
         }
-        if (!existsSync4(filePath)) {
+        if (!existsSync5(filePath)) {
           res.status(404).json({ error: "File not found" });
           return;
         }
-        const absolutePath = path8.resolve(filePath);
+        const absolutePath = path9.resolve(filePath);
         const options2 = {
           dotfiles: "deny"
         };
@@ -43883,7 +44192,7 @@ class AgentServer {
             const ext2 = extname(filename).toLowerCase();
             const mimeType = ext2 === ".png" ? "image/png" : ext2 === ".jpg" || ext2 === ".jpeg" ? "image/jpeg" : "application/octet-stream";
             res.setHeader("Content-Type", mimeType);
-            const stream = fs6.createReadStream(absolutePath);
+            const stream = fs7.createReadStream(absolutePath);
             stream.on("error", () => res.status(404).json({ error: "File not found" }));
             stream.pipe(res);
           }
@@ -43898,20 +44207,20 @@ class AgentServer {
           return;
         }
         const sanitizedFilename = basename2(filename);
-        const channelUploadsPath = join4(uploadsBasePath, "channels", channelId);
-        const filePath = join4(channelUploadsPath, sanitizedFilename);
+        const channelUploadsPath = join5(uploadsBasePath, "channels", channelId);
+        const filePath = join5(channelUploadsPath, sanitizedFilename);
         if (!filePath.startsWith(channelUploadsPath)) {
           res.status(403).json({ error: "Access denied" });
           return;
         }
         res.sendFile(filePath, (err) => {
           if (err) {
-            logger30.warn({ err, filePath }, `[STATIC] Channel media file not found: ${filePath}`);
+            logger31.warn({ err, filePath }, `[STATIC] Channel media file not found: ${filePath}`);
             if (!res.headersSent) {
               res.status(404).json({ error: "File not found" });
             }
           } else {
-            logger30.debug(`[STATIC] Served channel media file: ${filePath}`);
+            logger31.debug(`[STATIC] Served channel media file: ${filePath}`);
           }
         });
       });
@@ -43955,11 +44264,11 @@ class AgentServer {
       if (this.isWebUIEnabled) {
         const possiblePaths = [
           this.clientPath,
-          path8.resolve(__dirname3, "client"),
-          path8.resolve(__dirname3, "../../client/dist"),
+          path9.resolve(__dirname3, "client"),
+          path9.resolve(__dirname3, "../../client/dist"),
           (() => {
             try {
-              return path8.resolve(path8.dirname(__require.resolve("@elizaos/client/package.json")), "dist");
+              return path9.resolve(path9.dirname(__require.resolve("@elizaos/client/package.json")), "dist");
             } catch {
               return null;
             }
@@ -43967,12 +44276,12 @@ class AgentServer {
           (() => {
             try {
               if (process.argv[1]) {
-                const serverPath = path8.dirname(process.argv[1]);
-                const possibleClientPath = path8.join(serverPath, "client");
-                if (existsSync4(path8.join(possibleClientPath, "index.html"))) {
+                const serverPath = path9.dirname(process.argv[1]);
+                const possibleClientPath = path9.join(serverPath, "client");
+                if (existsSync5(path9.join(possibleClientPath, "index.html"))) {
                   return possibleClientPath;
                 }
-                if (existsSync4(path8.join(serverPath, "index.html"))) {
+                if (existsSync5(path9.join(serverPath, "index.html"))) {
                   return serverPath;
                 }
               }
@@ -43981,8 +44290,8 @@ class AgentServer {
           })(),
           (() => {
             try {
-              const bunGlobalPath = path8.join(os3.homedir(), ".bun/install/global/node_modules/@elizaos/server/dist/client");
-              if (existsSync4(path8.join(bunGlobalPath, "index.html"))) {
+              const bunGlobalPath = path9.join(os3.homedir(), ".bun/install/global/node_modules/@elizaos/server/dist/client");
+              if (existsSync5(path9.join(bunGlobalPath, "index.html"))) {
                 return bunGlobalPath;
               }
               try {
@@ -43992,8 +44301,8 @@ class AgentServer {
                 });
                 if (proc.exitCode === 0 && proc.stdout) {
                   const npmRoot = new TextDecoder().decode(proc.stdout).trim();
-                  const globalServerPath = path8.join(npmRoot, "@elizaos/server/dist/client");
-                  if (existsSync4(path8.join(globalServerPath, "index.html"))) {
+                  const globalServerPath = path9.join(npmRoot, "@elizaos/server/dist/client");
+                  if (existsSync5(path9.join(globalServerPath, "index.html"))) {
                     return globalServerPath;
                   }
                 }
@@ -44004,15 +44313,15 @@ class AgentServer {
           ...[
             "/usr/local/lib/node_modules/@elizaos/server/dist/client",
             "/usr/lib/node_modules/@elizaos/server/dist/client",
-            path8.join(os3.homedir(), ".npm-global/lib/node_modules/@elizaos/server/dist/client"),
+            path9.join(os3.homedir(), ".npm-global/lib/node_modules/@elizaos/server/dist/client"),
             (() => {
               try {
-                const nvmPath = path8.join(os3.homedir(), ".nvm/versions/node");
-                if (existsSync4(nvmPath)) {
-                  const versions = fs6.readdirSync(nvmPath);
+                const nvmPath = path9.join(os3.homedir(), ".nvm/versions/node");
+                if (existsSync5(nvmPath)) {
+                  const versions = fs7.readdirSync(nvmPath);
                   for (const version of versions) {
-                    const cliPath = path8.join(nvmPath, version, "lib/node_modules/@elizaos/server/dist/client");
-                    if (existsSync4(path8.join(cliPath, "index.html"))) {
+                    const cliPath = path9.join(nvmPath, version, "lib/node_modules/@elizaos/server/dist/client");
+                    if (existsSync5(path9.join(cliPath, "index.html"))) {
                       return cliPath;
                     }
                   }
@@ -44022,37 +44331,37 @@ class AgentServer {
             })()
           ].filter(Boolean)
         ].filter(Boolean);
-        logger30.debug(`[STATIC] process.argv[0]: ${process.argv[0]}`);
-        logger30.debug(`[STATIC] process.argv[1]: ${process.argv[1]}`);
-        logger30.debug(`[STATIC] __dirname: ${__dirname3}`);
+        logger31.debug(`[STATIC] process.argv[0]: ${process.argv[0]}`);
+        logger31.debug(`[STATIC] process.argv[1]: ${process.argv[1]}`);
+        logger31.debug(`[STATIC] __dirname: ${__dirname3}`);
         for (const possiblePath of possiblePaths) {
-          if (possiblePath && existsSync4(path8.join(possiblePath, "index.html"))) {
+          if (possiblePath && existsSync5(path9.join(possiblePath, "index.html"))) {
             clientPath = possiblePath;
-            logger30.info(`[STATIC] Found client files at: ${clientPath}`);
+            logger31.info(`[STATIC] Found client files at: ${clientPath}`);
             break;
           }
         }
         if (clientPath) {
           this.clientPath = clientPath;
           this.app.use(express33.static(clientPath, staticOptions));
-          logger30.info(`[STATIC] Serving static files from: ${clientPath}`);
+          logger31.info(`[STATIC] Serving static files from: ${clientPath}`);
         } else {
-          logger30.warn("[STATIC] Client dist path not found. Searched locations:");
+          logger31.warn("[STATIC] Client dist path not found. Searched locations:");
           possiblePaths.forEach((p) => {
             if (p)
-              logger30.warn(`[STATIC]   - ${p}`);
+              logger31.warn(`[STATIC]   - ${p}`);
           });
-          logger30.warn("[STATIC] The web UI will not be available.");
-          logger30.warn("[STATIC] To fix this, ensure the client is built: cd packages/client && bun run build");
-          logger30.warn("[STATIC] Then rebuild the server: cd packages/server && bun run build");
+          logger31.warn("[STATIC] The web UI will not be available.");
+          logger31.warn("[STATIC] To fix this, ensure the client is built: cd packages/client && bun run build");
+          logger31.warn("[STATIC] Then rebuild the server: cd packages/server && bun run build");
         }
       }
-      const pluginRouteHandler = createPluginRouteHandler(this.agents);
+      const pluginRouteHandler = createPluginRouteHandler(this.elizaOS);
       this.app.use(pluginRouteHandler);
-      const apiRouter = createApiRouter(this.agents, this);
+      const apiRouter = createApiRouter(this.elizaOS, this);
       this.app.use("/api", (req, _res, next) => {
         if (req.path !== "/ping") {
-          logger30.debug(`API request: ${req.method} ${req.path}`);
+          logger31.debug(`API request: ${req.method} ${req.path}`);
         }
         next();
       }, apiRouter, (err, req, res, _next) => {
@@ -44067,7 +44376,7 @@ class AgentServer {
             return scope;
           });
         }
-        logger30.error({ err }, `API error: ${req.method} ${req.path}`);
+        logger31.error({ err }, `API error: ${req.method} ${req.path}`);
         res.status(500).json({
           success: false,
           error: {
@@ -44115,29 +44424,29 @@ class AgentServer {
           }
           const resolvedClientPath = clientPath || this.clientPath;
           if (resolvedClientPath) {
-            const indexFilePath = path8.join(resolvedClientPath, "index.html");
-            if (!existsSync4(indexFilePath)) {
-              logger30.error(`[STATIC] index.html not found at expected path: ${indexFilePath}`);
-              logger30.error(`[STATIC] Client path was: ${resolvedClientPath}`);
+            const indexFilePath = path9.join(resolvedClientPath, "index.html");
+            if (!existsSync5(indexFilePath)) {
+              logger31.error(`[STATIC] index.html not found at expected path: ${indexFilePath}`);
+              logger31.error(`[STATIC] Client path was: ${resolvedClientPath}`);
               res.status(404).send("Client application not found");
               return;
             }
             res.sendFile("index.html", { root: resolvedClientPath }, (err) => {
               if (err) {
-                logger30.warn(`[STATIC] Failed to serve index.html: ${err.message}`);
-                logger30.warn(`[STATIC] Attempted root: ${resolvedClientPath}`);
-                logger30.warn(`[STATIC] Full path was: ${indexFilePath}`);
-                logger30.warn(`[STATIC] Error code: ${err.code || "unknown"}`);
+                logger31.warn(`[STATIC] Failed to serve index.html: ${err.message}`);
+                logger31.warn(`[STATIC] Attempted root: ${resolvedClientPath}`);
+                logger31.warn(`[STATIC] Full path was: ${indexFilePath}`);
+                logger31.warn(`[STATIC] Error code: ${err.code || "unknown"}`);
                 if (!res.headersSent) {
                   res.status(404).send("Client application not found");
                 }
               } else {
-                logger30.debug(`[STATIC] Successfully served index.html for route: ${req.path}`);
+                logger31.debug(`[STATIC] Successfully served index.html for route: ${req.path}`);
               }
             });
           } else {
-            logger30.warn("[STATIC] Client dist path not found in SPA fallback");
-            logger30.warn("[STATIC] Neither local nor instance clientPath variables are set");
+            logger31.warn("[STATIC] Client dist path not found in SPA fallback");
+            logger31.warn("[STATIC] Neither local nor instance clientPath variables are set");
             res.status(404).send("Client application not found");
           }
         });
@@ -44147,10 +44456,10 @@ class AgentServer {
         });
       }
       this.server = http4.createServer(this.app);
-      this.socketIO = setupSocketIO(this.server, this.agents, this);
-      logger30.success("AgentServer HTTP server and Socket.IO initialized");
+      this.socketIO = setupSocketIO(this.server, this.elizaOS, this);
+      logger31.success("AgentServer HTTP server and Socket.IO initialized");
     } catch (error2) {
-      logger30.error({ error: error2 }, "Failed to complete server initialization:");
+      logger31.error({ error: error2 }, "Failed to complete server initialization:");
       throw error2;
     }
   }
@@ -44165,63 +44474,64 @@ class AgentServer {
       if (!runtime.character) {
         throw new Error("Runtime missing character configuration");
       }
-      this.agents.set(runtime.agentId, runtime);
-      logger30.debug(`Agent ${runtime.character.name} (${runtime.agentId}) added to agents map`);
+      logger31.debug(`Agent ${runtime.character.name} (${runtime.agentId}) registered`);
       try {
         if (messageBusConnectorPlugin) {
           await runtime.registerPlugin(messageBusConnectorPlugin);
-          logger30.info(`[AgentServer] Automatically registered MessageBusConnector for agent ${runtime.character.name}`);
+          logger31.info(`[AgentServer] Automatically registered MessageBusConnector for agent ${runtime.character.name}`);
         } else {
-          logger30.error(`[AgentServer] CRITICAL: MessageBusConnector plugin definition not found.`);
+          logger31.error(`[AgentServer] CRITICAL: MessageBusConnector plugin definition not found.`);
         }
       } catch (e) {
-        logger30.error({ error: e }, `[AgentServer] CRITICAL: Failed to register MessageBusConnector for agent ${runtime.character.name}`);
+        logger31.error({ error: e }, `[AgentServer] CRITICAL: Failed to register MessageBusConnector for agent ${runtime.character.name}`);
       }
       const teePlugin = runtime.plugins.find((p) => p.name === "phala-tee-plugin");
       if (teePlugin) {
-        logger30.debug(`Found TEE plugin for agent ${runtime.agentId}`);
+        logger31.debug(`Found TEE plugin for agent ${runtime.agentId}`);
         if (teePlugin.providers) {
           for (const provider of teePlugin.providers) {
             runtime.registerProvider(provider);
-            logger30.debug(`Registered TEE provider: ${provider.name}`);
+            logger31.debug(`Registered TEE provider: ${provider.name}`);
           }
         }
         if (teePlugin.actions) {
           for (const action of teePlugin.actions) {
             runtime.registerAction(action);
-            logger30.debug(`Registered TEE action: ${action.name}`);
+            logger31.debug(`Registered TEE action: ${action.name}`);
           }
         }
       }
-      logger30.success(`Successfully registered agent ${runtime.character.name} (${runtime.agentId}) with core services.`);
+      logger31.success(`Successfully registered agent ${runtime.character.name} (${runtime.agentId}) with core services.`);
       await this.addAgentToServer(DEFAULT_SERVER_ID6, runtime.agentId);
-      logger30.info(`[AgentServer] Auto-associated agent ${runtime.character.name} with server ID: ${DEFAULT_SERVER_ID6}`);
+      logger31.info(`[AgentServer] Auto-associated agent ${runtime.character.name} with server ID: ${DEFAULT_SERVER_ID6}`);
     } catch (error2) {
-      logger30.error({ error: error2 }, "Failed to register agent:");
+      logger31.error({ error: error2 }, "Failed to register agent:");
       throw error2;
     }
   }
-  unregisterAgent(agentId) {
+  async unregisterAgent(agentId) {
     if (!agentId) {
-      logger30.warn("[AGENT UNREGISTER] Attempted to unregister undefined or invalid agent runtime");
+      logger31.warn("[AGENT UNREGISTER] Attempted to unregister undefined or invalid agent runtime");
       return;
     }
     try {
-      const agent = this.agents.get(agentId);
+      const agent = this.elizaOS?.getAgent(agentId);
       if (agent) {
         try {
           agent.stop().catch((stopError) => {
-            logger30.error({ error: stopError, agentId }, `[AGENT UNREGISTER] Error stopping agent services for ${agentId}:`);
+            logger31.error({ error: stopError, agentId }, `[AGENT UNREGISTER] Error stopping agent services for ${agentId}:`);
           });
-          logger30.debug(`[AGENT UNREGISTER] Stopping services for agent ${agentId}`);
+          logger31.debug(`[AGENT UNREGISTER] Stopping services for agent ${agentId}`);
         } catch (stopError) {
-          logger30.error({ error: stopError, agentId }, `[AGENT UNREGISTER] Error initiating stop for agent ${agentId}:`);
+          logger31.error({ error: stopError, agentId }, `[AGENT UNREGISTER] Error initiating stop for agent ${agentId}:`);
         }
       }
-      this.agents.delete(agentId);
-      logger30.debug(`Agent ${agentId} removed from agents map`);
+      if (this.elizaOS) {
+        await this.elizaOS.deleteAgents([agentId]);
+      }
+      logger31.debug(`Agent ${agentId} unregistered`);
     } catch (error2) {
-      logger30.error({ error: error2, agentId }, `Error removing agent ${agentId}:`);
+      logger31.error({ error: error2, agentId }, `Error removing agent ${agentId}:`);
     }
   }
   registerMiddleware(middleware2) {
@@ -44233,9 +44543,9 @@ class AgentServer {
         if (!port || typeof port !== "number") {
           throw new Error(`Invalid port number: ${port}`);
         }
-        logger30.debug(`Starting server on port ${port}...`);
-        logger30.debug(`Current agents count: ${this.agents.size}`);
-        logger30.debug(`Environment: ${"development"}`);
+        logger31.debug(`Starting server on port ${port}...`);
+        logger31.debug(`Current agents count: ${this.elizaOS?.getAgents().length || 0}`);
+        logger31.debug(`Environment: ${"development"}`);
         const host = process.env.SERVER_HOST || "0.0.0.0";
         this.server.listen(port, host, () => {
           if (this.isWebUIEnabled && false) {} else if (!this.isWebUIEnabled) {
@@ -44248,25 +44558,26 @@ class AgentServer {
 ` + `  \x1B[1m${baseUrl}/api/messaging\x1B[22m\x1B[0m`);
           }
           console.log(`AgentServer is listening on port ${port}`);
-          logger30.success(`REST API bound to ${host}:${port}. If running locally, access it at http://localhost:${port}.`);
-          logger30.debug(`Active agents: ${this.agents.size}`);
-          this.agents.forEach((agent, id) => {
-            logger30.debug(`- Agent ${id}: ${agent.character.name}`);
+          logger31.success(`REST API bound to ${host}:${port}. If running locally, access it at http://localhost:${port}.`);
+          const agents = this.elizaOS?.getAgents() || [];
+          logger31.debug(`Active agents: ${agents.length}`);
+          agents.forEach((agent) => {
+            logger31.debug(`- Agent ${agent.agentId}: ${agent.character.name}`);
           });
           resolve2();
         }).on("error", (error2) => {
-          logger30.error({ error: error2, host, port }, `Failed to bind server to ${host}:${port}:`);
+          logger31.error({ error: error2, host, port }, `Failed to bind server to ${host}:${port}:`);
           if (error2.code === "EADDRINUSE") {
-            logger30.error(`Port ${port} is already in use. Please try a different port or stop the process using that port.`);
+            logger31.error(`Port ${port} is already in use. Please try a different port or stop the process using that port.`);
           } else if (error2.code === "EACCES") {
-            logger30.error(`Permission denied to bind to port ${port}. Try using a port above 1024 or running with appropriate permissions.`);
+            logger31.error(`Permission denied to bind to port ${port}. Try using a port above 1024 or running with appropriate permissions.`);
           } else if (error2.code === "EADDRNOTAVAIL") {
-            logger30.error(`Cannot bind to ${host}:${port} - address not available. Check if the host address is correct.`);
+            logger31.error(`Cannot bind to ${host}:${port} - address not available. Check if the host address is correct.`);
           }
           reject(error2);
         });
       } catch (error2) {
-        logger30.error({ error: error2 }, "Failed to start server:");
+        logger31.error({ error: error2 }, "Failed to start server:");
         reject(error2);
       }
     });
@@ -44274,7 +44585,7 @@ class AgentServer {
   async stop() {
     if (this.server) {
       this.server.close(() => {
-        logger30.success("Server stopped");
+        logger31.success("Server stopped");
       });
     }
   }
@@ -44321,7 +44632,7 @@ class AgentServer {
     for (const message of messages) {
       await this.database.deleteMessage(message.id);
     }
-    logger30.info(`[AgentServer] Cleared all messages for central channel: ${channelId}`);
+    logger31.info(`[AgentServer] Cleared all messages for central channel: ${channelId}`);
   }
   async findOrCreateCentralDmChannel(user1Id, user2Id, messageServerId) {
     return this.database.findOrCreateDmChannel(user1Id, user2Id, messageServerId);
@@ -44344,7 +44655,7 @@ class AgentServer {
         metadata: createdMessage.metadata
       };
       bus_default.emit("new_message", messageForBus);
-      logger30.info(`[AgentServer] Published message ${createdMessage.id} to internal message bus`);
+      logger31.info(`[AgentServer] Published message ${createdMessage.id} to internal message bus`);
     }
     return createdMessage;
   }
@@ -44355,7 +44666,7 @@ class AgentServer {
     return this.database.updateMessage(messageId, patch);
   }
   async removeParticipantFromChannel() {
-    logger30.warn(`[AgentServer] Remove participant operation not directly supported in database adapter`);
+    logger31.warn(`[AgentServer] Remove participant operation not directly supported in database adapter`);
   }
   async addAgentToServer(serverId, agentId) {
     const server = await this.getServerById(serverId);
@@ -44383,31 +44694,32 @@ class AgentServer {
   }
   registerSignalHandlers() {
     const gracefulShutdown = async () => {
-      logger30.info("Received shutdown signal, initiating graceful shutdown...");
-      logger30.debug("Stopping all agents...");
-      for (const [id, agent] of this.agents.entries()) {
+      logger31.info("Received shutdown signal, initiating graceful shutdown...");
+      logger31.debug("Stopping all agents...");
+      const agents = this.elizaOS?.getAgents() || [];
+      for (const agent of agents) {
         try {
           await agent.stop();
-          logger30.debug(`Stopped agent ${id}`);
+          logger31.debug(`Stopped agent ${agent.agentId}`);
         } catch (error2) {
-          logger30.error({ error: error2, agentId: id }, `Error stopping agent ${id}:`);
+          logger31.error({ error: error2, agentId: agent.agentId }, `Error stopping agent ${agent.agentId}:`);
         }
       }
       if (this.database) {
         try {
           await this.database.close();
-          logger30.info("Database closed.");
+          logger31.info("Database closed.");
         } catch (error2) {
-          logger30.error({ error: error2 }, "Error closing database:");
+          logger31.error({ error: error2 }, "Error closing database:");
         }
       }
       if (this.server) {
         this.server.close(() => {
-          logger30.success("Server closed successfully");
+          logger31.success("Server closed successfully");
           process.exit(0);
         });
         setTimeout(() => {
-          logger30.error("Could not close connections in time, forcing shutdown");
+          logger31.error("Could not close connections in time, forcing shutdown");
           process.exit(1);
         }, 5000);
       } else {
@@ -44416,7 +44728,7 @@ class AgentServer {
     };
     process.on("SIGTERM", gracefulShutdown);
     process.on("SIGINT", gracefulShutdown);
-    logger30.debug("Shutdown handlers registered");
+    logger31.debug("Shutdown handlers registered");
   }
 }
 export {
@@ -44430,5 +44742,8 @@ export {
   isWebUIEnabled,
   hasValidRemoteUrls,
   expandTildePath,
+  PluginLoader,
+  ElizaOS3 as ElizaOS,
+  ConfigManager,
   AgentServer
 };