@elizaos/api-client 1.0.12

package/dist/index.d.ts

@@ -0,0 +1,776 @@
+import { UUID, ChannelType } from '@elizaos/core';
+
+interface ApiSuccessResponse<T> {
+    success: true;
+    data: T;
+}
+interface ApiErrorResponse {
+    success: false;
+    error: {
+        code: string;
+        message: string;
+        details?: string;
+    };
+}
+type ApiResponse<T> = ApiSuccessResponse<T> | ApiErrorResponse;
+interface RequestConfig {
+    headers?: Record<string, string>;
+    params?: Record<string, any>;
+    timeout?: number;
+}
+interface PaginationParams {
+    page?: number;
+    limit?: number;
+    offset?: number;
+}
+interface ApiClientConfig {
+    baseUrl: string;
+    apiKey?: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+}
+
+declare class ApiError extends Error {
+    code: string;
+    details?: string;
+    status?: number;
+    constructor(code: string, message: string, details?: string, status?: number);
+}
+declare abstract class BaseApiClient {
+    protected baseUrl: string;
+    protected apiKey?: string;
+    protected timeout: number;
+    protected defaultHeaders: Record<string, string>;
+    constructor(config: ApiClientConfig);
+    protected request<T>(method: string, path: string, options?: {
+        body?: any;
+        params?: Record<string, any>;
+        headers?: Record<string, string>;
+        config?: RequestConfig;
+    }): Promise<T>;
+    protected get<T>(path: string, options?: Omit<Parameters<typeof this.request>[2], 'body'>): Promise<T>;
+    protected post<T>(path: string, body?: any, options?: Parameters<typeof this.request>[2]): Promise<T>;
+    protected put<T>(path: string, body?: any, options?: Parameters<typeof this.request>[2]): Promise<T>;
+    protected patch<T>(path: string, body?: any, options?: Parameters<typeof this.request>[2]): Promise<T>;
+    protected delete<T>(path: string, options?: Omit<Parameters<typeof this.request>[2], 'body'>): Promise<T>;
+}
+
+interface Agent {
+    id: UUID;
+    name: string;
+    description?: string;
+    status: 'active' | 'inactive' | 'stopped';
+    createdAt: Date;
+    updatedAt: Date;
+    metadata?: Record<string, any>;
+}
+interface AgentCreateParams {
+    name: string;
+    description?: string;
+    metadata?: Record<string, any>;
+}
+interface AgentUpdateParams {
+    name?: string;
+    description?: string;
+    metadata?: Record<string, any>;
+}
+interface AgentWorld {
+    id: UUID;
+    name: string;
+    description?: string;
+    agents?: Agent[];
+}
+interface AgentWorldSettings {
+    worldId: UUID;
+    settings: Record<string, any>;
+}
+interface AgentPanel {
+    id: string;
+    name: string;
+    url: string;
+    type: string;
+    metadata?: Record<string, any>;
+}
+interface AgentLog {
+    id: UUID;
+    agentId: UUID;
+    level: 'debug' | 'info' | 'warn' | 'error';
+    message: string;
+    timestamp: Date;
+    metadata?: Record<string, any>;
+}
+interface AgentLogsParams extends PaginationParams {
+    level?: 'debug' | 'info' | 'warn' | 'error';
+    from?: Date | string;
+    to?: Date | string;
+    search?: string;
+}
+
+declare class AgentsService extends BaseApiClient {
+    /**
+     * List all agents with minimal details
+     */
+    listAgents(): Promise<{
+        agents: Agent[];
+    }>;
+    /**
+     * Get specific agent details
+     */
+    getAgent(agentId: UUID): Promise<Agent>;
+    /**
+     * Create a new agent
+     */
+    createAgent(params: AgentCreateParams): Promise<Agent>;
+    /**
+     * Update an existing agent
+     */
+    updateAgent(agentId: UUID, params: AgentUpdateParams): Promise<Agent>;
+    /**
+     * Delete an agent
+     */
+    deleteAgent(agentId: UUID): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Start an existing agent
+     */
+    startAgent(agentId: UUID): Promise<{
+        status: string;
+    }>;
+    /**
+     * Stop a running agent
+     */
+    stopAgent(agentId: UUID): Promise<{
+        status: string;
+    }>;
+    /**
+     * Get all available worlds
+     */
+    getWorlds(): Promise<{
+        worlds: AgentWorld[];
+    }>;
+    /**
+     * Add agent to a world
+     */
+    addAgentToWorld(agentId: UUID, worldId: UUID): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Update agent's world settings
+     */
+    updateAgentWorldSettings(agentId: UUID, worldId: UUID, settings: Record<string, any>): Promise<AgentWorldSettings>;
+    /**
+     * Get agent's plugin panels
+     */
+    getAgentPanels(agentId: UUID): Promise<{
+        panels: AgentPanel[];
+    }>;
+    /**
+     * Get agent logs
+     */
+    getAgentLogs(agentId: UUID, params?: AgentLogsParams): Promise<{
+        logs: AgentLog[];
+    }>;
+    /**
+     * Delete a specific log entry
+     */
+    deleteAgentLog(agentId: UUID, logId: UUID): Promise<{
+        success: boolean;
+    }>;
+}
+
+interface MessageServer {
+    id: UUID;
+    name: string;
+    sourceType: string;
+    sourceId?: string;
+    metadata?: Record<string, any>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface MessageChannel {
+    id: UUID;
+    messageServerId: UUID;
+    name: string;
+    type: ChannelType;
+    sourceType?: string;
+    sourceId?: string;
+    topic?: string;
+    metadata?: Record<string, any>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface Message {
+    id: UUID;
+    channelId: UUID;
+    authorId: UUID;
+    content: string;
+    rawMessage?: any;
+    inReplyToRootMessageId?: UUID;
+    sourceType?: string;
+    sourceId?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    metadata?: Record<string, any>;
+}
+interface MessageSubmitParams {
+    agentId: UUID;
+    channelId: UUID;
+    content: string;
+    inReplyToMessageId?: UUID;
+    metadata?: Record<string, any>;
+}
+interface MessageCompleteParams {
+    messageId: UUID;
+    status: 'completed' | 'failed';
+    error?: string;
+}
+interface ExternalMessageParams {
+    platform: string;
+    channelId: string;
+    messages: Array<{
+        id: string;
+        authorId: string;
+        content: string;
+        timestamp: number;
+        metadata?: Record<string, any>;
+    }>;
+}
+interface ChannelCreateParams {
+    name: string;
+    type: ChannelType;
+    serverId?: UUID;
+    metadata?: Record<string, any>;
+}
+interface GroupChannelCreateParams {
+    name: string;
+    participantIds: UUID[];
+    metadata?: Record<string, any>;
+}
+interface DmChannelParams {
+    participantIds: [UUID, UUID];
+}
+interface ChannelParticipant {
+    id: UUID;
+    channelId: UUID;
+    userId: UUID;
+    role?: string;
+    joinedAt: Date;
+}
+interface MessageSearchParams extends PaginationParams {
+    query?: string;
+    channelId?: UUID;
+    authorId?: UUID;
+    from?: Date | string;
+    to?: Date | string;
+}
+interface ServerCreateParams {
+    name: string;
+    sourceType: string;
+    sourceId?: string;
+    metadata?: Record<string, any>;
+}
+interface ServerSyncParams {
+    channels: Array<{
+        name: string;
+        type: ChannelType;
+        sourceId: string;
+    }>;
+}
+
+declare class MessagingService extends BaseApiClient {
+    /**
+     * Submit agent replies or system messages
+     */
+    submitMessage(params: MessageSubmitParams): Promise<Message>;
+    /**
+     * Notify message completion
+     */
+    completeMessage(params: MessageCompleteParams): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Ingest messages from external platforms
+     */
+    ingestExternalMessages(params: ExternalMessageParams): Promise<{
+        processed: number;
+    }>;
+    /**
+     * Create a new channel
+     */
+    createChannel(params: ChannelCreateParams): Promise<MessageChannel>;
+    /**
+     * Create a group channel
+     */
+    createGroupChannel(params: GroupChannelCreateParams): Promise<MessageChannel>;
+    /**
+     * Find or create a DM channel
+     */
+    getOrCreateDmChannel(params: DmChannelParams): Promise<MessageChannel>;
+    /**
+     * Get channel details
+     */
+    getChannelDetails(channelId: UUID): Promise<MessageChannel>;
+    /**
+     * Get channel participants
+     */
+    getChannelParticipants(channelId: UUID): Promise<{
+        participants: ChannelParticipant[];
+    }>;
+    /**
+     * Add agent to channel
+     */
+    addAgentToChannel(channelId: UUID, agentId: UUID): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Remove agent from channel
+     */
+    removeAgentFromChannel(channelId: UUID, agentId: UUID): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Delete a channel
+     */
+    deleteChannel(channelId: UUID): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Clear channel history
+     */
+    clearChannelHistory(channelId: UUID): Promise<{
+        deleted: number;
+    }>;
+    /**
+     * Post a new message to a channel
+     */
+    postMessage(channelId: UUID, content: string, metadata?: Record<string, any>): Promise<Message>;
+    /**
+     * Get channel messages
+     */
+    getChannelMessages(channelId: UUID, params?: PaginationParams & {
+        before?: Date | string;
+        after?: Date | string;
+    }): Promise<{
+        messages: Message[];
+    }>;
+    /**
+     * Get a specific message
+     */
+    getMessage(messageId: UUID): Promise<Message>;
+    /**
+     * Delete a message
+     */
+    deleteMessage(messageId: UUID): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Update a message
+     */
+    updateMessage(messageId: UUID, content: string): Promise<Message>;
+    /**
+     * Search messages
+     */
+    searchMessages(params: MessageSearchParams): Promise<{
+        messages: Message[];
+    }>;
+    /**
+     * List all message servers
+     */
+    listServers(): Promise<{
+        servers: MessageServer[];
+    }>;
+    /**
+     * Get server channels
+     */
+    getServerChannels(serverId: UUID): Promise<{
+        channels: MessageChannel[];
+    }>;
+    /**
+     * Create a new server
+     */
+    createServer(params: ServerCreateParams): Promise<MessageServer>;
+    /**
+     * Sync server channels
+     */
+    syncServerChannels(serverId: UUID, params: ServerSyncParams): Promise<{
+        synced: number;
+    }>;
+    /**
+     * Delete a server
+     */
+    deleteServer(serverId: UUID): Promise<{
+        success: boolean;
+    }>;
+}
+
+interface Memory {
+    id: UUID;
+    agentId: UUID;
+    roomId?: UUID;
+    type: string;
+    content: any;
+    embedding?: number[];
+    createdAt: Date;
+    updatedAt: Date;
+    metadata?: Record<string, any>;
+}
+interface Room {
+    id: UUID;
+    agentId: UUID;
+    name: string;
+    type?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    metadata?: Record<string, any>;
+}
+interface MemoryParams extends PaginationParams {
+    type?: string;
+    search?: string;
+    from?: Date | string;
+    to?: Date | string;
+}
+interface MemoryUpdateParams {
+    content?: any;
+    metadata?: Record<string, any>;
+}
+interface RoomCreateParams {
+    name: string;
+    type?: string;
+    metadata?: Record<string, any>;
+}
+interface WorldCreateParams {
+    serverId: UUID;
+    name: string;
+    description?: string;
+}
+
+declare class MemoryService extends BaseApiClient {
+    /**
+     * Get agent memories
+     */
+    getAgentMemories(agentId: UUID, params?: MemoryParams): Promise<{
+        memories: Memory[];
+    }>;
+    /**
+     * Get room-specific memories
+     */
+    getRoomMemories(agentId: UUID, roomId: UUID, params?: MemoryParams): Promise<{
+        memories: Memory[];
+    }>;
+    /**
+     * Update a memory
+     */
+    updateMemory(agentId: UUID, memoryId: UUID, params: MemoryUpdateParams): Promise<Memory>;
+    /**
+     * Clear all agent memories
+     */
+    clearAgentMemories(agentId: UUID): Promise<{
+        deleted: number;
+    }>;
+    /**
+     * Clear room memories
+     */
+    clearRoomMemories(agentId: UUID, roomId: UUID): Promise<{
+        deleted: number;
+    }>;
+    /**
+     * List agent's rooms
+     */
+    listAgentRooms(agentId: UUID): Promise<{
+        rooms: Room[];
+    }>;
+    /**
+     * Get room details
+     */
+    getRoom(agentId: UUID, roomId: UUID): Promise<Room>;
+    /**
+     * Create a room
+     */
+    createRoom(agentId: UUID, params: RoomCreateParams): Promise<Room>;
+    /**
+     * Create world from server
+     */
+    createWorldFromServer(serverId: UUID, params: WorldCreateParams): Promise<{
+        worldId: UUID;
+    }>;
+    /**
+     * Delete a world
+     */
+    deleteWorld(serverId: UUID): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Clear world memories
+     */
+    clearWorldMemories(serverId: UUID): Promise<{
+        deleted: number;
+    }>;
+}
+
+interface SpeechConversationParams {
+    audio: Blob | Buffer | string;
+    format?: 'mp3' | 'wav' | 'ogg' | 'webm';
+    language?: string;
+    metadata?: Record<string, any>;
+}
+interface SpeechGenerateParams {
+    text: string;
+    voice?: string;
+    language?: string;
+    speed?: number;
+    pitch?: number;
+}
+interface AudioSynthesizeParams {
+    messageId: UUID;
+    voice?: string;
+    format?: 'mp3' | 'wav' | 'ogg';
+}
+interface TranscribeParams {
+    audio: Blob | Buffer | string;
+    format?: 'mp3' | 'wav' | 'ogg' | 'webm';
+    language?: string;
+}
+interface SpeechResponse {
+    text?: string;
+    audio?: string;
+    duration?: number;
+    metadata?: Record<string, any>;
+}
+interface TranscriptionResponse {
+    text: string;
+    language?: string;
+    confidence?: number;
+    words?: Array<{
+        word: string;
+        start: number;
+        end: number;
+        confidence?: number;
+    }>;
+}
+
+declare class AudioService extends BaseApiClient {
+    /**
+     * Convert audio input to appropriate FormData value
+     */
+    private processAudioInput;
+    /**
+     * Check if a string appears to be base64 encoded
+     */
+    private isBase64String;
+    /**
+     * Safe check for Buffer type (works in both Node.js and browser environments)
+     */
+    private isBuffer;
+    /**
+     * Handle speech conversation
+     */
+    speechConversation(agentId: UUID, params: SpeechConversationParams): Promise<SpeechResponse>;
+    /**
+     * Generate speech from text
+     */
+    generateSpeech(agentId: UUID, params: SpeechGenerateParams): Promise<{
+        audio: string;
+        format: string;
+    }>;
+    /**
+     * Synthesize audio message
+     */
+    synthesizeAudioMessage(agentId: UUID, params: AudioSynthesizeParams): Promise<{
+        audio: string;
+        format: string;
+    }>;
+    /**
+     * Transcribe audio to text
+     */
+    transcribe(agentId: UUID, params: TranscribeParams): Promise<TranscriptionResponse>;
+    /**
+     * Process speech input
+     */
+    processSpeech(agentId: UUID, audio: Blob | Buffer | string, metadata?: Record<string, any>): Promise<SpeechResponse>;
+}
+
+interface MediaUploadParams {
+    file: File | Blob;
+    filename?: string;
+    contentType?: string;
+    metadata?: Record<string, any>;
+}
+interface MediaUploadResponse {
+    id: UUID;
+    filename: string;
+    url: string;
+    size: number;
+    contentType: string;
+    uploadedAt: Date;
+    metadata?: Record<string, any>;
+}
+interface ChannelUploadParams {
+    files: Array<File | Blob>;
+    messageId?: UUID;
+    metadata?: Record<string, any>;
+}
+interface ChannelUploadResponse {
+    uploads: MediaUploadResponse[];
+    totalSize: number;
+}
+
+declare class MediaService extends BaseApiClient {
+    /**
+     * Upload media for an agent
+     */
+    uploadAgentMedia(agentId: UUID, params: MediaUploadParams): Promise<MediaUploadResponse>;
+    /**
+     * Upload files to a channel
+     */
+    uploadChannelFiles(channelId: UUID, params: ChannelUploadParams): Promise<ChannelUploadResponse>;
+}
+
+interface ServerHealth {
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    uptime: number;
+    timestamp: Date;
+    version?: string;
+    checks?: Record<string, {
+        status: 'pass' | 'fail';
+        message?: string;
+    }>;
+}
+interface ServerStatus {
+    agents: {
+        total: number;
+        active: number;
+        inactive: number;
+    };
+    memory: {
+        used: number;
+        total: number;
+        percentage: number;
+    };
+    uptime: number;
+    version: string;
+}
+interface ServerDebugInfo {
+    runtime: {
+        agents: Array<{
+            id: UUID;
+            name: string;
+            status: string;
+        }>;
+        connections: number;
+        memory: any;
+    };
+    environment: Record<string, string>;
+}
+interface LogSubmitParams {
+    level: 'debug' | 'info' | 'warn' | 'error';
+    message: string;
+    source?: string;
+    metadata?: Record<string, any>;
+}
+
+declare class ServerService extends BaseApiClient {
+    /**
+     * Health check
+     */
+    checkHealth(): Promise<ServerHealth>;
+    /**
+     * Simple ping
+     */
+    ping(): Promise<{
+        pong: boolean;
+    }>;
+    /**
+     * Hello endpoint
+     */
+    hello(): Promise<{
+        message: string;
+    }>;
+    /**
+     * Get server status
+     */
+    getStatus(): Promise<ServerStatus>;
+    /**
+     * Stop the server
+     */
+    stopServer(): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Get runtime debug info
+     */
+    getDebugInfo(): Promise<ServerDebugInfo>;
+    /**
+     * Submit logs
+     */
+    submitLogs(logs: LogSubmitParams[]): Promise<{
+        received: number;
+    }>;
+    /**
+     * Clear logs
+     */
+    clearLogs(): Promise<{
+        cleared: number;
+    }>;
+}
+
+interface SystemEnvironment {
+    nodeVersion: string;
+    platform: string;
+    environment: 'development' | 'production' | 'test';
+    features: {
+        authentication: boolean;
+        tee: boolean;
+        plugins: string[];
+    };
+    configuration: Record<string, any>;
+}
+interface LocalEnvironmentUpdateParams {
+    variables: Record<string, string>;
+    merge?: boolean;
+}
+
+declare class SystemService 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> }
+     */
+    getEnvironment(): Promise<Record<string, string>>;
+    /**
+     * 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)
+     */
+    updateLocalEnvironment(params: LocalEnvironmentUpdateParams | {
+        content: Record<string, string>;
+    } | Record<string, string>): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+}
+
+declare class ElizaClient {
+    readonly agents: AgentsService;
+    readonly messaging: MessagingService;
+    readonly memory: MemoryService;
+    readonly audio: AudioService;
+    readonly media: MediaService;
+    readonly server: ServerService;
+    readonly system: SystemService;
+    constructor(config: ApiClientConfig);
+    /**
+     * Create a new ElizaClient instance
+     */
+    static create(config: ApiClientConfig): ElizaClient;
+}
+
+export { type Agent, type AgentCreateParams, type AgentLog, type AgentLogsParams, type AgentPanel, type AgentUpdateParams, type AgentWorld, type AgentWorldSettings, AgentsService, type ApiClientConfig, ApiError, type ApiErrorResponse, type ApiResponse, type ApiSuccessResponse, AudioService, type AudioSynthesizeParams, BaseApiClient, type ChannelCreateParams, type ChannelParticipant, type ChannelUploadParams, type ChannelUploadResponse, type DmChannelParams, ElizaClient, type ExternalMessageParams, type GroupChannelCreateParams, type LocalEnvironmentUpdateParams, type LogSubmitParams, MediaService, type MediaUploadParams, type MediaUploadResponse, type Memory, type MemoryParams, MemoryService, type MemoryUpdateParams, type Message, type MessageChannel, type MessageCompleteParams, type MessageSearchParams, type MessageServer, type MessageSubmitParams, MessagingService, type PaginationParams, type RequestConfig, type Room, type RoomCreateParams, type ServerCreateParams, type ServerDebugInfo, type ServerHealth, ServerService, type ServerStatus, type ServerSyncParams, type SpeechConversationParams, type SpeechGenerateParams, type SpeechResponse, type SystemEnvironment, SystemService, type TranscribeParams, type TranscriptionResponse, type WorldCreateParams };