@elizaos/core 1.0.0-alpha.48 → 1.0.0-alpha.49

package/dist/runtime.d.ts

@@ -1,290 +0,0 @@
-import { type Action, type Agent, ChannelType, type Character, type Component, type Entity, type Evaluator, type HandlerCallback, type IAgentRuntime, type IDatabaseAdapter, type IMemoryManager, type KnowledgeItem, type Memory, type ModelParamsMap, type ModelResultMap, type ModelType, type Participant, type Plugin, type Provider, type Relationship, type Room, type Route, type Service, type ServiceType, type State, type Task, type TaskWorker, type UUID, type World } from "./types";
-/**
- * Represents the runtime environment for an agent, handling message processing,
- * action registration, and interaction with external services like OpenAI and Supabase.
- */
-/**
- * Represents the runtime environment for an agent.
- * @class
- * @implements { IAgentRuntime }
- * @property { number } #conversationLength - The maximum length of a conversation.
- * @property { UUID } agentId - The unique identifier for the agent.
- * @property { Character } character - The character associated with the agent.
- * @property { IDatabaseAdapter } databaseAdapter - The adapter for interacting with the database.
- * @property {Action[]} actions - The list of actions available to the agent.
- * @property {Evaluator[]} evaluators - The list of evaluators for decision making.
- * @property {Provider[]} providers - The list of providers for external services.
- * @property {Plugin[]} plugins - The list of plugins to extend functionality.
- */
-export declare class AgentRuntime implements IAgentRuntime {
-    #private;
-    readonly agentId: UUID;
-    readonly character: Character;
-    databaseAdapter: IDatabaseAdapter;
-    readonly actions: Action[];
-    readonly evaluators: Evaluator[];
-    readonly providers: Provider[];
-    readonly plugins: Plugin[];
-    events: Map<string, ((params: any) => Promise<void>)[]>;
-    stateCache: Map<`${string}-${string}-${string}-${string}-${string}`, {
-        values: {
-            [key: string]: any;
-        };
-        data: {
-            [key: string]: any;
-        };
-        text: string;
-    }>;
-    readonly fetch: typeof fetch;
-    services: Map<ServiceType, Service>;
-    adapter: IDatabaseAdapter;
-    private readonly knowledgeRoot;
-    models: Map<string, ((params: any) => Promise<any>)[]>;
-    routes: Route[];
-    private taskWorkers;
-    private eventHandlers;
-    constructor(opts: {
-        conversationLength?: number;
-        agentId?: UUID;
-        character?: Character;
-        plugins?: Plugin[];
-        fetch?: typeof fetch;
-        databaseAdapter?: IDatabaseAdapter;
-        adapter?: IDatabaseAdapter;
-        events?: {
-            [key: string]: ((params: any) => void)[];
-        };
-        ignoreBootstrap?: boolean;
-    });
-    /**
-     * Registers a plugin with the runtime and initializes its components
-     * @param plugin The plugin to register
-     */
-    registerPlugin(plugin: Plugin): Promise<void>;
-    getAllServices(): Map<ServiceType, Service>;
-    stop(): Promise<void>;
-    initialize(): Promise<void>;
-    private handleProcessingError;
-    private checkExistingKnowledge;
-    getKnowledge(message: Memory): Promise<KnowledgeItem[]>;
-    addKnowledge(item: KnowledgeItem, options?: {
-        targetTokens: number;
-        overlap: number;
-        modelContextSize: number;
-    }): Promise<void>;
-    processCharacterKnowledge(items: string[]): Promise<void>;
-    setSetting(key: string, value: string | boolean | null | any, secret?: boolean): void;
-    getSetting(key: string): string | boolean | null | any;
-    /**
-     * Get the number of messages that are kept in the conversation buffer.
-     * @returns The number of recent messages to be kept in memory.
-     */
-    getConversationLength(): number;
-    registerDatabaseAdapter(adapter: IDatabaseAdapter): void;
-    /**
-     * Register a provider for the agent to use.
-     * @param provider The provider to register.
-     */
-    registerProvider(provider: Provider): void;
-    /**
-     * Register an action for the agent to perform.
-     * @param action The action to register.
-     */
-    registerAction(action: Action): void;
-    /**
-     * Register an evaluator to assess and guide the agent's responses.
-     * @param evaluator The evaluator to register.
-     */
-    registerEvaluator(evaluator: Evaluator): void;
-    /**
-     * Register a context provider to provide context for message generation.
-     * @param provider The context provider to register.
-     */
-    registerContextProvider(provider: Provider): void;
-    /**
-     * Process the actions of a message.
-     * @param message The message to process.
-     * @param responses The array of response memories to process actions from.
-     * @param state Optional state object for the action processing.
-     * @param callback Optional callback handler for action results.
-     */
-    processActions(message: Memory, responses: Memory[], state?: State, callback?: HandlerCallback): Promise<void>;
-    /**
-     * Evaluate the message and state using the registered evaluators.
-     * @param message The message to evaluate.
-     * @param state The state of the agent.
-     * @param didRespond Whether the agent responded to the message.~
-     * @param callback The handler callback
-     * @returns The results of the evaluation.
-     */
-    evaluate(message: Memory, state: State, didRespond?: boolean, callback?: HandlerCallback, responses?: Memory[]): Promise<Evaluator[]>;
-    ensureParticipantInRoom(entityId: UUID, roomId: UUID): Promise<void>;
-    ensureConnection({ entityId, roomId, userName, name, source, type, channelId, serverId, worldId, }: {
-        entityId: UUID;
-        roomId: UUID;
-        userName?: string;
-        name?: string;
-        source?: string;
-        type?: ChannelType;
-        channelId?: string;
-        serverId?: string;
-        worldId?: UUID;
-    }): Promise<void>;
-    /**
-     * Ensure the existence of a world.
-     */
-    ensureWorldExists({ id, name, serverId, metadata }: World): Promise<void>;
-    /**
-     * Ensure the existence of a room between the agent and a user. If no room exists, a new room is created and the user
-     * and agent are added as participants. The room ID is returned.
-     * @param entityId - The user ID to create a room with.
-     * @returns The room ID of the room between the agent and the user.
-     * @throws An error if the room cannot be created.
-     */
-    ensureRoomExists({ id, name, source, type, channelId, serverId, worldId, }: Room): Promise<void>;
-    /**
-     * Composes the agent's state by gathering data from enabled providers.
-     * @param message - The message to use as context for state composition
-     * @param filterList - Optional list of provider names to include, filtering out all others
-     * @param includeList - Optional list of private provider names to include that would otherwise be filtered out
-     * @returns A State object containing provider data, values, and text
-     */
-    composeState(message: Memory, filterList?: string[] | null, // only get providers that are in the filterList
-    includeList?: string[] | null): Promise<State>;
-    getMemoryManager(tableName: string): IMemoryManager | null;
-    getService<T extends Service>(service: ServiceType): T | null;
-    registerService(service: typeof Service): Promise<void>;
-    registerModel(modelType: ModelType, handler: (params: any) => Promise<any>): void;
-    getModel(modelType: ModelType): ((runtime: IAgentRuntime, params: any) => Promise<any>) | undefined;
-    /**
-     * Use a model with strongly typed parameters and return values based on model type
-     * @template T - The model type to use
-     * @template R - The expected return type, defaults to the type defined in ModelResultMap[T]
-     * @param {T} modelType - The type of model to use
-     * @param {ModelParamsMap[T] | any} params - The parameters for the model, typed based on model type
-     * @returns {Promise<R>} - The model result, typed based on the provided generic type parameter
-     */
-    useModel<T extends ModelType, R = ModelResultMap[T]>(modelType: T, params: Omit<ModelParamsMap[T], "runtime"> | any): Promise<R>;
-    registerEvent(event: string, handler: (params: any) => Promise<void>): void;
-    getEvent(event: string): ((params: any) => Promise<void>)[] | undefined;
-    emitEvent(event: string | string[], params: any): Promise<void>;
-    ensureEmbeddingDimension(): Promise<void>;
-    registerTaskWorker(taskHandler: TaskWorker): void;
-    /**
-     * Get a task worker by name
-     */
-    getTaskWorker(name: string): TaskWorker | undefined;
-    get db(): any;
-    init(): Promise<void>;
-    close(): Promise<void>;
-    getAgent(agentId: UUID): Promise<Agent | null>;
-    getAgents(): Promise<Agent[]>;
-    createAgent(agent: Partial<Agent>): Promise<boolean>;
-    updateAgent(agentId: UUID, agent: Partial<Agent>): Promise<boolean>;
-    deleteAgent(agentId: UUID): Promise<boolean>;
-    ensureAgentExists(agent: Partial<Agent>): Promise<void>;
-    getEntityById(entityId: UUID): Promise<Entity | null>;
-    getEntitiesForRoom(roomId: UUID, includeComponents?: boolean): Promise<Entity[]>;
-    createEntity(entity: Entity): Promise<boolean>;
-    updateEntity(entity: Entity): Promise<void>;
-    getComponent(entityId: UUID, type: string, worldId?: UUID, sourceEntityId?: UUID): Promise<Component | null>;
-    getComponents(entityId: UUID, worldId?: UUID, sourceEntityId?: UUID): Promise<Component[]>;
-    createComponent(component: Component): Promise<boolean>;
-    updateComponent(component: Component): Promise<void>;
-    deleteComponent(componentId: UUID): Promise<void>;
-    getMemories(params: {
-        roomId: UUID;
-        count?: number;
-        unique?: boolean;
-        tableName: string;
-        start?: number;
-        end?: number;
-    }): Promise<Memory[]>;
-    getMemoryById(id: UUID): Promise<Memory | null>;
-    getMemoriesByIds(ids: UUID[], tableName?: string): Promise<Memory[]>;
-    getMemoriesByRoomIds(params: {
-        tableName: string;
-        roomIds: UUID[];
-        limit?: number;
-    }): Promise<Memory[]>;
-    getCachedEmbeddings(params: {
-        query_table_name: string;
-        query_threshold: number;
-        query_input: string;
-        query_field_name: string;
-        query_field_sub_name: string;
-        query_match_count: number;
-    }): Promise<{
-        embedding: number[];
-        levenshtein_score: number;
-    }[]>;
-    log(params: {
-        body: {
-            [key: string]: unknown;
-        };
-        entityId: UUID;
-        roomId: UUID;
-        type: string;
-    }): Promise<void>;
-    searchMemories(params: {
-        embedding: number[];
-        match_threshold?: number;
-        count?: number;
-        roomId?: UUID;
-        unique?: boolean;
-        tableName: string;
-    }): Promise<Memory[]>;
-    createMemory(memory: Memory, tableName: string, unique?: boolean): Promise<UUID>;
-    removeMemory(memoryId: UUID, tableName: string): Promise<void>;
-    removeAllMemories(roomId: UUID, tableName: string): Promise<void>;
-    countMemories(roomId: UUID, unique?: boolean, tableName?: string): Promise<number>;
-    createWorld(world: World): Promise<UUID>;
-    getWorld(id: UUID): Promise<World | null>;
-    getAllWorlds(): Promise<World[]>;
-    updateWorld(world: World): Promise<void>;
-    getRoom(roomId: UUID): Promise<Room | null>;
-    createRoom({ id, name, source, type, channelId, serverId, worldId, }: Room): Promise<UUID>;
-    deleteRoom(roomId: UUID): Promise<void>;
-    updateRoom(room: Room): Promise<void>;
-    getRoomsForParticipant(entityId: UUID): Promise<UUID[]>;
-    getRoomsForParticipants(userIds: UUID[]): Promise<UUID[]>;
-    getRooms(worldId: UUID): Promise<Room[]>;
-    addParticipant(entityId: UUID, roomId: UUID): Promise<boolean>;
-    removeParticipant(entityId: UUID, roomId: UUID): Promise<boolean>;
-    getParticipantsForEntity(entityId: UUID): Promise<Participant[]>;
-    getParticipantsForRoom(roomId: UUID): Promise<UUID[]>;
-    getParticipantUserState(roomId: UUID, entityId: UUID): Promise<"FOLLOWED" | "MUTED" | null>;
-    setParticipantUserState(roomId: UUID, entityId: UUID, state: "FOLLOWED" | "MUTED" | null): Promise<void>;
-    createRelationship(params: {
-        sourceEntityId: UUID;
-        targetEntityId: UUID;
-        tags?: string[];
-        metadata?: {
-            [key: string]: any;
-        };
-    }): Promise<boolean>;
-    updateRelationship(relationship: Relationship): Promise<void>;
-    getRelationship(params: {
-        sourceEntityId: UUID;
-        targetEntityId: UUID;
-    }): Promise<Relationship | null>;
-    getRelationships(params: {
-        entityId: UUID;
-        tags?: string[];
-    }): Promise<Relationship[]>;
-    getCache<T>(key: string): Promise<T | undefined>;
-    setCache<T>(key: string, value: T): Promise<boolean>;
-    deleteCache(key: string): Promise<boolean>;
-    createTask(task: Task): Promise<UUID>;
-    getTasks(params: {
-        roomId?: UUID;
-        tags?: string[];
-    }): Promise<Task[]>;
-    getTask(id: UUID): Promise<Task | null>;
-    getTasksByName(name: string): Promise<Task[]>;
-    updateTask(id: UUID, task: Partial<Task>): Promise<void>;
-    deleteTask(id: UUID): Promise<void>;
-    on(event: string, callback: (data: any) => void): void;
-    off(event: string, callback: (data: any) => void): void;
-    emit(event: string, data: any): void;
-}

