@elizaos/core 1.6.4 → 1.6.5-alpha.2

package/dist/node/index.node.js

@@ -25,7 +25,6 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../node_modules/retry/lib/retry_operation.js
@@ -9834,217 +9833,6 @@ Length provided: ${this.length}. Number of dictionaries provided: ${this.diction
   };
 });
 
-// src/utils/environment.ts
-var exports_environment = {};
-__export(exports_environment, {
-  setEnv: () => setEnv,
-  loadEnvConfig: () => loadEnvConfig,
-  initBrowserEnvironment: () => initBrowserEnvironment,
-  hasEnv: () => hasEnv,
-  getNumberEnv: () => getNumberEnv,
-  getEnvironment: () => getEnvironment,
-  getEnv: () => getEnv3,
-  getBooleanEnv: () => getBooleanEnv,
-  findEnvFile: () => findEnvFile,
-  detectEnvironment: () => detectEnvironment,
-  currentRuntime: () => currentRuntime,
-  Environment: () => Environment
-});
-function detectEnvironment() {
-  if (typeof process !== "undefined" && process.versions && process.versions.node) {
-    return "node";
-  }
-  if (typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined" && typeof globalThis.window.document !== "undefined") {
-    return "browser";
-  }
-  return "unknown";
-}
-
-class BrowserEnvironmentStore {
-  store = {};
-  constructor() {
-    if (typeof globalThis !== "undefined" && globalThis.window && globalThis.window.ENV) {
-      this.store = { ...globalThis.window.ENV };
-    }
-    if (typeof globalThis !== "undefined" && globalThis.__ENV__) {
-      this.store = { ...this.store, ...globalThis.__ENV__ };
-    }
-  }
-  get(key) {
-    const value = this.store[key];
-    return value !== undefined ? String(value) : undefined;
-  }
-  set(key, value) {
-    this.store[key] = value;
-  }
-  has(key) {
-    return key in this.store;
-  }
-  getAll() {
-    return { ...this.store };
-  }
-}
-
-class Environment {
-  runtime;
-  browserStore;
-  cache = new Map;
-  constructor() {
-    this.runtime = detectEnvironment();
-    if (this.runtime === "browser") {
-      this.browserStore = new BrowserEnvironmentStore;
-    }
-  }
-  getRuntime() {
-    return this.runtime;
-  }
-  isNode() {
-    return this.runtime === "node";
-  }
-  isBrowser() {
-    return this.runtime === "browser";
-  }
-  get(key, defaultValue) {
-    if (this.cache.has(key)) {
-      const cached = this.cache.get(key);
-      return cached === undefined && defaultValue !== undefined ? defaultValue : cached;
-    }
-    let value;
-    switch (this.runtime) {
-      case "node":
-        if (typeof process !== "undefined" && process.env) {
-          value = process.env[key];
-        }
-        break;
-      case "browser":
-        if (this.browserStore) {
-          value = this.browserStore.get(key);
-        }
-        break;
-      default:
-        value = undefined;
-    }
-    this.cache.set(key, value);
-    return value === undefined && defaultValue !== undefined ? defaultValue : value;
-  }
-  set(key, value) {
-    const stringValue = String(value);
-    this.cache.delete(key);
-    switch (this.runtime) {
-      case "node":
-        if (typeof process !== "undefined" && process.env) {
-          process.env[key] = stringValue;
-        }
-        break;
-      case "browser":
-        if (this.browserStore) {
-          this.browserStore.set(key, value);
-        }
-        break;
-    }
-  }
-  has(key) {
-    const value = this.get(key);
-    return value !== undefined;
-  }
-  getAll() {
-    switch (this.runtime) {
-      case "node":
-        if (typeof process !== "undefined" && process.env) {
-          return { ...process.env };
-        }
-        break;
-      case "browser":
-        if (this.browserStore) {
-          return this.browserStore.getAll();
-        }
-        break;
-    }
-    return {};
-  }
-  getBoolean(key, defaultValue = false) {
-    const value = this.get(key);
-    if (value === undefined) {
-      return defaultValue;
-    }
-    return ["true", "1", "yes", "on"].includes(value.toLowerCase());
-  }
-  getNumber(key, defaultValue) {
-    const value = this.get(key);
-    if (value === undefined) {
-      return defaultValue;
-    }
-    const parsed = Number(value);
-    return isNaN(parsed) ? defaultValue : parsed;
-  }
-  clearCache() {
-    this.cache.clear();
-  }
-}
-function getEnvironment() {
-  if (!environmentInstance) {
-    environmentInstance = new Environment;
-  }
-  return environmentInstance;
-}
-function getEnv3(key, defaultValue) {
-  return getEnvironment().get(key, defaultValue);
-}
-function setEnv(key, value) {
-  getEnvironment().set(key, value);
-}
-function hasEnv(key) {
-  return getEnvironment().has(key);
-}
-function getBooleanEnv(key, defaultValue = false) {
-  return getEnvironment().getBoolean(key, defaultValue);
-}
-function getNumberEnv(key, defaultValue) {
-  return getEnvironment().getNumber(key, defaultValue);
-}
-function initBrowserEnvironment(config) {
-  const env = getEnvironment();
-  if (env.isBrowser()) {
-    Object.entries(config).forEach(([key, value]) => {
-      if (value !== undefined) {
-        env.set(key, value);
-      }
-    });
-  }
-}
-function findEnvFile() {
-  if (typeof process === "undefined" || !process.cwd) {
-    return null;
-  }
-  const fs = __require("node:fs");
-  const path = __require("node:path");
-  const possiblePaths = [path.join(process.cwd(), ".env"), path.join(process.cwd(), ".env.local")];
-  for (const envPath of possiblePaths) {
-    if (fs.existsSync(envPath)) {
-      return envPath;
-    }
-  }
-  return null;
-}
-async function loadEnvConfig(envPath) {
-  if (typeof process === "undefined" || !process.cwd) {
-    return {};
-  }
-  const dotenv = __require("dotenv");
-  const resolvedPath = envPath || findEnvFile();
-  if (resolvedPath) {
-    const result = dotenv.config({ path: resolvedPath });
-    if (result.error) {
-      throw result.error;
-    }
-  }
-  return process.env;
-}
-var environmentInstance = null, currentRuntime;
-var init_environment = __esm(() => {
-  currentRuntime = detectEnvironment();
-});
-
 // ../../node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS((exports, module) => {
   var p = process || {};
