@elizaos/agent 0.25.8 → 0.25.9

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@elizaos/agent",
-    "version": "0.25.8",
+    "version": "0.25.9",
     "main": "src/index.ts",
     "type": "module",
     "scripts": {
@@ -18,19 +18,19 @@
         "exec": "node --enable-source-maps --loader ts-node/esm src/index.ts"
     },
     "dependencies": {
-        "@elizaos/client-direct": "0.25.8",
-        "@elizaos/core": "0.25.8",
-        "@elizaos/plugin-bootstrap": "0.25.8",
-        "readline": "1.3.0",
-        "ws": "8.18.0",
+        "@elizaos/client-direct": "0.25.9",
+        "@elizaos/core": "0.25.9",
+        "@elizaos/plugin-bootstrap": "0.25.9",
+        "@types/node": "^22.13.5",
+        "json5": "2.2.3",
+        "ts-node": "^10.9.2",
         "yargs": "17.7.2"
     },
     "devDependencies": {
+        "@jest/globals": "^29.7.0",
         "@types/jest": "^29.5.14",
         "jest": "^29.7.0",
-        "ts-jest": "^29.2.5",
-        "ts-node": "10.9.2",
-        "tsup": "8.3.5"
+        "ts-jest": "^29.2.6"
     },
-    "gitHead": "c04f89aa880196967228c890fe16f852c0dd8b48"
+    "gitHead": "2c06f567daea051fb3413b1fb83a3092f64544d1"
 }

package/src/defaultCharacter.ts

@@ -1,4 +1,4 @@
-import { Character, ModelProviderName } from "@elizaos/core";
+import { type Character, ModelProviderName } from "@elizaos/core";
 
 export const defaultCharacter: Character = {
     name: "Eliza",

package/src/index.ts

@@ -4,6 +4,7 @@ import {
     AgentRuntime,
     CacheManager,
     CacheStore,
+    type Plugin,
     type Character,
     type ClientInstance,
     DbCacheAdapter,
@@ -21,6 +22,7 @@ import {
 import { defaultCharacter } from "./defaultCharacter.ts";
 
 import { bootstrapPlugin } from "@elizaos/plugin-bootstrap";
+import JSON5 from 'json5';
 
 import fs from "fs";
 import net from "net";
@@ -62,7 +64,7 @@ export function parseArguments(): {
             })
             .parseSync();
     } catch (error) {
-        elizaLogger.error("Error parsing arguments:", error);
+        console.error("Error parsing arguments:", error);
         return {};
     }
 }
@@ -116,7 +118,7 @@ export async function loadCharacterFromOnchain(): Promise<Character[]> {
     if (!jsonText) return [];
     const loadedCharacters = [];
     try {
-        const character = JSON.parse(jsonText);
+        const character = JSON5.parse(jsonText);
         validateCharacterConfig(character);
 
         // .id isn't really valid
@@ -182,7 +184,7 @@ async function loadCharactersFromUrl(url: string): Promise<Character[]> {
         }
         return characters;
     } catch (e) {
-        elizaLogger.error(`Error loading character(s) from ${url}: ${e}`);
+        console.error(`Error loading character(s) from ${url}: `, e);
         process.exit(1);
     }
 }
@@ -213,6 +215,15 @@ async function jsonToCharacter(
     }
     // Handle plugins
     character.plugins = await handlePluginImporting(character.plugins);
