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

package/dist/node/index.node.js

@@ -27300,9 +27300,45 @@ var _getFetchImplementation = (debug) => {
 var getDefaultProjectName = () => {
   return getLangSmithEnvironmentVariable("PROJECT") ?? getEnvironmentVariable2("LANGCHAIN_SESSION") ?? "default";
 };
+// ../../node_modules/langsmith/dist/utils/warn.js
+var warnedMessages = {};
+function warnOnce(message) {
+  if (!warnedMessages[message]) {
+    console.warn(message);
+    warnedMessages[message] = true;
+  }
+}
 
+// ../../node_modules/langsmith/dist/utils/_uuid.js
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var UUID7_WARNING_EMITTED = false;
+function assertUuid(str, which) {
+  if (!UUID_REGEX.test(str)) {
+    const msg = which !== undefined ? `Invalid UUID for ${which}: ${str}` : `Invalid UUID: ${str}`;
+    throw new Error(msg);
+  }
+  return str;
+}
+function uuid7FromTime(timestamp) {
+  const msecs = typeof timestamp === "string" ? Date.parse(timestamp) : timestamp;
+  return v72({ msecs, seq: 0 });
+}
+function getUuidVersion(uuidStr) {
+  if (!UUID_REGEX.test(uuidStr)) {
+    return null;
+  }
+  const versionChar = uuidStr[14];
+  return parseInt(versionChar, 16);
+}
+function warnIfNotUuidV7(uuidStr, _idType) {
+  const version3 = getUuidVersion(uuidStr);
+  if (version3 !== null && version3 !== 7 && !UUID7_WARNING_EMITTED) {
+    UUID7_WARNING_EMITTED = true;
+    warnOnce(`LangSmith now uses UUID v7 for run and trace identifiers. ` + `This warning appears when passing custom IDs. ` + `Please use: import { uuidv7 } from 'langsmith'; const id = uuidv7(); ` + `Future versions will require UUID v7.`);
+  }
+}
 // ../../node_modules/langsmith/dist/index.js
-var __version__ = "0.3.79";
+var __version__ = "0.3.80";
 
 // ../../node_modules/langsmith/dist/utils/env.js
 var globalEnv;
@@ -27914,6 +27950,12 @@ class AsyncCaller {
       writable: true,
       value: undefined
     });
