@elizaos/core 1.6.3-alpha.1 → 1.6.3-alpha.11

package/dist/node/index.node.js

@@ -42290,15 +42290,10 @@ function byteLength(buffer) {
   return buffer.length;
 }
 function randomBytes(size) {
-  if (hasNativeBuffer()) {
-    try {
-      const crypto = __require("crypto");
-      return crypto.randomBytes(size);
-    } catch {}
-  }
   const bytes = new Uint8Array(size);
-  if (typeof globalThis !== "undefined" && globalThis.crypto && globalThis.crypto.getRandomValues) {
-    globalThis.crypto.getRandomValues(bytes);
+  const cryptoGlobal = typeof globalThis !== "undefined" ? globalThis.crypto || globalThis.webcrypto : undefined;
+  if (cryptoGlobal && typeof cryptoGlobal.getRandomValues === "function") {
+    cryptoGlobal.getRandomValues(bytes);
   } else {
     for (let i = 0;i < size; i++) {
       bytes[i] = Math.floor(Math.random() * 256);
@@ -44980,8 +44975,8 @@ class AgentRuntime {
     const parentRunId = this.getCurrentRunId();
     const runId = this.createRunId();
     let actionPlan = null;
+    const thought = responses[0]?.content?.thought || `Executing ${allActions.length} actions: ${allActions.join(", ")}`;
     if (hasMultipleActions) {
-      const thought = responses[0]?.content?.thought || `Executing ${allActions.length} actions: ${allActions.join(", ")}`;
       actionPlan = {
         runId,
         totalSteps: allActions.length,
@@ -45120,7 +45115,7 @@ class AgentRuntime {
                 actionId,
                 runId,
                 type: "agent_action",
-                thought: actionPlan?.thought,
+                thought,
                 source: message.content?.source
               }
             });
@@ -45204,6 +45199,7 @@ class AgentRuntime {
                 actionStatus: statusText,
                 actionId,
                 type: "agent_action",
+                thought,
                 actionResult,
                 source: message.content?.source
               }
@@ -45344,6 +45340,10 @@ class AgentRuntime {
       }
     }
   }
+  getActionResults(messageId) {
+    const cachedState = this.stateCache?.get(`${messageId}_action_results`);
+    return cachedState?.data?.actionResults || [];
+  }
   async evaluate(message, state, didRespond, callback, responses) {
     try {
       const evaluatorPromises = this.evaluators.map(async (evaluator) => {
@@ -46562,8 +46562,51 @@ async function setDefaultSecretsFromEnv(character) {
 }
 
 // src/settings.ts
-var import_crypto_browserify = __toESM(require_crypto_browserify(), 1);
 init_environment();
+
+// src/utils/crypto-compat.ts
+function hasNodeCrypto() {
+  try {
+    return typeof process !== "undefined" && (process.versions?.node !== undefined || process.versions?.bun !== undefined);
+  } catch {
+    return false;
+  }
+}
+function getCryptoModule() {
+  if (hasNodeCrypto()) {
+    return __require("crypto");
+  }
+  return require_crypto_browserify();
+}
+function createHash(algorithm) {
+  const crypto = getCryptoModule();
+  const hash = crypto.createHash(algorithm);
+  return {
+    update(data2) {
+      hash.update(data2);
+      return this;
+    },
+    digest() {
+      return new Uint8Array(hash.digest());
+    }
+  };
+}
+function createCipheriv(algorithm, key, iv) {
+  if (algorithm !== "aes-256-cbc") {
+    throw new Error(`Unsupported algorithm: ${algorithm}. Only 'aes-256-cbc' is currently supported.`);
+  }
+  const crypto = getCryptoModule();
+  return crypto.createCipheriv(algorithm, key, iv);
+}
+function createDecipheriv(algorithm, key, iv) {
+  if (algorithm !== "aes-256-cbc") {
+    throw new Error(`Unsupported algorithm: ${algorithm}. Only 'aes-256-cbc' is currently supported.`);
+  }
+  const crypto = getCryptoModule();
+  return crypto.createDecipheriv(algorithm, key, iv);
+}
+
+// src/settings.ts
 function createSettingFromConfig(configSetting) {
   return {
     name: configSetting.name,
@@ -46628,9 +46671,9 @@ function encryptStringValue(value, salt) {
       }
     } catch (e) {}
   }
-  const key = import_crypto_browserify.default.createHash("sha256").update(salt).digest().slice(0, 32);
+  const key = createHash("sha256").update(salt).digest().slice(0, 32);
   const iv = BufferUtils.randomBytes(16);
-  const cipher = import_crypto_browserify.default.createCipheriv("aes-256-cbc", key, iv);
+  const cipher = createCipheriv("aes-256-cbc", key, iv);
   let encrypted = cipher.update(value, "utf8", "hex");
   encrypted += cipher.final("hex");
   return `${BufferUtils.toHex(iv)}:${encrypted}`;
@@ -46659,8 +46702,8 @@ function decryptStringValue(value, salt) {
       }
       return value;
     }
-    const key = import_crypto_browserify.default.createHash("sha256").update(salt).digest().slice(0, 32);
-    const decipher = import_crypto_browserify.default.createDecipheriv("aes-256-cbc", key, iv);
+    const key = createHash("sha256").update(salt).digest().slice(0, 32);
+    const decipher = createDecipheriv("aes-256-cbc", key, iv);
     let decrypted = decipher.update(encrypted, "hex", "utf8");
     decrypted += decipher.final("utf8");
     return decrypted;
@@ -47711,5 +47754,5 @@ export {
   AgentRuntime
 };
 
-//# debugId=738C38AE1C103AEB64756E2164756E21
+//# debugId=9B89E2D616BB564964756E2164756E21
 //# sourceMappingURL=index.node.js.map