@elizaos/core 1.0.1 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elizaos/core",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -13,13 +13,25 @@
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"
       }
+    },
+    "./v1": {
+      "import": {
+        "types": "./dist/specs/v1/index.d.ts",
+        "default": "./dist/specs/v1/index.js"
+      }
+    },
+    "./v2": {
+      "import": {
+        "types": "./dist/specs/v2/index.d.ts",
+        "default": "./dist/specs/v2/index.js"
+      }
     }
   },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsup && tsc -p tsconfig.build.json",
+    "build": "tsup",
     "watch": "tsc --watch",
     "clean": "rm -rf dist .turbo node_modules .turbo-tsconfig.json tsconfig.tsbuildinfo",
     "dev": "tsup --watch",
@@ -88,5 +100,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "990909cd4fc651f0242b346b05680a88264876be"
+  "gitHead": "f22f2e8e548aa92d01489864d573b633725b1182"
 }

package/dist/actions.d.ts

@@ -1,22 +0,0 @@
-import type { Action } from './types';
-/**
- * Composes a set of example conversations based on provided actions and a specified count.
- * It randomly selects examples from the provided actions and formats them with generated names.
- *
- * @param actionsData - An array of `Action` objects from which to draw examples.
- * @param count - The number of examples to generate.
- * @returns A string containing formatted examples of conversations.
- */
-export declare const composeActionExamples: (actionsData: Action[], count: number) => string;
-/**
- * Formats the names of the provided actions into a comma-separated string.
- * @param actions - An array of `Action` objects from which to extract names.
- * @returns A comma-separated string of action names.
- */
-export declare function formatActionNames(actions: Action[]): string;
-/**
- * Formats the provided actions into a detailed string listing each action's name and description.
- * @param actions - An array of `Action` objects to format.
- * @returns A detailed string of actions, including names and descriptions.
- */
-export declare function formatActions(actions: Action[]): string;

package/dist/database.d.ts

