@elizaos/core 1.6.5-alpha.8 → 1.6.5-alpha.9

package/dist/node/index.node.js

@@ -46146,20 +46146,23 @@ class AgentRuntime {
     }
     if (plugin.services) {
       for (const service of plugin.services) {
-        if (!this.servicePromises.has(service.serviceType)) {
-          this._createServiceResolver(service.serviceType);
+        const serviceType = service.serviceType;
+        const serviceName = service.name || "Unknown";
+        this.logger.debug(`Plugin ${plugin.name} registering service: ${serviceType}`);
+        if (!this.servicePromises.has(serviceType)) {
+          this._createServiceResolver(serviceType);
         }
-        this.serviceRegistrationStatus.set(service.serviceType, "pending");
+        this.serviceRegistrationStatus.set(serviceType, "pending");
         this.registerService(service).catch((error) => {
-          this.logger.error(`Service registration failed for ${service.serviceType}: ${error instanceof Error ? error.message : String(error)}`);
-          const handler = this.servicePromiseHandlers.get(service.serviceType);
+          this.logger.error(`Plugin ${plugin.name} failed to register service ${serviceType}: ${error instanceof Error ? error.message : String(error)}`);
+          const handler = this.servicePromiseHandlers.get(serviceType);
           if (handler) {
-            const serviceError = new Error(`Service ${service.serviceType} failed to register: ${error instanceof Error ? error.message : String(error)}`);
+            const serviceError = new Error(`Service ${serviceType} from plugin ${plugin.name} failed to register: ${error instanceof Error ? error.message : String(error)}`);
             handler.reject(serviceError);
-            this.servicePromiseHandlers.delete(service.serviceType);
-            this.servicePromises.delete(service.serviceType);
+            this.servicePromiseHandlers.delete(serviceType);
+            this.servicePromises.delete(serviceType);
           }
-          this.serviceRegistrationStatus.set(service.serviceType, "failed");
+          this.serviceRegistrationStatus.set(serviceType, "failed");
         });
       }
     }
@@ -47209,11 +47212,12 @@ class AgentRuntime {
   }
   async registerService(serviceDef) {
     const serviceType = serviceDef.serviceType;
+    const serviceName = serviceDef.name || "Unknown";
     if (!serviceType) {
-      this.logger.warn(`Service ${serviceDef.name} is missing serviceType. Please define a static serviceType property.`);
+      this.logger.warn(`Service ${serviceName} is missing serviceType. Please define a static serviceType property.`);
       return;
     }
-    this.logger.debug(`${this.character.name}(${this.agentId}) - Registering service:`, serviceType);
+    this.logger.info(`Registering service: ${serviceType}`);
     this.serviceRegistrationStatus.set(serviceType, "registering");
     try {
       this.logger.debug(`Service ${serviceType} waiting for initialization...`);
@@ -47223,8 +47227,13 @@ class AgentRuntime {
         }, 30000);
       });
       await Promise.race([this.initPromise, initTimeout]);
-      this.logger.debug(`Service ${serviceType} proceeding - initialization complete`);
+      if (typeof serviceDef.start !== "function") {
+        throw new Error(`Service ${serviceType} does not have a static start method. All services must implement static async start(runtime: IAgentRuntime): Promise<Service>.`);
+      }
       const serviceInstance = await serviceDef.start(this);
+      if (!serviceInstance) {
+        throw new Error(`Service ${serviceType}  start() method returned null or undefined. It must return a Service instance.`);
+      }
       if (!this.services.has(serviceType)) {
         this.services.set(serviceType, []);
       }
@@ -47244,14 +47253,26 @@ class AgentRuntime {
         serviceDef.registerSendHandlers(this, serviceInstance);
       }
       this.serviceRegistrationStatus.set(serviceType, "registered");
