@elizaos/core 1.5.10 → 1.5.11-alpha.2

package/dist/node/index.node.js

@@ -19680,8 +19680,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);
@@ -25878,7 +25878,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;
@@ -42315,85 +42315,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 +42332,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 +42340,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 +42348,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 +42356,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 +42364,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 +42372,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 +42424,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 +45115,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 +45809,206 @@ 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 || []
+      });
+      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 +46373,7 @@ export {
   IBrowserService,
   EventType,
   Environment,
+  ElizaOS,
   DatabaseAdapter,
   ContentType,
   ChannelType,
@@ -46172,5 +46384,5 @@ export {
   AgentRuntime
 };
 
-//# debugId=919E5D09308269D664756E2164756E21
+//# debugId=796B1B79AC3F114D64756E2164756E21
 //# sourceMappingURL=index.node.js.map