@@ -25990,7 +25778,7 @@ var getDefaultProjectName = () => {
 };
 
 // ../../node_modules/langsmith/dist/index.js
-var __version__ = "0.3.78";
+var __version__ = "0.3.79";
 
 // ../../node_modules/langsmith/dist/utils/env.js
 var globalEnv;
@@ -39317,8 +39105,218 @@ var import_handlebars = __toESM(require_lib(), 1);
 var import_unique_names_generator = __toESM(require_dist4(), 1);
 import { z as z2 } from "zod";
 
-// src/logger.ts
-init_environment();
+// src/utils/environment.ts
+function detectEnvironment() {
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    return "node";
+  }
+  if (typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined" && typeof globalThis.window.document !== "undefined") {
+    return "browser";
+  }
+  return "unknown";
+}
+
+class BrowserEnvironmentStore {
+  store = {};
+  constructor() {
+    if (typeof globalThis !== "undefined" && globalThis.window && globalThis.window.ENV) {
+      this.store = { ...globalThis.window.ENV };
+    }
+    if (typeof globalThis !== "undefined" && globalThis.__ENV__) {
+      this.store = { ...this.store, ...globalThis.__ENV__ };
+    }
+  }
+  get(key) {
+    const value = this.store[key];
+    return value !== undefined ? String(value) : undefined;
+  }
+  set(key, value) {
+    this.store[key] = value;
+  }
+  has(key) {
+    return key in this.store;
+  }
+  getAll() {
+    return { ...this.store };
+  }
+}
+
+class Environment {
+  runtime;
+  browserStore;
+  cache = new Map;
+  constructor() {
+    this.runtime = detectEnvironment();
+    if (this.runtime === "browser") {
+      this.browserStore = new BrowserEnvironmentStore;
+    }
+  }
+  getRuntime() {
+    return this.runtime;
+  }
+  isNode() {
+    return this.runtime === "node";
+  }
+  isBrowser() {
+    return this.runtime === "browser";
+  }
+  get(key, defaultValue) {
+    if (this.cache.has(key)) {
+      const cached = this.cache.get(key);
+      return cached === undefined && defaultValue !== undefined ? defaultValue : cached;
+    }
+    let value;
+    switch (this.runtime) {
+      case "node":
+        if (typeof process !== "undefined" && process.env) {
+          value = process.env[key];
+        }
+        break;
+      case "browser":
+        if (this.browserStore) {
+          value = this.browserStore.get(key);
+        }
+        break;
+      default:
+        value = undefined;
+    }
+    this.cache.set(key, value);
+    return value === undefined && defaultValue !== undefined ? defaultValue : value;
+  }
+  set(key, value) {
+    const stringValue = String(value);
+    this.cache.delete(key);
+    switch (this.runtime) {
+      case "node":
+        if (typeof process !== "undefined" && process.env) {
+          process.env[key] = stringValue;
+        }
+        break;
+      case "browser":
+        if (this.browserStore) {
+          this.browserStore.set(key, value);
+        }
+        break;
+    }
+  }
+  has(key) {
+    const value = this.get(key);
+    return value !== undefined;
+  }
+  getAll() {
+    switch (this.runtime) {
+      case "node":
+        if (typeof process !== "undefined" && process.env) {
+          return { ...process.env };
+        }
+        break;
+      case "browser":
+        if (this.browserStore) {
+          return this.browserStore.getAll();
+        }
+        break;
+    }
+    return {};
+  }
+  getBoolean(key, defaultValue = false) {
+    const value = this.get(key);
+    if (value === undefined) {
+      return defaultValue;
+    }
+    return ["true", "1", "yes", "on"].includes(value.toLowerCase());
+  }
+  getNumber(key, defaultValue) {
+    const value = this.get(key);
+    if (value === undefined) {
+      return defaultValue;
+    }
+    const parsed = Number(value);
+    return isNaN(parsed) ? defaultValue : parsed;
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+}
+var environmentInstance = null;
+function getEnvironment() {
+  if (!environmentInstance) {
+    environmentInstance = new Environment;
+  }
+  return environmentInstance;
+}
+function getEnv3(key, defaultValue) {
+  return getEnvironment().get(key, defaultValue);
+}
+function setEnv(key, value) {
+  getEnvironment().set(key, value);
+}
+function hasEnv(key) {
+  return getEnvironment().has(key);
+}
+function getBooleanEnv(key, defaultValue = false) {
+  return getEnvironment().getBoolean(key, defaultValue);
+}
+function getNumberEnv(key, defaultValue) {
+  return getEnvironment().getNumber(key, defaultValue);
+}
+function initBrowserEnvironment(config) {
+  const env = getEnvironment();
+  if (env.isBrowser()) {
+    Object.entries(config).forEach(([key, value]) => {
+      if (value !== undefined) {
+        env.set(key, value);
+      }
+    });
+  }
+}
+var currentRuntime = detectEnvironment();
+function findEnvFile(startDir, filenames = [".env", ".env.local"]) {
+  if (typeof process === "undefined" || !process.cwd) {
+    return null;
+  }
+  const fs = __require("node:fs");
+  const path = __require("node:path");
+  let currentDir = startDir || process.cwd();
+  while (true) {
+    for (const filename of filenames) {
+      const candidate = path.join(currentDir, filename);
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return null;
+}
+function loadEnvFile(envPath) {
+  if (typeof process === "undefined" || !process.cwd) {
+    return false;
+  }
+  try {
+    const dotenv = __require("dotenv");
+    const resolvedPath = envPath || findEnvFile();
+    if (!resolvedPath) {
+      return false;
+    }
+    const result = dotenv.config({ path: resolvedPath });
+    if (result.error) {
+      if (typeof console !== "undefined" && console.warn) {
+        console.warn(`Failed to parse .env file at ${resolvedPath}:`, result.error);
+      }
+      return false;
+    }
+    return true;
+  } catch (error) {
+    if (typeof console !== "undefined" && console.warn) {
+      console.warn("Failed to load .env file:", error);
+    }
+    return false;
+  }
+}
 // ../../node_modules/adze/dist/tools.js
 class Tools {
   globalStore;
@@ -41454,7 +41452,6 @@ var recentLogs = () => globalInMemoryDestination.recentLogs();
 var logger_default = logger;
 
 // src/utils.ts
-init_environment();
 function upgradeDoubleToTriple(tpl) {
   return tpl.replace(/(?<!{){{(?![{#\/!>])([\s\S]*?)}}/g, (_match, inner) => {
     if (inner.trim() === "else")
@@ -42166,10 +42163,6 @@ function parseAndValidateCharacter(jsonString) {
 function isValidCharacter(data2) {
   return validateCharacter(data2).success;
 }
-
-// src/index.node.ts
-init_environment();
-
 // src/utils/buffer.ts
 function hasNativeBuffer() {
   return typeof Buffer !== "undefined" && typeof Buffer.from === "function";
@@ -42998,9 +42991,6 @@ function v43(options, buf, offset) {
   return _v4(options, buf, offset);
 }
 var v4_default = v43;
-// src/runtime.ts
-init_environment();
-
 // src/services/default-message-service.ts
 var latestResponseIds = new Map;
 
@@ -46567,37 +46557,30 @@ ${input}`;
 }
 
 // src/secrets.ts
-init_environment();
 function hasCharacterSecrets(character) {
   return Boolean(character?.settings?.secrets && Object.keys(character.settings.secrets).length > 0);
 }
 async function loadSecretsNodeImpl(character) {
-  const fs = await import("node:fs");
-  const dotenv = await import("dotenv");
-  const { findEnvFile: findEnvFile2 } = await Promise.resolve().then(() => (init_environment(), exports_environment));
-  const envPath = findEnvFile2();
-  if (!envPath)
-    return false;
-  try {
-    const buf = fs.readFileSync(envPath);
-    const envVars = dotenv.parse(buf);
-    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;
-  } catch {
-    return false;
+  const envVars = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== undefined) {
+      envVars[key] = value;
+    }
   }
+  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) {
   const env2 = detectEnvironment();
@@ -46607,9 +46590,6 @@ async function setDefaultSecretsFromEnv(character) {
   return loadSecretsNodeImpl(character);
 }
 
-// src/settings.ts
-init_environment();
-
 // src/utils/crypto-compat.ts
 function hasNodeCrypto() {
   try {
@@ -46930,7 +46910,6 @@ function defineService(definition) {
 }
 
 // src/plugin.ts
-init_environment();
 var attemptedInstalls = new Set;
 function isAutoInstallAllowed() {
   if (process.env.ELIZA_NO_AUTO_INSTALL === "true")
@@ -47734,7 +47713,7 @@ export {
   mediaSchema,
   logger,
   loadPlugin,
-  loadEnvConfig,
+  loadEnvFile,
   loadAndPreparePlugin,
   knowledgeItemSchema,
   isValidPluginShape,
@@ -47846,5 +47825,5 @@ export {
   AgentRuntime
 };
 
-//# debugId=13ABC5DE829D763B64756E2164756E21
+//# debugId=ACD09762158B47C164756E2164756E21
 //# sourceMappingURL=index.node.js.map