npm - @elizaos/server - Versions diffs - 1.6.0-beta.1 → 1.6.1-alpha.1 - Mend

@elizaos/server 1.6.0-beta.1 → 1.6.1-alpha.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/dist/client/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <link rel="icon" type="image/x-icon" href="/favicon.ico" />
     <title>ElizaOS - Client</title>
-    <script type="module" crossorigin src="/assets/main-BXR0yfv8.js"></script>
+    <script type="module" crossorigin src="/assets/main-C4q5_rtN.js"></script>
   </head>
   <body>
     <div id="root"></div>

package/dist/index.js CHANGED Viewed

@@ -23032,6 +23032,16 @@ import { validateUuid as validateUuid6 } from "@elizaos/core";
 import express6 from "express";
 function createAgentRunsRouter(elizaOS) {
   const router = express6.Router();
+  const RUNS_CACHE_TTL = 15000;
+  const runsCache = new Map;
+  const buildCacheKey = (agentId, query) => JSON.stringify({
+    agentId,
+    roomId: query.roomId || null,
+    status: query.status || null,
+    limit: query.limit || null,
+    from: query.from || null,
+    to: query.to || null
+  });
   router.get("/:agentId/runs", async (req, res) => {
     const agentId = validateUuid6(req.params.agentId);
     if (!agentId) {
@@ -23049,74 +23059,179 @@ function createAgentRunsRouter(elizaOS) {
       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({
+      const cacheKey = !fromTime && !toTime ? buildCacheKey(agentId, { roomId, status, limit: limitNum }) : null;
+      if (cacheKey) {
+        const cached = runsCache.get(cacheKey);
+        if (cached && cached.expiresAt > Date.now()) {
+          return sendSuccess(res, cached.payload);
+        }
+      }
+      const adapter = runtime.adapter;
+      const allowedStatuses = [
+        "started",
+        "completed",
+        "timeout",
+        "error",
+        "all"
+      ];
+      const statusFilter = typeof status === "string" && allowedStatuses.includes(status) ? status : undefined;
+      if (adapter?.getAgentRunSummaries) {
+        try {
+          const fastResult = await adapter.getAgentRunSummaries({
+            limit: limitNum,
+            roomId: roomId ? roomId : undefined,
+            status: statusFilter,
+            from: fromTime,
+            to: toTime
+          });
+          if (cacheKey) {
+            runsCache.set(cacheKey, {
+              payload: fastResult,
+              expiresAt: Date.now() + RUNS_CACHE_TTL
+            });
+          }
+          return sendSuccess(res, fastResult);
+        } catch (error) {
+          runtime.logger?.warn?.(`Optimized run summary query failed, falling back to log aggregation: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      const directAgentRunEventsPromise = runtime.getLogs({
         entityId: agentId,
         roomId: roomId ? roomId : undefined,
         type: "run_event",
-        count: limitNum * 3
-      });
+        count: 1000
+      }).catch(() => []);
+      const directRunEvents = await directAgentRunEventsPromise;
       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;
+      const ingestRunEvents = (logs) => {
+        for (const log of logs) {
+          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;
+            }
           }
         }
+      };
+      ingestRunEvents(directRunEvents);
+      const needsMoreRuns = () => runMap.size < limitNum;
+      if (needsMoreRuns()) {
+        try {
+          const recentMessages = await runtime.getMemories({
+            tableName: "messages",
+            roomId: roomId ? roomId : undefined,
+            count: 200
+          });
+          const authorIds = Array.from(new Set(recentMessages.map((m) => m.entityId).filter((eid) => Boolean(eid) && eid !== agentId))).slice(0, 10);
+          const authorRunEvents = await Promise.all(authorIds.map((authorId) => runtime.getLogs({
+            entityId: authorId,
+            roomId: roomId ? roomId : undefined,
+            type: "run_event",
+            count: 500
+          }).catch(() => [])));
+          for (const logs of authorRunEvents) {
+            ingestRunEvents(logs);
+            if (!needsMoreRuns())
+              break;
+          }
+        } catch {}
+      }
+      if (!roomId && needsMoreRuns()) {
+        try {
+          const worlds = await runtime.getAllWorlds();
+          const roomIds = [];
+          for (const w of worlds) {
+            try {
+              const rooms = await runtime.getRooms(w.id);
+              roomIds.push(...rooms.map((r) => r.id));
+            } catch {}
+            if (roomIds.length > 20)
+              break;
+          }
+          const participantLogs = await Promise.all(roomIds.map(async (rId) => {
+            try {
+              const participants = await runtime.getParticipantsForRoom(rId);
+              const otherParticipants = participants.filter((pid) => pid !== agentId).slice(0, 5);
+              const logsPerParticipant = await Promise.all(otherParticipants.map((participantId) => runtime.getLogs({
+                entityId: participantId,
+                roomId: rId,
+                type: "run_event",
+                count: 300
+              }).catch(() => [])));
+              return logsPerParticipant.flat();
+            } catch {
+              return [];
+            }
+          }));
+          for (const logs of participantLogs) {
+            ingestRunEvents(logs);
+            if (!needsMoreRuns())
+              break;
+          }
+        } catch {}
       }
       let runs = Array.from(runMap.values());
-      if (status && status !== "all") {
-        runs = runs.filter((run) => run.status === status);
+      if (statusFilter && statusFilter !== "all") {
+        runs = runs.filter((run) => run.status === statusFilter);
       }
       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
-        })
-      ]);
+      let actionLogs = [];
+      let evaluatorLogs = [];
+      let genericLogs = [];
+      if (runIdSet.size > 0) {
+        const logFetchCount = Math.max(200, limitNum * 50);
+        const [action, evaluator, generic] = await Promise.all([
+          runtime.getLogs({
+            entityId: agentId,
+            roomId: roomId ? roomId : undefined,
+            type: "action",
+            count: logFetchCount
+          }).catch(() => []),
+          runtime.getLogs({
+            entityId: agentId,
+            roomId: roomId ? roomId : undefined,
+            type: "evaluator",
+            count: logFetchCount
+          }).catch(() => []),
+          runtime.getLogs({
+            entityId: agentId,
+            roomId: roomId ? roomId : undefined,
+            count: logFetchCount
+          }).catch(() => [])
+        ]);
+        actionLogs = action;
+        evaluatorLogs = evaluator;
+        genericLogs = generic;
+      }
       const countsByRunId = {};
       for (const run of limitedRuns) {
         countsByRunId[run.runId] = { actions: 0, modelCalls: 0, errors: 0, evaluators: 0 };
@@ -23171,6 +23286,12 @@ function createAgentRunsRouter(elizaOS) {
         total: runs.length,
         hasMore: runs.length > limitNum
       };
+      if (cacheKey) {
+        runsCache.set(cacheKey, {
+          payload: response,
+          expiresAt: Date.now() + RUNS_CACHE_TTL
+        });
+      }
       sendSuccess(res, response);
     } catch (error) {
       sendError(res, 500, "RUNS_ERROR", "Error retrieving agent runs", error instanceof Error ? error.message : String(error));
@@ -23196,7 +23317,25 @@ function createAgentRunsRouter(elizaOS) {
         roomId: roomId ? roomId : undefined,
         count: 2000
       });
-      const related = logs.filter((l) => l.body.runId === runId);
+      const recentForDetail = await runtime.getMemories({
+        tableName: "messages",
+        roomId: roomId ? roomId : undefined,
+        count: 300
+      });
+      const detailAuthorIds = Array.from(new Set(recentForDetail.map((m) => m.entityId).filter((eid) => Boolean(eid) && eid !== agentId)));
+      const participantRunEvents = [];
+      for (const authorId of detailAuthorIds) {
+        try {
+          const rLogs = await runtime.getLogs({
+            entityId: authorId,
+            roomId: roomId ? roomId : undefined,
+            type: "run_event",
+            count: 2000
+          });
+          participantRunEvents.push(...rLogs);
+        } catch {}
+      }
+      const related = logs.concat(participantRunEvents).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];
@@ -27458,7 +27597,7 @@ import express30 from "express";
 // package.json
 var package_default = {
   name: "@elizaos/server",
-  version: "1.6.0-beta.1",
+  version: "1.6.1-alpha.1",
   description: "ElizaOS Server - Core server infrastructure for ElizaOS agents",
   publishConfig: {
     access: "public",

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@elizaos/server",
-  "version": "1.6.0-beta.1",
+  "version": "1.6.1-alpha.1",
   "description": "ElizaOS Server - Core server infrastructure for ElizaOS agents",
   "publishConfig": {
     "access": "public",
@@ -44,7 +44,7 @@
     "dev": "bun run build.ts --watch"
   },
   "devDependencies": {
-    "@elizaos/client": "1.6.0-beta.1",
+    "@elizaos/client": "1.6.1-alpha.1",
     "@types/node": "^24.0.1",
     "prettier": "3.5.3",
     "tsx": "4.19.4",
@@ -52,10 +52,10 @@
     "which": "^4.0.0",
     "ws": "^8.18.0"
   },
-  "gitHead": "0432e28a2c39c59e34737a4bd0ca67b3290b7334",
+  "gitHead": "d7b2569dc9bb3b51e140b20d90ac4c22a4c9400e",
   "dependencies": {
-    "@elizaos/core": "1.6.0-beta.1",
-    "@elizaos/plugin-sql": "1.6.0-beta.1",
+    "@elizaos/core": "1.6.1-alpha.1",
+    "@elizaos/plugin-sql": "1.6.1-alpha.1",
     "@sentry/node": "^10.11.0",
     "@types/express": "^5.0.2",
     "@types/helmet": "^4.0.0",