@elizaos/core 1.0.2 → 1.0.3

package/dist/index.d.ts

@@ -1,14 +1,1161 @@
-export * from './types';
-export * from './actions';
-export * from './database';
-export * from './entities';
-export * from './logger';
-export * from './prompts';
-export * from './roles';
-export * from './runtime';
-export * from './settings';
-export * from './utils';
-export * from './services';
-export * from './instrumentation/types';
-export * from './instrumentation/service';
-export * from './sentry/instrument';
+import { A as Action, I as IDatabaseAdapter, U as UUID, E as Entity, C as Component, M as Memory, L as Log, a as MemoryMetadata, W as World, R as Room, P as Participant, b as Relationship, c as Agent, T as Task, d as IAgentRuntime, S as State, e as Role, f as Service, g as Character, h as Evaluator, i as Provider, j as Plugin, k as ServiceTypeName, l as ModelHandler, m as Route, n as RuntimeSettings, H as HandlerCallback, o as ChannelType, p as ModelTypeName, q as ModelResultMap, r as ModelParamsMap, s as TaskWorker, t as SendHandlerFunction, u as TargetInfo, v as Content, w as Setting, x as WorldSettings, O as OnboardingConfig, y as TemplateType, z as v2 } from './index-DVKkCFlY.js';
+export { a_ as ActionEventPayload, D as ActionExample, ah as AgentStatus, aO as AudioProcessingParams, a0 as BaseMetadata, aG as BaseModelParams, aq as CacheKeyPrefix, as as ChunkRow, bn as ComponentData, ad as ContentType, bu as ControlMessage, a5 as CustomMetadata, bq as DbConnection, aA as DeriveKeyAttestationData, a4 as DescriptionMetadata, au as DetokenizeTextParams, ar as DirectoryItem, a1 as DocumentMetadata, ai as EmbeddingSearchResult, bm as EnhancedState, aW as EntityPayload, a9 as EvaluationExample, a$ as EvaluatorEventPayload, bo as EventDataObject, b3 as EventHandler, aU as EventPayload, b2 as EventPayloadMap, aS as EventType, a2 as FragmentMetadata, at as GenerateTextParams, a7 as Handler, aL as ImageDescriptionParams, aK as ImageGenerationParams, aY as InvokePayload, K as IsValidServiceType, aQ as JSONSchema, ao as KnowledgeItem, ap as KnowledgeScope, ac as Media, aj as MemoryRetrievalOptions, $ as MemoryScope, ak as MemorySearchOptions, _ as MemoryType, Z as MemoryTypeAlias, a6 as MessageExample, b5 as MessageMemory, a3 as MessageMetadata, aX as MessagePayload, b1 as MessageReceivedHandlerParams, br as MetadataObject, b0 as ModelEventPayload, F as ModelType, al as MultiRoomMemoryOptions, aR as ObjectGenerationParams, aT as PlatformPrefix, ae as PluginEvents, ag as Project, af as ProjectAgent, aa as ProviderResult, aB as RemoteAttestationMessage, az as RemoteAttestationQuote, ab as RoomMetadata, aZ as RunEventPayload, b4 as SOCKET_MESSAGE_TYPE, bv as ServiceBuilder, Q as ServiceClassMap, bs as ServiceConfig, bx as ServiceDefinition, be as ServiceError, V as ServiceInstance, X as ServiceRegistry, Y as ServiceType, G as ServiceTypeRegistry, J as ServiceTypeValue, bl as StateArray, bk as StateObject, bj as StateValue, ay as TEEMode, aF as TaskMetadata, ax as TeeAgent, aE as TeePluginConfig, aC as TeeType, aD as TeeVendorConfig, av as TestCase, aw as TestSuite, aI as TextEmbeddingParams, aH as TextGenerationParams, aN as TextToSpeechParams, aJ as TokenizeTextParams, aM as TranscriptionParams, bp as TypedEventHandler, b7 as TypedService, N as TypedServiceClass, am as UnifiedMemoryOptions, an as UnifiedSearchOptions, bt as VECTOR_DIMS, a8 as Validator, aP as VideoProcessingParams, aV as WorldPayload, B as asUUID, b6 as createMessageMemory, bw as createService, bi as createServiceError, by as defineService, bh as getMemoryText, b8 as getTypedService, bd as isCustomMetadata, bc as isDescriptionMetadata, bf as isDocumentMemory, b9 as isDocumentMetadata, bg as isFragmentMemory, ba as isFragmentMetadata, bb as isMessageMetadata } from './index-DVKkCFlY.js';
+import { Pool } from 'pg';
+import { PGlite } from '@electric-sql/pglite';
+import * as pino from 'pino';
+import { Tracer, Meter, Span, Context } from '@opentelemetry/api';
+import * as browser from '@sentry/browser';
+export { browser as Sentry };
+export { i as v1 } from './index-Cy9ZgQIe.js';
+import './types-DzoA9aTJ.js';
+import 'stream';
+
+/**
+ * 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.
+ */
+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.
+ */
+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.
+ */
+declare function formatActions(actions: Action[]): string;
+
+/**
+ * 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
+ */
+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 | Pool>;
+    /**
+     * 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 agent exists in the database.
+     * @param agent The agent object to ensure exists.
+     * @returns A Promise that resolves when the agent has been ensured to exist.
+     */
+    abstract ensureAgentExists(agent: Partial<Agent>): Promise<Agent>;
+    /**
+     * 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>;
+}
+
+/**
+ * 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.
+ */
+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.
+ */
+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
+ */
+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.
+ */
+declare function formatEntities({ entities }: {
+    entities: Entity[];
+}): string;
+
+declare let logger: pino.Logger<string, boolean>;
+declare const createLogger: (bindings?: {}) => pino.Logger<never, boolean>;
+
+declare const elizaLogger: pino.Logger<string, boolean>;
+
+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>";
+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>";
+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>.";
+declare const booleanFooter = "Respond with only a YES or a NO.";
+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>";
+
+/**
+ * Represents the state of server ownership, including a mapping of server IDs to their respective World objects.
+ */
+/**
+ * Interface representing the ownership state of servers.
+ * @property {Object.<string, World>} servers - The servers and their corresponding worlds, where the key is the server ID and the value is the World object.
+ */
+interface ServerOwnershipState {
+    servers: {
+        [serverId: string]: World;
+    };
+}
+/**
+ * Gets a user's role from world metadata
+ */
+/**
+ * Retrieve the server role of a specified user entity within a given server.
+ *
+ * @param {IAgentRuntime} runtime - The runtime object containing necessary configurations and services.
+ * @param {string} entityId - The unique identifier of the user entity.
+ * @param {string} serverId - The unique identifier of the server.
+ * @returns {Promise<Role>} The role of the user entity within the server, resolved as a Promise.
+ */
+declare function getUserServerRole(runtime: IAgentRuntime, entityId: string, serverId: string): Promise<Role>;
+/**
+ * Finds a server where the given user is the owner
+ */
+declare function findWorldsForOwner(runtime: IAgentRuntime, entityId: string): Promise<World[] | null>;
+
+interface InstrumentationConfig {
+    serviceName?: string;
+    otlpEndpoint?: string;
+    enabled?: boolean;
+}
+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>;
+}
+
+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>;
+}
+
+declare class Semaphore {
+    private permits;
+    private waiting;
+    constructor(count: number);
+    acquire(): Promise<void>;
+    release(): void;
+}
+declare class AgentRuntime implements IAgentRuntime {
+    #private;
+    readonly agentId: UUID;
+    readonly character: Character;
+    adapter: IDatabaseAdapter;
+    readonly actions: Action[];
+    readonly evaluators: Evaluator[];
+    readonly providers: Provider[];
+    readonly plugins: Plugin[];
+    private isInitialized;
+    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<ServiceTypeName, Service>;
+    private serviceTypes;
+    models: Map<string, ModelHandler[]>;
+    routes: Route[];
+    private taskWorkers;
+    private sendHandlers;
+    private eventHandlers;
+    private allAvailablePlugins;
+    private characterPlugins;
+    logger: any;
+    private settings;
+    private servicesInitQueue;
+    instrumentationService: InstrumentationService;
+    tracer: any;
+    constructor(opts: {
+        conversationLength?: number;
+        agentId?: UUID;
+        character?: Character;
+        plugins?: Plugin[];
+        fetch?: typeof fetch;
+        adapter?: IDatabaseAdapter;
+        settings?: RuntimeSettings;
+        events?: {
+            [key: string]: ((params: any) => void)[];
+        };
+        allAvailablePlugins?: Plugin[];
+    });
+    startSpan<T>(name: string, fn: (span: Span) => Promise<T>, parentContext?: Context): Promise<T>;
+    endSpan(ctx: Context | undefined, name: string): void;
+    startActiveSpan(name: string, options?: any): Span;
+    registerPlugin(plugin: Plugin): Promise<void>;
+    private resolvePluginDependencies;
+    getAllServices(): Map<ServiceTypeName, Service>;
+    stop(): Promise<void>;
+    initialize(): Promise<void>;
+    getConnection(): Promise<PGlite | Pool>;
+    setSetting(key: string, value: string | boolean | null | any, secret?: boolean): void;
+    getSetting(key: string): string | boolean | null | any;
+    getConversationLength(): number;
+    registerDatabaseAdapter(adapter: IDatabaseAdapter): void;
+    registerProvider(provider: Provider): void;
+    registerAction(action: Action): void;
+    registerEvaluator(evaluator: Evaluator): void;
+    processActions(message: Memory, responses: Memory[], state?: State, callback?: HandlerCallback): Promise<void>;
+    evaluate(message: Memory, state: State, didRespond?: boolean, callback?: HandlerCallback, responses?: Memory[]): Promise<Evaluator[]>;
+    ensureConnection({ entityId, roomId, worldId, worldName, userName, name, source, type, channelId, serverId, userId, metadata, }: {
+        entityId: UUID;
+        roomId: UUID;
+        worldId: UUID;
+        worldName?: string;
+        userName?: string;
+        name?: string;
+        source?: string;
+        type?: ChannelType;
+        channelId?: string;
+        serverId?: string;
+        userId?: UUID;
+        metadata?: Record<string, any>;
+    }): Promise<void>;
+    ensureParticipantInRoom(entityId: UUID, roomId: UUID): Promise<void>;
+    removeParticipant(entityId: UUID, roomId: UUID): Promise<boolean>;
+    getParticipantsForEntity(entityId: UUID): Promise<Participant[]>;
+    getParticipantsForRoom(roomId: UUID): Promise<UUID[]>;
+    addParticipant(entityId: UUID, roomId: UUID): Promise<boolean>;
+    addParticipantsRoom(entityIds: UUID[], roomId: UUID): Promise<boolean>;
+    /**
+     * Ensure the existence of a world.
+     */
+    ensureWorldExists({ id, name, serverId, metadata }: World): Promise<void>;
+    ensureRoomExists({ id, name, source, type, channelId, serverId, worldId, metadata }: Room): Promise<void>;
+    composeState(message: Memory, includeList?: string[] | null, onlyInclude?: boolean, skipCache?: boolean): Promise<State>;
+    getService<T extends Service = Service>(serviceName: ServiceTypeName | string): T | null;
+    /**
+     * Type-safe service getter that ensures the correct service type is returned
+     * @template T - The expected service class type
+     * @param serviceName - The service type name
+     * @returns The service instance with proper typing, or null if not found
+     */
+    getTypedService<T extends Service = Service>(serviceName: ServiceTypeName | string): T | null;
+    /**
+     * Get all registered service types
+     * @returns Array of registered service type names
+     */
+    getRegisteredServiceTypes(): ServiceTypeName[];
+    /**
+     * Check if a service type is registered
+     * @param serviceType - The service type to check
+     * @returns true if the service is registered
+     */
+    hasService(serviceType: ServiceTypeName | string): boolean;
+    registerService(serviceDef: typeof Service): Promise<void>;
+    registerModel(modelType: ModelTypeName, handler: (params: any) => Promise<any>, provider: string, priority?: number): void;
+    getModel(modelType: ModelTypeName, provider?: string): ((runtime: IAgentRuntime, params: any) => Promise<any>) | undefined;
+    useModel<T extends ModelTypeName, R = ModelResultMap[T]>(modelType: T, params: Omit<ModelParamsMap[T], 'runtime'> | any, provider?: string): 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;
+    getTaskWorker(name: string): TaskWorker | undefined;
+    get db(): any;
+    init(): Promise<void>;
+    close(): Promise<void>;
+    getAgent(agentId: UUID): Promise<Agent | null>;
+    getAgents(): Promise<Partial<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<Agent>;
+    getEntityById(entityId: UUID): Promise<Entity | null>;
+    getEntityByIds(entityIds: UUID[]): Promise<Entity[] | null>;
+    getEntitiesForRoom(roomId: UUID, includeComponents?: boolean): Promise<Entity[]>;
+    createEntity(entity: Entity): Promise<boolean>;
+    createEntities(entities: 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>;
+    addEmbeddingToMemory(memory: Memory): Promise<Memory>;
+    getMemories(params: {
+        entityId?: UUID;
+        agentId?: UUID;
+        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[];
+        query?: string;
+        match_threshold?: number;
+        count?: number;
+        roomId?: UUID;
+        unique?: boolean;
+        worldId?: UUID;
+        entityId?: UUID;
+        tableName: string;
+    }): Promise<Memory[]>;
+    rerankMemories(query: string, memories: Memory[]): Promise<Memory[]>;
+    createMemory(memory: Memory, tableName: string, unique?: boolean): Promise<UUID>;
+    updateMemory(memory: Partial<Memory> & {
+        id: UUID;
+        metadata?: MemoryMetadata;
+    }): Promise<boolean>;
+    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>;
+    removeWorld(worldId: UUID): Promise<void>;
+    getAllWorlds(): Promise<World[]>;
+    updateWorld(world: World): Promise<void>;
+    getRoom(roomId: UUID): Promise<Room | null>;
+    getRoomsByIds(roomIds: UUID[]): Promise<Room[] | null>;
+    createRoom({ id, name, source, type, channelId, serverId, worldId }: Room): Promise<UUID>;
+    createRooms(rooms: Room[]): Promise<UUID[]>;
+    deleteRoom(roomId: UUID): Promise<void>;
+    deleteRoomsByWorldId(worldId: UUID): Promise<void>;
+    updateRoom(room: Room): Promise<void>;
+    getRoomsForParticipant(entityId: UUID): Promise<UUID[]>;
+    getRoomsForParticipants(userIds: UUID[]): Promise<UUID[]>;
+    getRooms(worldId: UUID): Promise<Room[]>;
+    getRoomsByWorld(worldId: UUID): Promise<Room[]>;
+    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[];
+        entityId?: UUID;
+    }): 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;
+    sendControlMessage(params: {
+        roomId: UUID;
+        action: 'enable_input' | 'disable_input';
+        target?: string;
+    }): Promise<void>;
+    registerSendHandler(source: string, handler: SendHandlerFunction): void;
+    sendMessageToTarget(target: TargetInfo, content: Content): Promise<void>;
+    getMemoriesByWorldId(params: {
+        worldId: UUID;
+        count?: number;
+        tableName?: string;
+    }): Promise<Memory[]>;
+}
+
+/**
+ * Creates a new Setting object based on provided config settings.
+ * @param {Omit<Setting, "value">} configSetting - The configuration settings for the new Setting object.
+ * @returns {Setting} - The newly created Setting object.
+ */
+/**
+ * Creates a Setting object from a configSetting object by omitting the 'value' property.
+ *
+ * @param {Omit<Setting, 'value'>} configSetting - The configSetting object to create the Setting from.
+ * @returns {Setting} A new Setting object created from the provided configSetting object.
+ */
+declare function createSettingFromConfig(configSetting: Omit<Setting, 'value'>): Setting;
+/**
+ * Retrieves the salt based on env variable SECRET_SALT
+ *
+ * @returns {string} The salt for the agent.
+ */
+declare function getSalt(): string;
+/**
+ * Common encryption function for string values
+ * @param {string} value - The string value to encrypt
+ * @param {string} salt - The salt to use for encryption
+ * @returns {string} - The encrypted value in 'iv:encrypted' format
+ */
+declare function encryptStringValue(value: string, salt: string): string;
+/**
+ * Common decryption function for string values
+ * @param {string} value - The encrypted value in 'iv:encrypted' format
+ * @param {string} salt - The salt to use for decryption
+ * @returns {string} - The decrypted string value
+ */
+declare function decryptStringValue(value: string, salt: string): string;
+/**
+ * Applies salt to the value of a setting
+ * Only applies to secret settings with string values
+ */
+declare function saltSettingValue(setting: Setting, salt: string): Setting;
+/**
+ * Removes salt from the value of a setting
+ * Only applies to secret settings with string values
+ */
+declare function unsaltSettingValue(setting: Setting, salt: string): Setting;
+/**
+ * Applies salt to all settings in a WorldSettings object
+ */
+declare function saltWorldSettings(worldSettings: WorldSettings, salt: string): WorldSettings;
+/**
+ * Removes salt from all settings in a WorldSettings object
+ */
+declare function unsaltWorldSettings(worldSettings: WorldSettings, salt: string): WorldSettings;
+/**
+ * Updates settings state in world metadata
+ */
+declare function updateWorldSettings(runtime: IAgentRuntime, serverId: string, worldSettings: WorldSettings): Promise<boolean>;
+/**
+ * Gets settings state from world metadata
+ */
+declare function getWorldSettings(runtime: IAgentRuntime, serverId: string): Promise<WorldSettings | null>;
+/**
+ * Initializes settings configuration for a server
+ */
+declare function initializeOnboarding(runtime: IAgentRuntime, world: World, config: OnboardingConfig): Promise<WorldSettings | null>;
+/**
+ * Encrypts sensitive data in a Character object
+ * @param {Character} character - The character object to encrypt secrets for
+ * @returns {Character} - A copy of the character with encrypted secrets
+ */
+declare function encryptedCharacter(character: Character): Character;
+/**
+ * Decrypts sensitive data in a Character object
+ * @param {Character} character - The character object with encrypted secrets
+ * @param {IAgentRuntime} runtime - The runtime information needed for salt generation
+ * @returns {Character} - A copy of the character with decrypted secrets
+ */
+declare function decryptedCharacter(character: Character, runtime: IAgentRuntime): Character;
+/**
+ * Helper function to encrypt all string values in an object
+ * @param {Record<string, any>} obj - Object with values to encrypt
+ * @param {string} salt - The salt to use for encryption
+ * @returns {Record<string, any>} - Object with encrypted values
+ */
+declare function encryptObjectValues(obj: Record<string, any>, salt: string): Record<string, any>;
+/**
+ * Helper function to decrypt all string values in an object
+ * @param {Record<string, any>} obj - Object with encrypted values
+ * @param {string} salt - The salt to use for decryption
+ * @returns {Record<string, any>} - Object with decrypted values
+ */
+declare function decryptObjectValues(obj: Record<string, any>, salt: string): Record<string, any>;
+
+/**
+ * Composes a context string by replacing placeholders in a template with corresponding values from the state.
+ *
+ * This function takes a template string with placeholders in the format `{{placeholder}}` and a state object.
+ * It replaces each placeholder with the value from the state object that matches the placeholder's name.
+ * If a matching key is not found in the state object for a given placeholder, the placeholder is replaced with an empty string.
+ *
+ * @param {Object} params - The parameters for composing the context.
+ * @param {State} params.state - The state object containing values to replace the placeholders in the template.
+ * @param {TemplateType} params.template - The template string or function containing placeholders to be replaced with state values.
+ * @returns {string} The composed context string with placeholders replaced by corresponding state values.
+ *
+ * @example
+ * // Given a state object and a template
+ * const state = { userName: "Alice", userAge: 30 };
+ * const template = "Hello, {{userName}}! You are {{userAge}} years old";
+ *
+ * // Composing the context with simple string replacement will result in:
+ * // "Hello, Alice! You are 30 years old."
+ * const contextSimple = composePromptFromState({ state, template });
+ *
+ * // Using composePromptFromState with a template function for dynamic template
+ * const template = ({ state }) => {
+ * const tone = Math.random() > 0.5 ? "kind" : "rude";
+ *   return `Hello, {{userName}}! You are {{userAge}} years old. Be ${tone}`;
+ * };
+ * const contextSimple = composePromptFromState({ state, template });
+ */
+/**
+ * Function to compose a prompt using a provided template and state.
+ * It compiles the template (upgrading double braces to triple braces for non-HTML escaping)
+ * and then populates it with values from the state. Additionally, it processes the
+ * resulting string with `composeRandomUser` to replace placeholders like `{{nameX}}`.
+ *
+ * @param {Object} options - Object containing state and template information.
+ * @param {State} options.state - The state object containing values to fill the template.
+ * @param {TemplateType} options.template - The template string or function to be used for composing the prompt.
+ * @returns {string} The composed prompt output, with state values and random user names populated.
+ */
+declare const composePrompt: ({ state, template, }: {
+    state: {
+        [key: string]: string;
+    };
+    template: TemplateType;
+}) => string;
+/**
+ * Function to compose a prompt using a provided template and state.
+ *
+ * @param {Object} options - Object containing state and template information.
+ * @param {State} options.state - The state object containing values to fill the template.
+ * @param {TemplateType} options.template - The template to be used for composing the prompt.
+ * @returns {string} The composed prompt output.
+ */
+declare const composePromptFromState: ({ state, template, }: {
+    state: State;
+    template: TemplateType;
+}) => string;
+/**
+ * Adds a header to a body of text.
+ *
+ * This function takes a header string and a body string and returns a new string with the header prepended to the body.
+ * If the body string is empty, the header is returned as is.
+ *
+ * @param {string} header - The header to add to the body.
+ * @param {string} body - The body to which to add the header.
+ * @returns {string} The body with the header prepended.
+ *
+ * @example
+ * // Given a header and a body
+ * const header = "Header";
+ * const body = "Body";
+ *
+ * // Adding the header to the body will result in:
+ * // "Header\nBody"
+ * const text = addHeader(header, body);
+ */
+declare const addHeader: (header: string, body: string) => string;
+declare const formatPosts: ({ messages, entities, conversationHeader, }: {
+    messages: Memory[];
+    entities: Entity[];
+    conversationHeader?: boolean;
+}) => string;
+/**
+ * Format messages into a string
+ * @param {Object} params - The formatting parameters
+ * @param {Memory[]} params.messages - List of messages to format
+ * @param {Entity[]} params.entities - List of entities for name resolution
+ * @returns {string} Formatted message string with timestamps and user information
+ */
+declare const formatMessages: ({ messages, entities, }: {
+    messages: Memory[];
+    entities: Entity[];
+}) => string;
+declare const formatTimestamp: (messageDate: number) => string;
+/**
+ * Parses key-value pairs from a simple XML structure within a given text.
+ * It looks for an XML block (e.g., <response>...</response>) and extracts
+ * text content from direct child elements (e.g., <key>value</key>).
+ *
+ * Note: This uses regex and is suitable for simple, predictable XML structures.
+ * For complex XML, a proper parsing library is recommended.
+ *
+ * @param text - The input text containing the XML structure.
+ * @returns An object with key-value pairs extracted from the XML, or null if parsing fails.
+ */
+declare function parseKeyValueXml(text: string): Record<string, any> | null;
+/**
+ * Parses a JSON object from a given text. The function looks for a JSON block wrapped in triple backticks
+ * with `json` language identifier, and if not found, it searches for an object pattern within the text.
+ * It then attempts to parse the JSON string into a JavaScript object. If parsing is successful and the result
+ * is an object (but not an array), it returns the object; otherwise, it tries to parse an array if the result
+ * is an array, or returns null if parsing is unsuccessful or the result is neither an object nor an array.
+ *
+ * @param text - The input text from which to extract and parse the JSON object.
+ * @returns An object parsed from the JSON string if successful; otherwise, null or the result of parsing an array.
+ */
+declare function parseJSONObjectFromText(text: string): Record<string, any> | null;
+/**
+ * Normalizes a JSON-like string by correcting formatting issues:
+ * - Removes extra spaces after '{' and before '}'.
+ * - Wraps unquoted values in double quotes.
+ * - Converts single-quoted values to double-quoted.
+ * - Ensures consistency in key-value formatting.
+ * - Normalizes mixed adjacent quote pairs.
+ *
+ * This is useful for cleaning up improperly formatted JSON strings
+ * before parsing them into valid JSON.
+ *
+ * @param str - The JSON-like string to normalize.
+ * @returns A properly formatted JSON string.
+ */
+declare const normalizeJsonString: (str: string) => string;
+/**
+ * Truncate text to fit within the character limit, ensuring it ends at a complete sentence.
+ */
+declare function truncateToCompleteSentence(text: string, maxLength: number): string;
+declare function splitChunks(content: string, chunkSize?: number, bleed?: number): Promise<string[]>;
+/**
+ * Trims the provided text prompt to a specified token limit using a tokenizer model and type.
+ */
+declare function trimTokens(prompt: string, maxTokens: number, runtime: IAgentRuntime): Promise<string>;
+declare function safeReplacer(): (key: string, value: any) => any;
+/**
+ * Parses a string to determine its boolean equivalent.
+ *
+ * Recognized affirmative values: "YES", "Y", "TRUE", "T", "1", "ON", "ENABLE"
+ * Recognized negative values: "NO", "N", "FALSE", "F", "0", "OFF", "DISABLE"
+ *
+ * @param {string | undefined | null} value - The input text to parse
+ * @returns {boolean} - Returns `true` for affirmative inputs, `false` for negative or unrecognized inputs
+ */
+declare function parseBooleanFromText(value: string | undefined | null): boolean;
+/**
+ * Validates a UUID value.
+ *
+ * @param {unknown} value - The value to validate.
+ * @returns {UUID | null} Returns the validated UUID value or null if validation fails.
+ */
+declare function validateUuid(value: unknown): UUID | null;
+/**
+ * Converts a string or number to a UUID.
+ *
+ * @param {string | number} target - The string or number to convert to a UUID.
+ * @returns {UUID} The UUID generated from the input target.
+ * @throws {TypeError} Throws an error if the input target is not a string.
+ */
+declare function stringToUuid(target: string | number): UUID;
+
+declare const defaultSpec: typeof v2;
+
+export { Action, Agent, AgentRuntime, ChannelType, Character, Component, Content, DatabaseAdapter, Entity, Evaluator, HandlerCallback, IAgentRuntime, IDatabaseAdapter, type IInstrumentationService, type InstrumentationConfig, InstrumentationService, Log, Memory, MemoryMetadata, ModelHandler, ModelParamsMap, ModelResultMap, ModelTypeName, OnboardingConfig, Participant, Plugin, Provider, Relationship, Role, Room, Route, RuntimeSettings, Semaphore, SendHandlerFunction, type ServerOwnershipState, Service, ServiceTypeName, Setting, State, TargetInfo, Task, TaskWorker, TemplateType, UUID, World, WorldSettings, addHeader, booleanFooter, composeActionExamples, composePrompt, composePromptFromState, createLogger, createSettingFromConfig, createUniqueUuid, decryptObjectValues, decryptStringValue as decryptSecret, decryptStringValue, decryptedCharacter, defaultSpec, elizaLogger, encryptObjectValues, encryptStringValue, encryptedCharacter, findEntityByName, findWorldsForOwner, formatActionNames, formatActions, formatEntities, formatMessages, formatPosts, formatTimestamp, getEntityDetails, getSalt, getUserServerRole, getWorldSettings, imageDescriptionTemplate, initializeOnboarding, logger, messageHandlerTemplate, normalizeJsonString, parseBooleanFromText, parseJSONObjectFromText, parseKeyValueXml, postCreationTemplate, safeReplacer, saltSettingValue, saltWorldSettings, shouldRespondTemplate, splitChunks, stringToUuid, trimTokens, truncateToCompleteSentence, unsaltSettingValue, unsaltWorldSettings, updateWorldSettings, v2, validateUuid };