package/dist/services/scenario.d.ts

@@ -1,106 +0,0 @@
-import { type IAgentRuntime, Service, type UUID } from "../types";
-interface ActionTracker {
-    actionId: UUID;
-    actionName: string;
-    startTime: number;
-    completed: boolean;
-    error?: Error;
-}
-interface EvaluatorTracker {
-    evaluatorId: UUID;
-    evaluatorName: string;
-    startTime: number;
-    completed: boolean;
-    error?: Error;
-}
-/**
- * Represents a service that allows the agent to interact in a scenario testing environment.
- * The agent can create rooms, send messages, and communicate with other agents in a live interactive testing environment.
- * @extends Service
- */
-export declare class ScenarioService extends Service {
-    protected runtime: IAgentRuntime;
-    static serviceType: string;
-    capabilityDescription: string;
-    private messageHandlers;
-    private worlds;
-    private activeActions;
-    private activeEvaluators;
-    /**
-     * Constructor for creating a new instance of the class.
-     *
-     * @param runtime - The IAgentRuntime instance to be passed to the constructor.
-     */
-    constructor(runtime: IAgentRuntime);
-    private setupEventListeners;
-    /**
-     * Start the scenario service with the given runtime.
-     * @param {IAgentRuntime} runtime - The agent runtime
-     * @returns {Promise<ScenarioService>} - The started scenario service
-     */
-    static start(runtime: IAgentRuntime): Promise<ScenarioService>;
-    /**
-     * Stops the Scenario service associated with the given runtime.
-     *
-     * @param {IAgentRuntime} runtime The runtime to stop the service for.
-     * @throws {Error} When the Scenario service is not found.
-     */
-    static stop(runtime: IAgentRuntime): Promise<void>;
-    /**
-     * Asynchronously stops the current process by clearing all message handlers and worlds.
-     */
-    stop(): Promise<void>;
-    /**
-     * Creates a new world with the specified name and owner.
-     * @param name The name of the world
-     * @param ownerName The name of the world owner
-     * @returns The created world's ID
-     */
-    createWorld(name: string, ownerName: string): Promise<UUID>;
-    /**
-     * Creates a room in the specified world.
-     * @param worldId The ID of the world to create the room in
-     * @param name The name of the room
-     * @returns The created room's ID
-     */
-    createRoom(worldId: UUID, name: string): Promise<UUID>;
-    /**
-     * Adds a participant to a room
-     * @param worldId The world ID
-     * @param roomId The room ID
-     * @param participantId The participant's ID
-     */
-    addParticipant(worldId: UUID, roomId: UUID, participantId: UUID): Promise<void>;
-    /**
-     * Sends a message in a specific room
-     * @param sender The runtime of the sending agent
-     * @param worldId The world ID
-     * @param roomId The room ID
-     * @param text The message text
-     */
-    sendMessage(sender: IAgentRuntime, worldId: UUID, roomId: UUID, text: string): Promise<void>;
-    /**
-     * Waits for all active actions and evaluators to complete
-     * @param timeout Maximum time to wait in milliseconds
-     * @returns True if all completed successfully, false if timeout occurred
-     */
-    waitForCompletion(timeout?: number): Promise<boolean>;
-    /**
-     * Gets the current state of all active actions and evaluators
-     */
-    getActiveState(): {
-        actions: ActionTracker[];
-        evaluators: EvaluatorTracker[];
-    };
-    /**
-     * Cleans up the scenario state
-     */
-    cleanup(): Promise<void>;
-}
-/**
- * Asynchronously starts the specified scenario for the given list of agent runtimes.
- * @param {IAgentRuntime[]} members - The list of agent runtimes participating in the scenario.
- * @returns {Promise<void>} - A promise that resolves when all scenarios have been executed.
- */
-export declare function startScenario(members: IAgentRuntime[]): Promise<void>;
-export {};

