@elizaos/api-client 1.0.12

package/dist/index.js

@@ -0,0 +1,721 @@
+"use client";
+
+// src/lib/base-client.ts
+var ApiError = class extends Error {
+  constructor(code, message, details, status) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.status = status;
+    this.name = "ApiError";
+  }
+};
+var BaseApiClient = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  defaultHeaders;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+    this.timeout = config.timeout || 3e4;
+    this.defaultHeaders = {
+      "Content-Type": "application/json",
+      ...config.headers
+    };
+    if (this.apiKey) {
+      this.defaultHeaders["X-API-KEY"] = this.apiKey;
+    }
+  }
+  async request(method, path, options) {
+    let url;
+    if (this.baseUrl) {
+      url = new URL(`${this.baseUrl}${path}`);
+    } else if (typeof window !== "undefined" && window.location) {
+      url = new URL(path, window.location.origin);
+    } else {
+      url = new URL(path, "http://localhost:3000");
+    }
+    if (options?.params) {
+      Object.entries(options.params).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const headers = {
+        ...this.defaultHeaders,
+        ...options?.config?.headers,
+        ...options?.headers
+      };
+      if (options?.body instanceof FormData) {
+        delete headers["Content-Type"];
+      }
+      const response = await fetch(url.toString(), {
+        method,
+        headers,
+        body: options?.body instanceof FormData ? options.body : options?.body ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const data = await response.json();
+      if (!response.ok || !data.success) {
+        const error = "error" in data ? data.error : {
+          code: "UNKNOWN_ERROR",
+          message: "An unknown error occurred"
+        };
+        throw new ApiError(error.code, error.message, error.details, response.status);
+      }
+      return data.data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof ApiError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new ApiError("TIMEOUT", "Request timed out");
+        }
+        throw new ApiError("NETWORK_ERROR", error.message);
+      }
+      throw new ApiError("UNKNOWN_ERROR", "An unknown error occurred");
+    }
+  }
+  async get(path, options) {
+    return this.request("GET", path, options);
+  }
+  async post(path, body, options) {
+    return this.request("POST", path, { ...options, body });
+  }
+  async put(path, body, options) {
+    return this.request("PUT", path, { ...options, body });
+  }
+  async patch(path, body, options) {
+    return this.request("PATCH", path, { ...options, body });
+  }
+  async delete(path, options) {
+    return this.request("DELETE", path, options);
+  }
+};
+
+// src/services/agents.ts
+var AgentsService = class extends BaseApiClient {
+  /**
+   * List all agents with minimal details
+   */
+  async listAgents() {
+    return this.get("/api/agents");
+  }
+  /**
+   * Get specific agent details
+   */
+  async getAgent(agentId) {
+    return this.get(`/api/agents/${agentId}`);
+  }
+  /**
+   * Create a new agent
+   */
+  async createAgent(params) {
+    return this.post("/api/agents", params);
+  }
+  /**
+   * Update an existing agent
+   */
+  async updateAgent(agentId, params) {
+    return this.patch(`/api/agents/${agentId}`, params);
+  }
+  /**
+   * Delete an agent
+   */
+  async deleteAgent(agentId) {
+    return this.delete(`/api/agents/${agentId}`);
+  }
+  /**
+   * Start an existing agent
+   */
+  async startAgent(agentId) {
+    return this.post(`/api/agents/${agentId}/start`);
+  }
+  /**
+   * Stop a running agent
+   */
+  async stopAgent(agentId) {
+    return this.post(`/api/agents/${agentId}/stop`);
+  }
+  /**
+   * Get all available worlds
+   */
+  async getWorlds() {
+    return this.get("/api/agents/worlds");
+  }
+  /**
+   * Add agent to a world
+   */
+  async addAgentToWorld(agentId, worldId) {
+    return this.post(`/api/agents/${agentId}/worlds`, { worldId });
+  }
+  /**
+   * Update agent's world settings
+   */
+  async updateAgentWorldSettings(agentId, worldId, settings) {
+    return this.patch(`/api/agents/${agentId}/worlds/${worldId}`, { settings });
+  }
+  /**
+   * Get agent's plugin panels
+   */
+  async getAgentPanels(agentId) {
+    return this.get(`/api/agents/${agentId}/panels`);
+  }
+  /**
+   * Get agent logs
+   */
+  async getAgentLogs(agentId, params) {
+    return this.get(`/api/agents/${agentId}/logs`, { params });
+  }
+  /**
+   * Delete a specific log entry
+   */
+  async deleteAgentLog(agentId, logId) {
+    return this.delete(`/api/agents/${agentId}/logs/${logId}`);
+  }
+};
+
+// src/services/messaging.ts
+var MessagingService = class extends BaseApiClient {
+  /**
+   * Submit agent replies or system messages
+   */
+  async submitMessage(params) {
+    return this.post("/api/messaging/submit", params);
+  }
+  /**
+   * Notify message completion
+   */
+  async completeMessage(params) {
+    return this.post("/api/messaging/complete", params);
+  }
+  /**
+   * Ingest messages from external platforms
+   */
+  async ingestExternalMessages(params) {
+    return this.post("/api/messaging/ingest-external", params);
+  }
+  /**
+   * Create a new channel
+   */
+  async createChannel(params) {
+    return this.post("/api/messaging/channels", params);
+  }
+  /**
+   * Create a group channel
+   */
+  async createGroupChannel(params) {
+    return this.post("/api/messaging/central-channels", params);
+  }
+  /**
+   * Find or create a DM channel
+   */
+  async getOrCreateDmChannel(params) {
+    return this.get("/api/messaging/dm-channel", { params });
+  }
+  /**
+   * Get channel details
+   */
+  async getChannelDetails(channelId) {
+    return this.get(`/api/messaging/central-channels/${channelId}/details`);
+  }
+  /**
+   * Get channel participants
+   */
+  async getChannelParticipants(channelId) {
+    return this.get(
+      `/api/messaging/central-channels/${channelId}/participants`
+    );
+  }
+  /**
+   * Add agent to channel
+   */
+  async addAgentToChannel(channelId, agentId) {
+    return this.post(`/api/messaging/central-channels/${channelId}/agents`, {
+      agentId
+    });
+  }
+  /**
+   * Remove agent from channel
+   */
+  async removeAgentFromChannel(channelId, agentId) {
+    return this.delete(
+      `/api/messaging/central-channels/${channelId}/agents/${agentId}`
+    );
+  }
+  /**
+   * Delete a channel
+   */
+  async deleteChannel(channelId) {
+    return this.delete(`/api/messaging/channels/${channelId}`);
+  }
+  /**
+   * Clear channel history
+   */
+  async clearChannelHistory(channelId) {
+    return this.post(`/api/messaging/channels/${channelId}/clear`);
+  }
+  /**
+   * Post a new message to a channel
+   */
+  async postMessage(channelId, content, metadata) {
+    return this.post(`/api/messaging/central-channels/${channelId}/messages`, {
+      content,
+      metadata
+    });
+  }
+  /**
+   * Get channel messages
+   */
+  async getChannelMessages(channelId, params) {
+    return this.get(
+      `/api/messaging/central-channels/${channelId}/messages`,
+      { params }
+    );
+  }
+  /**
+   * Get a specific message
+   */
+  async getMessage(messageId) {
+    return this.get(`/api/messaging/messages/${messageId}`);
+  }
+  /**
+   * Delete a message
+   */
+  async deleteMessage(messageId) {
+    return this.delete(`/api/messaging/messages/${messageId}`);
+  }
+  /**
+   * Update a message
+   */
+  async updateMessage(messageId, content) {
+    return this.patch(`/api/messaging/messages/${messageId}`, { content });
+  }
+  /**
+   * Search messages
+   */
+  async searchMessages(params) {
+    return this.post("/api/messaging/messages/search", params);
+  }
+  /**
+   * List all message servers
+   */
+  async listServers() {
+    return this.get("/api/messaging/central-servers");
+  }
+  /**
+   * Get server channels
+   */
+  async getServerChannels(serverId) {
+    return this.get(
+      `/api/messaging/central-servers/${serverId}/channels`
+    );
+  }
+  /**
+   * Create a new server
+   */
+  async createServer(params) {
+    return this.post("/api/messaging/servers", params);
+  }
+  /**
+   * Sync server channels
+   */
+  async syncServerChannels(serverId, params) {
+    return this.post(
+      `/api/messaging/servers/${serverId}/sync-channels`,
+      params
+    );
+  }
+  /**
+   * Delete a server
+   */
+  async deleteServer(serverId) {
+    return this.delete(`/api/messaging/servers/${serverId}`);
+  }
+};
+
+// src/services/memory.ts
+var MemoryService = class extends BaseApiClient {
+  /**
+   * Get agent memories
+   */
+  async getAgentMemories(agentId, params) {
+    return this.get(`/api/memory/${agentId}/memories`, { params });
+  }
+  /**
+   * Get room-specific memories
+   */
+  async getRoomMemories(agentId, roomId, params) {
+    return this.get(`/api/memory/${agentId}/rooms/${roomId}/memories`, {
+      params
+    });
+  }
+  /**
+   * Update a memory
+   */
+  async updateMemory(agentId, memoryId, params) {
+    return this.patch(`/api/memory/${agentId}/memories/${memoryId}`, params);
+  }
+  /**
+   * Clear all agent memories
+   */
+  async clearAgentMemories(agentId) {
+    return this.delete(`/api/memory/${agentId}/memories`);
+  }
+  /**
+   * Clear room memories
+   */
+  async clearRoomMemories(agentId, roomId) {
+    return this.delete(`/api/memory/${agentId}/memories/all/${roomId}`);
+  }
+  /**
+   * List agent's rooms
+   */
+  async listAgentRooms(agentId) {
+    return this.get(`/api/memory/${agentId}/rooms`);
+  }
+  /**
+   * Get room details
+   */
+  async getRoom(agentId, roomId) {
+    return this.get(`/api/memory/${agentId}/rooms/${roomId}`);
+  }
+  /**
+   * Create a room
+   */
+  async createRoom(agentId, params) {
+    return this.post(`/api/memory/${agentId}/rooms`, params);
+  }
+  /**
+   * Create world from server
+   */
+  async createWorldFromServer(serverId, params) {
+    return this.post(`/api/memory/groups/${serverId}`, params);
+  }
+  /**
+   * Delete a world
+   */
+  async deleteWorld(serverId) {
+    return this.delete(`/api/memory/groups/${serverId}`);
+  }
+  /**
+   * Clear world memories
+   */
+  async clearWorldMemories(serverId) {
+    return this.delete(`/api/memory/groups/${serverId}/memories`);
+  }
+};
+
+// src/services/audio.ts
+var AudioService = class extends BaseApiClient {
+  /**
+   * Convert audio input to appropriate FormData value
+   */
+  processAudioInput(audio) {
+    if (audio instanceof Blob) {
+      return audio;
+    }
+    if (typeof audio === "string") {
+      if (audio.startsWith("data:")) {
+        try {
+          const [header, base64Data] = audio.split(",");
+          const mimeMatch = header.match(/data:([^;]+)/);
+          const mimeType = mimeMatch ? mimeMatch[1] : "audio/wav";
+          const binaryString = atob(base64Data);
+          const bytes = new Uint8Array(binaryString.length);
+          for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+          }
+          return new Blob([bytes], { type: mimeType });
+        } catch (error) {
+          throw new Error(
+            `Invalid base64 data URL: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      }
+      if (this.isBase64String(audio)) {
+        try {
+          const binaryString = atob(audio);
+          const bytes = new Uint8Array(binaryString.length);
+          for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+          }
+          return new Blob([bytes], { type: "audio/wav" });
+        } catch (error) {
+          return audio;
+        }
+      }
+      return audio;
+    }
+    if (this.isBuffer(audio)) {
+      return new Blob([audio], { type: "audio/wav" });
+    }
+    const audioAsAny = audio;
+    if (audioAsAny instanceof ArrayBuffer) {
+      return new Blob([audioAsAny], { type: "audio/wav" });
+    }
+    if (audioAsAny && typeof audioAsAny === "object" && "buffer" in audioAsAny && audioAsAny.buffer instanceof ArrayBuffer) {
+      return new Blob([audioAsAny.buffer], { type: "audio/wav" });
+    }
+    throw new Error(
+      `Unsupported audio input type: ${typeof audio}. Expected Blob, Buffer, ArrayBuffer, or string.`
+    );
+  }
+  /**
+   * Check if a string appears to be base64 encoded
+   */
+  isBase64String(str) {
+    const base64Pattern = /^[A-Za-z0-9+/]*={0,2}$/;
+    if (str.length < 4 || str.length % 4 !== 0) {
+      return false;
+    }
+    return base64Pattern.test(str);
+  }
+  /**
+   * Safe check for Buffer type (works in both Node.js and browser environments)
+   */
+  isBuffer(obj) {
+    return obj != null && typeof obj === "object" && typeof obj.constructor === "function" && obj.constructor.name === "Buffer" && typeof obj.readUInt8 === "function";
+  }
+  /**
+   * Handle speech conversation
+   */
+  async speechConversation(agentId, params) {
+    const formData = new FormData();
+    const processedAudio = this.processAudioInput(params.audio);
+    if (processedAudio instanceof Blob) {
+      formData.append("audio", processedAudio);
+    } else {
+      formData.append("audio", processedAudio);
+    }
+    if (params.format) formData.append("format", params.format);
+    if (params.language) formData.append("language", params.language);
+    if (params.metadata) formData.append("metadata", JSON.stringify(params.metadata));
+    return this.request("POST", `/api/audio/${agentId}/speech/conversation`, {
+      body: formData
+    });
+  }
+  /**
+   * Generate speech from text
+   */
+  async generateSpeech(agentId, params) {
+    return this.post(
+      `/api/audio/${agentId}/speech/generate`,
+      params
+    );
+  }
+  /**
+   * Synthesize audio message
+   */
+  async synthesizeAudioMessage(agentId, params) {
+    return this.post(
+      `/api/audio/${agentId}/audio-messages/synthesize`,
+      params
+    );
+  }
+  /**
+   * Transcribe audio to text
+   */
+  async transcribe(agentId, params) {
+    const formData = new FormData();
+    const processedAudio = this.processAudioInput(params.audio);
+    if (processedAudio instanceof Blob) {
+      formData.append("audio", processedAudio);
+    } else {
+      formData.append("audio", processedAudio);
+    }
+    if (params.format) formData.append("format", params.format);
+    if (params.language) formData.append("language", params.language);
+    return this.request("POST", `/api/audio/${agentId}/transcribe`, {
+      body: formData
+    });
+  }
+  /**
+   * Process speech input
+   */
+  async processSpeech(agentId, audio, metadata) {
+    const formData = new FormData();
+    const processedAudio = this.processAudioInput(audio);
+    if (processedAudio instanceof Blob) {
+      formData.append("audio", processedAudio);
+    } else {
+      formData.append("audio", processedAudio);
+    }
+    if (metadata) formData.append("metadata", JSON.stringify(metadata));
+    return this.request("POST", `/api/audio/${agentId}/speech`, {
+      body: formData
+    });
+  }
+};
+
+// src/services/media.ts
+var MediaService = class extends BaseApiClient {
+  /**
+   * Upload media for an agent
+   */
+  async uploadAgentMedia(agentId, params) {
+    const formData = new FormData();
+    formData.append("file", params.file, params.filename);
+    if (params.contentType) formData.append("contentType", params.contentType);
+    if (params.metadata) formData.append("metadata", JSON.stringify(params.metadata));
+    return this.request("POST", `/api/media/${agentId}/upload-media`, {
+      body: formData
+    });
+  }
+  /**
+   * Upload files to a channel
+   */
+  async uploadChannelFiles(channelId, params) {
+    const formData = new FormData();
+    params.files.forEach((file, index) => {
+      formData.append(`files[${index}]`, file);
+    });
+    if (params.messageId) formData.append("messageId", params.messageId);
+    if (params.metadata) formData.append("metadata", JSON.stringify(params.metadata));
+    return this.request(
+      "POST",
+      `/api/media/central-channels/${channelId}/upload`,
+      {
+        body: formData
+      }
+    );
+  }
+};
+
+// src/services/server.ts
+var ServerService = class extends BaseApiClient {
+  /**
+   * Health check
+   */
+  async checkHealth() {
+    return this.get("/api/server/health");
+  }
+  /**
+   * Simple ping
+   */
+  async ping() {
+    return this.get("/api/server/ping");
+  }
+  /**
+   * Hello endpoint
+   */
+  async hello() {
+    return this.get("/api/server/hello");
+  }
+  /**
+   * Get server status
+   */
+  async getStatus() {
+    return this.get("/api/server/status");
+  }
+  /**
+   * Stop the server
+   */
+  async stopServer() {
+    return this.post("/api/server/stop");
+  }
+  /**
+   * Get runtime debug info
+   */
+  async getDebugInfo() {
+    return this.get("/api/server/servers");
+  }
+  /**
+   * Submit logs
+   */
+  async submitLogs(logs) {
+    return this.post("/api/server/logs", { logs });
+  }
+  /**
+   * Clear logs
+   */
+  async clearLogs() {
+    return this.delete("/api/server/logs");
+  }
+};
+
+// src/services/system.ts
+var SystemService = class extends BaseApiClient {
+  /**
+   * Retrieve the local environment variables from the ElizaOS server.
+   *
+   * Server route (packages/server/src/api/system):
+   *   GET /api/system/env/local  ->  { success: true, data: Record<string,string> }
+   */
+  async getEnvironment() {
+    return this.get("/api/system/env/local");
+  }
+  /**
+   * Update (overwrite or merge) the local .env file on the ElizaOS server.
+   *
+   * Server route (packages/server/src/api/system):
+   *   POST /api/system/env/local  ->  { success: true, message: string }
+   *   Body: { content: Record<string,string> }
+   *
+   * For developer-ergonomics we accept several shapes:
+   *   1. { variables: Record<string,string>; merge?: boolean }
+   *   2. { content:   Record<string,string> }      (server-native)
+   *   3. Record<string,string>                      (shorthand)
+   */
+  async updateLocalEnvironment(params) {
+    if (!params || typeof params !== "object") {
+      throw new Error("updateLocalEnvironment requires a configuration object");
+    }
+    let body;
+    if ("variables" in params) {
+      body = { content: params.variables };
+    } else if ("content" in params) {
+      body = { content: params.content };
+    } else {
+      body = { content: params };
+    }
+    return this.post("/api/system/env/local", body);
+  }
+};
+
+// src/client.ts
+var ElizaClient = class _ElizaClient {
+  agents;
+  messaging;
+  memory;
+  audio;
+  media;
+  server;
+  system;
+  constructor(config) {
+    this.agents = new AgentsService(config);
+    this.messaging = new MessagingService(config);
+    this.memory = new MemoryService(config);
+    this.audio = new AudioService(config);
+    this.media = new MediaService(config);
+    this.server = new ServerService(config);
+    this.system = new SystemService(config);
+  }
+  /**
+   * Create a new ElizaClient instance
+   */
+  static create(config) {
+    return new _ElizaClient(config);
+  }
+};
+export {
+  AgentsService,
+  ApiError,
+  AudioService,
+  BaseApiClient,
+  ElizaClient,
+  MediaService,
+  MemoryService,
+  MessagingService,
+  ServerService,
+  SystemService
+};
+//# sourceMappingURL=index.js.map