-      this.logger.debug(`${this.character.name}(${this.agentId}) - Service ${serviceType} registered successfully`);
+      this.logger.info(`Service ${serviceType} registered successfully`);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.logger.error(`${this.character.name}(${this.agentId}) - Failed to register service ${serviceType}: ${errorMessage}`);
+      const errorStack = error instanceof Error ? error.stack : undefined;
+      this.logger.error(`Failed to register service ${serviceType}: ${errorMessage}`);
       if (error?.message?.includes("timed out waiting for runtime initialization")) {
         this.logger.error(`Service ${serviceType} failed due to runtime initialization timeout. Check if runtime.initialize() is being called and completing successfully.`);
+      } else if (error?.message?.includes("Not implemented")) {
+        this.logger.error(`Service ${serviceType} failed because it does not implement the static start() method. ` + `All services must override the base Service.start() method. ` + `Add: static async start(runtime: IAgentRuntime): Promise<${serviceName}> { return new ${serviceName}(runtime); }`);
+        if (errorStack) {
+          this.logger.debug(`Stack trace: ${errorStack}`);
+        }
       } else if (error?.message?.includes("Service") && error?.message?.includes("failed to start")) {
-        this.logger.error(`Service ${serviceType} failed to start. Check service implementation and dependencies.`);
+        this.logger.error(`Service ${serviceType} (${serviceName}) failed to start. Check service implementation and dependencies.`);
+      } else if (error?.message?.includes("does not have a static start method")) {
+        this.logger.error(`Service ${serviceType} (${serviceName}) is missing required static start() method implementation.`);
+      } else {
+        if (errorStack) {
+          this.logger.debug(`Service ${serviceType} (${serviceName}) error stack: ${errorStack}`);
+        }
       }
       this.serviceRegistrationStatus.set(serviceType, "failed");
       const handler = this.servicePromiseHandlers.get(serviceType);
@@ -47375,8 +47396,25 @@ class AgentRuntime {
       const errorMsg = `No handler found for delegate type: ${modelKey}`;
       throw new Error(errorMsg);
     }
