@elizaos/core 1.0.0-beta.37 → 1.0.0-beta.38

package/dist/index.d.ts

@@ -1,14 +1,2861 @@
-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 './uuid';
-export * from './audioUtils';
-export * from './utils';
-export * from './instrumentation/types';
-export * from './instrumentation/service';
+import * as pino from 'pino';
+import { Tracer, Meter, Span, Context } from '@opentelemetry/api';
+import { z } from 'zod';
+import { Buffer as Buffer$1 } from 'buffer';
+
+/**
+ * Type definition for a Universally Unique Identifier (UUID) using a specific format.
+ * @typedef {`${string}-${string}-${string}-${string}-${string}`} UUID
+ */
+/**
+ * Defines a custom type UUID representing a universally unique identifier
+ */
+type UUID = `${string}-${string}-${string}-${string}-${string}`;
+/**
+ * Helper function to safely cast a string to strongly typed UUID
+ * @param id The string UUID to validate and cast
+ * @returns The same UUID with branded type information
+ */
+declare function asUUID(id: string): UUID;
+/**
+ * Represents the content of a memory, message, or other information
+ */
+interface Content {
+    /** The agent's internal thought process */
+    thought?: string;
+    /** The main text content visible to users */
+    text?: string;
+    /** Optional actions to be performed */
+    actions?: string[];
+    /** Optional providers to use for context generation */
+    providers?: string[];
+    /** Optional source/origin of the content */
+    source?: string;
+    /** URL of the original message/post (e.g. tweet URL, Discord message link) */
+    url?: string;
+    /** UUID of parent message if this is a reply/thread */
+    inReplyTo?: UUID;
+    /** Array of media attachments */
+    attachments?: Media[];
+    /**
+     * Additional dynamic properties
+     * Use specific properties above instead of this when possible
+     */
+    [key: string]: unknown;
+}
+/**
+ * Example content with associated user for demonstration purposes
+ */
+interface ActionExample {
+    /** User associated with the example */
+    name: string;
+    /** Content of the example */
+    content: Content;
+}
+type ModelTypeName = (typeof ModelType)[keyof typeof ModelType] | string;
+/**
+ * Model size/type classification
+ */
+declare const ModelType: {
+    readonly SMALL: "TEXT_SMALL";
+    readonly MEDIUM: "TEXT_LARGE";
+    readonly LARGE: "TEXT_LARGE";
+    readonly TEXT_SMALL: "TEXT_SMALL";
+    readonly TEXT_LARGE: "TEXT_LARGE";
+    readonly TEXT_EMBEDDING: "TEXT_EMBEDDING";
+    readonly TEXT_TOKENIZER_ENCODE: "TEXT_TOKENIZER_ENCODE";
+    readonly TEXT_TOKENIZER_DECODE: "TEXT_TOKENIZER_DECODE";
+    readonly TEXT_REASONING_SMALL: "REASONING_SMALL";
+    readonly TEXT_REASONING_LARGE: "REASONING_LARGE";
+    readonly TEXT_COMPLETION: "TEXT_COMPLETION";
+    readonly IMAGE: "IMAGE";
+    readonly IMAGE_DESCRIPTION: "IMAGE_DESCRIPTION";
+    readonly TRANSCRIPTION: "TRANSCRIPTION";
+    readonly TEXT_TO_SPEECH: "TEXT_TO_SPEECH";
+    readonly AUDIO: "AUDIO";
+    readonly VIDEO: "VIDEO";
+    readonly OBJECT_SMALL: "OBJECT_SMALL";
+    readonly OBJECT_LARGE: "OBJECT_LARGE";
+};
+type ServiceTypeName = (typeof ServiceType)[keyof typeof ServiceType];
+declare const ServiceType: {
+    readonly TRANSCRIPTION: "transcription";
+    readonly VIDEO: "video";
+    readonly BROWSER: "browser";
+    readonly PDF: "pdf";
+    readonly REMOTE_FILES: "aws_s3";
+    readonly WEB_SEARCH: "web_search";
+    readonly EMAIL: "email";
+    readonly TEE: "tee";
+    readonly TASK: "task";
+    readonly INSTRUMENTATION: "instrumentation";
+};
+/**
+ * Represents the current state/context of a conversation
+ */
+interface State {
+    /** Additional dynamic properties */
+    [key: string]: any;
+    values: {
+        [key: string]: any;
+    };
+    data: {
+        [key: string]: any;
+    };
+    text: string;
+}
+/**
+ * Memory type enumeration for built-in memory types
+ */
+type MemoryTypeAlias = string;
+declare enum MemoryType {
+    DOCUMENT = "document",
+    FRAGMENT = "fragment",
+    MESSAGE = "message",
+    DESCRIPTION = "description",
+    CUSTOM = "custom"
+}
+type MemoryScope = 'shared' | 'private' | 'room';
+/**
+ * Base interface for all memory metadata types
+ */
+interface BaseMetadata {
+    type: MemoryTypeAlias;
+    source?: string;
+    sourceId?: UUID;
+    scope?: MemoryScope;
+    timestamp?: number;
+    tags?: string[];
+}
+interface DocumentMetadata extends BaseMetadata {
+    type: MemoryType.DOCUMENT;
+}
+interface FragmentMetadata extends BaseMetadata {
+    type: MemoryType.FRAGMENT;
+    documentId: UUID;
+    position: number;
+}
+interface MessageMetadata extends BaseMetadata {
+    type: MemoryType.MESSAGE;
+}
+interface DescriptionMetadata extends BaseMetadata {
+    type: MemoryType.DESCRIPTION;
+}
+interface CustomMetadata extends BaseMetadata {
+    [key: string]: unknown;
+}
+type MemoryMetadata = DocumentMetadata | FragmentMetadata | MessageMetadata | DescriptionMetadata | CustomMetadata;
+/**
+ * Represents a stored memory/message
+ */
+interface Memory {
+    /** Optional unique identifier */
+    id?: UUID;
+    /** Associated user ID */
+    entityId: UUID;
+    /** Associated agent ID */
+    agentId?: UUID;
+    /** Optional creation timestamp in milliseconds since epoch */
+    createdAt?: number;
+    /** Memory content */
+    content: Content;
+    /** Optional embedding vector for semantic search */
+    embedding?: number[];
+    /** Associated room ID */
+    roomId: UUID;
+    /** Whether memory is unique (used to prevent duplicates) */
+    unique?: boolean;
+    /** Embedding similarity score (set when retrieved via search) */
+    similarity?: number;
+    /** Metadata for the memory */
+    metadata?: MemoryMetadata;
+}
+/**
+ * Represents a log entry
+ */
+interface Log {
+    /** Optional unique identifier */
+    id?: UUID;
+    /** Associated entity ID */
+    entityId: UUID;
+    /** Associated room ID */
+    roomId?: UUID;
+    /** Log body */
+    body: {
+        [key: string]: unknown;
+    };
+    /** Log type */
+    type: string;
+    /** Log creation timestamp */
+    createdAt: Date;
+}
+/**
+ * Example message for demonstration
+ */
+interface MessageExample {
+    /** Associated user */
+    name: string;
+    /** Message content */
+    content: Content;
+}
+/**
+ * Handler function type for processing messages
+ */
+type Handler = (runtime: IAgentRuntime, message: Memory, state?: State, options?: {
+    [key: string]: unknown;
+}, callback?: HandlerCallback, responses?: Memory[]) => Promise<unknown>;
+/**
+ * Callback function type for handlers
+ */
+type HandlerCallback = (response: Content, files?: any) => Promise<Memory[]>;
+/**
+ * Validator function type for actions/evaluators
+ */
+type Validator = (runtime: IAgentRuntime, message: Memory, state?: State) => Promise<boolean>;
+/**
+ * Represents an action the agent can perform
+ */
+interface Action {
+    /** Similar action descriptions */
+    similes?: string[];
+    /** Detailed description */
+    description: string;
+    /** Example usages */
+    examples?: ActionExample[][];
+    /** Handler function */
+    handler: Handler;
+    /** Action name */
+    name: string;
+    /** Validation function */
+    validate: Validator;
+}
+/**
+ * Example for evaluating agent behavior
+ */
+interface EvaluationExample {
+    /** Evaluation context */
+    prompt: string;
+    /** Example messages */
+    messages: Array<ActionExample>;
+    /** Expected outcome */
+    outcome: string;
+}
+/**
+ * Evaluator for assessing agent responses
+ */
+interface Evaluator {
+    /** Whether to always run */
+    alwaysRun?: boolean;
+    /** Detailed description */
+    description: string;
+    /** Similar evaluator descriptions */
+    similes?: string[];
+    /** Example evaluations */
+    examples: EvaluationExample[];
+    /** Handler function */
+    handler: Handler;
+    /** Evaluator name */
+    name: string;
+    /** Validation function */
+    validate: Validator;
+}
+interface ProviderResult {
+    values?: {
+        [key: string]: any;
+    };
+    data?: {
+        [key: string]: any;
+    };
+    text?: string;
+}
+/**
+ * Provider for external data/services
+ */
+interface Provider {
+    /** Provider name */
+    name: string;
+    /** Description of the provider */
+    description?: string;
+    /** Whether the provider is dynamic */
+    dynamic?: boolean;
+    /** Position of the provider in the provider list, positive or negative */
+    position?: number;
+    /**
+     * Whether the provider is private
+     *
+     * Private providers are not displayed in the regular provider list, they have to be called explicitly
+     */
+    private?: boolean;
+    /** Data retrieval function */
+    get: (runtime: IAgentRuntime, message: Memory, state: State) => Promise<ProviderResult>;
+}
+/**
+ * Represents a relationship between users
+ */
+interface Relationship {
+    /** Unique identifier */
+    id: UUID;
+    /** First user ID */
+    sourceEntityId: UUID;
+    /** Second user ID */
+    targetEntityId: UUID;
+    /** Agent ID */
+    agentId: UUID;
+    /** Tags for filtering/categorizing relationships */
+    tags: string[];
+    /** Additional metadata about the relationship */
+    metadata: {
+        [key: string]: any;
+    };
+    /** Optional creation timestamp */
+    createdAt?: string;
+}
+interface Component {
+    id: UUID;
+    entityId: UUID;
+    agentId: UUID;
+    roomId: UUID;
+    worldId: UUID;
+    sourceEntityId: UUID;
+    type: string;
+    data: {
+        [key: string]: any;
+    };
+}
+/**
+ * Represents a user account
+ */
+interface Entity {
+    /** Unique identifier, optional on creation */
+    id?: UUID;
+    /** Names of the entity */
+    names: string[];
+    /** Optional additional metadata */
+    metadata?: {
+        [key: string]: any;
+    };
+    /** Agent ID this account is related to, for agents should be themselves */
+    agentId: UUID;
+    /** Optional array of components */
+    components?: Component[];
+}
+type World = {
+    id: UUID;
+    name?: string;
+    agentId: UUID;
+    serverId: string;
+    metadata?: {
+        ownership?: {
+            ownerId: string;
+        };
+        roles?: {
+            [entityId: UUID]: Role;
+        };
+        [key: string]: unknown;
+    };
+};
+type Room = {
+    id: UUID;
+    name?: string;
+    agentId?: UUID;
+    source: string;
+    type: ChannelType;
+    channelId?: string;
+    serverId?: string;
+    worldId?: UUID;
+    metadata?: Record<string, unknown>;
+};
+/**
+ * Room participant with account details
+ */
+interface Participant {
+    /** Unique identifier */
+    id: UUID;
+    /** Associated account */
+    entity: Entity;
+}
+/**
+ * Represents a media attachment
+ */
+type Media = {
+    /** Unique identifier */
+    id: string;
+    /** Media URL */
+    url: string;
+    /** Media title */
+    title: string;
+    /** Media source */
+    source: string;
+    /** Media description */
+    description: string;
+    /** Text content */
+    text: string;
+    /** Content type */
+    contentType?: string;
+};
+declare enum ChannelType {
+    SELF = "SELF",// Messages to self
+    DM = "dm",// Direct messages between two participants
+    GROUP = "group",// Group messages with multiple participants
+    VOICE_DM = "VOICE_DM",// Voice direct messages
+    VOICE_GROUP = "VOICE_GROUP",// Voice channels with multiple participants
+    FEED = "FEED",// Social media feed
+    THREAD = "THREAD",// Threaded conversation
+    WORLD = "WORLD",// World channel
+    FORUM = "FORUM",// Forum discussion
+    API = "API"
+}
+/**
+ * Client instance
+ */
+declare abstract class Service {
+    /** Runtime instance */
+    protected runtime: IAgentRuntime;
+    constructor(runtime?: IAgentRuntime);
+    abstract stop(): Promise<void>;
+    /** Service type */
+    static serviceType: string;
+    /** Service name */
+    abstract capabilityDescription: string;
+    /** Service configuration */
+    config?: {
+        [key: string]: any;
+    };
+    /** Start service connection */
+    static start(_runtime: IAgentRuntime): Promise<Service>;
+    /** Stop service connection */
+    static stop(_runtime: IAgentRuntime): Promise<unknown>;
+}
+type Route = {
+    type: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'STATIC';
+    path: string;
+    filePath?: string;
+    handler?: (req: any, res: any, runtime: IAgentRuntime) => Promise<void>;
+};
+/**
+ * Plugin for extending agent functionality
+ */
+interface Plugin {
+    name: string;
+    description: string;
+    init?: (config: Record<string, string>, runtime: IAgentRuntime) => Promise<void>;
+    config?: {
+        [key: string]: any;
+    };
+    services?: (typeof Service)[];
+    componentTypes?: {
+        name: string;
+        schema: Record<string, unknown>;
+        validator?: (data: any) => boolean;
+    }[];
+    actions?: Action[];
+    providers?: Provider[];
+    evaluators?: Evaluator[];
+    adapter?: IDatabaseAdapter;
+    models?: {
+        [key: string]: (...args: any[]) => Promise<any>;
+    };
+    events?: {
+        [K in keyof EventPayloadMap]?: EventHandler<K>[];
+    } & {
+        [key: string]: ((params: EventPayload) => Promise<any>)[];
+    };
+    routes?: Route[];
+    tests?: TestSuite[];
+}
+interface ProjectAgent {
+    character: Character;
+    init?: (runtime: IAgentRuntime) => Promise<void>;
+    plugins?: Plugin[];
+    tests?: TestSuite | TestSuite[];
+}
+interface Project {
+    agents: ProjectAgent[];
+}
+type TemplateType = string | ((options: {
+    state: State | {
+        [key: string]: string;
+    };
+}) => string);
+/**
+ * Configuration for an agent character
+ */
+interface Character {
+    /** Optional unique identifier */
+    id?: UUID;
+    /** Character name */
+    name: string;
+    /** Optional username */
+    username?: string;
+    /** Optional system prompt */
+    system?: string;
+    /** Optional prompt templates */
+    templates?: {
+        [key: string]: TemplateType;
+    };
+    /** Character biography */
+    bio: string | string[];
+    /** Example messages */
+    messageExamples?: MessageExample[][];
+    /** Example posts */
+    postExamples?: string[];
+    /** Known topics */
+    topics?: string[];
+    /** Character traits */
+    adjectives?: string[];
+    /** Optional knowledge base */
+    knowledge?: (string | {
+        path: string;
+        shared?: boolean;
+    } | {
+        directory: string;
+        shared?: boolean;
+    })[];
+    /** Available plugins */
+    plugins?: string[];
+    /** Optional configuration */
+    settings?: {
+        [key: string]: any | string | boolean | number;
+    };
+    /** Optional secrets */
+    secrets?: {
+        [key: string]: string | boolean | number;
+    };
+    /** Writing style guides */
+    style?: {
+        all?: string[];
+        chat?: string[];
+        post?: string[];
+    };
+}
+declare enum AgentStatus {
+    ACTIVE = "active",
+    INACTIVE = "inactive"
+}
+interface Agent extends Character {
+    enabled?: boolean;
+    status?: AgentStatus;
+    createdAt: number;
+    updatedAt: number;
+}
+/**
+ * Interface for database operations
+ */
+interface IDatabaseAdapter {
+    /** Database instance */
+    db: any;
+    /** Initialize database connection */
+    init(): Promise<void>;
+    /** Close database connection */
+    close(): Promise<void>;
+    getAgent(agentId: UUID): Promise<Agent | null>;
+    /** Get all agents */
+    getAgents(): Promise<Agent[]>;
+    createAgent(agent: Partial<Agent>): Promise<boolean>;
+    updateAgent(agentId: UUID, agent: Partial<Agent>): Promise<boolean>;
+    deleteAgent(agentId: UUID): Promise<boolean>;
+    ensureAgentExists(agent: Partial<Agent>): Promise<Agent>;
+    ensureEmbeddingDimension(dimension: number): Promise<void>;
+    /** Get entity by ID */
+    getEntityById(entityId: UUID): Promise<Entity | null>;
+    /** Get entities for room */
+    getEntitiesForRoom(roomId: UUID, includeComponents?: boolean): Promise<Entity[]>;
+    /** Create new entity */
+    createEntity(entity: Entity): Promise<boolean>;
+    /** Update entity */
+    updateEntity(entity: Entity): Promise<void>;
+    /** Get component by ID */
+    getComponent(entityId: UUID, type: string, worldId?: UUID, sourceEntityId?: UUID): Promise<Component | null>;
+    /** Get all components for an entity */
+    getComponents(entityId: UUID, worldId?: UUID, sourceEntityId?: UUID): Promise<Component[]>;
+    /** Create component */
+    createComponent(component: Component): Promise<boolean>;
+    /** Update component */
+    updateComponent(component: Component): Promise<void>;
+    /** Delete component */
+    deleteComponent(componentId: UUID): Promise<void>;
+    /** Get memories matching criteria */
+    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>;
+    getLogs(params: {
+        entityId: UUID;
+        roomId?: UUID;
+        type?: string;
+        count?: number;
+        offset?: number;
+    }): Promise<Log[]>;
+    deleteLog(logId: UUID): Promise<void>;
+    searchMemories(params: {
+        embedding: number[];
+        match_threshold?: number;
+        count?: number;
+        roomId?: UUID;
+        unique?: boolean;
+        tableName: string;
+    }): Promise<Memory[]>;
+    createMemory(memory: Memory, tableName: string, unique?: boolean): Promise<UUID>;
+    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>;
+    createWorld(world: World): Promise<UUID>;
+    getWorld(id: UUID): Promise<World | null>;
+    getAllWorlds(): Promise<World[]>;
+    updateWorld(world: World): Promise<void>;
+    getRoom(roomId: UUID): Promise<Room | null>;
+    createRoom({ id, name, source, type, channelId, serverId, worldId }: Room): Promise<UUID>;
+    deleteRoom(roomId: UUID): Promise<void>;
+    updateRoom(room: Room): Promise<void>;
+    getRoomsForParticipant(entityId: UUID): Promise<UUID[]>;
+    getRoomsForParticipants(userIds: UUID[]): Promise<UUID[]>;
+    getRooms(worldId: UUID): Promise<Room[]>;
+    addParticipant(entityId: UUID, roomId: UUID): Promise<boolean>;
+    removeParticipant(entityId: UUID, roomId: UUID): Promise<boolean>;
+    getParticipantsForEntity(entityId: UUID): Promise<Participant[]>;
+    getParticipantsForRoom(roomId: UUID): Promise<UUID[]>;
+    getParticipantUserState(roomId: UUID, entityId: UUID): Promise<'FOLLOWED' | 'MUTED' | null>;
+    setParticipantUserState(roomId: UUID, entityId: UUID, state: 'FOLLOWED' | 'MUTED' | null): Promise<void>;
+    /**
+     * Creates a new relationship between two entities.
+     * @param params Object containing the relationship details
+     * @returns Promise resolving to boolean indicating success
+     */
+    createRelationship(params: {
+        sourceEntityId: UUID;
+        targetEntityId: UUID;
+        tags?: string[];
+        metadata?: {
+            [key: string]: any;
+        };
+    }): Promise<boolean>;
+    /**
+     * Updates an existing relationship between two entities.
+     * @param relationship The relationship object with updated data
+     * @returns Promise resolving to void
+     */
+    updateRelationship(relationship: Relationship): Promise<void>;
+    /**
+     * Retrieves a relationship between two entities if it exists.
+     * @param params Object containing the entity IDs and agent ID
+     * @returns Promise resolving to the Relationship object or null if not found
+     */
+    getRelationship(params: {
+        sourceEntityId: UUID;
+        targetEntityId: UUID;
+    }): Promise<Relationship | null>;
+    /**
+     * Retrieves all relationships for a specific entity.
+     * @param params Object containing the user ID, agent ID and optional tags to filter by
+     * @returns Promise resolving to an array of Relationship objects
+     */
+    getRelationships(params: {
+        entityId: UUID;
+        tags?: string[];
+    }): Promise<Relationship[]>;
+    ensureEmbeddingDimension(dimension: number): Promise<void>;
+    getCache<T>(key: string): Promise<T | undefined>;
+    setCache<T>(key: string, value: T): Promise<boolean>;
+    deleteCache(key: string): Promise<boolean>;
+    createTask(task: Task): Promise<UUID>;
+    getTasks(params: {
+        roomId?: UUID;
+        tags?: string[];
+    }): Promise<Task[]>;
+    getTask(id: UUID): Promise<Task | null>;
+    getTasksByName(name: string): Promise<Task[]>;
+    updateTask(id: UUID, task: Partial<Task>): Promise<void>;
+    deleteTask(id: UUID): Promise<void>;
+}
+/**
+ * Result interface for embedding similarity searches
+ */
+interface EmbeddingSearchResult {
+    embedding: number[];
+    levenshtein_score: number;
+}
+/**
+ * Options for memory retrieval operations
+ */
+interface MemoryRetrievalOptions {
+    roomId: UUID;
+    count?: number;
+    unique?: boolean;
+    start?: number;
+    end?: number;
+    agentId?: UUID;
+}
+/**
+ * Options for memory search operations
+ */
+interface MemorySearchOptions {
+    embedding: number[];
+    match_threshold?: number;
+    count?: number;
+    roomId: UUID;
+    agentId?: UUID;
+    unique?: boolean;
+    metadata?: Partial<MemoryMetadata>;
+}
+/**
+ * Options for multi-room memory retrieval
+ */
+interface MultiRoomMemoryOptions {
+    roomIds: UUID[];
+    limit?: number;
+    agentId?: UUID;
+}
+/**
+ * Unified options pattern for memory operations
+ * Provides a simpler, more consistent interface
+ */
+interface UnifiedMemoryOptions {
+    roomId: UUID;
+    limit?: number;
+    agentId?: UUID;
+    unique?: boolean;
+    start?: number;
+    end?: number;
+}
+/**
+ * Specialized memory search options
+ */
+interface UnifiedSearchOptions extends UnifiedMemoryOptions {
+    embedding: number[];
+    similarity?: number;
+}
+interface IAgentRuntime extends IDatabaseAdapter {
+    agentId: UUID;
+    character: Character;
+    providers: Provider[];
+    actions: Action[];
+    evaluators: Evaluator[];
+    plugins: Plugin[];
+    services: Map<ServiceTypeName, Service>;
+    events: Map<string, ((params: any) => Promise<void>)[]>;
+    fetch?: typeof fetch | null;
+    routes: Route[];
+    registerPlugin(plugin: Plugin): Promise<void>;
+    initialize(): Promise<void>;
+    getKnowledge(message: Memory): Promise<KnowledgeItem[]>;
+    addKnowledge(item: KnowledgeItem, options: {
+        targetTokens: number;
+        overlap: number;
+        modelContextSize: number;
+    }): Promise<void>;
+    getService<T extends Service>(service: ServiceTypeName | string): T | null;
+    getAllServices(): Map<ServiceTypeName, Service>;
+    registerService(service: typeof Service): Promise<void>;
+    registerDatabaseAdapter(adapter: IDatabaseAdapter): void;
+    setSetting(key: string, value: string | boolean | null | any, secret: boolean): void;
+    getSetting(key: string): string | boolean | null | any;
+    getConversationLength(): number;
+    processActions(message: Memory, responses: Memory[], state?: State, callback?: HandlerCallback): Promise<void>;
+    evaluate(message: Memory, state?: State, didRespond?: boolean, callback?: HandlerCallback, responses?: Memory[]): Promise<Evaluator[] | null>;
+    registerProvider(provider: Provider): void;
+    registerAction(action: Action): void;
+    registerEvaluator(evaluator: Evaluator): void;
+    ensureConnection({ entityId, roomId, userName, name, source, channelId, serverId, type, worldId, userId, }: {
+        entityId: UUID;
+        roomId: UUID;
+        userName?: string;
+        name?: string;
+        source?: string;
+        channelId?: string;
+        serverId?: string;
+        type: ChannelType;
+        worldId?: UUID;
+        userId?: UUID;
+    }): Promise<void>;
+    ensureParticipantInRoom(entityId: UUID, roomId: UUID): Promise<void>;
+    ensureWorldExists(world: World): Promise<void>;
+    ensureRoomExists(room: Room): Promise<void>;
+    composeState(message: Memory, filterList?: string[], includeList?: string[]): Promise<State>;
+    /**
+     * Use a model with strongly typed parameters and return values based on model type
+     * @template T - The model type to use
+     * @template R - The expected return type, defaults to the type defined in ModelResultMap[T]
+     * @param {T} modelType - The type of model to use
+     * @param {ModelParamsMap[T] | any} params - The parameters for the model, typed based on model type
+     * @returns {Promise<R>} - The model result, typed based on the provided generic type parameter
+     */
+    useModel<T extends ModelTypeName, R = ModelResultMap[T]>(modelType: T, params: Omit<ModelParamsMap[T], 'runtime'> | any): Promise<R>;
+    registerModel(modelType: ModelTypeName | string, handler: (params: any) => Promise<any>): void;
+    getModel(modelType: ModelTypeName | string): ((runtime: IAgentRuntime, params: any) => Promise<any>) | undefined;
+    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>;
+    registerTaskWorker(taskHandler: TaskWorker): void;
+    getTaskWorker(name: string): TaskWorker | undefined;
+    stop(): Promise<void>;
+    addEmbeddingToMemory(memory: Memory): Promise<Memory>;
+}
+/**
+ * Interface for settings object with key-value pairs.
+ */
+/**
+ * Interface representing settings with string key-value pairs.
+ */
+interface RuntimeSettings {
+    [key: string]: string | undefined;
+}
+type KnowledgeItem = {
+    id: UUID;
+    content: Content;
+    metadata?: MemoryMetadata;
+};
+declare enum KnowledgeScope {
+    SHARED = "shared",
+    PRIVATE = "private"
+}
+declare enum CacheKeyPrefix {
+    KNOWLEDGE = "knowledge"
+}
+interface DirectoryItem {
+    directory: string;
+    shared?: boolean;
+}
+interface ChunkRow {
+    id: string;
+}
+type GenerateTextParams = {
+    runtime: IAgentRuntime;
+    prompt: string;
+    modelType: ModelTypeName;
+    maxTokens?: number;
+    temperature?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    stopSequences?: string[];
+};
+interface IVideoService extends Service {
+    isVideoUrl(url: string): boolean;
+    fetchVideoInfo(url: string): Promise<Media>;
+    downloadVideo(videoInfo: Media): Promise<string>;
+    processVideo(url: string, runtime: IAgentRuntime): Promise<Media>;
+}
+interface IBrowserService extends Service {
+    getPageContent(url: string, runtime: IAgentRuntime): Promise<{
+        title: string;
+        description: string;
+        bodyContent: string;
+    }>;
+}
+interface IPdfService extends Service {
+    convertPdfToText(pdfBuffer: Buffer): Promise<string>;
+}
+interface IFileService extends Service {
+    uploadFile(imagePath: string, subDirectory: string, useSignedUrl: boolean, expiresIn: number): Promise<{
+        success: boolean;
+        url?: string;
+        error?: string;
+    }>;
+    generateSignedUrl(fileName: string, expiresIn: number): Promise<string>;
+}
+interface TestCase {
+    name: string;
+    fn: (runtime: IAgentRuntime) => Promise<void> | void;
+}
+interface TestSuite {
+    name: string;
+    tests: TestCase[];
+}
+interface TeeAgent {
+    id: string;
+    agentId: string;
+    agentName: string;
+    createdAt: number;
+    publicKey: string;
+    attestation: string;
+}
+declare enum TEEMode {
+    OFF = "OFF",
+    LOCAL = "LOCAL",// For local development with simulator
+    DOCKER = "DOCKER",// For docker development with simulator
+    PRODUCTION = "PRODUCTION"
+}
+interface RemoteAttestationQuote {
+    quote: string;
+    timestamp: number;
+}
+interface DeriveKeyAttestationData {
+    agentId: string;
+    publicKey: string;
+    subject?: string;
+}
+interface RemoteAttestationMessage {
+    agentId: string;
+    timestamp: number;
+    message: {
+        entityId: string;
+        roomId: string;
+        content: string;
+    };
+}
+declare enum TeeType {
+    TDX_DSTACK = "tdx_dstack"
+}
+interface TeeVendorConfig {
+    [key: string]: unknown;
+}
+interface TeePluginConfig {
+    vendor?: string;
+    vendorConfig?: TeeVendorConfig;
+}
+interface TaskWorker {
+    name: string;
+    execute: (runtime: IAgentRuntime, options: {
+        [key: string]: unknown;
+    }, task: Task) => Promise<void>;
+    validate?: (runtime: IAgentRuntime, message: Memory, state: State) => Promise<boolean>;
+}
+interface Task {
+    id?: UUID;
+    name: string;
+    updatedAt?: number;
+    metadata?: {
+        updateInterval?: number;
+        options?: {
+            name: string;
+            description: string;
+        }[];
+        [key: string]: unknown;
+    };
+    description: string;
+    roomId?: UUID;
+    worldId?: UUID;
+    tags: string[];
+}
+declare enum Role {
+    OWNER = "OWNER",
+    ADMIN = "ADMIN",
+    NONE = "NONE"
+}
+interface Setting {
+    name: string;
+    description: string;
+    usageDescription: string;
+    value: string | boolean | null;
+    required: boolean;
+    public?: boolean;
+    secret?: boolean;
+    validation?: (value: any) => boolean;
+    dependsOn?: string[];
+    onSetAction?: (value: any) => string;
+    visibleIf?: (settings: {
+        [key: string]: Setting;
+    }) => boolean;
+}
+interface WorldSettings {
+    [key: string]: Setting;
+}
+interface OnboardingConfig {
+    settings: {
+        [key: string]: Omit<Setting, 'value'>;
+    };
+}
+/**
+ * Base parameters common to all model types
+ */
+interface BaseModelParams {
+    /** The agent runtime for accessing services and utilities */
+    runtime: IAgentRuntime;
+}
+/**
+ * Parameters for text generation models
+ */
+interface TextGenerationParams extends BaseModelParams {
+    /** The prompt to generate text from */
+    prompt: string;
+    /** Model temperature (0.0 to 1.0, lower is more deterministic) */
+    temperature?: number;
+    /** Maximum number of tokens to generate */
+    maxTokens?: number;
+    /** Sequences that should stop generation when encountered */
+    stopSequences?: string[];
+    /** Frequency penalty to apply */
+    frequencyPenalty?: number;
+    /** Presence penalty to apply */
+    presencePenalty?: number;
+}
+/**
+ * Parameters for text embedding models
+ */
+interface TextEmbeddingParams extends BaseModelParams {
+    /** The text to create embeddings for */
+    text: string;
+}
+interface TokenizeTextParams {
+    prompt: string;
+    modelType: ModelTypeName;
+}
+/**
+ * Parameters for text tokenization models
+ */
+interface TokenizeTextParams extends BaseModelParams {
+    /** The text to tokenize */
+    prompt: string;
+    /** The model type to use for tokenization */
+    modelType: ModelTypeName;
+}
+interface DetokenizeTextParams {
+    tokens: number[];
+    modelType: ModelTypeName;
+}
+/**
+ * Parameters for text detokenization models
+ */
+interface DetokenizeTextParams extends BaseModelParams {
+    /** The tokens to convert back to text */
+    tokens: number[];
+    /** The model type to use for detokenization */
+    modelType: ModelTypeName;
+}
+/**
+ * Parameters for image generation models
+ */
+interface ImageGenerationParams extends BaseModelParams {
+    /** The prompt describing the image to generate */
+    prompt: string;
+    /** The dimensions of the image to generate */
+    size?: string;
+    /** Number of images to generate */
+    count?: number;
+}
+/**
+ * Parameters for image description models
+ */
+interface ImageDescriptionParams extends BaseModelParams {
+    /** The URL or path of the image to describe */
+    imageUrl: string;
+    /** Optional prompt to guide the description */
+    prompt?: string;
+}
+/**
+ * Parameters for transcription models
+ */
+interface TranscriptionParams extends BaseModelParams {
+    /** The URL or path of the audio file to transcribe */
+    audioUrl: string;
+    /** Optional prompt to guide transcription */
+    prompt?: string;
+}
+/**
+ * Parameters for text-to-speech models
+ */
+interface TextToSpeechParams extends BaseModelParams {
+    /** The text to convert to speech */
+    text: string;
+    /** The voice to use */
+    voice?: string;
+    /** The speaking speed */
+    speed?: number;
+}
+/**
+ * Parameters for audio processing models
+ */
+interface AudioProcessingParams extends BaseModelParams {
+    /** The URL or path of the audio file to process */
+    audioUrl: string;
+    /** The type of audio processing to perform */
+    processingType: string;
+}
+/**
+ * Parameters for video processing models
+ */
+interface VideoProcessingParams extends BaseModelParams {
+    /** The URL or path of the video file to process */
+    videoUrl: string;
+    /** The type of video processing to perform */
+    processingType: string;
+}
+/**
+ * Optional JSON schema for validating generated objects
+ */
+type JSONSchema = {
+    type: string;
+    properties?: Record<string, any>;
+    required?: string[];
+    items?: JSONSchema;
+    [key: string]: any;
+};
+/**
+ * Parameters for object generation models
+ * @template T - The expected return type, inferred from schema if provided
+ */
+interface ObjectGenerationParams<T = any> extends BaseModelParams {
+    /** The prompt describing the object to generate */
+    prompt: string;
+    /** Optional JSON schema for validation */
+    schema?: JSONSchema;
+    /** Type of object to generate */
+    output?: 'object' | 'array' | 'enum';
+    /** For enum type, the allowed values */
+    enumValues?: string[];
+    /** Model type to use */
+    modelType?: ModelTypeName;
+    /** Model temperature (0.0 to 1.0) */
+    temperature?: number;
+    /** Sequences that should stop generation */
+    stopSequences?: string[];
+}
+/**
+ * Map of model types to their parameter types
+ */
+interface ModelParamsMap {
+    [ModelType.TEXT_SMALL]: TextGenerationParams;
+    [ModelType.TEXT_LARGE]: TextGenerationParams;
+    [ModelType.TEXT_EMBEDDING]: TextEmbeddingParams | string | null;
+    [ModelType.TEXT_TOKENIZER_ENCODE]: TokenizeTextParams;
+    [ModelType.TEXT_TOKENIZER_DECODE]: DetokenizeTextParams;
+    [ModelType.TEXT_REASONING_SMALL]: TextGenerationParams;
+    [ModelType.TEXT_REASONING_LARGE]: TextGenerationParams;
+    [ModelType.IMAGE]: ImageGenerationParams;
+    [ModelType.IMAGE_DESCRIPTION]: ImageDescriptionParams | string;
+    [ModelType.TRANSCRIPTION]: TranscriptionParams | Buffer | string;
+    [ModelType.TEXT_TO_SPEECH]: TextToSpeechParams | string;
+    [ModelType.AUDIO]: AudioProcessingParams;
+    [ModelType.VIDEO]: VideoProcessingParams;
+    [ModelType.OBJECT_SMALL]: ObjectGenerationParams<any>;
+    [ModelType.OBJECT_LARGE]: ObjectGenerationParams<any>;
+    [key: string]: BaseModelParams | any;
+}
+/**
+ * Map of model types to their return value types
+ */
+interface ModelResultMap {
+    [ModelType.TEXT_SMALL]: string;
+    [ModelType.TEXT_LARGE]: string;
+    [ModelType.TEXT_EMBEDDING]: number[];
+    [ModelType.TEXT_TOKENIZER_ENCODE]: number[];
+    [ModelType.TEXT_TOKENIZER_DECODE]: string;
+    [ModelType.TEXT_REASONING_SMALL]: string;
+    [ModelType.TEXT_REASONING_LARGE]: string;
+    [ModelType.IMAGE]: {
+        url: string;
+    }[];
+    [ModelType.IMAGE_DESCRIPTION]: {
+        title: string;
+        description: string;
+    };
+    [ModelType.TRANSCRIPTION]: string;
+    [ModelType.TEXT_TO_SPEECH]: any | Buffer;
+    [ModelType.AUDIO]: any;
+    [ModelType.VIDEO]: any;
+    [ModelType.OBJECT_SMALL]: any;
+    [ModelType.OBJECT_LARGE]: any;
+    [key: string]: any;
+}
+/**
+ * Standard event types across all platforms
+ */
+declare enum EventType {
+    WORLD_JOINED = "WORLD_JOINED",
+    WORLD_CONNECTED = "WORLD_CONNECTED",
+    WORLD_LEFT = "WORLD_LEFT",
+    ENTITY_JOINED = "ENTITY_JOINED",
+    ENTITY_LEFT = "ENTITY_LEFT",
+    ENTITY_UPDATED = "ENTITY_UPDATED",
+    ROOM_JOINED = "ROOM_JOINED",
+    ROOM_LEFT = "ROOM_LEFT",
+    MESSAGE_RECEIVED = "MESSAGE_RECEIVED",
+    MESSAGE_SENT = "MESSAGE_SENT",
+    VOICE_MESSAGE_RECEIVED = "VOICE_MESSAGE_RECEIVED",
+    VOICE_MESSAGE_SENT = "VOICE_MESSAGE_SENT",
+    REACTION_RECEIVED = "REACTION_RECEIVED",
+    POST_GENERATED = "POST_GENERATED",
+    INTERACTION_RECEIVED = "INTERACTION_RECEIVED",
+    RUN_STARTED = "RUN_STARTED",
+    RUN_ENDED = "RUN_ENDED",
+    RUN_TIMEOUT = "RUN_TIMEOUT",
+    ACTION_STARTED = "ACTION_STARTED",
+    ACTION_COMPLETED = "ACTION_COMPLETED",
+    EVALUATOR_STARTED = "EVALUATOR_STARTED",
+    EVALUATOR_COMPLETED = "EVALUATOR_COMPLETED",
+    MODEL_USED = "MODEL_USED"
+}
+/**
+ * Platform-specific event type prefix
+ */
+declare enum PlatformPrefix {
+    DISCORD = "DISCORD",
+    TELEGRAM = "TELEGRAM",
+    TWITTER = "TWITTER"
+}
+/**
+ * Base payload interface for all events
+ */
+interface EventPayload {
+    runtime: IAgentRuntime;
+    source: string;
+    onComplete?: () => void;
+}
+/**
+ * Payload for world-related events
+ */
+interface WorldPayload extends EventPayload {
+    world: World;
+    rooms: Room[];
+    entities: Entity[];
+}
+/**
+ * Payload for entity-related events
+ */
+interface EntityPayload extends EventPayload {
+    entityId: UUID;
+    worldId?: UUID;
+    roomId?: UUID;
+    metadata?: {
+        orginalId: string;
+        username: string;
+        displayName?: string;
+        [key: string]: any;
+    };
+}
+/**
+ * Payload for reaction-related events
+ */
+interface MessagePayload extends EventPayload {
+    message: Memory;
+    callback?: HandlerCallback;
+    onComplete?: () => void;
+}
+/**
+ * Payload for events that are invoked without a message
+ */
+interface InvokePayload extends EventPayload {
+    worldId: UUID;
+    userId: string;
+    roomId: UUID;
+    callback?: HandlerCallback;
+    source: string;
+}
+/**
+ * Run event payload type
+ */
+interface RunEventPayload extends EventPayload {
+    runId: UUID;
+    messageId: UUID;
+    roomId: UUID;
+    entityId: UUID;
+    startTime: number;
+    status: 'started' | 'completed' | 'timeout';
+    endTime?: number;
+    duration?: number;
+    error?: string;
+}
+/**
+ * Action event payload type
+ */
+interface ActionEventPayload extends EventPayload {
+    actionId: UUID;
+    actionName: string;
+    startTime?: number;
+    completed?: boolean;
+    error?: Error;
+}
+/**
+ * Evaluator event payload type
+ */
+interface EvaluatorEventPayload extends EventPayload {
+    evaluatorId: UUID;
+    evaluatorName: string;
+    startTime?: number;
+    completed?: boolean;
+    error?: Error;
+}
+/**
+ * Model event payload type
+ */
+interface ModelEventPayload extends EventPayload {
+    provider: string;
+    type: ModelTypeName;
+    prompt: string;
+    tokens?: {
+        prompt: number;
+        completion: number;
+        total: number;
+    };
+}
+/**
+ * Represents the parameters for a message received handler.
+ * @typedef {Object} MessageReceivedHandlerParams
+ * @property {IAgentRuntime} runtime - The agent runtime associated with the message.
+ * @property {Memory} message - The message received.
+ * @property {HandlerCallback} callback - The callback function to be executed after handling the message.
+ */
+type MessageReceivedHandlerParams = {
+    runtime: IAgentRuntime;
+    message: Memory;
+    callback: HandlerCallback;
+    onComplete?: () => void;
+};
+/**
+ * Maps event types to their corresponding payload types
+ */
+interface EventPayloadMap {
+    [EventType.WORLD_JOINED]: WorldPayload;
+    [EventType.WORLD_CONNECTED]: WorldPayload;
+    [EventType.WORLD_LEFT]: WorldPayload;
+    [EventType.ENTITY_JOINED]: EntityPayload;
+    [EventType.ENTITY_LEFT]: EntityPayload;
+    [EventType.ENTITY_UPDATED]: EntityPayload;
+    [EventType.MESSAGE_RECEIVED]: MessagePayload;
+    [EventType.MESSAGE_SENT]: MessagePayload;
+    [EventType.REACTION_RECEIVED]: MessagePayload;
+    [EventType.POST_GENERATED]: InvokePayload;
+    [EventType.INTERACTION_RECEIVED]: MessagePayload;
+    [EventType.RUN_STARTED]: RunEventPayload;
+    [EventType.RUN_ENDED]: RunEventPayload;
+    [EventType.RUN_TIMEOUT]: RunEventPayload;
+    [EventType.ACTION_STARTED]: ActionEventPayload;
+    [EventType.ACTION_COMPLETED]: ActionEventPayload;
+    [EventType.EVALUATOR_STARTED]: EvaluatorEventPayload;
+    [EventType.EVALUATOR_COMPLETED]: EvaluatorEventPayload;
+    [EventType.MODEL_USED]: ModelEventPayload;
+}
+/**
+ * Event handler function type
+ */
+type EventHandler<T extends keyof EventPayloadMap> = (payload: EventPayloadMap[T]) => Promise<void>;
+/**
+ * Update the Plugin interface with typed events
+ */
+declare enum SOCKET_MESSAGE_TYPE {
+    ROOM_JOINING = 1,
+    SEND_MESSAGE = 2,
+    MESSAGE = 3,
+    ACK = 4,
+    THINKING = 5,
+    CONTROL = 6
+}
+/**
+ * Specialized memory type for messages with enhanced type checking
+ */
+interface MessageMemory extends Memory {
+    metadata: MessageMetadata;
+    content: Content & {
+        text: string;
+    };
+}
+/**
+ * Factory function to create a new message memory with proper defaults
+ */
+declare function createMessageMemory(params: {
+    id?: UUID;
+    entityId: UUID;
+    agentId?: UUID;
+    roomId: UUID;
+    content: Content & {
+        text: string;
+    };
+    embedding?: number[];
+}): MessageMemory;
+/**
+ * Generic service interface that provides better type checking for services
+ * @template ConfigType The configuration type for this service
+ * @template ResultType The result type returned by the service operations
+ */
+interface TypedService<ConfigType = unknown, ResultType = unknown> extends Service {
+    /**
+     * The configuration for this service instance
+     */
+    config: ConfigType;
+    /**
+     * Process an input with this service
+     * @param input The input to process
+     * @returns A promise resolving to the result
+     */
+    process(input: unknown): Promise<ResultType>;
+}
+/**
+ * Generic factory function to create a typed service instance
+ * @param runtime The agent runtime
+ * @param serviceType The type of service to get
+ * @returns The service instance or null if not available
+ */
+declare function getTypedService<T extends TypedService<any, any>>(runtime: IAgentRuntime, serviceType: ServiceTypeName): T | null;
+/**
+ * Type guard to check if a memory metadata is a DocumentMetadata
+ * @param metadata The metadata to check
+ * @returns True if the metadata is a DocumentMetadata
+ */
+declare function isDocumentMetadata(metadata: MemoryMetadata): metadata is DocumentMetadata;
+/**
+ * Type guard to check if a memory metadata is a FragmentMetadata
+ * @param metadata The metadata to check
+ * @returns True if the metadata is a FragmentMetadata
+ */
+declare function isFragmentMetadata(metadata: MemoryMetadata): metadata is FragmentMetadata;
+/**
+ * Type guard to check if a memory metadata is a MessageMetadata
+ * @param metadata The metadata to check
+ * @returns True if the metadata is a MessageMetadata
+ */
+declare function isMessageMetadata(metadata: MemoryMetadata): metadata is MessageMetadata;
+/**
+ * Type guard to check if a memory metadata is a DescriptionMetadata
+ * @param metadata The metadata to check
+ * @returns True if the metadata is a DescriptionMetadata
+ */
+declare function isDescriptionMetadata(metadata: MemoryMetadata): metadata is DescriptionMetadata;
+/**
+ * Type guard to check if a memory metadata is a CustomMetadata
+ * @param metadata The metadata to check
+ * @returns True if the metadata is a CustomMetadata
+ */
+declare function isCustomMetadata(metadata: MemoryMetadata): metadata is CustomMetadata;
+/**
+ * Standardized service error type for consistent error handling
+ */
+interface ServiceError {
+    code: string;
+    message: string;
+    details?: unknown;
+    cause?: Error;
+}
+/**
+ * Type-safe helper for accessing the video service
+ */
+declare function getVideoService(runtime: IAgentRuntime): IVideoService | null;
+/**
+ * Type-safe helper for accessing the browser service
+ */
+declare function getBrowserService(runtime: IAgentRuntime): IBrowserService | null;
+/**
+ * Type-safe helper for accessing the PDF service
+ */
+declare function getPdfService(runtime: IAgentRuntime): IPdfService | null;
+/**
+ * Type-safe helper for accessing the file service
+ */
+declare function getFileService(runtime: IAgentRuntime): IFileService | null;
+/**
+ * Memory type guard for document memories
+ */
+declare function isDocumentMemory(memory: Memory): memory is Memory & {
+    metadata: DocumentMetadata;
+};
+/**
+ * Memory type guard for fragment memories
+ */
+declare function isFragmentMemory(memory: Memory): memory is Memory & {
+    metadata: FragmentMetadata;
+};
+/**
+ * Safely access the text content of a memory
+ * @param memory The memory to extract text from
+ * @param defaultValue Optional default value if no text is found
+ * @returns The text content or default value
+ */
+declare function getMemoryText(memory: Memory, defaultValue?: string): string;
+/**
+ * Safely create a ServiceError from any caught error
+ */
+declare function createServiceError(error: unknown, code?: string): ServiceError;
+/**
+ * Replace 'any' types with more specific types
+ */
+type StateValue = string | number | boolean | null | StateObject | StateArray;
+interface StateObject {
+    [key: string]: StateValue;
+}
+type StateArray = StateValue[];
+/**
+ * Enhanced State interface with more specific types
+ */
+interface EnhancedState {
+    values: StateObject;
+    data: StateObject;
+    text: string;
+    [key: string]: StateValue;
+}
+type ComponentData = Record<string, unknown>;
+type EventDataObject = Record<string, unknown>;
+type TypedEventHandler = (data: EventDataObject) => Promise<void> | void;
+type DbConnection = unknown;
+type MetadataObject = Record<string, unknown>;
+type ModelHandler = (runtime: IAgentRuntime, params: Record<string, unknown>) => Promise<unknown>;
+type ServiceConfig = Record<string, unknown>;
+declare const VECTOR_DIMS: {
+    readonly SMALL: 384;
+    readonly MEDIUM: 512;
+    readonly LARGE: 768;
+    readonly XL: 1024;
+    readonly XXL: 1536;
+    readonly XXXL: 3072;
+};
+/**
+ * Interface for control messages sent from the backend to the frontend
+ * to manage UI state and interaction capabilities
+ */
+interface ControlMessage {
+    /** Message type identifier */
+    type: 'control';
+    /** Control message payload */
+    payload: {
+        /** Action to perform */
+        action: 'disable_input' | 'enable_input';
+        /** Optional target element identifier */
+        target?: string;
+        /** Additional optional parameters */
+        [key: string]: unknown;
+    };
+    /** Room ID to ensure signal is directed to the correct chat window */
+    roomId: UUID;
+}
+
+/**
+ * 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.
+ */
+/**
+ * Compose a specified number of random action examples from the given actionsData.
+ *
+ * @param {Action[]} actionsData - The list of actions to generate examples from.
+ * @param {number} count - The number of examples to compose.
+ * @returns {string} The formatted action examples.
+ */
+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, separated by commas and newlines.
+ * @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 an account by its ID.
+     * @param entityId The UUID of the user account to retrieve.
+     * @returns A Promise that resolves to the Entity object or null if not found.
+     */
+    abstract getEntityById(entityId: UUID): Promise<Entity | null>;
+    abstract getEntitiesForRoom(roomId: UUID, includeComponents?: boolean): Promise<Entity[]>;
+    /**
+     * Creates a new entity in the database.
+     * @param entity The entity object to create.
+     * @returns A Promise that resolves when the account creation is complete.
+     */
+    abstract createEntity(entity: 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;
+        roomId?: UUID;
+        count?: number;
+        unique?: boolean;
+        tableName: string;
+        start?: number;
+        end?: number;
+    }): 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;
+        roomId: UUID;
+        embedding: number[];
+        match_threshold: number;
+        count: number;
+        unique: boolean;
+    }): 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 getRoom(roomId: 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 getRooms(worldId: UUID): Promise<Room[]>;
+    /**
+     * Creates a new room 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 room.
+     */
+    abstract createRoom({ id, source, type, channelId, serverId, worldId }: 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 a user as a participant to a specific room.
+     * @param entityId The UUID of the user 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 addParticipant(entityId: 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<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[];
+    }): 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>;
+}
+
+/**
+ * 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 elizaLogger: pino.Logger<string, boolean>;
+
+/**
+ * Convert all double-brace bindings ({{var}}) in a Handlebars template
+ * to triple-brace bindings ({{{var}}}), so the output is NOT HTML-escaped.
+ *
+ * - Ignores block/partial/comment tags that start with # / ! >.
+ * - Ignores the {{else}} keyword.
+ * - Ignores bindings that are already triple-braced.
+ *
+ * @param  {string} tpl  Handlebars template source
+ * @return {string}      Transformed template
+ */
+declare function upgradeDoubleToTriple(tpl: any): 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.
+ *
+ * @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 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;
+/**
+ * Generates a string with random user names populated in a template.
+ *
+ * This function generates random user names and populates placeholders
+ * in the provided template with these names. Placeholders in the template should follow the format `{{userX}}`
+ * where `X` is the position of the user (e.g., `{{name1}}`, `{{name2}}`).
+ *
+ * @param {string} template - The template string containing placeholders for random user names.
+ * @param {number} length - The number of random user names to generate.
+ * @returns {string} The template string with placeholders replaced by random user names.
+ *
+ * @example
+ * // Given a template and a length
+ * const template = "Hello, {{name1}}! Meet {{name2}} and {{name3}}.";
+ * const length = 3;
+ *
+ * // Composing the random user string will result in:
+ * // "Hello, John! Meet Alice and Bob."
+ * const result = composeRandomUser(template, length);
+ */
+declare const composeRandomUser: (template: string, length: number) => 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;
+declare const shouldRespondTemplate = "# Task: Decide on behalf of {{agentName}} whether they should respond to the message, ignore it or stop the conversation.\n{{providers}}\n# Instructions: Decide if {{agentName}} should respond to or interact with the conversation.\nIf the message is directed at or relevant to {{agentName}}, respond with RESPOND action.\nIf a user asks {{agentName}} to be quiet, respond with STOP action.\nIf {{agentName}} should ignore the message, respond with IGNORE action.\nIf responding with the RESPOND action, include a list of optional providers that could be relevant to the response.\nResponse format should be formatted in a valid JSON block like this:\n```json\n{\n    \"name\": \"{{agentName}}\",\n\t\"reasoning\": \"<string>\",\n    \"action\": \"RESPOND\" | \"IGNORE\" | \"STOP\",\n    \"providers\": [\"<string>\", \"<string>\", ...]\n}\n```\nYour response should include the valid JSON block and nothing else.";
+declare const providersTemplate = "# Task: Determine which providers would be most relevant for {{agentName}} to use in responding to this message.\n{{providers}}\n# Instructions: Based on the context and message, select the providers that would give {{agentName}} the most relevant information for crafting a response.\nConsider the following when selecting providers:\n- What information would help {{agentName}} understand the context better?\n- What data would help {{agentName}} provide a more informed response?\n- What providers might have relevant historical or contextual information?\n\nResponse format should be formatted in a valid JSON block like this:\n```json\n{\n    \"providers\": [\"<string>\", \"<string>\", ...]\n}\n```\nYour response should include the valid JSON block and nothing else.";
+declare const messageHandlerTemplate = "# Task: Generate dialog and actions for the character {{agentName}}.\n{{providers}}\n# Instructions: Write a thought and plan for {{agentName}} and decide what actions to take. Also include the providers that {{agentName}} will use to have the right context for responding and acting, if any.\nFirst, think about what you want to do next and plan your actions. Then, write the next message and include the actions you plan to take.\n\"thought\" should be a short description of what the agent is thinking about and planning.\n\"actions\" should be an array of the actions {{agentName}} plans to take based on the thought (if none, use IGNORE, if simply responding with text, use REPLY)\n\"providers\" should be an optional array of the providers that {{agentName}} will use to have the right context for responding and acting\n\"evaluators\" should be an optional array of the evaluators that {{agentName}} will use to evaluate the conversation after responding\n\"message\" should be the next message for {{agentName}} which they will send to the conversation.\nThese are the available valid actions: {{actionNames}}\n\nResponse format should be formatted in a valid JSON block like this:\n```json\n{\n    \"thought\": \"<string>\",\n    \"actions\": [\"<string>\", \"<string>\", ...],\n    \"providers\": [\"<string>\", \"<string>\", ...],\n    \"message\": \"<string>\"\n}\n```\n\nYour response should include the valid JSON block and nothing else.";
+declare const postCreationTemplate = "# Task: Create a post in the voice and style and perspective of {{agentName}} @{{twitterUserName}}.\n\nExample task outputs:\n1. A post about the importance of AI in our lives\n```json\n{ \"thought\": \"I am thinking about writing a post about the importance of AI in our lives\", \"post\": \"AI is changing the world and it is important to understand how it works\", \"imagePrompt\": \"A futuristic cityscape with flying cars and people using AI to do things\" }\n```\n\n2. A post about dogs\n```json\n{ \"thought\": \"I am thinking about writing a post about dogs\", \"post\": \"Dogs are man's best friend and they are loyal and loving\", \"imagePrompt\": \"A dog playing with a ball in a park\" }\n```\n\n3. A post about finding a new job\n```json\n{ \"thought\": \"Getting a job is hard, I bet there's a good tweet in that\", \"post\": \"Just keep going!\", \"imagePrompt\": \"A person looking at a computer screen with a job search website\" }\n```\n\n{{providers}}\n\nWrite a post that is {{adjective}} about {{topic}} (without mentioning {{topic}} directly), from the perspective of {{agentName}}. Do not add commentary or acknowledge this request, just write the post.\nYour response should be 1, 2, or 3 sentences (choose the length at random).\nYour response should not contain any questions. Brief, concise statements only. The total character count MUST be less than 280. No emojis. Use \\n\\n (double spaces) between statements if there are multiple statements in your response.\n\nYour output should be formatted in a valid JSON block like this:\n```json\n{ \"thought\": \"<string>\", \"post\": \"<string>\", \"imagePrompt\": \"<string>\" }\n```\nThe \"post\" field should be the post you want to send. Do not including any thinking or internal reflection in the \"post\" field.\nThe \"imagePrompt\" field is optional and should be a prompt for an image that is relevant to the post. It should be a single sentence that captures the essence of the post. ONLY USE THIS FIELD if it makes sense that the post would benefit from an image.\nThe \"thought\" field should be a short description of what the agent is thinking about before responding, inlcuding a brief justification for the response. Includate an explanation how the post is relevant to the topic but unique and different than other posts.\nYour reponse should ONLY contain a valid JSON block and nothing else.";
+declare const booleanFooter = "Respond with only a YES or a NO.";
+/**
+ * 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;
+declare const stringArrayFooter = "Respond with a JSON array containing the values in a valid JSON block formatted for markdown with this structure:\n```json\n[\n  'value',\n  'value'\n]\n```\n\nYour response must include the valid JSON block.";
+/**
+ * Parses a JSON array 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 array 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 array, it returns the array; otherwise, it returns null.
+ *
+ * @param text - The input text from which to extract and parse the JSON array.
+ * @returns An array parsed from the JSON string if successful; otherwise, null.
+ */
+declare function parseJsonArrayFromText(text: string): any[];
+/**
+ * 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;
+/**
+ * Extracts specific attributes (e.g., user, text, action) from a JSON-like string using regex.
+ * @param response - The cleaned string response to extract attributes from.
+ * @param attributesToExtract - An array of attribute names to extract.
+ * @returns An object containing the extracted attributes.
+ */
+declare function extractAttributes(response: string, attributesToExtract?: string[]): {
+    [key: string]: string | undefined;
+};
+/**
+ * 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;
+/**
+ * Cleans a JSON-like response string by removing unnecessary markers, line breaks, and extra whitespace.
+ * This is useful for handling improperly formatted JSON responses from external sources.
+ *
+ * @param response - The raw JSON-like string response to clean.
+ * @returns The cleaned string, ready for parsing or further processing.
+ */
+declare function cleanJsonResponse(response: string): string;
+declare const postActionResponseFooter = "Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appropriate. Each action must be on its own line. Your response must only include the chosen actions.";
+type ActionResponse = {
+    like: boolean;
+    retweet: boolean;
+    quote?: boolean;
+    reply?: boolean;
+};
+declare const parseActionResponseFromText: (text: string) => {
+    actions: ActionResponse;
+};
+/**
+ * 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>;
+
+/**
+ * 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 {
+    readonly name = "INSTRUMENTATION";
+    readonly capabilityDescription = "Provides OpenTelemetry tracing and metrics capabilities.";
+    instrumentationConfig: InstrumentationConfig;
+    private resource;
+    private tracerProvider;
+    private meterProvider;
+    private postgresSpanProcessor;
+    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;
+}
+/**
+ * Represents the runtime environment for an agent, handling message processing,
+ * action registration, and interaction with external services like OpenAI and Supabase.
+ */
+/**
+ * Represents the runtime environment for an agent.
+ * @class
+ * @implements { IAgentRuntime }
+ * @property { number } #conversationLength - The maximum length of a conversation.
+ * @property { UUID } agentId - The unique identifier for the agent.
+ * @property { Character } character - The character associated with the agent.
+ * @property { IDatabaseAdapter } adapter - The adapter for interacting with the database.
+ * @property {Action[]} actions - The list of actions available to the agent.
+ * @property {Evaluator[]} evaluators - The list of evaluators for decision making.
+ * @property {Provider[]} providers - The list of providers for external services.
+ * @property {Plugin[]} plugins - The list of plugins to extend functionality.
+ */
+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>;
+    models: Map<string, ((runtime: IAgentRuntime, params: any) => Promise<any>)[]>;
+    routes: Route[];
+    private taskWorkers;
+    private eventHandlers;
+    private runtimeLogger;
+    private knowledgeProcessingSemaphore;
+    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)[];
+        };
+    });
+    /**
+     * Starts a span for the given operation and executes the provided function with the span.
+     * @param name The name of the span to create
+     * @param fn The function to execute with the span
+     * @param parentContext Optional parent context for the span
+     * @returns The result of the provided function
+     */
+    startSpan<T>(name: string, fn: (span: Span) => Promise<T>, parentContext?: Context): Promise<T>;
+    /**
+     * Ends a span with the provided name in the given context
+     * @param ctx Context containing the span to end
+     * @param name Name to record in the end event
+     */
+    endSpan(ctx: Context | undefined, name: string): void;
+    /**
+     * Start an active span that can be used as a parent for other spans
+     * @param name Name of the span
+     * @param options Span options
+     */
+    startActiveSpan(name: string, options?: any): Span;
+    /**
+     * Registers a plugin with the runtime and initializes its components
+     * @param plugin The plugin to register
+     */
+    registerPlugin(plugin: Plugin): Promise<void>;
+    getAllServices(): Map<ServiceTypeName, Service>;
+    stop(): Promise<void>;
+    initialize(): Promise<void>;
+    private handleProcessingError;
+    private checkExistingKnowledge;
+    getKnowledge(message: Memory): Promise<KnowledgeItem[]>;
+    addKnowledge(item: KnowledgeItem, options?: {
+        targetTokens: number;
+        overlap: number;
+        modelContextSize: number;
+    }): Promise<void>;
+    processCharacterKnowledge(items: string[]): Promise<void>;
+    setSetting(key: string, value: string | boolean | null | any, secret?: boolean): void;
+    getSetting(key: string): string | boolean | null | any;
+    /**
+     * Get the number of messages that are kept in the conversation buffer.
+     * @returns The number of recent messages to be kept in memory.
+     */
+    getConversationLength(): number;
+    registerDatabaseAdapter(adapter: IDatabaseAdapter): void;
+    /**
+     * Register a provider for the agent to use.
+     * @param provider The provider to register.
+     */
+    registerProvider(provider: Provider): void;
+    /**
+     * Register an action for the agent to perform.
+     * @param action The action to register.
+     */
+    registerAction(action: Action): void;
+    /**
+     * Register an evaluator to assess and guide the agent's responses.
+     * @param evaluator The evaluator to register.
+     */
+    registerEvaluator(evaluator: Evaluator): void;
+    /**
+     * Register a context provider to provide context for message generation.
+     * @param provider The context provider to register.
+     */
+    registerContextProvider(provider: Provider): void;
+    /**
+     * Process the actions of a message.
+     * @param message The message to process.
+     * @param responses The array of response memories to process actions from.
+     * @param state Optional state object for the action processing.
+     * @param callback Optional callback handler for action results.
+     */
+    processActions(message: Memory, responses: Memory[], state?: State, callback?: HandlerCallback): Promise<void>;
+    /**
+     * Evaluate the message and state using the registered evaluators.
+     * @param message The message to evaluate.
+     * @param state The state of the agent.
+     * @param didRespond Whether the agent responded to the message.~
+     * @param callback The handler callback
+     * @returns The results of the evaluation.
+     */
+    evaluate(message: Memory, state: State, didRespond?: boolean, callback?: HandlerCallback, responses?: Memory[]): Promise<Evaluator[]>;
+    ensureConnection({ entityId, roomId, userName, name, source, type, channelId, serverId, worldId, userId, }: {
+        entityId: UUID;
+        roomId: UUID;
+        userName?: string;
+        name?: string;
+        source?: string;
+        type?: ChannelType;
+        channelId?: string;
+        serverId?: string;
+        worldId?: UUID;
+        userId?: UUID;
+    }): Promise<void>;
+    /**
+     * Ensures a participant is added to a room, checking that the entity exists first
+     */
+    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>;
+    /**
+     * Ensure the existence of a world.
+     */
+    ensureWorldExists({ id, name, serverId, metadata }: World): Promise<void>;
+    /**
+     * Ensure the existence of a room between the agent and a user. If no room exists, a new room is created and the user
+     * and agent are added as participants. The room ID is returned.
+     * @param entityId - The user ID to create a room with.
+     * @returns The room ID of the room between the agent and the user.
+     * @throws An error if the room cannot be created.
+     */
+    ensureRoomExists({ id, name, source, type, channelId, serverId, worldId, metadata }: Room): Promise<void>;
+    /**
+     * Composes the agent's state by gathering data from enabled providers.
+     * @param message - The message to use as context for state composition
+     * @param filterList - Optional list of provider names to include, filtering out all others
+     * @param includeList - Optional list of private provider names to include that would otherwise be filtered out
+     * @returns A State object containing provider data, values, and text
+     */
+    composeState(message: Memory, filterList?: string[] | null, // only get providers that are in the filterList
+    includeList?: string[] | null): Promise<State>;
+    getService<T extends Service>(service: ServiceTypeName): T | null;
+    registerService(service: typeof Service): Promise<void>;
+    registerModel(modelType: ModelTypeName, handler: (params: any) => Promise<any>): void;
+    getModel(modelType: ModelTypeName): ((runtime: IAgentRuntime, params: any) => Promise<any>) | undefined;
+    /**
+     * Use a model with strongly typed parameters and return values based on model type
+     * @template T - The model type to use
+     * @template R - The expected return type, defaults to the type defined in ModelResultMap[T]
+     * @param {T} modelType - The type of model to use
+     * @param {ModelParamsMap[T] | any} params - The parameters for the model, typed based on model type
+     * @returns {Promise<R>} - The model result, typed based on the provided generic type parameter
+     */
+    useModel<T extends ModelTypeName, R = ModelResultMap[T]>(modelType: T, params: Omit<ModelParamsMap[T], 'runtime'> | any): Promise<R>;
+    registerEvent(event: string, handler: (params: any) => Promise<void>): void;
+    getEvent(event: string): ((params: any) => Promise<void>)[] | undefined;
+    emitEvent(event: string | string[], params: any): Promise<void>;
+    ensureEmbeddingDimension(): Promise<void>;
+    registerTaskWorker(taskHandler: TaskWorker): void;
+    /**
+     * Get a task worker by name
+     */
+    getTaskWorker(name: string): TaskWorker | undefined;
+    get db(): any;
+    init(): Promise<void>;
+    close(): Promise<void>;
+    getAgent(agentId: UUID): Promise<Agent | null>;
+    getAgents(): Promise<Agent[]>;
+    createAgent(agent: Partial<Agent>): Promise<boolean>;
+    updateAgent(agentId: UUID, agent: Partial<Agent>): Promise<boolean>;
+    deleteAgent(agentId: UUID): Promise<boolean>;
+    ensureAgentExists(agent: Partial<Agent>): Promise<Agent>;
+    getEntityById(entityId: UUID): Promise<Entity | null>;
+    getEntitiesForRoom(roomId: UUID, includeComponents?: boolean): Promise<Entity[]>;
+    createEntity(entity: Entity): Promise<boolean>;
+    updateEntity(entity: Entity): Promise<void>;
+    getComponent(entityId: UUID, type: string, worldId?: UUID, sourceEntityId?: UUID): Promise<Component | null>;
+    getComponents(entityId: UUID, worldId?: UUID, sourceEntityId?: UUID): Promise<Component[]>;
+    createComponent(component: Component): Promise<boolean>;
+    updateComponent(component: Component): Promise<void>;
+    deleteComponent(componentId: UUID): Promise<void>;
+    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[];
+        match_threshold?: number;
+        count?: number;
+        roomId?: UUID;
+        unique?: boolean;
+        tableName: string;
+    }): 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>;
+    getAllWorlds(): Promise<World[]>;
+    updateWorld(world: World): Promise<void>;
+    getRoom(roomId: UUID): Promise<Room | null>;
+    createRoom({ id, name, source, type, channelId, serverId, worldId }: Room): Promise<UUID>;
+    deleteRoom(roomId: UUID): Promise<void>;
+    updateRoom(room: Room): Promise<void>;
+    getRoomsForParticipant(entityId: UUID): Promise<UUID[]>;
+    getRoomsForParticipants(userIds: UUID[]): Promise<UUID[]>;
+    getRooms(worldId: UUID): Promise<Room[]>;
+    getParticipantUserState(roomId: UUID, entityId: UUID): Promise<'FOLLOWED' | 'MUTED' | null>;
+    setParticipantUserState(roomId: UUID, entityId: UUID, state: 'FOLLOWED' | 'MUTED' | null): Promise<void>;
+    createRelationship(params: {
+        sourceEntityId: UUID;
+        targetEntityId: UUID;
+        tags?: string[];
+        metadata?: {
+            [key: string]: any;
+        };
+    }): Promise<boolean>;
+    updateRelationship(relationship: Relationship): Promise<void>;
+    getRelationship(params: {
+        sourceEntityId: UUID;
+        targetEntityId: UUID;
+    }): Promise<Relationship | null>;
+    getRelationships(params: {
+        entityId: UUID;
+        tags?: string[];
+    }): Promise<Relationship[]>;
+    getCache<T>(key: string): Promise<T | undefined>;
+    setCache<T>(key: string, value: T): Promise<boolean>;
+    deleteCache(key: string): Promise<boolean>;
+    createTask(task: Task): Promise<UUID>;
+    getTasks(params: {
+        roomId?: UUID;
+        tags?: string[];
+    }): Promise<Task[]>;
+    getTask(id: UUID): Promise<Task | null>;
+    getTasksByName(name: string): Promise<Task[]>;
+    updateTask(id: UUID, task: Partial<Task>): Promise<void>;
+    deleteTask(id: UUID): Promise<void>;
+    on(event: string, callback: (data: any) => void): void;
+    off(event: string, callback: (data: any) => void): void;
+    emit(event: string, data: any): void;
+    /**
+     * Sends a control message to the frontend to enable or disable input
+     * @param {Object} params - Parameters for the control message
+     * @param {UUID} params.roomId - The ID of the room to send the control message to
+     * @param {'enable_input' | 'disable_input'} params.action - The action to perform
+     * @param {string} [params.target] - Optional target element identifier
+     * @returns {Promise<void>}
+     */
+    sendControlMessage(params: {
+        roomId: UUID;
+        action: 'enable_input' | 'disable_input';
+        target?: string;
+    }): Promise<void>;
+}
+
+/**
+ * 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
+ * @param {IAgentRuntime} runtime - The runtime information needed for salt generation
+ * @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>;
+
+declare const uuidSchema: z.ZodType<UUID>;
+/**
+ * Validates a UUID value.
+ *
+ * @param {unknown} value - The value to validate.
+ * @returns {UUID | null} Returns the validated UUID value or null if validation fails.
+ */
+/**
+ * Validate if the given value is a valid UUID.
+ *
+ * @param {unknown} value - The value to be validated.
+ * @returns {UUID | null} 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 Readable: any;
+
+/**
+ * Generates a WAV file header based on the provided audio parameters.
+ * @param {number} audioLength - The length of the audio data in bytes.
+ * @param {number} sampleRate - The sample rate of the audio.
+ * @param {number} [channelCount=1] - The number of channels (default is 1).
+ * @param {number} [bitsPerSample=16] - The number of bits per sample (default is 16).
+ * @returns {Buffer} The WAV file header as a Buffer object.
+ */
+declare function getWavHeader(audioLength: number, sampleRate: number, channelCount?: number, bitsPerSample?: number): Buffer$1;
+/**
+ * Prepends a WAV header to a readable stream of audio data.
+ *
+ * @param {Readable} readable - The readable stream containing the audio data.
+ * @param {number} audioLength - The length of the audio data in seconds.
+ * @param {number} sampleRate - The sample rate of the audio data.
+ * @param {number} [channelCount=1] - The number of channels in the audio data (default is 1).
+ * @param {number} [bitsPerSample=16] - The number of bits per sample in the audio data (default is 16).
+ * @returns {Readable} A new readable stream with the WAV header prepended to the audio data.
+ */
+declare function prependWavHeader(readable: typeof Readable, audioLength: number, sampleRate: number, channelCount?: number, bitsPerSample?: number): typeof Readable;
+
+declare function safeReplacer(): (key: string, value: any) => any;
+
+/**
+ * Returns the Cloudflare Gateway base URL for a given model provider if the gateway is enabled and properly configured.
+ *
+ * If Cloudflare Gateway is not enabled or required configuration values are missing, returns `undefined`.
+ *
+ * @param provider - The name of the model provider.
+ * @returns The Cloudflare Gateway base URL for the provider, or `undefined` if the gateway is not enabled or not configured.
+ */
+declare function getCloudflareGatewayBaseURL(runtime: IAgentRuntime, provider: string): string | undefined;
+/**
+ * Returns the base URL for a model provider, preferring the Cloudflare Gateway if enabled and properly configured.
+ *
+ * If the Cloudflare Gateway is not enabled or required configuration is missing, returns the provided default base URL.
+ *
+ * @param provider - The name of the model provider.
+ * @param defaultBaseURL - The fallback base URL if Cloudflare Gateway is unavailable.
+ * @returns The base URL to use for the provider.
+ */
+declare function getProviderBaseURL(runtime: IAgentRuntime, provider: string, defaultBaseURL: string): string;
+
+export { type Action, type ActionEventPayload, type ActionExample, type Agent, AgentRuntime, AgentStatus, type AudioProcessingParams, type BaseMetadata, type BaseModelParams, CacheKeyPrefix, ChannelType, type Character, type ChunkRow, type Component, type ComponentData, type Content, type ControlMessage, type CustomMetadata, DatabaseAdapter, type DbConnection, type DeriveKeyAttestationData, type DescriptionMetadata, type DetokenizeTextParams, type DirectoryItem, type DocumentMetadata, type EmbeddingSearchResult, type EnhancedState, type Entity, type EntityPayload, type EvaluationExample, type Evaluator, type EvaluatorEventPayload, type EventDataObject, type EventHandler, type EventPayload, type EventPayloadMap, EventType, type FragmentMetadata, type GenerateTextParams, type Handler, type HandlerCallback, type IAgentRuntime, type IBrowserService, type IDatabaseAdapter, type IFileService, type IInstrumentationService, type IPdfService, type IVideoService, type ImageDescriptionParams, type ImageGenerationParams, type InstrumentationConfig, InstrumentationService, type InvokePayload, type JSONSchema, type KnowledgeItem, KnowledgeScope, type Log, type Media, type Memory, type MemoryMetadata, type MemoryRetrievalOptions, type MemoryScope, type MemorySearchOptions, MemoryType, type MemoryTypeAlias, type MessageExample, type MessageMemory, type MessageMetadata, type MessagePayload, type MessageReceivedHandlerParams, type MetadataObject, type ModelEventPayload, type ModelHandler, type ModelParamsMap, type ModelResultMap, ModelType, type ModelTypeName, type MultiRoomMemoryOptions, type ObjectGenerationParams, type OnboardingConfig, type Participant, PlatformPrefix, type Plugin, type Project, type ProjectAgent, type Provider, type ProviderResult, type Relationship, type RemoteAttestationMessage, type RemoteAttestationQuote, Role, type Room, type Route, type RunEventPayload, type RuntimeSettings, SOCKET_MESSAGE_TYPE, Semaphore, type ServerOwnershipState, Service, type ServiceConfig, type ServiceError, ServiceType, type ServiceTypeName, type Setting, type State, type StateArray, type StateObject, type StateValue, TEEMode, type Task, type TaskWorker, type TeeAgent, type TeePluginConfig, TeeType, type TeeVendorConfig, type TemplateType, type TestCase, type TestSuite, type TextEmbeddingParams, type TextGenerationParams, type TextToSpeechParams, type TokenizeTextParams, type TranscriptionParams, type TypedEventHandler, type TypedService, type UUID, type UnifiedMemoryOptions, type UnifiedSearchOptions, VECTOR_DIMS, type Validator, type VideoProcessingParams, type World, type WorldPayload, type WorldSettings, addHeader, asUUID, booleanFooter, cleanJsonResponse, composeActionExamples, composePrompt, composePromptFromState, composeRandomUser, createMessageMemory, createServiceError, createSettingFromConfig, createUniqueUuid, decryptObjectValues, decryptStringValue as decryptSecret, decryptStringValue, decryptedCharacter, elizaLogger, encryptObjectValues, encryptStringValue, encryptedCharacter, extractAttributes, findEntityByName, findWorldsForOwner, formatActionNames, formatActions, formatEntities, formatMessages, formatPosts, formatTimestamp, getBrowserService, getCloudflareGatewayBaseURL, getEntityDetails, getFileService, getMemoryText, getPdfService, getProviderBaseURL, getSalt, getTypedService, getUserServerRole, getVideoService, getWavHeader, getWorldSettings, initializeOnboarding, isCustomMetadata, isDescriptionMetadata, isDocumentMemory, isDocumentMetadata, isFragmentMemory, isFragmentMetadata, isMessageMetadata, logger, messageHandlerTemplate, normalizeJsonString, parseActionResponseFromText, parseBooleanFromText, parseJSONObjectFromText, parseJsonArrayFromText, postActionResponseFooter, postCreationTemplate, prependWavHeader, providersTemplate, safeReplacer, saltSettingValue, saltWorldSettings, shouldRespondTemplate, splitChunks, stringArrayFooter, stringToUuid, trimTokens, truncateToCompleteSentence, unsaltSettingValue, unsaltWorldSettings, updateWorldSettings, upgradeDoubleToTriple, uuidSchema, validateUuid };