@elizaos/core 1.5.12 → 1.5.13-alpha.2

package/dist/node/index.node.js

@@ -10054,12 +10054,13 @@ var require_algorithms = __commonJS((exports, module) => {
 
 // ../../node_modules/pbkdf2/lib/precondition.js
 var require_precondition = __commonJS((exports, module) => {
+  var $isFinite = isFinite;
   var MAX_ALLOC = Math.pow(2, 30) - 1;
   module.exports = function(iterations, keylen) {
     if (typeof iterations !== "number") {
       throw new TypeError("Iterations not a number");
     }
-    if (iterations < 0) {
+    if (iterations < 0 || !$isFinite(iterations)) {
       throw new TypeError("Bad iterations");
     }
     if (typeof keylen !== "number") {
@@ -11317,7 +11318,10 @@ var require_to_buffer = __commonJS((exports, module) => {
   var useArrayBuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
   var useFromArrayBuffer = useArrayBuffer && (Buffer2.prototype instanceof Uint8Array || Buffer2.TYPED_ARRAY_SUPPORT);
   module.exports = function toBuffer(data2, encoding) {
-    if (data2 instanceof Buffer2) {
+    if (Buffer2.isBuffer(data2)) {
+      if (data2.constructor && !("isBuffer" in data2)) {
+        return Buffer2.from(data2);
+      }
       return data2;
     }
     if (typeof data2 === "string") {
@@ -11521,6 +11525,12 @@ var require_async = __commonJS((exports, module) => {
       callback = digest;
       digest = undefined;
     }
+    checkParameters(iterations, keylen);
+    password = toBuffer(password, defaultEncoding, "Password");
+    salt = toBuffer(salt, defaultEncoding, "Salt");
+    if (typeof callback !== "function") {
+      throw new Error("No callback provided to pbkdf2");
+    }
     digest = digest || "sha1";
     var algo = toBrowser[digest.toLowerCase()];
     if (!algo || typeof global.Promise !== "function") {
@@ -11536,12 +11546,6 @@ var require_async = __commonJS((exports, module) => {
       });
       return;
     }
-    checkParameters(iterations, keylen);
-    password = toBuffer(password, defaultEncoding, "Password");
-    salt = toBuffer(salt, defaultEncoding, "Salt");
-    if (typeof callback !== "function") {
-      throw new Error("No callback provided to pbkdf2");
-    }
     resolvePromise(checkNative(algo).then(function(resp) {
       if (resp) {
         return browserPbkdf2(password, salt, iterations, keylen, algo);
@@ -19680,8 +19684,8 @@ var require_reporter = __commonJS((exports) => {
       errors: state.errors
     };
   };
-  function ReporterError(path2, msg) {
-    this.path = path2;
+  function ReporterError(path, msg) {
+    this.path = path;
     this.rethrow(msg);
   }
   inherits(ReporterError, Error);
@@ -21391,7 +21395,7 @@ var require_parse_asn1 = __commonJS((exports, module) => {
   var aesid = require_aesid();
   var fixProc = require_fixProc();
   var ciphers = require_browserify_aes();
-  var compat = require_pbkdf2();
+  var pbkdf2Sync = require_pbkdf2().pbkdf2Sync;
   var Buffer2 = require_safe_buffer().Buffer;
   function decrypt(data2, password) {
     var salt = data2.algorithm.decrypt.kde.kdeparams.salt;
@@ -21400,7 +21404,7 @@ var require_parse_asn1 = __commonJS((exports, module) => {
     var iv = data2.algorithm.decrypt.cipher.iv;
     var cipherText = data2.subjectPrivateKey;
     var keylen = parseInt(algo.split("-")[1], 10) / 8;
-    var key = compat.pbkdf2Sync(password, salt, iters, keylen, "sha1");
+    var key = pbkdf2Sync(password, salt, iters, keylen, "sha1");
     var cipher = ciphers.createDecipheriv(algo, key, iv);
     var out = [];
     out.push(cipher.update(cipherText));
@@ -25878,7 +25882,7 @@ var getDefaultProjectName = () => {
 };
 
 // ../../node_modules/langsmith/dist/index.js
-var __version__ = "0.3.68";
+var __version__ = "0.3.69";
 
 // ../../node_modules/langsmith/dist/utils/env.js
 var globalEnv;
@@ -41884,7 +41888,7 @@ function parseBooleanFromText2(value) {
   }
   return false;
 }
-var uuidSchema = z2.string().uuid();
+var uuidSchema = z2.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, "Invalid UUID format");
 function validateUuid(value) {
   const result = uuidSchema.safeParse(value);
   return result.success ? result.data : null;
@@ -42110,14 +42114,14 @@ var styleSchema = z3.object({
   chat: z3.array(z3.string()).optional(),
   post: z3.array(z3.string()).optional()
 }).optional();
-var settingsSchema = z3.record(z3.union([z3.string(), z3.boolean(), z3.number(), z3.any()])).optional();
-var secretsSchema = z3.record(z3.union([z3.string(), z3.boolean(), z3.number()])).optional();
+var settingsSchema = z3.record(z3.string(), z3.union([z3.string(), z3.boolean(), z3.number(), z3.any()])).optional();
+var secretsSchema = z3.record(z3.string(), z3.union([z3.string(), z3.boolean(), z3.number()])).optional();
 var characterSchema = z3.object({
   id: uuidSchema2.optional(),
   name: z3.string().min(1, "Character name is required"),
   username: z3.string().optional(),
   system: z3.string().optional(),
-  templates: z3.record(templateTypeSchema).optional(),
+  templates: z3.record(z3.string(), templateTypeSchema).optional(),
   bio: z3.union([z3.string(), z3.array(z3.string())]),
   messageExamples: z3.array(z3.array(messageExampleSchema)).optional(),
   postExamples: z3.array(z3.string()).optional(),
@@ -42315,85 +42319,16 @@ var BufferUtils = {
   byteLength,
   randomBytes
 };
-// src/utils/server-health.ts
-async function waitForServerReady(options) {
-  const {
-    port,
-    endpoint = "/api/agents",
-    maxWaitTime = 30000,
-    pollInterval = 1000,
-    requestTimeout = 2000,
-    host = "localhost",
-    protocol = "http"
-  } = options;
-  const url = `${protocol}://${host}:${port}${endpoint}`;
-  const startTime = Date.now();
-  while (Date.now() - startTime < maxWaitTime) {
-    let controller;
-    let timeoutId;
+// src/utils/paths.ts
+var pathJoin = (...parts) => {
+  if (typeof process !== "undefined" && process.platform) {
     try {
-      controller = new AbortController;
-      timeoutId = setTimeout(() => {
-        if (controller) {
-          controller.abort();
-        }
-      }, requestTimeout);
-      const response = await fetch(url, {
-        signal: controller.signal
-      });
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-        timeoutId = undefined;
-      }
-      if (response.ok) {
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        return;
-      }
-    } catch (error) {} finally {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-    }
-    await new Promise((resolve) => setTimeout(resolve, pollInterval));
-  }
-  throw new Error(`Server failed to become ready at ${url} within ${maxWaitTime}ms`);
-}
-async function pingServer(options) {
-  const {
-    port,
-    endpoint = "/api/agents",
-    requestTimeout = 2000,
-    host = "localhost",
-    protocol = "http"
-  } = options;
-  const url = `${protocol}://${host}:${port}${endpoint}`;
-  let controller;
-  let timeoutId;
-  try {
-    controller = new AbortController;
-    timeoutId = setTimeout(() => {
-      if (controller) {
-        controller.abort();
-      }
-    }, requestTimeout);
-    const response = await fetch(url, {
-      signal: controller.signal
-    });
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-      timeoutId = undefined;
-    }
-    return response.ok;
-  } catch (error) {
-    return false;
-  } finally {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
+      const path = __require("node:path");
+      return path.join(...parts);
+    } catch {}
   }
-}
-// src/utils/paths.ts
-import path from "node:path";
+  return parts.filter((part) => part).join("/").replace(/\/+/g, "/").replace(/\/$/, "");
+};
 
 class ElizaPaths {
   cache = new Map;
@@ -42401,7 +42336,7 @@ class ElizaPaths {
     const cached = this.cache.get("dataDir");
     if (cached)
       return cached;
-    const dir = process.env.ELIZA_DATA_DIR || path.join(process.cwd(), ".eliza");
+    const dir = typeof process !== "undefined" && process.env?.ELIZA_DATA_DIR || (typeof process !== "undefined" && process.cwd ? pathJoin(process.cwd(), ".eliza") : ".eliza");
     this.cache.set("dataDir", dir);
     return dir;
   }
@@ -42409,7 +42344,7 @@ class ElizaPaths {
     const cached = this.cache.get("databaseDir");
     if (cached)
       return cached;
-    const dir = process.env.ELIZA_DATABASE_DIR || process.env.PGLITE_DATA_DIR || path.join(this.getDataDir(), ".elizadb");
+    const dir = typeof process !== "undefined" && process.env?.ELIZA_DATABASE_DIR || typeof process !== "undefined" && process.env?.PGLITE_DATA_DIR || pathJoin(this.getDataDir(), ".elizadb");
     this.cache.set("databaseDir", dir);
     return dir;
   }
@@ -42417,7 +42352,7 @@ class ElizaPaths {
     const cached = this.cache.get("charactersDir");
     if (cached)
       return cached;
-    const dir = process.env.ELIZA_DATA_DIR_CHARACTERS || path.join(this.getDataDir(), "data", "characters");
+    const dir = typeof process !== "undefined" && process.env?.ELIZA_DATA_DIR_CHARACTERS || pathJoin(this.getDataDir(), "data", "characters");
     this.cache.set("charactersDir", dir);
     return dir;
   }
@@ -42425,7 +42360,7 @@ class ElizaPaths {
     const cached = this.cache.get("generatedDir");
     if (cached)
       return cached;
-    const dir = process.env.ELIZA_DATA_DIR_GENERATED || path.join(this.getDataDir(), "data", "generated");
+    const dir = typeof process !== "undefined" && process.env?.ELIZA_DATA_DIR_GENERATED || pathJoin(this.getDataDir(), "data", "generated");
     this.cache.set("generatedDir", dir);
     return dir;
   }
@@ -42433,7 +42368,7 @@ class ElizaPaths {
     const cached = this.cache.get("uploadsAgentsDir");
     if (cached)
       return cached;
-    const dir = process.env.ELIZA_DATA_DIR_UPLOADS_AGENTS || path.join(this.getDataDir(), "data", "uploads", "agents");
+    const dir = typeof process !== "undefined" && process.env?.ELIZA_DATA_DIR_UPLOADS_AGENTS || pathJoin(this.getDataDir(), "data", "uploads", "agents");
     this.cache.set("uploadsAgentsDir", dir);
     return dir;
   }
@@ -42441,7 +42376,7 @@ class ElizaPaths {
     const cached = this.cache.get("uploadsChannelsDir");
     if (cached)
       return cached;
-    const dir = process.env.ELIZA_DATA_DIR_UPLOADS_CHANNELS || path.join(this.getDataDir(), "data", "uploads", "channels");
+    const dir = typeof process !== "undefined" && process.env?.ELIZA_DATA_DIR_UPLOADS_CHANNELS || pathJoin(this.getDataDir(), "data", "uploads", "channels");
     this.cache.set("uploadsChannelsDir", dir);
     return dir;
   }
@@ -42493,6 +42428,84 @@ function resetPaths() {
   }
   pathsInstance = null;
 }
+
+// src/utils/server-health.ts
+async function waitForServerReady(options) {
+  const {
+    port,
+    endpoint = "/api/agents",
+    maxWaitTime = 30000,
+    pollInterval = 1000,
+    requestTimeout = 2000,
+    host = "localhost",
+    protocol = "http"
+  } = options;
+  const url = `${protocol}://${host}:${port}${endpoint}`;
+  const startTime = Date.now();
+  while (Date.now() - startTime < maxWaitTime) {
+    let controller;
+    let timeoutId;
+    try {
+      controller = new AbortController;
+      timeoutId = setTimeout(() => {
+        if (controller) {
+          controller.abort();
+        }
+      }, requestTimeout);
+      const response = await fetch(url, {
+        signal: controller.signal
+      });
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = undefined;
+      }
+      if (response.ok) {
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        return;
+      }
+    } catch (error) {} finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+  }
+  throw new Error(`Server failed to become ready at ${url} within ${maxWaitTime}ms`);
+}
+async function pingServer(options) {
+  const {
+    port,
+    endpoint = "/api/agents",
+    requestTimeout = 2000,
+    host = "localhost",
+    protocol = "http"
+  } = options;
+  const url = `${protocol}://${host}:${port}${endpoint}`;
+  let controller;
+  let timeoutId;
+  try {
+    controller = new AbortController;
+    timeoutId = setTimeout(() => {
+      if (controller) {
+        controller.abort();
+      }
+    }, requestTimeout);
+    const response = await fetch(url, {
+      signal: controller.signal
+    });
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = undefined;
+    }
+    return response.ok;
+  } catch (error) {
+    return false;
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
 // src/actions.ts
 var import_unique_names_generator2 = __toESM(require_dist4(), 1);
 var composeActionExamples = (actionsData, count) => {
@@ -45106,7 +45119,9 @@ class AgentRuntime {
     await this.adapter.init();
   }
   async close() {
-    await this.adapter.close();
+    if (this.adapter) {
+      await this.adapter.close();
+    }
   }
   async getAgent(agentId) {
     return await this.adapter.getAgent(agentId);
@@ -45798,6 +45813,207 @@ function defineService(definition) {
   return createService(definition.serviceType).withDescription(definition.description).withStart(definition.start).withStop(definition.stop || (() => Promise.resolve())).build();
 }
 
+// src/elizaos.ts
+class ElizaOS extends EventTarget {
+  runtimes = new Map;
+  editableMode = false;
+  async addAgents(agents) {
+    const promises = agents.map(async (agent) => {
+      const runtime = new AgentRuntime({
+        character: agent.character,
+        plugins: agent.plugins || [],
+        settings: agent.settings || {}
+      });
+      this.runtimes.set(runtime.agentId, runtime);
+      this.dispatchEvent(new CustomEvent("agent:added", {
+        detail: { agentId: runtime.agentId, character: agent.character }
+      }));
+      return runtime.agentId;
+    });
+    const ids = await Promise.all(promises);
+    this.dispatchEvent(new CustomEvent("agents:added", {
+      detail: { agentIds: ids, count: ids.length }
+    }));
+    return ids;
+  }
+  registerAgent(runtime) {
+    if (this.runtimes.has(runtime.agentId)) {
+      throw new Error(`Agent ${runtime.agentId} already registered`);
+    }
+    this.runtimes.set(runtime.agentId, runtime);
+    this.dispatchEvent(new CustomEvent("agent:registered", {
+      detail: { agentId: runtime.agentId, runtime }
+    }));
+  }
+  async updateAgent(agentId, updates) {
+    if (!this.editableMode) {
+      throw new Error("Editable mode not enabled");
+    }
+    const runtime = this.runtimes.get(agentId);
+    if (!runtime) {
+      throw new Error(`Agent ${agentId} not found`);
+    }
+    Object.assign(runtime.character, updates);
+    this.dispatchEvent(new CustomEvent("agent:updated", {
+      detail: { agentId, updates }
+    }));
+  }
+  async deleteAgents(agentIds) {
+    await this.stopAgents(agentIds);
+    for (const id of agentIds) {
+      this.runtimes.delete(id);
+    }
+    this.dispatchEvent(new CustomEvent("agents:deleted", {
+      detail: { agentIds, count: agentIds.length }
+    }));
+  }
+  async startAgents(agentIds) {
+    const ids = agentIds || Array.from(this.runtimes.keys());
+    await Promise.all(ids.map(async (id) => {
+      const runtime = this.runtimes.get(id);
+      if (!runtime) {
+        throw new Error(`Agent ${id} not found`);
+      }
+      await runtime.initialize();
+      this.dispatchEvent(new CustomEvent("agent:started", {
+        detail: { agentId: id }
+      }));
+    }));
+    this.dispatchEvent(new CustomEvent("agents:started", {
+      detail: { agentIds: ids, count: ids.length }
+    }));
+  }
+  async stopAgents(agentIds) {
+    const ids = agentIds || Array.from(this.runtimes.keys());
+    await Promise.all(ids.map(async (id) => {
+      const runtime = this.runtimes.get(id);
+      if (runtime) {
+        await runtime.stop();
+      }
+    }));
+    this.dispatchEvent(new CustomEvent("agents:stopped", {
+      detail: { agentIds: ids, count: ids.length }
+    }));
+  }
+  getAgent(id) {
+    return this.runtimes.get(id);
+  }
+  getAgents() {
+    return Array.from(this.runtimes.values());
+  }
+  getAgentsByIds(ids) {
+    return ids.map((id) => this.runtimes.get(id)).filter((runtime) => runtime !== undefined);
+  }
+  getAgentsByNames(names3) {
+    const nameSet = new Set(names3.map((n) => n.toLowerCase()));
+    return this.getAgents().filter((runtime) => nameSet.has(runtime.character.name.toLowerCase()));
+  }
+  getAgentById(id) {
+    return this.getAgent(id);
+  }
+  getAgentByName(name) {
+    const lowercaseName = name.toLowerCase();
+    return this.getAgents().find((runtime) => runtime.character.name.toLowerCase() === lowercaseName);
+  }
+  getAgentByCharacterName(name) {
+    return this.getAgentByName(name);
+  }
+  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`);
+    }
+    const memory = typeof message === "string" ? {
+      id: v4_default(),
+      entityId: options?.userId || "system",
+      agentId,
+      roomId: options?.roomId || agentId,
+      content: { text: message },
+      createdAt: Date.now(),
+      metadata: options?.metadata
+    } : message;
+    const responses = [];
+    await runtime.processActions(memory, responses);
+    this.dispatchEvent(new CustomEvent("message:sent", {
+      detail: { agentId, message: memory, responses }
+    }));
+    return responses;
+  }
+  async sendMessages(messages) {
+    const results = await Promise.all(messages.map(async ({ agentId, message, options }) => {
+      try {
+        const responses = await this.sendMessage(agentId, message, options);
+        return { agentId, responses };
+      } catch (error) {
+        return {
+          agentId,
+          responses: [],
+          error: error instanceof Error ? error : new Error(String(error))
+        };
+      }
+    }));
+    this.dispatchEvent(new CustomEvent("messages:sent", {
+      detail: { results, count: messages.length }
+    }));
+    return results;
+  }
+  async validateApiKeys(agents) {
+    const results = new Map;
+    const ids = agents || Array.from(this.runtimes.keys());
+    for (const id of ids) {
+      const runtime = this.runtimes.get(id);
+      if (runtime) {
+        const hasKeys = !!(runtime.getSetting("OPENAI_API_KEY") || runtime.getSetting("ANTHROPIC_API_KEY"));
+        results.set(id, hasKeys);
+      }
+    }
+    return results;
+  }
+  async healthCheck(agents) {
+    const results = new Map;
+    const ids = agents || Array.from(this.runtimes.keys());
+    for (const id of ids) {
+      const runtime = this.runtimes.get(id);
+      const status = {
+        alive: !!runtime,
+        responsive: true
+      };
+      if (typeof process !== "undefined") {
+        status.memoryUsage = process.memoryUsage().heapUsed;
+        status.uptime = process.uptime();
+      }
+      results.set(id, status);
+    }
+    return results;
+  }
+  getRuntimeAccessor() {
+    return {
+      getAgent: (id) => this.getAgent(id),
+      getAgents: () => this.getAgents(),
+      getState: (agentId) => {
+        const agent = this.getAgent(agentId);
+        if (!agent)
+          return;
+        const agentRuntime = agent;
+        if (agentRuntime.stateCache && agentRuntime.stateCache.size > 0) {
+          const states = Array.from(agentRuntime.stateCache.values());
+          return states[states.length - 1];
+        }
+        return;
+      }
+    };
+  }
+  enableEditableMode() {
+    this.editableMode = true;
+    this.dispatchEvent(new CustomEvent("mode:editable", {
+      detail: { editable: true }
+    }));
+  }
+}
+
 // src/entities.ts
 var entityResolutionTemplate = `# Task: Resolve Entity Name
 Message Sender: {{senderName}} (ID: {{senderId}})
@@ -46162,6 +46378,7 @@ export {
   IBrowserService,
   EventType,
   Environment,
+  ElizaOS,
   DatabaseAdapter,
   ContentType,
   ChannelType,
@@ -46172,5 +46389,5 @@ export {
   AgentRuntime
 };
 
-//# debugId=919E5D09308269D664756E2164756E21
+//# debugId=4E86C04C1312961F64756E2164756E21
 //# sourceMappingURL=index.node.js.map