@elizaos/core 1.6.5-alpha.20 → 1.6.5-alpha.22

package/dist/node/index.node.js

@@ -26501,9 +26501,10 @@ function _mergeDicts(left = {}, right = {}) {
         "name",
         "output_version",
         "model_provider"
-      ].includes(key))
-        merged[key] = value;
-      else
+      ].includes(key)) {
+        if (value)
+          merged[key] = value;
+      } else
         merged[key] += value;
     else if (typeof merged[key] === "object" && !Array.isArray(merged[key]))
       merged[key] = _mergeDicts(merged[key], value);
@@ -26695,47 +26696,227 @@ function isToolMessageChunk(x) {
 }
 
 // ../../node_modules/@langchain/core/dist/utils/json.js
-function parsePartialJson(s) {
-  if (typeof s === "undefined")
-    return null;
+function strictParsePartialJson(s) {
   try {
     return JSON.parse(s);
   } catch {}
-  let new_s = "";
-  const stack = [];
-  let isInsideString = false;
-  let escaped = false;
-  for (let char of s) {
-    if (isInsideString)
-      if (char === '"' && !escaped)
-        isInsideString = false;
-      else if (char === `
-` && !escaped)
-        char = "\\n";
-      else if (char === "\\")
-        escaped = !escaped;
-      else
+  const buffer = s.trim();
+  if (buffer.length === 0)
+    throw new Error("Unexpected end of JSON input");
+  let pos = 0;
+  function skipWhitespace() {
+    while (pos < buffer.length && /\s/.test(buffer[pos]))
+      pos += 1;
+  }
+  function parseString() {
+    if (buffer[pos] !== '"')
+      throw new Error(`Expected '"' at position ${pos}, got '${buffer[pos]}'`);
+    pos += 1;
+    let result = "";
+    let escaped = false;
+    while (pos < buffer.length) {
+      const char = buffer[pos];
+      if (escaped) {
+        if (char === "n")
+          result += `
+`;
+        else if (char === "t")
+          result += "\t";
+        else if (char === "r")
+          result += "\r";
+        else if (char === "\\")
+          result += "\\";
+        else if (char === '"')
+          result += '"';
+        else if (char === "b")
+          result += "\b";
+        else if (char === "f")
+          result += "\f";
+        else if (char === "/")
+          result += "/";
+        else if (char === "u") {
+          const hex = buffer.substring(pos + 1, pos + 5);
+          if (/^[0-9A-Fa-f]{0,4}$/.test(hex)) {
+            if (hex.length === 4)
+              result += String.fromCharCode(Number.parseInt(hex, 16));
+            else
+              result += `u${hex}`;
+            pos += hex.length;
+          } else
+            throw new Error(`Invalid unicode escape sequence '\\u${hex}' at position ${pos}`);
+        } else
+          throw new Error(`Invalid escape sequence '\\${char}' at position ${pos}`);
         escaped = false;
-    else if (char === '"') {
-      isInsideString = true;
-      escaped = false;
-    } else if (char === "{")
-      stack.push("}");
-    else if (char === "[")
-      stack.push("]");
-    else if (char === "}" || char === "]")
-      if (stack && stack[stack.length - 1] === char)
-        stack.pop();
-      else
-        return null;
-    new_s += char;
+      } else if (char === "\\")
+        escaped = true;
+      else if (char === '"') {
+        pos += 1;
+        return result;
+      } else
+        result += char;
+      pos += 1;
+    }
+    if (escaped)
+      result += "\\";
+    return result;
   }
-  if (isInsideString)
-    new_s += '"';
-  for (let i = stack.length - 1;i >= 0; i -= 1)
-    new_s += stack[i];
+  function parseNumber() {
+    const start = pos;
+    let numStr = "";
+    if (buffer[pos] === "-") {
+      numStr += "-";
+      pos += 1;
+    }
+    if (pos < buffer.length && buffer[pos] === "0") {
+      numStr += "0";
+      pos += 1;
+      if (buffer[pos] >= "0" && buffer[pos] <= "9")
+        throw new Error(`Invalid number at position ${start}`);
+    }
+    if (pos < buffer.length && buffer[pos] >= "1" && buffer[pos] <= "9")
+      while (pos < buffer.length && buffer[pos] >= "0" && buffer[pos] <= "9") {
+        numStr += buffer[pos];
+        pos += 1;
+      }
+    if (pos < buffer.length && buffer[pos] === ".") {
+      numStr += ".";
+      pos += 1;
+      while (pos < buffer.length && buffer[pos] >= "0" && buffer[pos] <= "9") {
+        numStr += buffer[pos];
+        pos += 1;
+      }
+    }
+    if (pos < buffer.length && (buffer[pos] === "e" || buffer[pos] === "E")) {
+      numStr += buffer[pos];
+      pos += 1;
+      if (pos < buffer.length && (buffer[pos] === "+" || buffer[pos] === "-")) {
+        numStr += buffer[pos];
+        pos += 1;
+      }
+      while (pos < buffer.length && buffer[pos] >= "0" && buffer[pos] <= "9") {
+        numStr += buffer[pos];
+        pos += 1;
+      }
+    }
+    if (numStr === "-")
+      return -0;
+    const num = Number.parseFloat(numStr);
+    if (Number.isNaN(num)) {
+      pos = start;
+      throw new Error(`Invalid number '${numStr}' at position ${start}`);
+    }
+    return num;
+  }
+  function parseValue() {
+    skipWhitespace();
+    if (pos >= buffer.length)
+      throw new Error(`Unexpected end of input at position ${pos}`);
+    const char = buffer[pos];
+    if (char === "{")
+      return parseObject();
+    if (char === "[")
+      return parseArray();
+    if (char === '"')
+      return parseString();
+    if ("null".startsWith(buffer.substring(pos, pos + 4))) {
+      pos += Math.min(4, buffer.length - pos);
+      return null;
+    }
+    if ("true".startsWith(buffer.substring(pos, pos + 4))) {
+      pos += Math.min(4, buffer.length - pos);
+      return true;
+    }
+    if ("false".startsWith(buffer.substring(pos, pos + 5))) {
+      pos += Math.min(5, buffer.length - pos);
+      return false;
+    }
+    if (char === "-" || char >= "0" && char <= "9")
+      return parseNumber();
+    throw new Error(`Unexpected character '${char}' at position ${pos}`);
+  }
+  function parseArray() {
+    if (buffer[pos] !== "[")
+      throw new Error(`Expected '[' at position ${pos}, got '${buffer[pos]}'`);
+    const arr = [];
+    pos += 1;
+    skipWhitespace();
+    if (pos >= buffer.length)
+      return arr;
+    if (buffer[pos] === "]") {
+      pos += 1;
+      return arr;
+    }
+    while (pos < buffer.length) {
+      skipWhitespace();
+      if (pos >= buffer.length)
+        return arr;
+      arr.push(parseValue());
+      skipWhitespace();
+      if (pos >= buffer.length)
+        return arr;
+      if (buffer[pos] === "]") {
+        pos += 1;
+        return arr;
+      } else if (buffer[pos] === ",") {
+        pos += 1;
+        continue;
+      }
+      throw new Error(`Expected ',' or ']' at position ${pos}, got '${buffer[pos]}'`);
+    }
+    return arr;
+  }
+  function parseObject() {
+    if (buffer[pos] !== "{")
+      throw new Error(`Expected '{' at position ${pos}, got '${buffer[pos]}'`);
+    const obj = {};
+    pos += 1;
+    skipWhitespace();
+    if (pos >= buffer.length)
+      return obj;
+    if (buffer[pos] === "}") {
+      pos += 1;
+      return obj;
+    }
+    while (pos < buffer.length) {
+      skipWhitespace();
+      if (pos >= buffer.length)
+        return obj;
+      const key = parseString();
+      skipWhitespace();
+      if (pos >= buffer.length)
+        return obj;
+      if (buffer[pos] !== ":")
+        throw new Error(`Expected ':' at position ${pos}, got '${buffer[pos]}'`);
+      pos += 1;
+      skipWhitespace();
+      if (pos >= buffer.length)
+        return obj;
+      obj[key] = parseValue();
+      skipWhitespace();
+      if (pos >= buffer.length)
+        return obj;
+      if (buffer[pos] === "}") {
+        pos += 1;
+        return obj;
+      } else if (buffer[pos] === ",") {
+        pos += 1;
+        continue;
+      }
+      throw new Error(`Expected ',' or '}' at position ${pos}, got '${buffer[pos]}'`);
+    }
+    return obj;
+  }
+  const value = parseValue();
+  skipWhitespace();
+  if (pos < buffer.length)
+    throw new Error(`Unexpected character '${buffer[pos]}' at position ${pos}`);
+  return value;
+}
+function parsePartialJson(s) {
   try {
-    return JSON.parse(new_s);
+    if (typeof s === "undefined")
+      return null;
+    return strictParsePartialJson(s);
   } catch {
     return null;
   }
@@ -27208,59 +27389,12 @@ var AIMessageChunk = class extends BaseMessageChunk {
         tool_call_chunks: [],
         usage_metadata: fields.usage_metadata !== undefined ? fields.usage_metadata : undefined
       };
-    else {
-      const toolCallChunks = fields.tool_call_chunks ?? [];
-      const groupedToolCallChunks = toolCallChunks.reduce((acc, chunk) => {
-        const matchedChunkIndex = acc.findIndex(([match]) => {
-          if ("id" in chunk && chunk.id && "index" in chunk && chunk.index !== undefined)
-            return chunk.id === match.id && chunk.index === match.index;
-          if ("id" in chunk && chunk.id)
-            return chunk.id === match.id;
-          if ("index" in chunk && chunk.index !== undefined)
-            return chunk.index === match.index;
-          return false;
-        });
-        if (matchedChunkIndex !== -1)
-          acc[matchedChunkIndex].push(chunk);
-        else
-          acc.push([chunk]);
-        return acc;
-      }, []);
-      const toolCalls = [];
-      const invalidToolCalls = [];
-      for (const chunks of groupedToolCallChunks) {
-        let parsedArgs = null;
-        const name = chunks[0]?.name ?? "";
-        const joinedArgs = chunks.map((c) => c.args || "").join("");
-        const argsStr = joinedArgs.length ? joinedArgs : "{}";
-        const id = chunks[0]?.id;
-        try {
-          parsedArgs = parsePartialJson(argsStr);
-          if (!id || parsedArgs === null || typeof parsedArgs !== "object" || Array.isArray(parsedArgs))
-            throw new Error("Malformed tool call chunk args.");
-          toolCalls.push({
-            name,
-            args: parsedArgs,
-            id,
-            type: "tool_call"
-          });
-        } catch {
-          invalidToolCalls.push({
-            name,
-            args: argsStr,
-            id,
-            error: "Malformed args.",
-            type: "invalid_tool_call"
-          });
-        }
-      }
+    else
       initParams = {
         ...fields,
-        tool_calls: toolCalls,
-        invalid_tool_calls: invalidToolCalls,
+        ...collapseToolCallChunks(fields.tool_call_chunks ?? []),
         usage_metadata: fields.usage_metadata !== undefined ? fields.usage_metadata : undefined
       };
-    }
     super(initParams);
     this.tool_call_chunks = initParams.tool_call_chunks ?? this.tool_call_chunks;
     this.tool_calls = initParams.tool_calls ?? this.tool_calls;
@@ -27359,6 +27493,57 @@ function getBufferString(messages, humanPrefix = "Human", aiPrefix = "AI") {
   return string_messages.join(`
 `);
 }
+function collapseToolCallChunks(chunks) {
+  const groupedToolCallChunks = chunks.reduce((acc, chunk) => {
+    const matchedChunkIndex = acc.findIndex(([match]) => {
+      if ("id" in chunk && chunk.id && "index" in chunk && chunk.index !== undefined)
+        return chunk.id === match.id && chunk.index === match.index;
+      if ("id" in chunk && chunk.id)
+        return chunk.id === match.id;
+      if ("index" in chunk && chunk.index !== undefined)
+        return chunk.index === match.index;
+      return false;
+    });
+    if (matchedChunkIndex !== -1)
+      acc[matchedChunkIndex].push(chunk);
+    else
+      acc.push([chunk]);
+    return acc;
+  }, []);
+  const toolCalls = [];
+  const invalidToolCalls = [];
+  for (const chunks$1 of groupedToolCallChunks) {
+    let parsedArgs = null;
+    const name = chunks$1[0]?.name ?? "";
+    const joinedArgs = chunks$1.map((c) => c.args || "").join("").trim();
+    const argsStr = joinedArgs.length ? joinedArgs : "{}";
+    const id = chunks$1[0]?.id;
+    try {
+      parsedArgs = parsePartialJson(argsStr);
+      if (!id || parsedArgs === null || typeof parsedArgs !== "object" || Array.isArray(parsedArgs))
+        throw new Error("Malformed tool call chunk args.");
+      toolCalls.push({
+        name,
+        args: parsedArgs,
+        id,
+        type: "tool_call"
+      });
+    } catch {
+      invalidToolCalls.push({
+        name,
+        args: argsStr,
+        id,
+        error: "Malformed args.",
+        type: "invalid_tool_call"
+      });
+    }
+  }
+  return {
+    tool_call_chunks: chunks,
+    tool_calls: toolCalls,
+    invalid_tool_calls: invalidToolCalls
+  };
+}
 
 // ../../node_modules/@langchain/core/dist/utils/env.js
 var env_exports = {};
@@ -35825,7 +36010,7 @@ var EventStreamCallbackHandler = class extends BaseTracer {
   }
 };
 
-// ../../node_modules/is-network-error/index.js
+// ../../node_modules/@langchain/core/dist/utils/is-network-error/index.js
 var objectToString2 = Object.prototype.toString;
 var isError2 = (value) => objectToString2.call(value) === "[object Error]";
 var errorMessages2 = new Set([
@@ -35841,48 +36026,37 @@ var errorMessages2 = new Set([
 ]);
 function isNetworkError2(error) {
   const isValid = error && isError2(error) && error.name === "TypeError" && typeof error.message === "string";
-  if (!isValid) {
+  if (!isValid)
     return false;
-  }
   const { message, stack } = error;
-  if (message === "Load failed") {
+  if (message === "Load failed")
     return stack === undefined || "__sentry_captured__" in error;
-  }
-  if (message.startsWith("error sending request for url")) {
+  if (message.startsWith("error sending request for url"))
     return true;
-  }
   return errorMessages2.has(message);
 }
 
-// ../../node_modules/p-retry/index.js
+// ../../node_modules/@langchain/core/dist/utils/p-retry/index.js
 function validateRetries2(retries) {
   if (typeof retries === "number") {
-    if (retries < 0) {
+    if (retries < 0)
       throw new TypeError("Expected `retries` to be a non-negative number.");
-    }
-    if (Number.isNaN(retries)) {
+    if (Number.isNaN(retries))
       throw new TypeError("Expected `retries` to be a valid number or Infinity, got NaN.");
-    }
-  } else if (retries !== undefined) {
+  } else if (retries !== undefined)
     throw new TypeError("Expected `retries` to be a number or Infinity.");
-  }
 }
 function validateNumberOption2(name, value, { min = 0, allowInfinity = false } = {}) {
-  if (value === undefined) {
+  if (value === undefined)
     return;
-  }
-  if (typeof value !== "number" || Number.isNaN(value)) {
+  if (typeof value !== "number" || Number.isNaN(value))
     throw new TypeError(`Expected \`${name}\` to be a number${allowInfinity ? " or Infinity" : ""}.`);
-  }
-  if (!allowInfinity && !Number.isFinite(value)) {
+  if (!allowInfinity && !Number.isFinite(value))
     throw new TypeError(`Expected \`${name}\` to be a finite number.`);
-  }
-  if (value < min) {
+  if (value < min)
     throw new TypeError(`Expected \`${name}\` to be ≥ ${min}.`);
-  }
 }
-
-class AbortError2 extends Error {
+var AbortError2 = class extends Error {
   constructor(message) {
     super();
     if (message instanceof Error) {
@@ -35895,7 +36069,7 @@ class AbortError2 extends Error {
     this.name = "AbortError";
     this.message = message;
   }
-}
+};
 function calculateDelay2(retriesConsumed, options) {
   const attempt = Math.max(1, retriesConsumed + 1);
   const random = options.randomize ? Math.random() + 1 : 1;
@@ -35904,16 +36078,14 @@ function calculateDelay2(retriesConsumed, options) {
   return timeout;
 }
 function calculateRemainingTime2(start, max) {
-  if (!Number.isFinite(max)) {
+  if (!Number.isFinite(max))
     return max;
-  }
   return max - (performance.now() - start);
 }
 async function onAttemptFailure2({ error, attemptNumber, retriesConsumed, startTime, options }) {
-  const normalizedError = error instanceof Error ? error : new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`);
-  if (normalizedError instanceof AbortError2) {
+  const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`);
+  if (normalizedError instanceof AbortError2)
     throw normalizedError.originalError;
-  }
   const retriesLeft = Number.isFinite(options.retries) ? Math.max(0, options.retries - retriesConsumed) : options.retries;
   const maxRetryTime = options.maxRetryTime ?? Number.POSITIVE_INFINITY;
   const context = Object.freeze({
@@ -35923,31 +36095,27 @@ async function onAttemptFailure2({ error, attemptNumber, retriesConsumed, startT
     retriesConsumed
   });
   await options.onFailedAttempt(context);
-  if (calculateRemainingTime2(startTime, maxRetryTime) <= 0) {
+  if (calculateRemainingTime2(startTime, maxRetryTime) <= 0)
     throw normalizedError;
-  }
   const consumeRetry = await options.shouldConsumeRetry(context);
   const remainingTime = calculateRemainingTime2(startTime, maxRetryTime);
-  if (remainingTime <= 0 || retriesLeft <= 0) {
+  if (remainingTime <= 0 || retriesLeft <= 0)
     throw normalizedError;
-  }
   if (normalizedError instanceof TypeError && !isNetworkError2(normalizedError)) {
-    if (consumeRetry) {
+    if (consumeRetry)
       throw normalizedError;
-    }
     options.signal?.throwIfAborted();
     return false;
   }
-  if (!await options.shouldRetry(context)) {
+  if (!await options.shouldRetry(context))
     throw normalizedError;
-  }
   if (!consumeRetry) {
     options.signal?.throwIfAborted();
     return false;
   }
   const delayTime = calculateDelay2(retriesConsumed, options);
   const finalDelay = Math.min(delayTime, remainingTime);
-  if (finalDelay > 0) {
+  if (finalDelay > 0)
     await new Promise((resolve, reject) => {
       const onAbort = () => {
         clearTimeout(timeoutToken);
@@ -35958,21 +36126,18 @@ async function onAttemptFailure2({ error, attemptNumber, retriesConsumed, startT
         options.signal?.removeEventListener("abort", onAbort);
         resolve();
       }, finalDelay);
-      if (options.unref) {
+      if (options.unref)
         timeoutToken.unref?.();
-      }
       options.signal?.addEventListener("abort", onAbort, { once: true });
     });
-  }
   options.signal?.throwIfAborted();
   return true;
 }
 async function pRetry2(input, options = {}) {
   options = { ...options };
   validateRetries2(options.retries);
-  if (Object.hasOwn(options, "forever")) {
+  if (Object.hasOwn(options, "forever"))
     throw new Error("The `forever` option is no longer supported. For many use-cases, you can set `retries: Infinity` instead.");
-  }
   options.retries ??= 10;
   options.factor ??= 2;
   options.minTimeout ??= 1000;
@@ -35982,13 +36147,24 @@ async function pRetry2(input, options = {}) {
   options.onFailedAttempt ??= () => {};
   options.shouldRetry ??= () => true;
   options.shouldConsumeRetry ??= () => true;
-  validateNumberOption2("factor", options.factor, { min: 0, allowInfinity: false });
-  validateNumberOption2("minTimeout", options.minTimeout, { min: 0, allowInfinity: false });
-  validateNumberOption2("maxTimeout", options.maxTimeout, { min: 0, allowInfinity: true });
-  validateNumberOption2("maxRetryTime", options.maxRetryTime, { min: 0, allowInfinity: true });
-  if (!(options.factor > 0)) {
+  validateNumberOption2("factor", options.factor, {
+    min: 0,
+    allowInfinity: false
+  });
+  validateNumberOption2("minTimeout", options.minTimeout, {
+    min: 0,
+    allowInfinity: false
+  });
+  validateNumberOption2("maxTimeout", options.maxTimeout, {
+    min: 0,
+    allowInfinity: true
+  });
+  validateNumberOption2("maxRetryTime", options.maxRetryTime, {
+    min: 0,
+    allowInfinity: true
+  });
+  if (!(options.factor > 0))
     options.factor = 1;
-  }
   options.signal?.throwIfAborted();
   let attemptNumber = 0;
   let retriesConsumed = 0;
@@ -36007,9 +36183,8 @@ async function pRetry2(input, options = {}) {
         retriesConsumed,
         startTime,
         options
-      })) {
+      }))
         retriesConsumed++;
-      }
     }
   }
   throw new Error("Retry attempts exhausted without throwing an error.");
@@ -36056,7 +36231,7 @@ var AsyncCaller2 = class {
     const PQueue = "default" in import_p_queue3.default ? import_p_queue3.default.default : import_p_queue3.default;
     this.queue = new PQueue({ concurrency: this.maxConcurrency });
   }
-  call(callable, ...args) {
+  async call(callable, ...args) {
     return this.queue.add(() => pRetry2(() => callable(...args).catch((error) => {
       if (error instanceof Error)
         throw error;
@@ -36161,6 +36336,10 @@ var _RootEventFilter = class {
     return include;
   }
 };
+var toBase64Url = (str) => {
+  const encoded = btoa(str);
+  return encoded.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+};
 
 // ../../node_modules/@langchain/core/dist/utils/types/zod.js
 import { $ZodNever, $ZodOptional, $ZodUnknown, _never, _unknown, clone, globalRegistry, parse as parse3, parseAsync, util } from "zod/v4/core";
@@ -36236,6 +36415,20 @@ function isZodArrayV4(obj) {
     return true;
   return false;
 }
+function isZodOptionalV4(obj) {
+  if (!isZodSchemaV4(obj))
+    return false;
+  if (typeof obj === "object" && obj !== null && "_zod" in obj && typeof obj._zod === "object" && obj._zod !== null && "def" in obj._zod && typeof obj._zod.def === "object" && obj._zod.def !== null && "type" in obj._zod.def && obj._zod.def.type === "optional")
+    return true;
+  return false;
+}
+function isZodNullableV4(obj) {
+  if (!isZodSchemaV4(obj))
+    return false;
+  if (typeof obj === "object" && obj !== null && "_zod" in obj && typeof obj._zod === "object" && obj._zod !== null && "def" in obj._zod && typeof obj._zod.def === "object" && obj._zod.def !== null && "type" in obj._zod.def && obj._zod.def.type === "nullable")
+    return true;
+  return false;
+}
 function interopZodObjectStrict(schema, recursive = false) {
   if (isZodSchemaV3(schema))
     return schema.strict();
@@ -36306,6 +36499,18 @@ function interopZodTransformInputSchemaImpl(schema, recursive, cache) {
           ...outputSchema._zod.def,
           element: elementSchema
         });
+      } else if (isZodOptionalV4(outputSchema)) {
+        const innerSchema = interopZodTransformInputSchemaImpl(outputSchema._zod.def.innerType, recursive, cache);
+        outputSchema = clone(outputSchema, {
+          ...outputSchema._zod.def,
+          innerType: innerSchema
+        });
+      } else if (isZodNullableV4(outputSchema)) {
+        const innerSchema = interopZodTransformInputSchemaImpl(outputSchema._zod.def.innerType, recursive, cache);
+        outputSchema = clone(outputSchema, {
+          ...outputSchema._zod.def,
+          innerType: innerSchema
+        });
       }
     }
     const meta = globalRegistry.get(schema);
@@ -36414,7 +36619,7 @@ graph TD;
 async function drawMermaidImage(mermaidSyntax, config) {
   let backgroundColor = config?.backgroundColor ?? "white";
   const imageType = config?.imageType ?? "png";
-  const mermaidSyntaxEncoded = btoa(mermaidSyntax);
+  const mermaidSyntaxEncoded = toBase64Url(mermaidSyntax);
   if (backgroundColor !== undefined) {
     const hexColorPattern = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
     if (!hexColorPattern.test(backgroundColor))
@@ -49660,17 +49865,26 @@ class ElizaOS extends EventTarget {
   initFunctions = new Map;
   editableMode = false;
   async addAgents(agents, options) {
+    const createdRuntimes = [];
     const promises = agents.map(async (agent) => {
       const character = agent.character;
       await setDefaultSecretsFromEnv(character, { skipEnvMerge: options?.isTestMode });
-      const resolvedPlugins = agent.plugins ? await resolvePlugins(agent.plugins, options?.isTestMode || false) : [];
+      let resolvedPlugins = agent.plugins ? await resolvePlugins(agent.plugins, options?.isTestMode || false) : [];
+      if (agent.databaseAdapter) {
+        resolvedPlugins = resolvedPlugins.filter((p) => p.name !== "@elizaos/plugin-sql");
+      }
       const runtime = new AgentRuntime({
         character,
         plugins: resolvedPlugins,
         settings: agent.settings || {}
       });
+      if (agent.databaseAdapter) {
+        runtime.registerDatabaseAdapter(agent.databaseAdapter);
+      }
       runtime.elizaOS = this;
-      this.runtimes.set(runtime.agentId, runtime);
+      if (!options?.ephemeral) {
+        this.runtimes.set(runtime.agentId, runtime);
+      }
       if (typeof agent.init === "function") {
         this.initFunctions.set(runtime.agentId, agent.init);
       }
@@ -49682,15 +49896,33 @@ class ElizaOS extends EventTarget {
           character: {
             ...characterWithoutSecrets,
             settings: settingsWithoutSecrets
-          }
+          },
+          ephemeral: options?.ephemeral
         }
       }));
+      createdRuntimes.push(runtime);
       return runtime.agentId;
     });
     const ids = await Promise.all(promises);
+    if (options?.autoStart) {
+      await Promise.all(createdRuntimes.map(async (runtime) => {
+        await runtime.initialize({ skipMigrations: options?.skipMigrations });
+        const initFn = this.initFunctions.get(runtime.agentId);
+        if (initFn) {
+          await initFn(runtime);
+          this.initFunctions.delete(runtime.agentId);
+        }
+        this.dispatchEvent(new CustomEvent("agent:started", {
+          detail: { agentId: runtime.agentId }
+        }));
+      }));
+    }
     this.dispatchEvent(new CustomEvent("agents:added", {
-      detail: { agentIds: ids, count: ids.length }
+      detail: { agentIds: ids, count: ids.length, ephemeral: options?.ephemeral }
     }));
+    if (options?.returnRuntimes) {
+      return createdRuntimes;
+    }
     return ids;
   }
   registerAgent(runtime) {
@@ -49790,10 +50022,18 @@ class ElizaOS extends EventTarget {
   getAgentByCharacterId(characterId) {
     return this.getAgents().find((runtime) => runtime.character.id === characterId);
   }
-  async sendMessage(agentId, message, options) {
-    const runtime = this.runtimes.get(agentId);
-    if (!runtime) {
-      throw new Error(`Agent ${agentId} not found`);
+  async sendMessage(target, message, options) {
+    let runtime;
+    let agentId;
+    if (typeof target === "string") {
+      agentId = target;
+      runtime = this.runtimes.get(agentId);
+      if (!runtime) {
+        throw new Error(`Agent ${agentId} not found in registry`);
+      }
+    } else {
+      runtime = target;
+      agentId = runtime.agentId;
     }
     if (!runtime.messageService) {
       throw new Error("messageService is not initialized on runtime");
@@ -49854,13 +50094,13 @@ class ElizaOS extends EventTarget {
       }));
       return { messageId, userMessage };
     } else {
-      const result = await handleMessageWithEntityContext(() => runtime.messageService.handleMessage(runtime, userMessage, undefined, processingOptions));
+      const processing = await handleMessageWithEntityContext(() => runtime.messageService.handleMessage(runtime, userMessage, undefined, processingOptions));
       if (options?.onComplete)
         await options.onComplete();
       this.dispatchEvent(new CustomEvent("message:sent", {
-        detail: { agentId, messageId, mode: "sync", result }
+        detail: { agentId, messageId, mode: "sync", processing }
       }));
-      return { messageId, userMessage, result };
+      return { messageId, userMessage, processing };
     }
   }
   async sendMessages(messages) {
@@ -50325,5 +50565,5 @@ export {
   AgentRuntime
 };
 
-//# debugId=1AE99B04D756580C64756E2164756E21
+//# debugId=C89E737E05095B6864756E2164756E21
 //# sourceMappingURL=index.node.js.map