@elizaos/core 1.0.0-alpha.57 → 1.0.0-alpha.59

package/dist/logger.d.ts

@@ -1,3 +1,4 @@
-export declare const logger: import("pino").Logger<string, boolean>;
+declare let logger: import("pino").Logger<string, boolean>;
+export { logger };
 export declare const elizaLogger: import("pino").Logger<string, boolean>;
 export default logger;

package/dist/prompts.d.ts

@@ -113,6 +113,7 @@ export declare const formatMessages: ({ messages, entities, }: {
 export declare const formatTimestamp: (messageDate: number) => string;
 export declare const shouldRespondTemplate = "# Task: Decide on behalf of {{agentName}} whether they should respond to the message, ignore it or stop the conversation.\n{{providers}}\n# Instructions: Decide if {{agentName}} should respond to or interact with the conversation.\nIf the message is directed at or relevant to {{agentName}}, respond with RESPOND action.\nIf a user asks {{agentName}} to be quiet, respond with STOP action.\nIf {{agentName}} should ignore the message, respond with IGNORE action.\nIf responding with the RESPOND action, include a list of optional providers that could be relevant to the response.\nResponse format should be formatted in a valid JSON block like this:\n```json\n{\n    \"name\": \"{{agentName}}\",\n\t\"reasoning\": \"<string>\",\n    \"action\": \"RESPOND\" | \"IGNORE\" | \"STOP\",\n    \"providers\": [\"<string>\", \"<string>\", ...]\n}\n```\nYour response should include the valid JSON block and nothing else.";
 export declare const messageHandlerTemplate = "# Task: Generate dialog and actions for the character {{agentName}}.\n{{providers}}\n# Instructions: Write a thought and plan for {{agentName}} and decide what actions to take. Also include the providers that {{agentName}} will use to have the right context for responding and acting, if any.\nFirst, think about what you want to do next and plan your actions. Then, write the next message and include the actions you plan to take.\n\"thought\" should be a short description of what the agent is thinking about and planning.\n\"actions\" should be an array of the actions {{agentName}} plans to take based on the thought (if none, use IGNORE, if simply responding with text, use REPLY)\n\"providers\" should be an optional array of the providers that {{agentName}} will use to have the right context for responding and acting\n\"evaluators\" should be an optional array of the evaluators that {{agentName}} will use to evaluate the conversation after responding\n\"plan\" should be explanation of the message you plan to send, the actions you plan to take, and the data providers you plan to use.\nThese are the available valid actions: {{actionNames}}\n\nResponse format should be formatted in a valid JSON block like this:\n```json\n{\n    \"thought\": \"<string>\",\n    \"plan\": \"<string>\",\n    \"actions\": [\"<string>\", \"<string>\", ...],\n    \"providers\": [\"<string>\", \"<string>\", ...]\n}\n```\n\nYour response should include the valid JSON block and nothing else.";
+export declare const postCreationTemplate = "# Task: Create a post in the voice and style and perspective of {{agentName}} @{{twitterUserName}}.\n\nExample task outputs:\n1. A post about the importance of AI in our lives\n```json\n{ \"thought\": \"I am thinking about writing a post about the importance of AI in our lives\", \"post\": \"AI is changing the world and it is important to understand how it works\", \"imagePrompt\": \"A futuristic cityscape with flying cars and people using AI to do things\" }\n```\n\n2. A post about dogs\n```json\n{ \"thought\": \"I am thinking about writing a post about dogs\", \"post\": \"Dogs are man's best friend and they are loyal and loving\", \"imagePrompt\": \"A dog playing with a ball in a park\" }\n```\n\n3. A post about finding a new job\n```json\n{ \"thought\": \"Getting a job is hard, I bet there's a good tweet in that\", \"post\": \"Just keep going!\", \"imagePrompt\": \"A person looking at a computer screen with a job search website\" }\n```\n\n{{providers}}\n\nWrite a post that is {{adjective}} about {{topic}} (without mentioning {{topic}} directly), from the perspective of {{agentName}}. Do not add commentary or acknowledge this request, just write the post.\nYour response should be 1, 2, or 3 sentences (choose the length at random).\nYour response should not contain any questions. Brief, concise statements only. The total character count MUST be less than 280. No emojis. Use \\n\\n (double spaces) between statements if there are multiple statements in your response.\n\nYour output should be formatted in a valid JSON block like this:\n```json\n{ \"thought\": \"<string>\", \"post\": \"<string>\", \"imagePrompt\": \"<string>\" }\n```\nThe \"post\" field should be the post you want to send. Do not including any thinking or internal reflection in the \"post\" field.\nThe \"imagePrompt\" field is optional and should be a prompt for an image that is relevant to the post. It should be a single sentence that captures the essence of the post. ONLY USE THIS FIELD if it makes sense that the post would benefit from an image.\nThe \"thought\" field should be a short description of what the agent is thinking about before responding, inlcuding a brief justification for the response. Includate an explanation how the post is relevant to the topic but unique and different than other posts.\nYour reponse should ONLY contain a valid JSON block and nothing else.";
 export declare const booleanFooter = "Respond with only a YES or a NO.";
 /**
  * Parses a string to determine its boolean equivalent.

package/dist/runtime.d.ts

@@ -1,4 +1,12 @@
-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";
+import { ChannelType } from "./types";
+import type { Action, Agent, Character, Component, Entity, Evaluator, HandlerCallback, IAgentRuntime, IDatabaseAdapter, KnowledgeItem, Log, Memory, ModelParamsMap, ModelResultMap, ModelTypeName, Participant, Plugin, Provider, Relationship, Room, Route, Service, ServiceTypeName, State, Task, TaskWorker, UUID, World } from "./types";
+export declare class Semaphore {
+    private permits;
+    private waiting;
+    constructor(count: number);
+    acquire(): Promise<void>;
+    release(): void;
+}
 /**
  * Represents the runtime environment for an agent, handling message processing,
  * action registration, and interaction with external services like OpenAI and Supabase.
@@ -10,7 +18,7 @@ import { type Action, type Agent, ChannelType, type Character, type Component, t
  * @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 { IDatabaseAdapter } adapter - 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.
@@ -20,7 +28,7 @@ export declare class AgentRuntime implements IAgentRuntime {
     #private;
     readonly agentId: UUID;
     readonly character: Character;
-    databaseAdapter: IDatabaseAdapter;
+    adapter: IDatabaseAdapter;
     readonly actions: Action[];
     readonly evaluators: Evaluator[];
     readonly providers: Provider[];
@@ -36,20 +44,19 @@ export declare class AgentRuntime implements IAgentRuntime {
         text: string;
     }>;
     readonly fetch: typeof fetch;
-    services: Map<ServiceType, Service>;
-    adapter: IDatabaseAdapter;
-    private readonly knowledgeRoot;
-    models: Map<string, ((params: any) => Promise<any>)[]>;
+    services: Map<ServiceTypeName, Service>;
+    models: Map<string, ((runtime: IAgentRuntime, params: any) => Promise<any>)[]>;
     routes: Route[];
     private taskWorkers;
     private eventHandlers;
+    private runtimeLogger;
+    private knowledgeProcessingSemaphore;
     constructor(opts: {
         conversationLength?: number;
         agentId?: UUID;
         character?: Character;
         plugins?: Plugin[];
         fetch?: typeof fetch;
-        databaseAdapter?: IDatabaseAdapter;
         adapter?: IDatabaseAdapter;
         events?: {
             [key: string]: ((params: any) => void)[];
@@ -61,7 +68,7 @@ export declare class AgentRuntime implements IAgentRuntime {
      * @param plugin The plugin to register
      */
     registerPlugin(plugin: Plugin): Promise<void>;
-    getAllServices(): Map<ServiceType, Service>;
+    getAllServices(): Map<ServiceTypeName, Service>;
     stop(): Promise<void>;
     initialize(): Promise<void>;
     private handleProcessingError;
@@ -151,11 +158,10 @@ export declare class AgentRuntime implements IAgentRuntime {
      */
     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;
+    getService<T extends Service>(service: ServiceTypeName): 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;
+    registerModel(modelType: ModelTypeName, handler: (params: any) => Promise<any>): void;
+    getModel(modelType: ModelTypeName): ((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
@@ -164,7 +170,7 @@ export declare class AgentRuntime implements IAgentRuntime {
      * @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>;
+    useModel<T extends ModelTypeName, 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>;
@@ -192,6 +198,7 @@ export declare class AgentRuntime implements IAgentRuntime {
     createComponent(component: Component): Promise<boolean>;
     updateComponent(component: Component): Promise<void>;
     deleteComponent(componentId: UUID): Promise<void>;
+    addEmbeddingToMemory(memory: Memory): Promise<Memory>;
     getMemories(params: {
         roomId: UUID;
         count?: number;
@@ -235,9 +242,17 @@ export declare class AgentRuntime implements IAgentRuntime {
         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>;
+    deleteMemory(memoryId: UUID): Promise<void>;
+    deleteAllMemories(roomId: UUID, tableName: string): Promise<void>;
     countMemories(roomId: UUID, unique?: boolean, tableName?: string): Promise<number>;
+    getLogs(params: {
+        entityId: UUID;
+        roomId?: UUID;
+        type?: string;
+        count?: number;
+        offset?: number;
+    }): Promise<Log[]>;
+    deleteLog(logId: UUID): Promise<void>;
     createWorld(world: World): Promise<UUID>;
     getWorld(id: UUID): Promise<World | null>;
     getAllWorlds(): Promise<World[]>;

package/dist/services/task.d.ts

@@ -1,10 +1,10 @@
-import { type IAgentRuntime, Service, type ServiceType } from "../types";
+import { type IAgentRuntime, Service, type ServiceTypeName } 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 {ServiceTypeName} serviceType - Service type of TASK
  * @property {string} capabilityDescription - Description of the service's capability
  * @static
  * @method start - Static method to start the TaskService
@@ -20,7 +20,7 @@ import { type IAgentRuntime, Service, type ServiceType } from "../types";
 export declare class TaskService extends Service {
     private timer;
     private readonly TICK_INTERVAL;
-    static serviceType: ServiceType;
+    static serviceType: ServiceTypeName;
     capabilityDescription: string;
     /**
      * Start the TaskService with the given runtime.