+    elizaLogger.info(character.name, 'loaded plugins:', "[\n    " + character.plugins.map(p => `"${p.npmName}"`).join(", \n    ") + "\n]");
+
+    // Handle Post Processors plugins
+    if (character.postProcessors?.length > 0) {
+        elizaLogger.info(character.name, 'loading postProcessors', character.postProcessors);
+        character.postProcessors = await handlePluginImporting(character.postProcessors);
+    }
+
+    // Handle extends
     if (character.extends) {
         elizaLogger.info(
             `Merging  ${character.name} character with parent characters`
@@ -235,7 +246,7 @@ async function loadCharacter(filePath: string): Promise<Character> {
     if (!content) {
         throw new Error(`Character file not found: ${filePath}`);
     }
-    const character = JSON.parse(content);
+    const character = JSON5.parse(content);
     return jsonToCharacter(filePath, character);
 }
 
@@ -258,7 +269,7 @@ async function loadCharacterTryPath(characterPath: string): Promise<Character> {
         ), // relative to project root characters dir
     ];
 
-    elizaLogger.info(
+    elizaLogger.debug(
         "Trying paths:",
         pathsToTry.map((p) => ({
             path: p,
@@ -286,10 +297,10 @@ async function loadCharacterTryPath(characterPath: string): Promise<Character> {
     }
     try {
         const character: Character = await loadCharacter(resolvedPath);
-        elizaLogger.info(`Successfully loaded character from: ${resolvedPath}`);
+        elizaLogger.success(`Successfully loaded character from: ${resolvedPath}`);
         return character;
     } catch (e) {
-        elizaLogger.error(`Error parsing character from ${resolvedPath}: ${e}`);
+        console.error(`Error parsing character from ${resolvedPath}: `, e);
         throw new Error(`Error parsing character from ${resolvedPath}: ${e}`);
     }
 }
@@ -360,30 +371,35 @@ export async function loadCharacters(
 
 async function handlePluginImporting(plugins: string[]) {
     if (plugins.length > 0) {
-        elizaLogger.info("Plugins are: ", plugins);
+        // this logging should happen before calling, so we can include important context
+        //elizaLogger.info("Plugins are: ", plugins);
         const importedPlugins = await Promise.all(
             plugins.map(async (plugin) => {
                 try {
-                    const importedPlugin = await import(plugin);
+                    const importedPlugin:Plugin = await import(plugin);
                     const functionName =
                         plugin
                             .replace("@elizaos/plugin-", "")
                             .replace("@elizaos-plugins/plugin-", "")
                             .replace(/-./g, (x) => x[1].toUpperCase()) +
                         "Plugin"; // Assumes plugin function is camelCased with Plugin suffix
-                    return (
+                    if (!importedPlugin[functionName] && !importedPlugin.default) {
+                      elizaLogger.warn(plugin, 'does not have an default export or', functionName)
+                    }
+                    return {...(
                         importedPlugin.default || importedPlugin[functionName]
-                    );
+                    ), npmName: plugin };
                 } catch (importError) {
-                    elizaLogger.error(
+                    console.error(
                         `Failed to import plugin: ${plugin}`,
                         importError
                     );
-                    return []; // Return null for failed imports
+                    return false; // Return null for failed imports
                 }
             })
-        );
-        return importedPlugins;
+        )
+        // remove plugins that failed to load, so agent can try to start
+        return importedPlugins.filter(p => !!p);
     } else {
         return [];
     }
@@ -792,6 +808,26 @@ const hasValidRemoteUrls = () =>
     process.env.REMOTE_CHARACTER_URLS !== "" &&
     process.env.REMOTE_CHARACTER_URLS.startsWith("http");
 
+/**
+ * Post processing of character after loading
+ * @param character
+ */
+const handlePostCharacterLoaded = async (character: Character): Promise<Character> => {
+    let processedCharacter = character;
+    // Filtering the plugins with the method of handlePostCharacterLoaded
+    const processors = character?.postProcessors?.filter(p => typeof p.handlePostCharacterLoaded === 'function');
+    if (processors?.length > 0) {
+        processedCharacter = Object.assign({}, character, { postProcessors: undefined });
+        // process the character with each processor
+        // the order is important, so we loop through the processors
+        for (let i = 0; i < processors.length; i++) {
+            const processor = processors[i];
+            processedCharacter = await processor.handlePostCharacterLoaded(processedCharacter);
+        }
+    }
+    return processedCharacter;
+}
+
 const startAgents = async () => {
     const directClient = new DirectClient();
     let serverPort = Number.parseInt(settings.SERVER_PORT || "3000");
@@ -805,7 +841,8 @@ const startAgents = async () => {
 
     try {
         for (const character of characters) {
-            await startAgent(character, directClient);
+            const processedCharacter = await handlePostCharacterLoaded(character);
+            await startAgent(processedCharacter, directClient);
         }
     } catch (error) {
         elizaLogger.error("Error starting agents:", error);
@@ -824,9 +861,18 @@ const startAgents = async () => {
     directClient.startAgent = async (character) => {
         // Handle plugins
         character.plugins = await handlePluginImporting(character.plugins);
+        elizaLogger.info(character.name, 'loaded plugins:', '[' + character.plugins.map(p => `"${p.npmName}"`).join(', ') + ']');
+
+        // Handle Post Processors plugins
+        if (character.postProcessors?.length > 0) {
+            elizaLogger.info(character.name, 'loading postProcessors', character.postProcessors);
+            character.postProcessors = await handlePluginImporting(character.postProcessors);
+        }
+        // character's post processing
+        const processedCharacter = await handlePostCharacterLoaded(character);
 
         // wrap it so we don't have to inject directClient later
-        return startAgent(character, directClient);
+        return startAgent(processedCharacter, directClient);
     };
 
     directClient.loadCharacterTryPath = loadCharacterTryPath;
@@ -835,7 +881,7 @@ const startAgents = async () => {
     directClient.start(serverPort);
 
     if (serverPort !== Number.parseInt(settings.SERVER_PORT || "3000")) {
-        elizaLogger.log(`Server started on alternate port ${serverPort}`);
+        elizaLogger.warn(`Server started on alternate port ${serverPort}`);
     }
 
     elizaLogger.info(