package/dist/services/task.d.ts

@@ -1,72 +0,0 @@
-import { type IAgentRuntime, Service, type ServiceType } from "../types";
-/**
- * TaskService class representing a service that schedules and executes tasks.
- * @extends Service
- * @property {NodeJS.Timeout|null} timer - Timer for executing tasks
- * @property {number} TICK_INTERVAL - Interval in milliseconds to check for tasks
- * @property {ServiceType} serviceType - Service type of TASK
- * @property {string} capabilityDescription - Description of the service's capability
- * @static
- * @method start - Static method to start the TaskService
- * @method createTestTasks - Method to create test tasks
- * @method startTimer - Private method to start the timer for checking tasks
- * @method validateTasks - Private method to validate tasks
- * @method checkTasks - Private method to check tasks and execute them
- * @method executeTask - Private method to execute a task
- * @static
- * @method stop - Static method to stop the TaskService
- * @method stop - Method to stop the TaskService
- */
-export declare class TaskService extends Service {
-    private timer;
-    private readonly TICK_INTERVAL;
-    static serviceType: ServiceType;
-    capabilityDescription: string;
-    /**
-     * Start the TaskService with the given runtime.
-     * @param {IAgentRuntime} runtime - The runtime for the TaskService.
-     * @returns {Promise<TaskService>} A promise that resolves with the TaskService instance.
-     */
-    static start(runtime: IAgentRuntime): Promise<TaskService>;
-    /**
-     * Asynchronously creates test tasks by registering task workers for repeating and one-time tasks,
-     * validates the tasks, executes the tasks, and creates the tasks if they do not already exist.
-     */
-    createTestTasks(): Promise<void>;
-    /**
-     * Starts a timer that runs a function to check tasks at a specified interval.
-     */
-    private startTimer;
-    /**
-     * Validates an array of Task objects.
-     * Skips tasks without IDs or if no worker is found for the task.
-     * If a worker has a `validate` function, it will run the validation using the `runtime`, `Memory`, and `State` parameters.
-     * If the validation fails, the task will be skipped and the error will be logged.
-     * @param {Task[]} tasks - An array of Task objects to validate.
-     * @returns {Promise<Task[]>} - A Promise that resolves with an array of validated Task objects.
-     */
-    private validateTasks;
-    /**
-     * Asynchronous method that checks tasks with "queue" tag, validates and sorts them, then executes them based on interval and tags.
-     *
-     * @returns {Promise<void>} Promise that resolves once all tasks are checked and executed
-     */
-    private checkTasks;
-    /**
-     * Executes a given task asynchronously.
-     *
-     * @param {Task} task - The task to be executed.
-     */
-    private executeTask;
-    /**
-     * Stops the TASK service in the given agent runtime.
-     *
-     * @param {IAgentRuntime} runtime - The agent runtime containing the service.
-     * @returns {Promise<void>} - A promise that resolves once the service has been stopped.
-     */
-    static stop(runtime: IAgentRuntime): Promise<void>;
-    /**
-     * Stops the timer if it is currently running.
-     */
-    stop(): Promise<void>;
-}

