@elizaos/core 1.6.2-alpha.20 → 1.6.2-alpha.21

package/dist/node/index.node.js

@@ -43820,7 +43820,7 @@ class AgentRuntime {
   currentActionContext;
   maxWorkingMemoryEntries = 50;
   constructor(opts) {
-    this.agentId = opts.character?.id ?? opts?.agentId ?? stringToUuid(opts.character?.name ?? v4_default() + opts.character?.username);
+    this.agentId = opts.character?.id ?? opts?.agentId ?? stringToUuid(opts.character?.name ?? v4_default());
     this.character = opts.character;
     this.initPromise = new Promise((resolve, reject) => {
       this.initResolver = resolve;
@@ -43986,9 +43986,12 @@ class AgentRuntime {
       this.logger.info("Running plugin migrations...");
       await this.runPluginMigrations();
       this.logger.info("Plugin migrations completed.");
-      const existingAgent = await this.ensureAgentExists(this.character);
+      const existingAgent = await this.ensureAgentExists({
+        ...this.character,
+        id: this.agentId
+      });
       if (!existingAgent) {
-        const errorMsg = `Agent ${this.character.name} does not exist in database after ensureAgentExists call`;
+        const errorMsg = `Agent ${this.agentId} does not exist in database after ensureAgentExists call`;
         throw new Error(errorMsg);
       }
       let agentEntity = await this.getEntityById(this.agentId);
@@ -44536,42 +44539,56 @@ class AgentRuntime {
     }
   }
   async evaluate(message, state, didRespond, callback, responses) {
-    const evaluatorPromises = this.evaluators.map(async (evaluator) => {
-      if (!evaluator.handler) {
-        return null;
-      }
-      if (!didRespond && !evaluator.alwaysRun) {
-        return null;
-      }
-      const result = await evaluator.validate(this, message, state);
-      if (result) {
-        return evaluator;
+    try {
+      const evaluatorPromises = this.evaluators.map(async (evaluator) => {
+        try {
+          if (!evaluator.handler) {
+            return null;
+          }
+          if (!didRespond && !evaluator.alwaysRun) {
+            return null;
+          }
+          const result = await evaluator.validate(this, message, state);
+          if (result) {
+            return evaluator;
+          }
+          return null;
+        } catch (error) {
+          this.logger.error({ error, evaluatorName: evaluator.name }, `Error validating evaluator ${evaluator.name}`);
+          return null;
+        }
+      });
+      const evaluators = (await Promise.all(evaluatorPromises)).filter(Boolean);
+      if (evaluators.length === 0) {
+        return [];
       }
-      return null;
-    });
-    const evaluators = (await Promise.all(evaluatorPromises)).filter(Boolean);
-    if (evaluators.length === 0) {
+      state = await this.composeState(message, ["RECENT_MESSAGES", "EVALUATORS"]);
+      await Promise.all(evaluators.map(async (evaluator) => {
+        try {
+          if (evaluator.handler) {
+            await evaluator.handler(this, message, state, {}, callback, responses);
+            this.adapter.log({
+              entityId: message.entityId,
+              roomId: message.roomId,
+              type: "evaluator",
+              body: {
+                evaluator: evaluator.name,
+                messageId: message.id,
+                message: message.content.text,
+                state,
+                runId: this.getCurrentRunId()
+              }
+            });
+          }
+        } catch (error) {
+          this.logger.error({ error, evaluatorName: evaluator.name }, `Error executing evaluator ${evaluator.name}`);
+        }
+      }));
+      return evaluators;
+    } catch (error) {
+      this.logger.error({ error, messageId: message.id, roomId: message.roomId }, "Error in evaluate method");
       return [];
     }
-    state = await this.composeState(message, ["RECENT_MESSAGES", "EVALUATORS"]);
-    await Promise.all(evaluators.map(async (evaluator) => {
-      if (evaluator.handler) {
-        await evaluator.handler(this, message, state, {}, callback, responses);
-        this.adapter.log({
-          entityId: message.entityId,
-          roomId: message.roomId,
-          type: "evaluator",
-          body: {
-            evaluator: evaluator.name,
-            messageId: message.id,
-            message: message.content.text,
-            state,
-            runId: this.getCurrentRunId()
-          }
-        });
-      }
-    }));
-    return evaluators;
   }
   async ensureConnections(entities, rooms, source, world) {
     if (!entities) {
@@ -45307,34 +45324,33 @@ ${input}`;
     return await this.adapter.deleteAgent(agentId);
   }
   async ensureAgentExists(agent) {
-    if (!agent.name) {
-      throw new Error("Agent name is required");
+    if (!agent.id) {
+      throw new Error("Agent id is required");
     }
-    const agents = await this.adapter.getAgents();
-    const existingAgentId = agents.find((a) => a.name === agent.name)?.id;
-    if (existingAgentId) {
+    const existingAgent = await this.adapter.getAgent(agent.id);
+    if (existingAgent) {
       const updatedAgent = {
         ...agent,
-        id: existingAgentId,
+        id: agent.id,
         updatedAt: Date.now()
       };
-      await this.adapter.updateAgent(existingAgentId, updatedAgent);
-      const existingAgent = await this.adapter.getAgent(existingAgentId);
-      if (!existingAgent) {
-        throw new Error(`Failed to retrieve agent after update: ${existingAgentId}`);
+      await this.adapter.updateAgent(agent.id, updatedAgent);
+      const refreshedAgent = await this.adapter.getAgent(agent.id);
+      if (!refreshedAgent) {
+        throw new Error(`Failed to retrieve agent after update: ${agent.id}`);
       }
-      this.logger.debug(`Updated existing agent ${agent.name} on restart`);
-      return existingAgent;
+      this.logger.debug(`Updated existing agent ${agent.id} on restart`);
+      return refreshedAgent;
     }
     const newAgent = {
       ...agent,
-      id: stringToUuid(agent.name)
+      id: agent.id
     };
     const created = await this.adapter.createAgent(newAgent);
     if (!created) {
-      throw new Error(`Failed to create agent: ${agent.name}`);
+      throw new Error(`Failed to create agent: ${agent.id}`);
     }
-    this.logger.debug(`Created new agent ${agent.name}`);
+    this.logger.debug(`Created new agent ${agent.id}`);
     return newAgent;
   }
   async getEntityById(entityId) {
@@ -46928,5 +46944,5 @@ export {
   AgentRuntime
 };
 
-//# debugId=5D467EA1E4701BE864756E2164756E21
+//# debugId=4E1D16D9C214CAAC64756E2164756E21
 //# sourceMappingURL=index.node.js.map