+    Object.defineProperty(this, "maxQueueSizeBytes", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
     Object.defineProperty(this, "queue", {
       enumerable: true,
       configurable: true,
@@ -27926,8 +27968,15 @@ class AsyncCaller {
       writable: true,
       value: undefined
     });
+    Object.defineProperty(this, "queueSizeBytes", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: 0
+    });
     this.maxConcurrency = params.maxConcurrency ?? Infinity;
     this.maxRetries = params.maxRetries ?? 6;
+    this.maxQueueSizeBytes = params.maxQueueSizeBytes;
     if ("default" in import_p_queue.default) {
       this.queue = new import_p_queue.default.default({
         concurrency: this.maxConcurrency
@@ -27938,8 +27987,18 @@ class AsyncCaller {
     this.onFailedResponseHook = params?.onFailedResponseHook;
   }
   call(callable, ...args) {
+    return this.callWithOptions({}, callable, ...args);
+  }
+  callWithOptions(options, callable, ...args) {
+    const sizeBytes = options.sizeBytes ?? 0;
+    if (this.maxQueueSizeBytes !== undefined && sizeBytes > 0 && this.queueSizeBytes + sizeBytes > this.maxQueueSizeBytes) {
+      return Promise.reject(new Error(`Queue size limit (${this.maxQueueSizeBytes} bytes) exceeded. ` + `Current queue size: ${this.queueSizeBytes} bytes, attempted addition: ${sizeBytes} bytes.`));
+    }
+    if (sizeBytes > 0) {
+      this.queueSizeBytes += sizeBytes;
+    }
     const onFailedResponseHook = this.onFailedResponseHook;
-    return this.queue.add(() => import_p_retry.default(() => callable(...args).catch((error) => {
+    let promise = this.queue.add(() => import_p_retry.default(() => callable(...args).catch((error) => {
       if (error instanceof Error) {
         throw error;
       } else {
@@ -27970,11 +28029,14 @@ class AsyncCaller {
       retries: this.maxRetries,
       randomize: true
     }), { throwOnTimeout: true });
-  }
-  callWithOptions(options, callable, ...args) {
+    if (sizeBytes > 0) {
+      promise = promise.finally(() => {
+        this.queueSizeBytes -= sizeBytes;
+      });
+    }
     if (options.signal) {
       return Promise.race([
-        this.call(callable, ...args),
+        promise,
         new Promise((_, reject) => {
           options.signal?.addEventListener("abort", () => {
             reject(new Error("AbortError"));
@@ -27982,7 +28044,7 @@ class AsyncCaller {
         })
       ]);
     }
-    return this.call(callable, ...args);
+    return promise;
   }
 }
 
@@ -28001,25 +28063,6 @@ function convertLangChainMessageToExample(message) {
   return converted;
 }
 
-// ../../node_modules/langsmith/dist/utils/_uuid.js
-var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function assertUuid(str, which) {
-  if (!UUID_REGEX.test(str)) {
-    const msg = which !== undefined ? `Invalid UUID for ${which}: ${str}` : `Invalid UUID: ${str}`;
-    throw new Error(msg);
-  }
-  return str;
-}
-
-// ../../node_modules/langsmith/dist/utils/warn.js
-var warnedMessages = {};
-function warnOnce(message) {
-  if (!warnedMessages[message]) {
-    console.warn(message);
-    warnedMessages[message] = true;
-  }
-}
-
 // ../../node_modules/langsmith/dist/utils/prompts.js
 var import_semver = __toESM(require_semver2(), 1);
 function parsePromptIdentifier(identifier) {
@@ -28329,9 +28372,14 @@ function _formatFeedbackScore(score) {
   }
   return score;
 }
+var DEFAULT_UNCOMPRESSED_BATCH_SIZE_LIMIT_BYTES = 24 * 1024 * 1024;
+var DEFAULT_MAX_SIZE_BYTES = 1024 * 1024 * 1024;
+var SERVER_INFO_REQUEST_TIMEOUT_MS = 1e4;
+var DEFAULT_BATCH_SIZE_LIMIT = 100;
+var DEFAULT_API_URL = "https://api.smith.langchain.com";
 
 class AutoBatchQueue {
-  constructor() {
+  constructor(maxSizeBytes) {
     Object.defineProperty(this, "items", {
       enumerable: true,
       configurable: true,
@@ -28344,6 +28392,13 @@ class AutoBatchQueue {
       writable: true,
       value: 0
     });
+    Object.defineProperty(this, "maxSizeBytes", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
+    this.maxSizeBytes = maxSizeBytes ?? DEFAULT_MAX_SIZE_BYTES;
   }
   peek() {
     return this.items[0];
@@ -28354,6 +28409,11 @@ class AutoBatchQueue {
       itemPromiseResolve = resolve;
     });
     const size = serialize(item.item, `Serializing run with id: ${item.item.id}`).length;
+    if (this.sizeBytes + size > this.maxSizeBytes && this.items.length > 0) {
+      console.warn(`AutoBatchQueue size limit (${this.maxSizeBytes} bytes) exceeded. Dropping run with id: ${item.item.id}. ` + `Current queue size: ${this.sizeBytes} bytes, attempted addition: ${size} bytes.`);
+      itemPromiseResolve();
+      return itemPromise;
+    }
     this.items.push({
       action: item.action,
       payload: item.item,
@@ -28393,16 +28453,13 @@ class AutoBatchQueue {
         item: it.payload,
         otelContext: it.otelContext,
         apiKey: it.apiKey,
-        apiUrl: it.apiUrl
+        apiUrl: it.apiUrl,
+        size: it.size
       })),
       () => popped.forEach((it) => it.itemPromiseResolve())
     ];
   }
 }
-var DEFAULT_UNCOMPRESSED_BATCH_SIZE_LIMIT_BYTES = 24 * 1024 * 1024;
-var SERVER_INFO_REQUEST_TIMEOUT_MS = 1e4;
-var DEFAULT_BATCH_SIZE_LIMIT = 100;
-var DEFAULT_API_URL = "https://api.smith.langchain.com";
 
 class Client {
   get _fetch() {
@@ -28491,7 +28548,7 @@ class Client {
       enumerable: true,
       configurable: true,
       writable: true,
-      value: new AutoBatchQueue
+      value: undefined
     });
     Object.defineProperty(this, "autoBatchTimeout", {
       enumerable: true,
@@ -28613,9 +28670,11 @@ class Client {
     }
     this.debug = config.debug ?? this.debug;
     this.fetchImplementation = config.fetchImplementation;
+    const maxMemory = config.maxIngestMemoryBytes ?? DEFAULT_MAX_SIZE_BYTES;
     this.batchIngestCaller = new AsyncCaller({
-      maxRetries: 2,
+      maxRetries: 4,
       maxConcurrency: this.traceBatchConcurrency,
+      maxQueueSizeBytes: maxMemory,
       ...config.callerOptions ?? {},
       onFailedResponseHook: handle429,
       debug: config.debug ?? this.debug
@@ -28623,6 +28682,7 @@ class Client {
     this.hideInputs = config.hideInputs ?? config.anonymizer ?? defaultConfig.hideInputs;
     this.hideOutputs = config.hideOutputs ?? config.anonymizer ?? defaultConfig.hideOutputs;
     this.autoBatchTracing = config.autoBatchTracing ?? this.autoBatchTracing;
+    this.autoBatchQueue = new AutoBatchQueue(maxMemory);
     this.blockOnRootRunFinalization = config.blockOnRootRunFinalization ?? this.blockOnRootRunFinalization;
     this.batchSizeBytesLimit = config.batchSizeBytesLimit;
     this.batchSizeLimit = config.batchSizeLimit;
@@ -28893,6 +28953,7 @@ class Client {
     if (!batch.length) {
       return;
     }
+    const batchSizeBytes = batch.reduce((sum, item) => sum + (item.size ?? 0), 0);
     try {
       if (this.langSmithToOTELTranslator !== undefined) {
         this._sendBatchToOTELTranslator(batch);
@@ -28904,9 +28965,16 @@ class Client {
         const serverInfo = await this._ensureServerInfo();
         if (serverInfo?.batch_ingest_config?.use_multipart_endpoint) {
           const useGzip = serverInfo?.instance_flags?.gzip_body_enabled;
-          await this.multipartIngestRuns(ingestParams, { ...options, useGzip });
+          await this.multipartIngestRuns(ingestParams, {
+            ...options,
+            useGzip,
+            sizeBytes: batchSizeBytes
+          });
         } else {
-          await this.batchIngestRuns(ingestParams, options);
+          await this.batchIngestRuns(ingestParams, {
+            ...options,
+            sizeBytes: batchSizeBytes
+          });
         }
       }
     } catch (e) {
@@ -29140,7 +29208,7 @@ class Client {
     if (options?.apiKey !== undefined) {
       headers["x-api-key"] = options.apiKey;
     }
-    await this.batchIngestCaller.call(async () => {
+    await this.batchIngestCaller.callWithOptions({ sizeBytes: options?.sizeBytes }, async () => {
       const res = await this._fetch(`${options?.apiUrl ?? this.apiUrl}/runs/batch`, {
         method: "POST",
         headers,
@@ -29333,7 +29401,7 @@ class Client {
     const buildBuffered = () => this._createNodeFetchBody(parts, boundary);
     const buildStream = () => this._createMultipartStream(parts, boundary);
     const sendWithRetry = async (bodyFactory) => {
-      return this.batchIngestCaller.call(async () => {
+      return this.batchIngestCaller.callWithOptions({ sizeBytes: options?.sizeBytes }, async () => {
         const body = await bodyFactory();
         const headers = {
           ...this.headers,
@@ -31570,9 +31638,12 @@ var _LC_CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");
 function stripNonAlphanumeric(input) {
   return input.replace(/[-:.]/g, "");
 }
-function convertToDottedOrderFormat(epoch, runId, executionOrder = 1) {
+function getMicrosecondPrecisionDatestring(epoch, executionOrder = 1) {
   const paddedOrder = executionOrder.toFixed(0).slice(0, 3).padStart(3, "0");
-  const microsecondPrecisionDatestring = `${new Date(epoch).toISOString().slice(0, -1)}${paddedOrder}Z`;
+  return `${new Date(epoch).toISOString().slice(0, -1)}${paddedOrder}Z`;
+}
+function convertToDottedOrderFormat(epoch, runId, executionOrder = 1) {
+  const microsecondPrecisionDatestring = getMicrosecondPrecisionDatestring(epoch, executionOrder);
   return {
     dottedOrder: stripNonAlphanumeric(microsecondPrecisionDatestring) + runId,
     microsecondPrecisionDatestring
@@ -31820,24 +31891,37 @@ class RunTree {
       delete config.id;
     }
     Object.assign(this, { ...defaultConfig, ...config, client });
+    this.execution_order ??= 1;
+    this.child_execution_order ??= 1;
+    if (!this.dotted_order) {
+      this._serialized_start_time = getMicrosecondPrecisionDatestring(this.start_time, this.execution_order);
+    }
+    if (!this.id) {
+      this.id = uuid7FromTime(this._serialized_start_time ?? this.start_time);
+    }
+    if (config.id) {
+      warnIfNotUuidV7(config.id, "run_id");
+    }
     if (!this.trace_id) {
       if (this.parent_run) {
         this.trace_id = this.parent_run.trace_id ?? this.id;
       } else {
         this.trace_id = this.id;
       }
+    } else if (config.trace_id) {
+      warnIfNotUuidV7(config.trace_id, "trace_id");
+    }
+    if (config.parent_run_id) {
+      warnIfNotUuidV7(config.parent_run_id, "parent_run_id");
     }
     this.replicas = _ensureWriteReplicas(this.replicas);
-    this.execution_order ??= 1;
-    this.child_execution_order ??= 1;
     if (!this.dotted_order) {
-      const { dottedOrder, microsecondPrecisionDatestring } = convertToDottedOrderFormat(this.start_time, this.id, this.execution_order);
+      const { dottedOrder } = convertToDottedOrderFormat(this.start_time, this.id, this.execution_order);
       if (this.parent_run) {
         this.dotted_order = this.parent_run.dotted_order + "." + dottedOrder;
       } else {
         this.dotted_order = dottedOrder;
       }
-      this._serialized_start_time = microsecondPrecisionDatestring;
     }
   }
   set metadata(metadata) {
@@ -31853,15 +31937,15 @@ class RunTree {
     return this.extra?.metadata;
   }
   static getDefaultConfig() {
+    const start_time = Date.now();
     return {
-      id: v42(),
       run_type: "chain",
       project_name: getDefaultProjectName(),
       child_runs: [],
       api_url: getEnvironmentVariable2("LANGCHAIN_ENDPOINT") ?? "http://localhost:1984",
       api_key: getEnvironmentVariable2("LANGCHAIN_API_KEY"),
       caller_options: {},
-      start_time: Date.now(),
+      start_time,
       serialized: {},
       inputs: {},
       extra: {}
@@ -31965,39 +32049,10 @@ class RunTree {
   }
   _remapForProject(projectName, runtimeEnv, excludeChildRuns = true) {
     const baseRun = this._convertToCreate(this, runtimeEnv, excludeChildRuns);
-    if (projectName === this.project_name) {
-      return baseRun;
-    }
-    const createRemappedId = (originalId) => {
-      return v52(`${originalId}:${projectName}`, v52.DNS);
-    };
-    const newId = createRemappedId(baseRun.id);
-    const newTraceId = baseRun.trace_id ? createRemappedId(baseRun.trace_id) : undefined;
-    const newParentRunId = baseRun.parent_run_id ? createRemappedId(baseRun.parent_run_id) : undefined;
-    let newDottedOrder;
-    if (baseRun.dotted_order) {
-      const segments = _parseDottedOrder(baseRun.dotted_order);
-      const rebuilt = [];
-      for (let i = 0;i < segments.length - 1; i++) {
-        const [timestamp, segmentId] = segments[i];
-        const remappedId = createRemappedId(segmentId);
-        rebuilt.push(timestamp.toISOString().replace(/[-:]/g, "").replace(".", "") + remappedId);
-      }
-      const [lastTimestamp] = segments[segments.length - 1];
-      rebuilt.push(lastTimestamp.toISOString().replace(/[-:]/g, "").replace(".", "") + newId);
-      newDottedOrder = rebuilt.join(".");
-    } else {
-      newDottedOrder = undefined;
-    }
-    const remappedRun = {
+    return {
       ...baseRun,
-      id: newId,
-      trace_id: newTraceId,
-      parent_run_id: newParentRunId,
-      dotted_order: newDottedOrder,
       session_name: projectName
     };
-    return remappedRun;
   }
   async postRun(excludeChildRuns = true) {
     try {
@@ -32031,6 +32086,9 @@ class RunTree {
         const runData = this._remapForProject(projectName ?? this.project_name);
         const updatePayload = {
           id: runData.id,
+          name: runData.name,
+          run_type: runData.run_type,
+          start_time: runData.start_time,
           outputs: runData.outputs,
           error: runData.error,
           parent_run_id: runData.parent_run_id,
@@ -32057,6 +32115,9 @@ class RunTree {
     } else {
       try {
         const runUpdate = {
+          name: this.name,
+          run_type: this.run_type,
+          start_time: this._serialized_start_time ?? this.start_time,
           end_time: this.end_time,
           error: this.error,
           outputs: this.outputs,
@@ -32210,22 +32271,6 @@ function isCallbackManagerLike(x) {
 function isRunnableConfigLike(x) {
   return x != null && typeof x.callbacks === "object" && (containsLangChainTracerLike(x.callbacks?.handlers) || containsLangChainTracerLike(x.callbacks));
 }
-function _parseDottedOrder(dottedOrder) {
-  const parts = dottedOrder.split(".");
-  return parts.map((part) => {
-    const timestampStr = part.slice(0, -36);
-    const uuidStr = part.slice(-36);
-    const year = parseInt(timestampStr.slice(0, 4));
-    const month = parseInt(timestampStr.slice(4, 6)) - 1;
-    const day = parseInt(timestampStr.slice(6, 8));
-    const hour = parseInt(timestampStr.slice(9, 11));
-    const minute = parseInt(timestampStr.slice(11, 13));
-    const second = parseInt(timestampStr.slice(13, 15));
-    const microsecond = parseInt(timestampStr.slice(15, 21));
-    const timestamp = new Date(year, month, day, hour, minute, second, microsecond / 1000);
-    return [timestamp, uuidStr];
-  });
-}
 function _getWriteReplicasFromEnv() {
   const envVar = getEnvironmentVariable2("LANGSMITH_RUNS_ENDPOINTS");
   if (!envVar)
@@ -33790,7 +33835,9 @@ function patchConfig(config = {}, { callbacks, maxConcurrency, recursionLimit, r
   return newConfig;
 }
 function pickRunnableConfigKeys(config) {
-  return config ? {
+  if (!config)
+    return;
+  return {
     configurable: config.configurable,
     recursionLimit: config.recursionLimit,
     callbacks: config.callbacks,
@@ -33798,8 +33845,9 @@ function pickRunnableConfigKeys(config) {
     metadata: config.metadata,
     maxConcurrency: config.maxConcurrency,
     timeout: config.timeout,
-    signal: config.signal
-  } : undefined;
+    signal: config.signal,
+    store: config.store
+  };
 }
 
 // ../../node_modules/@langchain/core/dist/utils/signal.js
@@ -46098,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");
         });
       }
     }
@@ -47161,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...`);
@@ -47175,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, []);
       }
@@ -47196,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);
@@ -47327,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;
@@ -47943,23 +48029,21 @@ async function loadSecretsNodeImpl(character) {
   if (!character.settings) {
     character.settings = {};
   }
-  const existingSettings = { ...character.settings };
   const existingSecrets = character.settings.secrets && typeof character.settings.secrets === "object" ? { ...character.settings.secrets } : {};
-  character.settings = {
-    ...envVars,
-    ...existingSettings
-  };
   character.settings.secrets = {
     ...envVars,
     ...existingSecrets
   };
   return true;
 }
-async function setDefaultSecretsFromEnv(character) {
+async function setDefaultSecretsFromEnv(character, options) {
   const env2 = detectEnvironment();
   if (env2 !== "node") {
     return false;
   }
+  if (options?.skipEnvMerge) {
+    return false;
+  }
   return loadSecretsNodeImpl(character);
 }
 
@@ -48445,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 || []);
     }
-    visiting.delete(pluginName);
-    visited.add(pluginName);
-    resolutionOrder.push(pluginName);
+    for (const dep of deps) {
+      visit(dep);
+    }
+    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;
 }
@@ -48495,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);
         }
       }
     }
@@ -48545,7 +48668,7 @@ class ElizaOS extends EventTarget {
   async addAgents(agents, options) {
     const promises = agents.map(async (agent) => {
       const character = agent.character;
-      await setDefaultSecretsFromEnv(character);
+      await setDefaultSecretsFromEnv(character, { skipEnvMerge: options?.isTestMode });
       const resolvedPlugins = agent.plugins ? await resolvePlugins(agent.plugins, options?.isTestMode || false) : [];
       const runtime = new AgentRuntime({
         character,
@@ -49079,6 +49202,7 @@ export {
   parseCharacter,
   parseBooleanFromText2 as parseBooleanFromText,
   parseAndValidateCharacter,
+  normalizePluginName,
   normalizeJsonString,
   multiStepSummaryTemplate,
   multiStepDecisionTemplate,
@@ -49200,5 +49324,5 @@ export {
   AgentRuntime
 };
 
-//# debugId=8BDA0F1B9BD79A0864756E2164756E21
+//# debugId=14B681AD83723C0164756E2164756E21
 //# sourceMappingURL=index.node.js.map