package/dist/settings.d.ts

@@ -1,13 +0,0 @@
-import type { IAgentRuntime, OnboardingConfig, World, WorldSettings } from "./types";
-/**
- * Updates settings state in world metadata
- */
-export declare function updateWorldSettings(runtime: IAgentRuntime, serverId: string, worldSettings: WorldSettings): Promise<boolean>;
-/**
- * Gets settings state from world metadata
- */
-export declare function getWorldSettings(runtime: IAgentRuntime, serverId: string): Promise<WorldSettings | null>;
-/**
- * Initializes settings configuration for a server
- */
-export declare function initializeOnboarding(runtime: IAgentRuntime, world: World, config: OnboardingConfig): Promise<WorldSettings | null>;

package/dist/test_resources/constants.d.ts

@@ -1,9 +0,0 @@
-import type { UUID } from "@elizaos/core";
-export declare const SERVER_URL = "http://localhost:7998";
-export declare const SUPABASE_URL = "https://pronvzrzfwsptkojvudd.supabase.co";
-export declare const SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InByb252enJ6ZndzcHRrb2p2dWRkIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MDY4NTYwNDcsImV4cCI6MjAyMjQzMjA0N30.I6_-XrqssUb2SWYg5DjsUqSodNS3_RPoET3-aPdqywM";
-export declare const TEST_EMAIL = "testuser123@gmail.com";
-export declare const TEST_PASSWORD = "testuser123@gmail.com";
-export declare const TEST_EMAIL_2 = "testuser234@gmail.com";
-export declare const TEST_PASSWORD_2 = "testuser234@gmail.com";
-export declare const zeroUuid: UUID;

package/dist/test_resources/testSetup.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test_resources/types.d.ts

@@ -1,22 +0,0 @@
-/**
- * Interface representing a User.
- * @typedef {Object} User
- * @property {string} id - The user's ID.
- * @property {string} [email] - The user's email (optional).
- * @property {string} [phone] - The user's phone number (optional).
- * @property {string} [role] - The user's role (optional).
- */
-/**
- * Represents a User with optional properties.
- * @typedef {Object} User
- * @property {string} id - The unique identifier for the user.
- * @property {string} [email] - The email address of the user (optional).
- * @property {string} [phone] - The phone number of the user (optional).
- * @property {string} [role] - The role of the user (optional).
- */
-export interface User {
-    id: string;
-    email?: string;
-    phone?: string;
-    role?: string;
-}