@@ -1,461 +0,0 @@
-import type { Agent, Component, Entity, IDatabaseAdapter, Log, Memory, MemoryMetadata, Participant, Relationship, Room, Task, UUID, World } from './types';
-import { type Pool as PgPool } from 'pg';
-import { PGlite } from '@electric-sql/pglite';
-/**
- * An abstract class representing a database adapter for managing various entities
- * like entities, memories, entities, goals, and rooms.
- */
-/**
- * Database adapter class to be extended by individual database adapters.
- *
- * @template DB - The type of the database instance.
- * @abstract
- * implements IDatabaseAdapter
- */
-export declare abstract class DatabaseAdapter<DB = unknown> implements IDatabaseAdapter {
-    /**
-     * The database instance.
-     */
-    db: DB;
-    /**
-     * Initialize the database adapter.
-     * @returns A Promise that resolves when initialization is complete.
-     */
-    abstract init(): Promise<void>;
-    /**
-     * Optional close method for the database adapter.
-     * @returns A Promise that resolves when closing is complete.
-     */
-    abstract close(): Promise<void>;
-    /**
-     * Retrieves a connection to the database.
-     * @returns A Promise that resolves to the database connection.
-     */
-    abstract getConnection(): Promise<PGlite | PgPool>;
-    /**
-     * Retrieves an account by its ID.
-     * @param entityIds The UUIDs of the user account to retrieve.
-     * @returns A Promise that resolves to the Entity object or null if not found.
-     */
-    abstract getEntityByIds(entityIds: UUID[]): Promise<Entity[] | null>;
-    abstract getEntitiesForRoom(roomId: UUID, includeComponents?: boolean): Promise<Entity[]>;
-    /**
-     * Creates a new entities in the database.
-     * @param entities The entity objects to create.
-     * @returns A Promise that resolves when the account creation is complete.
-     */
-    abstract createEntities(entities: Entity[]): Promise<boolean>;
-    /**
-     * Updates an existing entity in the database.
-     * @param entity The entity object with updated properties.
-     * @returns A Promise that resolves when the account update is complete.
-     */
-    abstract updateEntity(entity: Entity): Promise<void>;
-    /**
-     * Retrieves a single component by entity ID and type.
-     * @param entityId The UUID of the entity the component belongs to
-     * @param type The type identifier for the component
-     * @param worldId Optional UUID of the world the component belongs to
-     * @param sourceEntityId Optional UUID of the source entity
-     * @returns Promise resolving to the Component if found, null otherwise
-     */
-    abstract getComponent(entityId: UUID, type: string, worldId?: UUID, sourceEntityId?: UUID): Promise<Component | null>;
-    /**
-     * Retrieves all components for an entity.
-     * @param entityId The UUID of the entity to get components for
-     * @param worldId Optional UUID of the world to filter components by
-     * @param sourceEntityId Optional UUID of the source entity to filter by
-     * @returns Promise resolving to array of Component objects
-     */
-    abstract getComponents(entityId: UUID, worldId?: UUID, sourceEntityId?: UUID): Promise<Component[]>;
-    /**
-     * Creates a new component in the database.
-     * @param component The component object to create
-     * @returns Promise resolving to true if creation was successful
-     */
-    abstract createComponent(component: Component): Promise<boolean>;
-    /**
-     * Updates an existing component in the database.
-     * @param component The component object with updated properties
-     * @returns Promise that resolves when the update is complete
-     */
-    abstract updateComponent(component: Component): Promise<void>;
-    /**
-     * Deletes a component from the database.
-     * @param componentId The UUID of the component to delete
-     * @returns Promise that resolves when the deletion is complete
-     */
-    abstract deleteComponent(componentId: UUID): Promise<void>;
-    /**
-     * Retrieves memories based on the specified parameters.
-     * @param params An object containing parameters for the memory retrieval.
-     * @returns A Promise that resolves to an array of Memory objects.
-     */
-    abstract getMemories(params: {
-        entityId?: UUID;
-        agentId?: UUID;
-        count?: number;
-        unique?: boolean;
-        tableName: string;
-        start?: number;
-        end?: number;
-        roomId?: UUID;
-        worldId?: UUID;
-    }): Promise<Memory[]>;
-    abstract getMemoriesByRoomIds(params: {
-        roomIds: UUID[];
-        tableName: string;
-        limit?: number;
-    }): Promise<Memory[]>;
-    abstract getMemoryById(id: UUID): Promise<Memory | null>;
-    /**
-     * Retrieves multiple memories by their IDs
-     * @param memoryIds Array of UUIDs of the memories to retrieve
-     * @param tableName Optional table name to filter memories by type
-     * @returns Promise resolving to array of Memory objects
-     */
-    abstract getMemoriesByIds(memoryIds: UUID[], tableName?: string): Promise<Memory[]>;
-    /**
-     * Retrieves cached embeddings based on the specified query parameters.
-     * @param params An object containing parameters for the embedding retrieval.
-     * @returns A Promise that resolves to an array of objects containing embeddings and levenshtein scores.
-     */
-    abstract getCachedEmbeddings({ query_table_name, query_threshold, query_input, query_field_name, query_field_sub_name, query_match_count, }: {
-        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;
-    }[]>;
-    /**
-     * Logs an event or action with the specified details.
-     * @param params An object containing parameters for the log entry.
-     * @returns A Promise that resolves when the log entry has been saved.
-     */
-    abstract log(params: {
-        body: {
-            [key: string]: unknown;
-        };
-        entityId: UUID;
-        roomId: UUID;
-        type: string;
-    }): Promise<void>;
-    /**
-     * Retrieves logs based on the specified parameters.
-     * @param params An object containing parameters for the log retrieval.
-     * @returns A Promise that resolves to an array of Log objects.
-     */
-    abstract getLogs(params: {
-        entityId: UUID;
-        roomId?: UUID;
-        type?: string;
-        count?: number;
-        offset?: number;
-    }): Promise<Log[]>;
-    /**
-     * Deletes a log from the database.
-     * @param logId The UUID of the log to delete.
-     * @returns A Promise that resolves when the log has been deleted.
-     */
-    abstract deleteLog(logId: UUID): Promise<void>;
-    /**
-     * Searches for memories based on embeddings and other specified parameters.
-     * @param params An object containing parameters for the memory search.
-     * @returns A Promise that resolves to an array of Memory objects.
-     */
-    abstract searchMemories(params: {
-        tableName: string;
-        embedding: number[];
-        match_threshold?: number;
-        count?: number;
-        unique?: boolean;
-        query?: string;
-        roomId?: UUID;
-        worldId?: UUID;
-        entityId?: UUID;
-    }): Promise<Memory[]>;
-    /**
-     * Creates a new memory in the database.
-     * @param memory The memory object to create.
-     * @param tableName The table where the memory should be stored.
-     * @param unique Indicates if the memory should be unique.
-     * @returns A Promise that resolves when the memory has been created.
-     */
-    abstract createMemory(memory: Memory, tableName: string, unique?: boolean): Promise<UUID>;
-    /**
-     * Updates an existing memory in the database.
-     * @param memory The memory object with updated content and optional embedding
-     * @returns Promise resolving to boolean indicating success
-     */
-    abstract updateMemory(memory: Partial<Memory> & {
-        id: UUID;
-        metadata?: MemoryMetadata;
-    }): Promise<boolean>;
-    /**
-     * Removes a specific memory from the database.
-     * @param memoryId The UUID of the memory to remove.
-     * @returns A Promise that resolves when the memory has been removed.
-     */
-    abstract deleteMemory(memoryId: UUID): Promise<void>;
-    /**
-     * Removes all memories associated with a specific room.
-     * @param roomId The UUID of the room whose memories should be removed.
-     * @param tableName The table from which the memories should be removed.
-     * @returns A Promise that resolves when all memories have been removed.
-     */
-    abstract deleteAllMemories(roomId: UUID, tableName: string): Promise<void>;
-    /**
-     * Counts the number of memories in a specific room.
-     * @param roomId The UUID of the room for which to count memories.
-     * @param unique Specifies whether to count only unique memories.
-     * @param tableName Optional table name to count memories from.
-     * @returns A Promise that resolves to the number of memories.
-     */
-    abstract countMemories(roomId: UUID, unique?: boolean, tableName?: string): Promise<number>;
-    /**
-     * Retrieves a world by its ID.
-     * @param id The UUID of the world to retrieve.
-     * @returns A Promise that resolves to the World object or null if not found.
-     */
-    abstract getWorld(id: UUID): Promise<World | null>;
-    /**
-     * Retrieves all worlds for an agent.
-     * @returns A Promise that resolves to an array of World objects.
-     */
-    abstract getAllWorlds(): Promise<World[]>;
-    /**
-     * Creates a new world in the database.
-     * @param world The world object to create.
-     * @returns A Promise that resolves to the UUID of the created world.
-     */
-    abstract createWorld(world: World): Promise<UUID>;
-    /**
-     * Updates an existing world in the database.
-     * @param world The world object with updated properties.
-     * @returns A Promise that resolves when the world has been updated.
-     */
-    abstract updateWorld(world: World): Promise<void>;
-    /**
-     * Removes a specific world from the database.
-     * @param id The UUID of the world to remove.
-     * @returns A Promise that resolves when the world has been removed.
-     */
-    abstract removeWorld(id: UUID): Promise<void>;
-    /**
-     * Retrieves the room ID for a given room, if it exists.
-     * @param roomId The UUID of the room to retrieve.
-     * @returns A Promise that resolves to the room ID or null if not found.
-     */
-    abstract getRoomsByIds(roomIds: UUID[]): Promise<Room[] | null>;
-    /**
-     * Retrieves all rooms for a given world.
-     * @param worldId The UUID of the world to retrieve rooms for.
-     * @returns A Promise that resolves to an array of Room objects.
-     */
-    abstract getRoomsByWorld(worldId: UUID): Promise<Room[]>;
-    /**
-     * Creates a new rooms with an optional specified ID.
-     * @param roomId Optional UUID to assign to the new room.
-     * @returns A Promise that resolves to the UUID of the created rooms.
-     */
-    abstract createRooms(rooms: Room[]): Promise<UUID[]>;
-    /**
-     * Updates a specific room in the database.
-     * @param room The room object with updated properties.
-     * @returns A Promise that resolves when the room has been updated.
-     */
-    abstract updateRoom(room: Room): Promise<void>;
-    /**
-     * Removes a specific room from the database.
-     * @param roomId The UUID of the room to remove.
-     * @returns A Promise that resolves when the room has been removed.
-     */
-    abstract deleteRoom(roomId: UUID): Promise<void>;
-    /**
-     * Retrieves room IDs for which a specific user is a participant.
-     * @param entityId The UUID of the user.
-     * @returns A Promise that resolves to an array of room IDs.
-     */
-    abstract getRoomsForParticipant(entityId: UUID): Promise<UUID[]>;
-    /**
-     * Retrieves room IDs for which specific users are participants.
-     * @param userIds An array of UUIDs of the users.
-     * @returns A Promise that resolves to an array of room IDs.
-     */
-    abstract getRoomsForParticipants(userIds: UUID[]): Promise<UUID[]>;
-    /**
-     * Adds users as a participant to a specific room.
-     * @param entityIds The UUIDs of the users to add as a participant.
-     * @param roomId The UUID of the room to which the user will be added.
-     * @returns A Promise that resolves to a boolean indicating success or failure.
-     */
-    abstract addParticipantsRoom(entityIds: UUID[], roomId: UUID): Promise<boolean>;
-    /**
-     * Removes a user as a participant from a specific room.
-     * @param entityId The UUID of the user to remove as a participant.
-     * @param roomId The UUID of the room from which the user will be removed.
-     * @returns A Promise that resolves to a boolean indicating success or failure.
-     */
-    abstract removeParticipant(entityId: UUID, roomId: UUID): Promise<boolean>;
-    /**
-     * Retrieves participants associated with a specific account.
-     * @param entityId The UUID of the account.
-     * @returns A Promise that resolves to an array of Participant objects.
-     */
-    abstract getParticipantsForEntity(entityId: UUID): Promise<Participant[]>;
-    /**
-     * Retrieves participants for a specific room.
-     * @param roomId The UUID of the room for which to retrieve participants.
-     * @returns A Promise that resolves to an array of UUIDs representing the participants.
-     */
-    abstract getParticipantsForRoom(roomId: UUID): Promise<UUID[]>;
-    abstract getParticipantUserState(roomId: UUID, entityId: UUID): Promise<'FOLLOWED' | 'MUTED' | null>;
-    abstract setParticipantUserState(roomId: UUID, entityId: UUID, state: 'FOLLOWED' | 'MUTED' | null): Promise<void>;
-    /**
-     * Creates a new relationship between two users.
-     * @param params Object containing the relationship details including entity IDs, agent ID, optional tags and metadata
-     * @returns A Promise that resolves to a boolean indicating success or failure of the creation.
-     */
-    abstract createRelationship(params: {
-        sourceEntityId: UUID;
-        targetEntityId: UUID;
-        tags?: string[];
-        metadata?: Record<string, unknown>;
-    }): Promise<boolean>;
-    /**
-     * Retrieves a relationship between two users if it exists.
-     * @param params Object containing the entity IDs and agent ID
-     * @returns A Promise that resolves to the Relationship object or null if not found.
-     */
-    abstract getRelationship(params: {
-        sourceEntityId: UUID;
-        targetEntityId: UUID;
-    }): Promise<Relationship | null>;
-    /**
-     * Retrieves all relationships for a specific user.
-     * @param params Object containing the user ID, agent ID and optional tags to filter by
-     * @returns A Promise that resolves to an array of Relationship objects.
-     */
-    abstract getRelationships(params: {
-        entityId: UUID;
-        tags?: string[];
-    }): Promise<Relationship[]>;
-    /**
-     * Updates an existing relationship between two users.
-     * @param params Object containing the relationship details to update including entity IDs, agent ID, optional tags and metadata
-     * @returns A Promise that resolves to a boolean indicating success or failure of the update.
-     */
-    abstract updateRelationship(params: {
-        sourceEntityId: UUID;
-        targetEntityId: UUID;
-        tags?: string[];
-        metadata?: Record<string, unknown>;
-    }): Promise<void>;
-    /**
-     * Retrieves an agent by its ID.
-     * @param agentId The UUID of the agent to retrieve.
-     * @returns A Promise that resolves to the Agent object or null if not found.
-     */
-    abstract getAgent(agentId: UUID): Promise<Agent | null>;
-    /**
-     * Retrieves all agents from the database.
-     * @returns A Promise that resolves to an array of Agent objects.
-     */
-    abstract getAgents(): Promise<Partial<Agent>[]>;
-    /**
-     * Creates a new agent in the database.
-     * @param agent The agent object to create.
-     * @returns A Promise that resolves to a boolean indicating success or failure of the creation.
-     */
-    abstract createAgent(agent: Partial<Agent>): Promise<boolean>;
-    /**
-     * Updates an existing agent in the database.
-     * @param agentId The UUID of the agent to update.
-     * @param agent The agent object with updated properties.
-     * @returns A Promise that resolves to a boolean indicating success or failure of the update.
-     */
-    abstract updateAgent(agentId: UUID, agent: Partial<Agent>): Promise<boolean>;
-    /**
-     * Deletes an agent from the database.
-     * @param agentId The UUID of the agent to delete.
-     * @returns A Promise that resolves to a boolean indicating success or failure of the deletion.
-     */
-    abstract deleteAgent(agentId: UUID): Promise<boolean>;
-    /**
-     * Ensures an embedding dimension exists in the database.
-     * @param dimension The dimension to ensure exists.
-     * @returns A Promise that resolves when the embedding dimension has been ensured to exist.
-     */
-    abstract ensureEmbeddingDimension(dimension: number): Promise<void>;
-    /**
-     * Retrieves a cached value by key from the database.
-     * @param key The key to look up in the cache
-     * @returns Promise resolving to the cached string value
-     */
-    abstract getCache<T>(key: string): Promise<T | undefined>;
-    /**
-     * Sets a value in the cache with the given key.
-     * @param params Object containing the cache key and value
-     * @param key The key to store the value under
-     * @param value The string value to cache
-     * @returns Promise resolving to true if the cache was set successfully
-     */
-    abstract setCache<T>(key: string, value: T): Promise<boolean>;
-    /**
-     * Deletes a value from the cache by key.
-     * @param key The key to delete from the cache
-     * @returns Promise resolving to true if the value was successfully deleted
-     */
-    abstract deleteCache(key: string): Promise<boolean>;
-    /**
-     * Creates a new task instance in the database.
-     * @param task The task object to create
-     * @returns Promise resolving to the UUID of the created task
-     */
-    abstract createTask(task: Task): Promise<UUID>;
-    /**
-     * Retrieves tasks based on specified parameters.
-     * @param params Object containing optional roomId and tags to filter tasks
-     * @returns Promise resolving to an array of Task objects
-     */
-    abstract getTasks(params: {
-        roomId?: UUID;
-        tags?: string[];
-        entityId?: UUID;
-    }): Promise<Task[]>;
-    /**
-     * Retrieves a specific task by its ID.
-     * @param id The UUID of the task to retrieve
-     * @returns Promise resolving to the Task object if found, null otherwise
-     */
-    abstract getTask(id: UUID): Promise<Task | null>;
-    /**
-     * Retrieves a specific task by its name.
-     * @param name The name of the task to retrieve
-     * @returns Promise resolving to the Task object if found, null otherwise
-     */
-    abstract getTasksByName(name: string): Promise<Task[]>;
-    /**
-     * Updates an existing task in the database.
-     * @param id The UUID of the task to update
-     * @param task Partial Task object containing the fields to update
-     * @returns Promise resolving when the update is complete
-     */
-    abstract updateTask(id: UUID, task: Partial<Task>): Promise<void>;
-    /**
-     * Deletes a task from the database.
-     * @param id The UUID of the task to delete
-     * @returns Promise resolving when the deletion is complete
-     */
-    abstract deleteTask(id: UUID): Promise<void>;
-    abstract getMemoriesByWorldId(params: {
-        worldId: UUID;
-        count?: number;
-        tableName?: string;
-    }): Promise<Memory[]>;
-    abstract deleteRoomsByWorldId(worldId: UUID): Promise<void>;
-}

package/dist/entities.d.ts

@@ -1,48 +0,0 @@
-import { type Entity, type IAgentRuntime, type Memory, type State, type UUID } from './types';
-/**
- * Finds an entity by name in the given runtime environment.
- *
- * @param {IAgentRuntime} runtime - The agent runtime environment.
- * @param {Memory} message - The memory message containing relevant information.
- * @param {State} state - The current state of the system.
- * @returns {Promise<Entity | null>} A promise that resolves to the found entity or null if not found.
- */
-export declare function findEntityByName(runtime: IAgentRuntime, message: Memory, state: State): Promise<Entity | null>;
-/**
- * Function to create a unique UUID based on the runtime and base user ID.
- *
- * @param {RuntimeContext} runtime - The runtime context object.
- * @param {UUID|string} baseUserId - The base user ID to use in generating the UUID.
- * @returns {UUID} - The unique UUID generated based on the runtime and base user ID.
- */
-export declare const createUniqueUuid: (runtime: any, baseUserId: UUID | string) => UUID;
-/**
- * Get details for a list of entities.
- */
-/**
- * Retrieves entity details for a specific room from the database.
- *
- * @param {Object} params - The input parameters
- * @param {IAgentRuntime} params.runtime - The Agent Runtime instance
- * @param {UUID} params.roomId - The ID of the room to retrieve entity details for
- * @returns {Promise<Array>} - A promise that resolves to an array of unique entity details
- */
-export declare function getEntityDetails({ runtime, roomId, }: {
-    runtime: IAgentRuntime;
-    roomId: UUID;
-}): Promise<any[]>;
-/**
- * Format entities into a string
- * @param entities - list of entities
- * @returns string
- */
-/**
- * Format the given entities into a string representation.
- *
- * @param {Object} options - The options object.
- * @param {Entity[]} options.entities - The list of entities to format.
- * @returns {string} A formatted string representing the entities.
- */
-export declare function formatEntities({ entities }: {
-    entities: Entity[];
-}): string;

package/dist/instrumentation/index.d.ts

@@ -1,2 +0,0 @@
-export * from './types';
-export * from './service';

package/dist/instrumentation/service.d.ts

@@ -1,21 +0,0 @@
-import { Meter, Tracer } from '@opentelemetry/api';
-import { IAgentRuntime, Service } from '../types';
-import { IInstrumentationService, InstrumentationConfig } from './types';
-export declare class InstrumentationService extends Service implements IInstrumentationService {
-    static serviceType: "instrumentation";
-    readonly name = "INSTRUMENTATION";
-    readonly capabilityDescription = "Provides OpenTelemetry tracing and metrics capabilities.";
-    instrumentationConfig: InstrumentationConfig;
-    private resource;
-    private tracerProvider;
-    private meterProvider;
-    private isShutdown;
-    constructor(config?: InstrumentationConfig);
-    private initializeProviders;
-    isEnabled(): boolean;
-    getTracer(name?: string, version?: string): Tracer | null;
-    getMeter(name?: string, version?: string): Meter | null;
-    flush(): Promise<void>;
-    stop(): Promise<void>;
-    static start(runtime: IAgentRuntime, config?: InstrumentationConfig): Promise<InstrumentationService>;
-}

package/dist/instrumentation/types.d.ts

@@ -1,16 +0,0 @@
-import { Tracer, Meter } from '@opentelemetry/api';
-export interface InstrumentationConfig {
-    serviceName?: string;
-    otlpEndpoint?: string;
-    enabled?: boolean;
-}
-export interface IInstrumentationService {
-    readonly name: string;
-    readonly capabilityDescription: string;
-    instrumentationConfig: InstrumentationConfig;
-    isEnabled(): boolean;
-    getTracer(name?: string, version?: string): Tracer | null;
-    getMeter(name?: string, version?: string): Meter | null;
-    flush(): Promise<void>;
-    stop(): Promise<void>;
-}

package/dist/logger.d.ts

@@ -1,5 +0,0 @@
-declare let logger: import("pino").Logger<string, boolean>;
-declare const createLogger: (bindings?: {}) => import("pino").Logger<never, boolean>;
-export { createLogger, logger };
-export declare const elizaLogger: import("pino").Logger<string, boolean>;
-export default logger;

package/dist/prompts.d.ts

@@ -1,5 +0,0 @@
-export declare const shouldRespondTemplate = "<task>Decide on behalf of {{agentName}} whether they should respond to the message, ignore it or stop the conversation.</task>\n\n<providers>\n{{providers}}\n</providers>\n\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.</instructions>\n\n<output>\nDo NOT include any thinking, reasoning, or <think> sections in your response. \nGo directly to the XML response format without any preamble or explanation.\n\nRespond using XML format like this:\n<response>\n  <name>{{agentName}}</name>\n  <reasoning>Your reasoning here</reasoning>\n  <action>RESPOND | IGNORE | STOP</action>\n</response>\n\nIMPORTANT: Your response must ONLY contain the <response></response> XML block above. Do not include any text, thinking, or reasoning before or after this XML block. Start your response immediately with <response> and end with </response>.\n</output>";
-export declare const messageHandlerTemplate = "<task>Generate dialog and actions for the character {{agentName}}.</task>\n\n<providers>\n{{providers}}\n</providers>\n\nThese are the available valid actions:\n<actionNames>\n{{actionNames}}\n</actionNames>\n\n<instructions>\nWrite 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.\n\nIMPORTANT PROVIDER SELECTION RULES:\n- If the message mentions images, photos, pictures, attachments, or visual content, OR if you see \"(Attachments:\" in the conversation, you MUST include \"ATTACHMENTS\" in your providers list\n- If the message asks about or references specific people, include \"ENTITIES\" in your providers list  \n- If the message asks about relationships or connections between people, include \"RELATIONSHIPS\" in your providers list\n- If the message asks about facts or specific information, include \"FACTS\" in your providers list\n- If the message asks about the environment or world context, include \"WORLD\" in your providers list\n- If you need external knowledge, information, or context beyond the current conversation to provide a helpful response, include \"KNOWLEDGE\" in your providers list\n\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</instructions>\n\n<keys>\n\"thought\" should be a short description of what the agent is thinking about and planning.\n\"actions\" should be a comma-separated list 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 a comma-separated list of the providers that {{agentName}} will use to have the right context for responding and acting (NEVER use \"IGNORE\" as a provider - use specific provider names like ATTACHMENTS, ENTITIES, FACTS, KNOWLEDGE, etc.)\n\"evaluators\" should be an optional comma-separated list of the evaluators that {{agentName}} will use to evaluate the conversation after responding\n\"text\" should be the text of the next message for {{agentName}} which they will send to the conversation.\n</keys>\n\n<output>\nDo NOT include any thinking, reasoning, or <think> sections in your response. \nGo directly to the XML response format without any preamble or explanation.\n\nRespond using XML format like this:\n<response>\n    <thought>Your thought here</thought>\n    <actions>ACTION1,ACTION2</actions>\n    <providers>PROVIDER1,PROVIDER2</providers>\n    <text>Your response text here</text>\n</response>\n\nIMPORTANT: Your response must ONLY contain the <response></response> XML block above. Do not include any text, thinking, or reasoning before or after this XML block. Start your response immediately with <response> and end with </response>.\n</output>";
-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<response>\n  <thought>I am thinking about writing a post about the importance of AI in our lives</thought>\n  <post>AI is changing the world and it is important to understand how it works</post>\n  <imagePrompt>A futuristic cityscape with flying cars and people using AI to do things</imagePrompt>\n</response>\n\n2. A post about dogs\n<response>\n  <thought>I am thinking about writing a post about dogs</thought>\n  <post>Dogs are man's best friend and they are loyal and loving</post>\n  <imagePrompt>A dog playing with a ball in a park</imagePrompt>\n</response>\n\n3. A post about finding a new job\n<response>\n  <thought>Getting a job is hard, I bet there's a good tweet in that</thought>\n  <post>Just keep going!</post>\n  <imagePrompt>A person looking at a computer screen with a job search website</imagePrompt>\n</response>\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 XML like this:\n<response>\n  <thought>Your thought here</thought>\n  <post>Your post text here</post>\n  <imagePrompt>Optional image prompt here</imagePrompt>\n</response>\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.\n\nDo NOT include any thinking, reasoning, or <think> sections in your response. \nGo directly to the XML response format without any preamble or explanation.\n\nIMPORTANT: Your response must ONLY contain the <response></response> XML block above. Do not include any text, thinking, or reasoning before or after this XML block. Start your response immediately with <response> and end with </response>.";
-export declare const booleanFooter = "Respond with only a YES or a NO.";
-export declare const imageDescriptionTemplate = "<task>Analyze the provided image and generate a comprehensive description with multiple levels of detail.</task>\n\n<instructions>\nCarefully examine the image and provide:\n1. A concise, descriptive title that captures the main subject or scene\n2. A brief summary description (1-2 sentences) highlighting the key elements\n3. An extensive, detailed description that covers all visible elements, composition, lighting, colors, mood, and any other relevant details\n\nBe objective and descriptive. Focus on what you can actually see in the image rather than making assumptions about context or meaning.\n</instructions>\n\n<output>\nDo NOT include any thinking, reasoning, or <think> sections in your response. \nGo directly to the XML response format without any preamble or explanation.\n\nRespond using XML format like this:\n<response>\n  <title>A concise, descriptive title for the image</title>\n  <description>A brief 1-2 sentence summary of the key elements in the image</description>\n  <text>An extensive, detailed description covering all visible elements, composition, lighting, colors, mood, setting, objects, people, activities, and any other relevant details you can observe in the image</text>\n</response>\n\nIMPORTANT: Your response must ONLY contain the <response></response> XML block above. Do not include any text, thinking, or reasoning before or after this XML block. Start your response immediately with <response> and end with </response>.\n</output>";