-    this.logger.debug(`[useModel] ${modelKey} input: ` + JSON.stringify(params, safeReplacer(), 2).replace(/\\n/g, `
+    const binaryModels = [ModelType.TRANSCRIPTION, ModelType.IMAGE, ModelType.AUDIO, ModelType.VIDEO];
+    if (!binaryModels.includes(modelKey)) {
+      this.logger.debug(`[useModel] ${modelKey} input: ` + JSON.stringify(params, safeReplacer(), 2).replace(/\\n/g, `
 `));
+    } else {
+      let sizeInfo = "unknown size";
+      if (Buffer.isBuffer(params)) {
+        sizeInfo = `${params.length} bytes`;
+      } else if (typeof Blob !== "undefined" && params instanceof Blob) {
+        sizeInfo = `${params.size} bytes`;
+      } else if (typeof params === "object" && params !== null) {
+        if ("audio" in params && Buffer.isBuffer(params.audio)) {
+          sizeInfo = `${params.audio.length} bytes`;
+        } else if ("audio" in params && typeof Blob !== "undefined" && params.audio instanceof Blob) {
+          sizeInfo = `${params.audio.size} bytes`;
+        }
+      }
+      this.logger.debug(`[useModel] ${modelKey} input: <binary data: ${sizeInfo}>`);
+    }
     let modelParams;
     if (params === null || params === undefined || typeof params !== "object" || Array.isArray(params) || BufferUtils.isBuffer(params)) {
       modelParams = params;
@@ -48491,42 +48529,74 @@ async function loadAndPreparePlugin(pluginName) {
     return null;
   }
 }
+function normalizePluginName(pluginName) {
+  const scopedMatch = pluginName.match(/^@[^/]+\/plugin-(.+)$/);
+  if (scopedMatch) {
+    return scopedMatch[1];
+  }
+  return pluginName;
+}
 function resolvePluginDependencies(availablePlugins, isTestMode = false) {
   const resolutionOrder = [];
   const visited = new Set;
   const visiting = new Set;
+  const lookupMap = new Map;
+  for (const [key, plugin] of availablePlugins.entries()) {
+    lookupMap.set(key, plugin);
+    if (plugin.name !== key) {
+      lookupMap.set(plugin.name, plugin);
+    }
+    if (!plugin.name.startsWith("@")) {
+      lookupMap.set(`@elizaos/plugin-${plugin.name}`, plugin);
+    }
+    const normalizedKey = normalizePluginName(key);
+    if (normalizedKey !== key) {
+      lookupMap.set(normalizedKey, plugin);
+    }
+  }
   function visit(pluginName) {
-    if (!availablePlugins.has(pluginName)) {
-      logger.warn(`Plugin dependency "${pluginName}" not found and will be skipped.`);
-      return;
+    const plugin = lookupMap.get(pluginName);
+    if (!plugin) {
+      const normalizedName = normalizePluginName(pluginName);
+      const pluginByNormalized = lookupMap.get(normalizedName);
+      if (!pluginByNormalized) {
+        logger.warn(`Plugin dependency "${pluginName}" not found and will be skipped.`);
+        return;
+      }
+      return visit(pluginByNormalized.name);
     }
-    if (visited.has(pluginName))
+    const canonicalName = plugin.name;
+    if (visited.has(canonicalName))
       return;
-    if (visiting.has(pluginName)) {
-      logger.error(`Circular dependency detected involving plugin: ${pluginName}`);
+    if (visiting.has(canonicalName)) {
+      logger.error(`Circular dependency detected involving plugin: ${canonicalName}`);
       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) {
-        visit(dep);
-      }
+    visiting.add(canonicalName);
+    const deps = [...plugin.dependencies || []];
+    if (isTestMode) {
+      deps.push(...plugin.testDependencies || []);
+    }
+    for (const dep of deps) {
+      visit(dep);
     }
-    visiting.delete(pluginName);
-    visited.add(pluginName);
-    resolutionOrder.push(pluginName);
+    visiting.delete(canonicalName);
+    visited.add(canonicalName);
+    resolutionOrder.push(canonicalName);
   }
-  for (const name of availablePlugins.keys()) {
-    if (!visited.has(name)) {
-      visit(name);
+  for (const plugin of availablePlugins.values()) {
+    if (!visited.has(plugin.name)) {
+      visit(plugin.name);
     }
   }
-  const finalPlugins = resolutionOrder.map((name) => availablePlugins.get(name)).filter((p) => Boolean(p));
+  const finalPlugins = resolutionOrder.map((name) => {
+    for (const plugin of availablePlugins.values()) {
+      if (plugin.name === name) {
+        return plugin;
+      }
+    }
+    return null;
+  }).filter((p) => Boolean(p));
   logger.info({ plugins: finalPlugins.map((p) => p.name) }, `Final plugins being loaded:`);
   return finalPlugins;
 }
@@ -48541,26 +48611,33 @@ async function loadPlugin(nameOrPlugin) {
   }
   return nameOrPlugin;
 }
+function queueDependency(depName, seenDependencies, pluginMap, queue2) {
+  const normalizedDepName = normalizePluginName(depName);
+  const alreadyQueued = seenDependencies.has(depName) || seenDependencies.has(normalizedDepName) || Array.from(pluginMap.keys()).some((key) => normalizePluginName(key) === normalizedDepName) || Array.from(pluginMap.values()).some((p) => normalizePluginName(p.name) === normalizedDepName || p.name === depName || p.name === normalizedDepName);
+  if (!alreadyQueued) {
+    seenDependencies.add(depName);
+    seenDependencies.add(normalizedDepName);
+    queue2.push(depName);
+  }
+}
 async function resolvePluginsImpl(plugins, isTestMode = false) {
   const pluginMap = new Map;
   const queue2 = [...plugins];
+  const seenDependencies = new Set;
   while (queue2.length > 0) {
     const next = queue2.shift();
     const loaded = await loadPlugin(next);
     if (!loaded)
       continue;
-    if (!pluginMap.has(loaded.name)) {
-      pluginMap.set(loaded.name, loaded);
+    const canonicalName = loaded.name;
+    if (!pluginMap.has(canonicalName)) {
+      pluginMap.set(canonicalName, loaded);
       for (const depName of loaded.dependencies ?? []) {
-        if (!pluginMap.has(depName)) {
-          queue2.push(depName);
-        }
+        queueDependency(depName, seenDependencies, pluginMap, queue2);
       }
       if (isTestMode) {
         for (const depName of loaded.testDependencies ?? []) {
-          if (!pluginMap.has(depName)) {
-            queue2.push(depName);
-          }
+          queueDependency(depName, seenDependencies, pluginMap, queue2);
         }
       }
     }
@@ -49125,6 +49202,7 @@ export {
   parseCharacter,
   parseBooleanFromText2 as parseBooleanFromText,
   parseAndValidateCharacter,
+  normalizePluginName,
   normalizeJsonString,
   multiStepSummaryTemplate,
   multiStepDecisionTemplate,
@@ -49246,5 +49324,5 @@ export {
   AgentRuntime
 };
 
-//# debugId=E31A2F74693DFF0064756E2164756E21
+//# debugId=14B681AD83723C0164756E2164756E21
 //# sourceMappingURL=index.node.js.map